{"id":126,"date":"2025-01-29T23:00:21","date_gmt":"2025-01-29T23:00:21","guid":{"rendered":"https:\/\/eugo.ro\/?p=126"},"modified":"2025-02-15T15:30:07","modified_gmt":"2025-02-15T13:30:07","slug":"c","status":"publish","type":"post","link":"https:\/\/eugo.ro\/?p=126","title":{"rendered":"C++"},"content":{"rendered":"
    \n
  1. \n

    ALGORITMI<\/b><\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

    A1. OBIECTELE CU CARE LUCREAZA ALGORITMII.<\/b><\/span><\/p>\n

    1. Date<\/b><\/u><\/span><\/p>\n

    Datele pot fi:<\/span><\/p>\n

    – <\/span>numerice<\/b><\/span> , care pot fi <\/span>intregi <\/b><\/span>sau <\/span>reale<\/b><\/span> ;<\/span><\/p>\n

    – <\/span>logice<\/b><\/span> , care au doua valori <\/span>TRUE (adevarat)<\/b><\/span> si <\/span>FALSE(fals)<\/b><\/span> ;<\/span><\/p>\n

    –<\/span> sir de caractere<\/b><\/span> , reprezinta un sir de caractere cuprins intre apostrofuri ex. ‘mesaj’<\/span><\/p>\n

    2. Variabile<\/b><\/u><\/span><\/p>\n

    Sunt urmatoarele tipuri de variabile:<\/span><\/p>\n

    – variabile de tip <\/span>intreg<\/b><\/span> notate <\/span>integer<\/b><\/span> ;<\/span><\/p>\n

    – variabile de tip <\/span>real<\/b><\/span> notate <\/span>real<\/b><\/span> ;<\/span><\/p>\n

    – variabile de tip <\/span>logic<\/b><\/span> notate <\/span>boolean<\/b><\/span> ;<\/span><\/p>\n

    – variabile de tip <\/span>sir<\/b><\/span> notate <\/span>string<\/b><\/span> ;<\/span><\/p>\n

    Pentru ca un algoritm sa poata folosii o variabila aceasta trebuie declarata astfel:<\/span><\/p>\n

    integer a, b;<\/span><\/p>\n

    real c;<\/span><\/p>\n

    string b.<\/span><\/p>\n

    3. Expresii<\/b><\/u><\/span><\/p>\n

    O expresie este alcatuita din doi sau mai multi operanzi legati intre ei prin operatori.<\/span><\/p>\n

    Operanzii<\/b><\/span> reprezinta valorile care intra in calcul si care pot fii <\/span>variabile<\/b><\/span> sau <\/span>constante.<\/b><\/span><\/p>\n

    Operatorii<\/b><\/span> desemneaza operatiile care se executa spre a obtine rezultatul. Pot fi <\/span>aritmetici<\/b><\/span>, <\/span>relationali<\/b><\/span>, <\/span>logici<\/b><\/span><\/p>\n

    3.1. Operatori aritmetici<\/b><\/u><\/span><\/p>\n

    + (adunare) ; – (scadere) ; * (inmultire) ; \/ (impartire)<\/b><\/span><\/p>\n

    – <\/b><\/span>div (impartire intreaga)<\/b><\/span> – operanzii trebuie sa fie de tip intreg si furnizeaza rezultatul corect daca ambele valori ale operanzilor sunt naturale.<\/span><\/p>\n

    Ex. <\/span>14 div 5 rezultatul va fi 2 (5 intra de 2 ori in 14)<\/b><\/span><\/p>\n

    – mod (rest al impartirii)<\/b><\/span> – operanzii trebuie sa fie de tip intreg si furnizeaza rezultatul corect daca ambele valori ale operanzilor sunt naturale<\/span><\/p>\n

    Ex. <\/span>14 mod 5 rezultatul va fi 4 (restul impartirii lui 14 la 5 este 4) <\/b><\/span><\/p>\n

    3.2. Operatori relationali<\/b><\/u><\/span><\/p>\n

    <(mai mic);<\/b><\/span><\/span> >(mai mare); =(egal); <>(diferit); <=(mai mic sau egal); >=(mai mare sau egal)<\/b><\/span><\/span><\/p>\n

    3.3 Operatori logici<\/b><\/u><\/span><\/p>\n

    NOT (negare) ; AND (si) ; OR(sau) ; XOR (sau exclusiv)<\/b><\/span><\/p>\n

    A2. OPERATIILE PE CARE LE EFECTUEAZA UN ALGORITM<\/b><\/span><\/p>\n

    1. Operatii de intrare \/ iesire<\/b><\/u><\/span><\/p>\n

    Operatia de intrare (<\/span>citire)<\/b><\/span> este <\/span>read<\/b><\/span><\/p>\n

    Operatia de iesire (<\/span>scriere)<\/b><\/span> este <\/span>write<\/b><\/span><\/p>\n

    Exemplu:<\/b><\/span><\/p>\n

    real a,b,c; <\/b><\/span>\/\/ se declara variabilele a,b,c\/\/<\/span><\/p>\n

    read a,b,c<\/b><\/span> \/\/ se citesc variabilele a,b,c\/\/<\/span><\/p>\n

    write a,b,c<\/b><\/span> \/\/ se afiseaza valorile variabilelor a,b,c introduse de la tastatura\/\/<\/span><\/p>\n

    2. Atribuiri<\/b><\/u><\/span><\/p>\n

    Prin operatia de atribuire se retine o anumita data intr-o variabila.<\/span><\/p>\n

    Tipul variabilei trebuie sa coincida cu tipul valorii atribuite, cu exceptia ca unei variabile de tip real i se poate atribui o data de tip intreg.<\/b><\/span><\/p>\n

    Exemple de forma1:<\/span><\/p>\n

    integer a;<\/b><\/span><\/p>\n

    a:=10; <\/b><\/span>\/\/ variabila <\/span>a<\/b><\/span> retine valoarea <\/span>10<\/b><\/span>\/\/<\/span><\/p>\n

    real b;<\/b><\/span><\/p>\n

    b:=9.55 <\/b><\/span>\/\/variabila <\/span>b<\/b><\/span> retine valoarea <\/span>9.55<\/b><\/span>\/\/<\/span><\/p>\n

    real c;<\/b><\/span><\/p>\n

    c:=8;<\/b><\/span> \/\/ variabila <\/span>c<\/b><\/span> retine valoarea <\/span>8<\/b><\/span>\/\/<\/span><\/p>\n

    string d;<\/b><\/span><\/p>\n

    d:=’limbajul C++’ ; <\/b><\/span>\/\/ variabila <\/span>d <\/b><\/span>retine valoarea de tip sir <\/span>limbajul C++<\/b><\/span><\/p>\n

    Exemple de forma 2:<\/span><\/p>\n

    a) integer a,b;<\/b><\/span><\/p>\n

    a:=5 b:=10;<\/b><\/span><\/p>\n

    a:=b <\/b><\/span>\/\/ variabilei <\/span>a<\/b><\/span> i se atribuie valoarea variabilei <\/span>b<\/b><\/span> \/\/<\/span><\/p>\n

    Dupa aceasta operatie variabila <\/span>a <\/b><\/span>are valoarea <\/span>10<\/b><\/span> iar variabila <\/span>b<\/b><\/span> ramine cu valoarea <\/span>10<\/b><\/span><\/p>\n

    b) integer a,b;<\/b><\/span><\/p>\n

    a:=5 b:=10;<\/b><\/span><\/p>\n

    b:=a<\/b><\/span> \/\/ variabilei <\/span>b<\/b><\/span> i se atribuie valoarea variabilei <\/span>a<\/b><\/span> \/\/<\/span><\/p>\n

    Dupa aceasta operatie variabila <\/span>a<\/b><\/span> ramine cu valoarea <\/span>5<\/b><\/span> iar variabilei <\/span>b <\/b><\/span>i se atribuie valoarea <\/span>5<\/b><\/span><\/p>\n

    c) integer a;<\/b><\/span><\/p>\n

    a:=5;<\/b><\/span><\/p>\n

    a:=a+1<\/b><\/span><\/p>\n

    Dupa aceasta operatie variabilei <\/span>a <\/b><\/span>i se atribuie valoarea <\/span>6 (5+1=6)<\/b><\/span><\/p>\n

    Pentru a inversa continutul a doua variabile intre ele trebuie utilizata <\/span>o variabila auxiliara<\/b><\/span> care realizeaza interschimbul de valori.<\/span><\/p>\n

    Exemplu:<\/span><\/p>\n

    integer a,b,m;<\/b><\/span><\/p>\n

    a:=1 b:=2;<\/b><\/span><\/p>\n

    m:=a <\/b><\/span>\/\/variabila <\/span>m <\/b><\/span>preia valoarea variabilei <\/span>a <\/b><\/span> si devine <\/span>1<\/b><\/span>\/\/<\/span><\/p>\n

    a:=b<\/b><\/span> \/\/variabila <\/span>a <\/b><\/span>preia valoarea variabilei <\/span>b<\/b><\/span> si devine <\/span>2<\/b><\/span>\/\/<\/span><\/p>\n

    b:=m<\/b><\/span> \/\/variabila <\/span>b <\/b><\/span>preia valoarea variabilei <\/span>m<\/b><\/span> si devine <\/span>1<\/b><\/span>\/\/<\/span><\/p>\n

    3. Operatii de decizie<\/b><\/u><\/span><\/p>\n

    Forma generala:<\/span><\/p>\n

    if <\/b><\/span>expresie logica <\/span>then<\/b><\/span> operatia1 <\/span>else <\/b><\/span>operatia2 <\/span>endif<\/b><\/span><\/p>\n

    Mod de executie: se evalueaza expresia logica, daca este <\/span>adevarata<\/b><\/span> se executa <\/span>operatia<\/b><\/span> 1<\/b><\/span>, iar daca este <\/span>falsa<\/b><\/span> se executa <\/span>operatia 2<\/b><\/span><\/p>\n

    Exemplul1.<\/span><\/p>\n

    integer a, b;<\/b><\/span><\/p>\n

    read a read b<\/b><\/span><\/p>\n

    if a>b then write a else write b<\/b><\/span><\/p>\n

    endif<\/b><\/span><\/p>\n

    Se citesc valorile variabilelor <\/span>a <\/b><\/span>si <\/span>b<\/b><\/span>. Daca valoarea lui <\/span>a<\/b><\/span> este mai mare decit valoarea lui <\/span>b <\/b><\/span>se afiseaza valoarea lui <\/span>a<\/b><\/span>, iar daca este invers se afiseaza valoarea lui <\/span>b<\/b><\/span>.<\/span><\/p>\n

    Exemplul 2.<\/span><\/p>\n

    Se citesc patru valori reale a,b,c,d si se evalueaza expresia:<\/span><\/p>\n

    a+b , c+d>0<\/span><\/p>\n

    E = a-b , c+d=0<\/span><\/p>\n

    a*b , c+d<0 <\/span><\/p>\n

    real a, b, c, d, rez;<\/b><\/span><\/p>\n

    read a, b, c, d<\/b><\/span><\/p>\n

    if c+d>0 then rez:=a+b<\/b><\/span><\/p>\n

    else<\/b><\/span><\/p>\n

    if c+d=0 then rez:=a-b<\/b><\/span><\/p>\n

    else<\/b><\/span><\/p>\n

    rez:=a*b<\/b><\/span><\/p>\n

    endif endif<\/b><\/span><\/p>\n

    write rez<\/b><\/span><\/p>\n

    B. PRINCIPIILE PROGRAMARII STRUCTURATE<\/b><\/span><\/span><\/p>\n

    1. Structura liniara<\/b><\/u><\/span><\/p>\n

    Exemplul1. Se citesc 2 valori si se afiseaza valoarea cea mai mare<\/span><\/p>\n

    real a, b;<\/b><\/span><\/p>\n

    read a, b<\/b><\/span><\/p>\n

    if a>b then write a else write b<\/b><\/span><\/p>\n

    endif<\/b><\/span><\/p>\n

    Exemplul 2. Se citesc 2 valori intregi a si b si se afiseaza media lor aritmetica<\/span><\/p>\n

    integer a, b<\/b><\/span><\/p>\n

    real medie<\/b><\/span><\/p>\n

    read a, b<\/b><\/span><\/p>\n

    medie:=(a+b)\/2<\/b><\/span><\/p>\n

    write medie <\/b><\/span><\/p>\n

    2.Structura alternativa<\/b><\/u><\/span><\/p>\n

    Exemplul1.<\/span> Se citeste o valoare intreaga. Daca aceasta este para se tipareste mesajul”am citit un numar par”<\/span><\/p>\n

    integer a;<\/b><\/span><\/p>\n

    read a<\/b><\/span><\/p>\n

    if a mod 2 = 0 write ‘am citit un numar par’<\/b><\/span><\/p>\n

    endif<\/b><\/span><\/p>\n

    Exemplul 2. Se citeste x numar real. Evaluati expresia:<\/span><\/p>\n

    x, x<0<\/span><\/p>\n

    2x 0\u2264x<10<\/span><\/p>\n

    f= 3x 10\u2264x<100<\/span><\/p>\n

    4x x\u2265100<\/span><\/p>\n

    real x,f;<\/b><\/span><\/p>\n

    read x;<\/b><\/span><\/p>\n

    if x<0 then f:=x<\/b><\/span><\/p>\n

    else<\/b><\/span><\/p>\n

    if x<10 then f:2*x<\/b><\/span><\/p>\n

    else<\/b><\/span><\/p>\n

    if x<100 then f:=3*x<\/b><\/span><\/p>\n

    else f:=4*x<\/b><\/span><\/p>\n

    endif endif endif<\/b><\/span><\/p>\n

    write f<\/b><\/span><\/p>\n

    3. Structura repetitiva<\/b><\/u><\/span><\/p>\n

    3.1. Structura WHILE DO<\/b><\/u><\/span><\/p>\n

    Forma generala. Fie <\/span>E<\/b><\/span> o expresie si <\/span>S<\/b><\/span> o structura.<\/span><\/p>\n

    while E<\/b><\/span><\/p>\n

    do S<\/b><\/span><\/p>\n

    endwhile<\/b><\/span><\/p>\n

    Se evalueaza expresia logica <\/span>E<\/b><\/span>, daca este adevarata se executa structura <\/span>S<\/b><\/span> apoi se repeta executia pina ce expresia logica devine falsa.<\/span><\/p>\n

    Exemplu. Se citesc numerele naturale n1 si n2 si se calculaeaza produsul lor fara a utiliza operatorul de inmultire.<\/span><\/p>\n

    integer n1, n2, s, i;<\/b><\/span><\/p>\n

    read n1 read n2<\/b><\/span><\/p>\n

    s:=0 i:=1<\/b><\/span><\/p>\n

    while i <= n2 do<\/b><\/span><\/p>\n

    s:=s+n1<\/b><\/span><\/p>\n

    i:=i+1<\/b><\/span><\/p>\n

    endwhile<\/b><\/span><\/p>\n

    write s<\/b><\/span><\/p>\n

    3.2. Structura FOR<\/b><\/u><\/span><\/p>\n

    Forma generala<\/b><\/span>. Fie o variabila <\/span>i (variabila de ciclare)<\/b><\/span> si doua valori intregi <\/span>a(valoare initiala)<\/b><\/span> si <\/span>b(valoare finala)<\/b><\/span> si o structura <\/span>S<\/b><\/span><\/p>\n

    for i:=a, b<\/b><\/span><\/p>\n

    S<\/b><\/span><\/p>\n

    repeat<\/b><\/span><\/p>\n

    Variabila de ciclare <\/span>i<\/b><\/span> ia valoarea initiala <\/span>a<\/b><\/span>, si se executa structura <\/span>S<\/b><\/span> pina ce se ajunge la valoarea finala <\/span>b <\/b><\/span><\/p>\n

    Exemplu. Se citeste numarul natural <\/span>n<\/b><\/span> si se efectueaza suma primelor <\/span>n<\/b><\/span> numere naturale<\/span><\/p>\n

    integer n, s, i;<\/b><\/span><\/p>\n

    read n<\/b><\/span><\/p>\n

    s:=0<\/b><\/span><\/p>\n

    for i:=1, n<\/b><\/span><\/p>\n

    s:=s+i<\/b><\/span><\/p>\n

    repeat<\/b><\/span><\/p>\n

    write s<\/b><\/span><\/p>\n

    3.3 Structura REPEAT UNTIL<\/b><\/u><\/span><\/p>\n

    Forma generala.<\/span><\/p>\n

    Fie o structura <\/span>S<\/b><\/span> si o expresie logica <\/span>E<\/b><\/span><\/p>\n

    repeat<\/b><\/span><\/p>\n

    S<\/b><\/span><\/p>\n

    until E<\/b><\/span><\/p>\n

    Se executa structura <\/span>S<\/b><\/span>, se evalueaza expresia <\/span>E<\/b><\/span>, daca este falsa se executa din nou structura <\/span>S<\/b><\/span>, iar daca este adevarata se trece mai departe<\/span><\/p>\n

    Exemplu. Calculul sumei primelor <\/span>n<\/b><\/span> numere naturale n>0<\/span><\/p>\n

    integer n, i, s;<\/b><\/span><\/p>\n

    read n<\/b><\/span><\/p>\n

    i:=1 s:=0<\/b><\/span><\/p>\n

    do<\/b><\/span><\/p>\n

    s:=s+i<\/b><\/span><\/p>\n

    i:=i+1<\/b><\/span><\/p>\n

    until i > n<\/b><\/span><\/p>\n

    write s<\/b><\/span><\/p>\n

    C.<\/span><\/span> ELEMENTELE DE BAZA ALE LIMBAJULUI C++<\/span><\/span><\/p>\n

    Un program scris in C++ <\/span>este alcatuit din una sau mai multe functii. Fiecare functie are mai multe instructiuni in C++ care codifica algoritmul programului. Instructiunile unei functii reprezinta corpul functiei si sunt cuprinse intre <\/span>{ }<\/b><\/span>. Dupa fiecare instructiune din corpul functiei se pune semnul<\/span> ;<\/b><\/span><\/p>\n

    Functiile de acelasi domeniu sunt grupate in fisiere <\/span>header<\/b><\/span> numite si <\/span>directive<\/b><\/span>.<\/span><\/p>\n

    La inceputul fiecarui program se specifica fisierele care contin functiile ce se utilizeaza in program astfel: <\/span># include <numefisier.h><\/b><\/span><\/p>\n

    Dupa specificarea directivelor trebuie scrisa functia radacina care se numeste <\/span>main( )<\/b><\/span> sau <\/span>void main( ).<\/b><\/span> Dupa numele directivelor sau a functiilor <\/span>nu se pune<\/b><\/span> semnul <\/span>;<\/b><\/span><\/p>\n

    1. Citiri , scrieri.<\/b><\/u><\/span><\/span><\/p>\n

    – <\/b><\/span>pentru realizarea <\/span>citirii<\/b><\/span> se utilizeaza : <\/span>cin>>nume variabila<\/b><\/span><\/p>\n

    cin>>a>>b>>c <\/b><\/span>– citeste variabilele a, b, c<\/span><\/p>\n

    – pentru realizarea <\/span>scrierii<\/b><\/span> se utilizeaza: <\/span>cout<<nume variabila<\/b><\/span><\/p>\n

    cout<<a<<b<<c <\/b><\/span>– scrie variabilele a, b, c<\/span><\/p>\n

    Exemplu<\/span>l 1:<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    int L,l,h;<\/b><\/span><\/p>\n

    clrscr(); <\/b><\/span>\/\/ sterge ecranul \/\/<\/span><\/p>\n

    cout<<“Lungimea=” ; cin>>L;<\/b><\/span><\/p>\n

    cout<<“Latimea=”; cin>>l;<\/b><\/span><\/p>\n

    cout<<“Inaltimea=”; cin>>h;<\/b><\/span><\/p>\n

    getch(); <\/b><\/span>\/\/ in C++ sub DOS permite vizualizarea rezultatului programului\/\/<\/span><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    Exemplul 2:<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    int L,l,h,v;<\/b><\/span><\/p>\n

    clrscr();<\/b><\/span><\/p>\n

    cout<<“Lungimea=” ; cin>>L;<\/b><\/span><\/p>\n

    cout<<“Latimea=”; cin>>l;<\/b><\/span><\/p>\n

    cout<<“Inaltimea=”; cin>>h;<\/b><\/span><\/p>\n

    v=L*l*h;<\/b><\/span><\/p>\n

    cout<<“Volumul este”<<” “<<v;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    2. TIPURI DE DATE.<\/u><\/span><\/span><\/strong><\/p>\n

    2.1. TIPURI INTREGI.<\/b><\/u><\/span><\/p>\n

    – int <\/b><\/span>(tip intreg care ocupa 16 biti)<\/span><\/p>\n

    – long<\/b><\/span> (tip intreg care ocupa 32 de biti)<\/span><\/p>\n

    – unsigned int <\/b><\/span>sau <\/span>unsigned long<\/b><\/span> (valorile datelor sunt fara semn, adica pozitive)<\/span><\/p>\n

    – <\/b><\/span>char<\/b><\/span> (tip caracter, aceste date se pun intre doua apostrofuri ‘ ‘ )<\/span><\/p>\n

    2.2. TIPURI REALE<\/b><\/u><\/span><\/p>\n

    – float <\/b><\/span>(tip real care retin si numerele zecimale , ocupa 32 biti)<\/span><\/p>\n

    ATENTIE!! <\/b><\/span>IN C++ LA SCRIEREA UNUI NUMAR ZECIMAL IN LOCUL VIRGULEI SE PUNE PUNCT<\/b><\/span><\/span><\/p>\n

    – double <\/b><\/span>( tip real care ocupa 64 biti)<\/span><\/p>\n

    – long double<\/b><\/span> (tip real care ocupa 80 biti)<\/span><\/p>\n

    2.3. CONSTANTE<\/b><\/u><\/span><\/p>\n

    Pentru a da un nume constantelor se foloseste declaratia <\/span>const <\/b><\/span> care are forma:<\/span><\/p>\n

    const [tip] nume=valoare ;<\/b><\/span><\/p>\n

    [tip]<\/b><\/span> – tipul constantei ; <\/span>nume <\/b><\/span>-numele constantei ; <\/span>valoare<\/b><\/span> – valoarea constantei<\/span><\/p>\n

    Exemplu:<\/span><\/p>\n

    const float a=12.6<\/b><\/span> constanta este de tip <\/span>float<\/b><\/span>, poarta denumirea <\/span>a<\/b><\/span>, are valoarea <\/span>12,6<\/b><\/span><\/p>\n

    3. OPERATORI C++<\/b><\/u><\/span><\/span><\/p>\n

    3.1. OPERATORI ARITMETICI.<\/b><\/u><\/span><\/p>\n

    + <\/b><\/span>(adunare) ; <\/span>– <\/b><\/span>(scadere) ; <\/span>* <\/b><\/span>(inmultire) ; <\/span>\/ <\/b><\/span>(impartire) ; <\/span>%<\/b><\/span> (restul impartirii intregi)<\/span><\/p>\n

    3.2. OPERATORI RELATIONALI.<\/b><\/u><\/span><\/p>\n

    <<\/b><\/span> (mai mic) ; <\/span><= <\/b><\/span>(mai mic sau egal) ; <\/span>> <\/b><\/span>(mai mare) ; <\/span>>=<\/b><\/span> (mai mare sau egal)<\/span><\/p>\n

    3.3. OPERATORI DE EGALITATE.<\/b><\/u><\/span><\/p>\n

    ==<\/b><\/span> (egalitate) ; <\/span>!=<\/b><\/span> (inegalitate)<\/span><\/p>\n

    3.4. OPERATORI DE INCREMENTARE SI DECREMENTARE.<\/b><\/u><\/span><\/p>\n

    ++<\/b><\/span> (incrementare) ; <\/span>—<\/b><\/span> (decrementare)<\/span><\/p>\n

    Operatorii pot fi : <\/span>prefixati<\/b><\/span> (in fata operandului) <\/span>situatie in care variabila este incrementata sau decrementata inainte ca valoarea retinuta de ea sa intre in calcul<\/b><\/span><\/p>\n

    postfixati<\/b><\/span> (dupa operand)<\/span> situatie in care variabila este incrementata sau decrementata dupa ce valoarea retinuta de ea intra in calcul<\/b><\/span><\/p>\n

    Exemplu:<\/span><\/p>\n

    Daca <\/span>a<\/b><\/span> si <\/span>b<\/b><\/span> sunt variabile de tip <\/span>int<\/b><\/span> care retin valorile <\/span>1 <\/b><\/span> si <\/span>3<\/b><\/span> atunci:<\/span><\/p>\n

    a++*b++ <\/b><\/span>produce valoarea <\/span>3<\/b><\/span>, dupa evaluare cele 2 variabile retin <\/span>2 <\/b><\/span>si <\/span>4<\/b><\/span><\/p>\n

    ++a*++b<\/b><\/span> produce valoarea <\/span>8<\/b><\/span>, dupa evaluare cele 2 variabile retin <\/span>4<\/b><\/span> si <\/span>4<\/b><\/span><\/p>\n

    3.5. OPERATORI LOGICI<\/b><\/u><\/span><\/p>\n

    !<\/b><\/span> – negare logica ; <\/span>&&<\/b><\/span> – SI logic ; <\/span>|| <\/b><\/span>SAU logic<\/span><\/p>\n

    3.6. OPERATORI DE ATRIBUIRE<\/b><\/u><\/span><\/p>\n

    Apare foarte frecvent si reprezinta<\/span> memorarea unei valori intr-o variabila<\/b><\/span><\/p>\n

    Este reprezentata prin semnul <\/span>=<\/b><\/span><\/p>\n

    a=3<\/b><\/span> (atribuie variabilei <\/span>a <\/b><\/span>valoarea <\/span>3<\/b><\/span>)<\/span><\/p>\n

    Se mai utilizeaza <\/span>operatori de atribuire combinati:<\/b><\/span><\/p>\n

    += ; -= ; *= ; \/= ; %= ; &= ; <<= ; >>=<\/b><\/span><\/p>\n

    Exemplu: <\/span>a=a+b<\/b><\/span> este echivalent cu <\/span>a+=b <\/b><\/span>; <\/span>a=a*b<\/b><\/span> este echivalent cu <\/span>a*=b<\/b><\/span><\/p>\n

    3.7. OPERATORUL CONDITIONAL.<\/b><\/u><\/span><\/p>\n

    Forma generala <\/span>e1 ? e2 : e3<\/b><\/span><\/p>\n

    Se evalueaza <\/span>e1<\/b><\/span>, daca este <\/span>adevarata<\/b><\/span> se executa <\/span>e2<\/b><\/span>, daca este <\/span>falsa <\/b><\/span>se executa <\/span>e3<\/b><\/span><\/p>\n

    Exemplu: Citirea unuui numar x si tiparirea numarului |x| (modulul numarului x)<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/span><\/p>\n

    void main() <\/b><\/span><\/span><\/p>\n

    {<\/b><\/span><\/span><\/p>\n

    float x;<\/b><\/span><\/span><\/p>\n

    clrscr();<\/b><\/span><\/span><\/p>\n

    cout<<“x=” ; cin>>x; cout<<“|x|=”<<” “<<(x>=0?x:-x);<\/b><\/span><\/span><\/p>\n

    getch();<\/b><\/span><\/span><\/p>\n

    }<\/b><\/span><\/span><\/p>\n

    D<\/b><\/span><\/span>. INSTRUCTIUNILE LIMBAJULUI C++<\/b><\/span><\/span><\/p>\n

    1. INSTRUCTIUNEA EXPRESIE.<\/b><\/u><\/span><\/p>\n

    Exemplul1. Interschimbarea continutului a 2 variabile care au fost initial citite.<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    int a,b,m;<\/b><\/span><\/p>\n

    clrscr();<\/b><\/span><\/p>\n

    cout<<“a=” ; cin>>a;<\/b><\/span><\/p>\n

    cout<<“b=”; cin>>b;<\/b><\/span><\/p>\n

    m=a,a=b,b=m;<\/b><\/span><\/p>\n

    cout<<“a=”<<” “<<a<<endl;<\/b><\/span><\/p>\n

    cout<<“b=”<<” “<<b;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    Exemplul2. Se citesc 3 valori intregi<\/span>a,b,c<\/b><\/span> si se afiseaza media lor aritmetica<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    int a,b,c;<\/b><\/span><\/p>\n

    float m;<\/b><\/span><\/p>\n

    clrscr();<\/b><\/span><\/p>\n

    cout<<“a=” ; cin>>a;<\/b><\/span><\/p>\n

    cout<<“b=”; cin>>b;<\/b><\/span><\/p>\n

    cout<<“c=” ; cin>>c;<\/b><\/span><\/p>\n

    m=float(a+b+c)\/3;<\/b><\/span><\/p>\n

    cout<<“media aritmetica =”<<” “<<m;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    2. INSTRUCTIUNEA IF.<\/b><\/u><\/span><\/p>\n

    Forma generala:<\/span><\/p>\n

    if (<\/b><\/span>expresie<\/span>)<\/b><\/span> instructiune1<\/span> else <\/b><\/span>instructiune2<\/span><\/p>\n

    Se evalueaza expresia, daca este<\/span>adevarata<\/b><\/span> se executa <\/span>instructiune1<\/b><\/span>, daca este <\/span>falsa<\/b><\/span> se executa <\/span>instructiune2<\/b><\/span><\/p>\n

    Exemplul 1. Calculeaza maximul dintre 2 numere citite<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    int a,b,max;<\/b><\/span><\/p>\n

    clrscr();<\/b><\/span><\/p>\n

    cout<<“a=” ; cin>>a;<\/b><\/span><\/p>\n

    cout<<“b=”; cin>>b;<\/b><\/span><\/p>\n

    if(a>b) max=a;<\/b><\/span><\/p>\n

    else max=b;<\/b><\/span><\/p>\n

    cout<<“numarul mai mare este “<<” “<<max;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    Exemplul 2. Se citesc coeficientii <\/span>a, b, c<\/b><\/span> ale unei ecuatii de gradul doi si se precizeaza natura radacinilor si semnul lor.<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<math.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    float a,b,c,d,s,p;<\/b><\/span><\/p>\n

    clrscr();<\/b><\/span><\/p>\n

    cout<<“a=”;cin>>a;cout<<“b=”;cin>>b;cout<<“c=”;cin>>c;<\/b><\/span><\/p>\n

    d=b*b-4*a*c; s=float(-b\/a); p=float(c\/a);<\/b><\/span><\/p>\n

    cout<<“Discriminantul ecuatiei D=”<<d<<endl;<\/b><\/span><\/p>\n

    cout<<“Produsul radacinilor P=”<<p<<endl;<\/b><\/span><\/p>\n

    cout<<“Suma radacinilor S=”<<s<<endl;<\/b><\/span><\/p>\n

    if(d<0) cout<<“Ecuatia nu are solutii reale”;<\/b><\/span><\/p>\n

    else<\/b><\/span><\/p>\n

    { if(d==0) {if(s>0) cout<<“Ecuatia are 2 solutii reale egale si pozitive”;<\/b><\/span><\/p>\n

    else cout<<“Ecuatia are 2 solutii reale egale si negative”;<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    else<\/b><\/span><\/p>\n

    if(p>0)<\/b><\/span><\/p>\n

    {if(s>0) cout<<“Ecuatia are 2 solutii reale pozitive”;<\/b><\/span><\/p>\n

    else cout<<“Ecuatia are 2 solutii reale negative”;<\/b><\/span><\/p>\n

    <\/b> }<\/b><\/span><\/p>\n

    else cout<<“Ecuatia are 2 solutii reale de semne opuse”;<\/b><\/span><\/p>\n

    } <\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    Exemplul 3. Rezolvarea unei ecuatii de gradul 1.<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    float a,b,x;<\/b><\/span><\/p>\n

    clrscr();<\/b><\/span><\/p>\n

    cout<<“a=” ; cin>>a;<\/b><\/span><\/p>\n

    cout<<“b=”; cin>>b;<\/b><\/span><\/p>\n

    if (a!=0)<\/b><\/span><\/p>\n

    {x= -b\/a ;cout<<“x=”<<” “<<x; }<\/b><\/span><\/p>\n

    else<\/b><\/span><\/p>\n

    if(b==0) cout<<“ecuatia are o infinitate de solutii”;<\/b><\/span><\/p>\n

    else cout<<“ecuatia nu are solutie”;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    Exemplul 4<\/span>. Rezolvarea unei ecuatii de gradul 2.<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    #include<math.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    float a,b,c,d,x1,x2,x; <\/b><\/span><\/p>\n

    clrscr();<\/b><\/span><\/p>\n

    cout<<“a=” ; cin>>a;<\/b><\/span><\/p>\n

    cout<<“b=”; cin>>b;<\/b><\/span><\/p>\n

    cout<<“c=” ; cin>>c;<\/b><\/span><\/p>\n

    d=float( b*b-4*a*c);cout<<“discriminantul ecuatiei este”<<” “<<sqrt(d)<<endl;<\/b><\/span><\/p>\n

    if(d<0) {cout<<“ecuatia nu are solutii reale”;}<\/b><\/span><\/p>\n

    else<\/b><\/span><\/p>\n

    if (d>0)<\/b><\/span><\/p>\n

    { x1=(-b+sqrt(d)) \/ (2*a) ; x2=(-b-sqrt(d)) \/ (2*a);<\/b><\/span><\/p>\n

    cout<<“x1=”<<x1<<endl;cout<<“x2=”<<x2<<endl;}<\/b><\/span><\/p>\n

    else<\/b><\/span><\/p>\n

    {x=float(-b\/2*a);cout<<“ecuatia are solutie unica x=x1=x2=”<<” “<<x;}<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    3. INSTRUCTIUNEA SWITCH.<\/b><\/u><\/span><\/p>\n

    Forma generala a instructiunii:<\/span><\/p>\n

    switch<\/b><\/span> (<\/b><\/span>expresie<\/span>) {<\/b><\/span><\/p>\n

    case <\/b><\/span>e1<\/span> : <\/b><\/span>secventa 1 <\/span>; break;<\/b><\/span><\/p>\n

    case <\/b><\/span>e2 <\/span>: <\/b><\/span>secventa 2 <\/span>; break;<\/b><\/span><\/p>\n

    ……………………………………….<\/b><\/span><\/p>\n

    case <\/b><\/span>en <\/span>: <\/b><\/span>secventa n <\/span>; break;<\/b><\/span><\/p>\n

    default : <\/b><\/span>secventa n+1<\/span>;<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    Se evalueaza <\/span>expresie <\/b><\/span>, daca <\/span>este egala<\/b><\/span> cu una din expresiile <\/span>e1, e2, …en<\/b><\/span> se executa secventa corespunzatoare expresiei <\/span>s1, s2, …sn<\/b><\/span>, iar daca <\/span>nu este egala <\/b><\/span>cu una din aceste expresii se executa numai <\/span>secventa n+1<\/b><\/span><\/p>\n

    Exemplul 1. <\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    int i;<\/b><\/span><\/p>\n

    clrscr();<\/b><\/span><\/p>\n

    cin>>i;<\/b><\/span><\/p>\n

    switch(i)<\/b><\/span><\/p>\n

    { case 1: cout<<“Am citit 1”;break;<\/b><\/span><\/p>\n

    case 2: cout<<“Am citit 2”;break;<\/b><\/span><\/p>\n

    default: cout<<“Am citit altceva”;<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    Exemplul2. Se afiseaza nat<\/span>ura sol. unei ec. de gr.2 in functie de semnul lui \u2206. <\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    int a,b,c,d;<\/b><\/span><\/p>\n

    clrscr();<\/b><\/span><\/p>\n

    cout<<“a=”;cin>>a;cout<<“b=”;cin>>b;cout<<“c=”;cin>>c;<\/b><\/span><\/p>\n

    d=b*b-4*a*c;<\/b><\/span><\/p>\n

    if(d>=0)<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    switch(d)<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    case 0: cout<<“Ecuatia are o solutie dubla”;break;<\/b><\/span><\/p>\n

    default:cout<<“Ecuatia are doua solutii reale diferite”;<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    else cout<<“Ecuatia nu are solutii reale”;<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    4. INSTRUCTIUNEA WHILE.<\/b><\/u><\/span><\/p>\n

    Aceasta instructiune permite programarea ciclurilor cu test initial.<\/span><\/p>\n

    Forma generala este:<\/span><\/p>\n

    while (<\/b><\/span>expresie<\/span>) <\/b><\/span><\/p>\n

    {……. instructiuni }<\/b><\/span><\/p>\n

    Se evalueaza <\/span>expresie<\/b><\/span>, daca este <\/span>adevarata<\/b><\/span> se executa <\/span>{….instructiuni} <\/b><\/span>dupa care se revine la evaluarea expresiei , daca este <\/span>falsa<\/b><\/span> se trece la instructiune urmatoare.<\/span><\/p>\n

    Exemplu<\/span>. Executarea unui program intr-un ciclu repetat pana la apasarea unei anumite taste(se introduc coeficientii unei ec. de gr.2 si se afiseaza solutiile de “n” ori pina la apasarea tastei “q”)<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    #include<math.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    float a,b,c,d,x1,x2,x;<\/b><\/span><\/p>\n

    int tasta;<\/b><\/span><\/p>\n

    while(tasta!=’q’)<\/b><\/span><\/p>\n

    { <\/b><\/span><\/p>\n

    clrscr();<\/b><\/span><\/p>\n

    cout<<“a=” ; cin>>a;<\/b><\/span><\/p>\n

    cout<<“b=”; cin>>b;<\/b><\/span><\/p>\n

    cout<<“c=” ; cin>>c;<\/b><\/span><\/p>\n

    d=float( b*b-4*a*c);cout<<“discriminantul ecuatiei este”<<” “<<sqrt(d)<<endl;<\/b><\/span><\/p>\n

    if(d<0) {cout<<“ecuatia nu are solutii reale”;}<\/b><\/span><\/p>\n

    else<\/b><\/span><\/p>\n

    if (d>0)<\/b><\/span><\/p>\n

    { x1=(-b+sqrt(d))\/(2*a) ; x2=(-b-sqrt(d))\/(2*a);<\/b><\/span><\/p>\n

    cout<<“x1=”<<x1<<endl;cout<<“x2=”<<x2<<endl;}<\/b><\/span><\/p>\n

    else<\/b><\/span><\/p>\n

    {x=float(-b\/2*a);cout<<“ecuatia are solutie unica x=x1=x2=”<<” “<<x<<endl;}<\/b><\/span><\/p>\n

    cout<<“Pentru continuare apasa o tasta”<<endl;<\/b><\/span><\/p>\n

    cout<<“Pentru iesire apasa tasta q”;<\/b><\/span><\/p>\n

    tasta=getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    5. INSTRUCTIUNEA DO WHILE.<\/b><\/u><\/span><\/p>\n

    Instructiunea permite programarea ciclurilor cu test final.<\/span><\/p>\n

    Forma generala este:<\/span><\/p>\n

    do<\/b><\/span><\/p>\n

    { instructiuni }<\/b><\/span><\/p>\n

    while ( <\/b><\/span>expresie <\/span>)<\/b><\/span><\/p>\n

    Se executa <\/span>{ instructiuni }<\/b><\/span> , se evalueaza <\/span>expresie<\/b><\/span>, daca este <\/span>adevarata<\/b><\/span> se executa din nou <\/span>{instructiuni}<\/b><\/span>, iar daca este <\/span>falsa<\/b><\/span> executia instructiunii <\/span>do <\/b><\/span>se termina.<\/span><\/p>\n

    Exemplu: Se citeste numarul natural <\/span>n<\/b><\/span> si se afiseaza suma primelor <\/span>n<\/b><\/span> numere naturale<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    long n, tasta,s=0,i=1;<\/b><\/span><\/p>\n

    while(tasta!=’q’)<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    clrscr();<\/b><\/span><\/p>\n

    cout<<“n=”;cin>>n;<\/b><\/span><\/p>\n

    do<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    s=s+i; i=i+1;<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    while(i<=n);<\/b><\/span><\/p>\n

    cout<<“Suma primelor n numere naturale este”<<” “<<s<<endl;<\/b><\/span><\/p>\n

    cout<<“Pentru a continua apasa o tasta”<<endl<<“Pentru a iesi din program apasa tasta ‘q'”;<\/b><\/span><\/p>\n

    tasta=getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    6. INSTRUCTIUNEA FOR<\/b><\/u><\/span><\/p>\n

    Se utilizeaza cel mai fracvent pentru programarea ciclurilor cu test initial.<\/span><\/p>\n

    Forma generala:<\/span><\/p>\n

    for(<\/b><\/span> e<\/span>INITIALIZARE<\/b><\/span><\/sub>; e<\/span>TEST<\/b><\/span><\/sub>; e<\/span>INCREMENTARE<\/b><\/span><\/sub>) instructiune<\/b><\/span><\/p>\n

    e<\/b><\/span>INITIALIZARE<\/b><\/span><\/sub> – se evalueaza o singura data pentru <\/span>initializarea<\/b><\/span> variabilei de ciclare inaintea primului ciclu ;<\/span><\/p>\n

    e<\/b><\/span>TEST<\/b><\/span><\/sub> – este evaluata inaintea fiecarui ciclu pentru <\/span>a testa <\/b><\/span>daca se executa instructiunea subordonata si reprezinta conditia de iesire din ciclu;<\/span><\/p>\n

    e<\/b><\/span>INCREMENTARE<\/b><\/span><\/sub> – se evalueaza la sfirsitul fiecarui ciclu pentru <\/span>incrementarea<\/b><\/span> variabilei de ciclare.<\/span><\/p>\n

    Principiul de executie:<\/span><\/p>\n

    Se evalueaza<\/span> e<\/b><\/span>INITIALIZARE<\/b><\/span><\/sub> <\/b>(numai la prima rulare), se evalueaza <\/span>e<\/b><\/span>TEST<\/b><\/span><\/sub> , daca este <\/span>adevarata <\/b><\/span> se executa <\/span>instructiunea<\/b><\/span> subordonata <\/span>for<\/b><\/span>, se evalueaza <\/span>e<\/b><\/span>INCREMENTARE<\/b><\/span><\/sub> si se revine la evaluarea expresiei <\/span>e<\/b><\/span>TEST<\/b><\/span><\/sub>. Daca <\/span>e<\/b><\/span>TEST<\/b><\/span><\/sub> este <\/span>falsa<\/b><\/span> se trece la urmatoarea instructiune (se termina executarea instructiunii <\/span>for<\/b><\/span>)<\/span><\/p>\n

    Observatie.<\/b><\/span> Daca expresia <\/span>e<\/b><\/span>TEST<\/b><\/span><\/sub> este <\/span>vida<\/b><\/span> se executa un ciclu infinit. Pentru a iesi din acest ciclu : <\/span>in DOS<\/b><\/span> se tasteaza <\/span>CTRL+PAUSE<\/b><\/span><\/p>\n

    in WINDOWS<\/b><\/span> se tasteaza <\/span>CTRL +ALT + DEL<\/b><\/span><\/p>\n

    Exemplul 1.<\/span> Se introduce de la tastatura numarul <\/span>n <\/b><\/span>si se calculeaza <\/span>suma<\/b><\/span> si <\/span>produsul <\/b><\/span>primelor <\/span>n <\/b><\/span>numere <\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    { N<\/b><\/span>2<\/b><\/span><\/sup><\/p>\n

    int i,n,tasta;<\/b><\/span><\/p>\n

    long double a,b;<\/b><\/span><\/p>\n

    while(tasta !=’q’) {<\/b><\/span><\/p>\n

    clrscr();<\/b><\/span><\/p>\n

    cout<<“Introduceti numarul”<<“”;cin>>n;<\/b><\/span><\/p>\n

    a=b=1;<\/b><\/span><\/p>\n

    for(i=2;i<=n;i++)<\/b><\/span><\/p>\n

    {a*=i;b+=i;}<\/b><\/span><\/p>\n

    cout<<“suma=”<<b<<endl;cout<<“produsul=”<<a<<endl;<\/b><\/span><\/p>\n

    cout<<“Pentru iesire apasa tasta q”;<\/b><\/span><\/p>\n

    tasta=getch(); }<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    Observatie.<\/b> Variabila n<\/b> poate fi definita la inceput fara a mai trebui introdusa de la tastatura utilizand #define n valoare <\/b>(comanda se scrie inainte de void main()<\/b> )<\/span><\/p>\n

    Exemplul2. Afisarea literelor alfabetului<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    char litere;<\/b><\/span><\/p>\n

    for(litere=’A’;litere<=’Z’;litere++)cout<<litere<<” “;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    Exemplul3. Afiseaza toate patratele si radicalii numerelor naturale pina la numarul <\/span>n<\/b><\/span> introdus de la tastatura.<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    #include<math.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    float i,n,a,b;<\/b><\/span><\/p>\n

    clrscr();<\/b><\/span><\/p>\n

    cout<<“n=”;cin>>n;<\/b><\/span><\/p>\n

    a=b=0;<\/b><\/span><\/p>\n

    for(i=1 ;i<=n;i++) {<\/b><\/span><\/p>\n

    a=sqrt(i) ; b=i*i;<\/b><\/span><\/p>\n

    cout<<“Patratul numarului”<<” “<<i<<” = “<<b<<‘\\t'<<<\/b><\/span><\/p>\n

    “Radicalul numarului”<<” “<<i<<” =”<<a<<endl;<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    Exemplul4.<\/span><\/p>\n

    7. INSTRUCTIUNI DE SALT<\/b><\/u><\/span><\/p>\n

    7.1. INSTRUCTIUNEA BREAK<\/b><\/u><\/span><\/p>\n

    Se utilizeaza pentru intreruperea neconditionata a unei secvente si numai in 2 contexte:<\/span><\/p>\n

    1) <\/b><\/span>in instructiunea <\/span>switch<\/b><\/span> pentru a marca incheierea secventei de instructiuni asociate unei selector <\/span>case<\/b><\/span> ;<\/span><\/p>\n

    2)<\/b><\/span> intr-o instructiune de ciclare (<\/span>while, do while, for<\/b><\/span>) pentru a determina iesirea fortata din ciclul respectiv. <\/span><\/p>\n

    Observatie.<\/b><\/span> Instructiunea <\/span>break<\/b><\/span> intrerupe executia de ciclare doar a blocului in care se afla, fara a afecta celelalte blocuri de ciclare in cazul ciclurilor imbricate.<\/span><\/p>\n

    7.2. INSTRUCTIUNEA CONTINUE<\/b><\/u><\/span><\/p>\n

    Se utilizeaza numai in blocul instructiunilor de ciclare pentru<\/span> a intrerupe executia iteratiei curente (sarind peste instructiunea urmatoare) dupa care:<\/span><\/p>\n

    – <\/b><\/span>in cazul instructiunilor <\/span>while<\/b><\/span> si <\/span>do while<\/b><\/span> se continua cu testarea conditiei de ciclare;<\/span><\/p>\n

    –<\/b><\/span> in cazul instructiunii <\/span>for<\/b><\/span> se continua cu evaluarea expresiei <\/span>e<\/b><\/span>INCREMENTARE<\/b><\/span><\/sub> (actualizarea contorilor) si apoi a expresiei <\/span>e<\/b><\/span>TEST<\/b><\/span><\/sub> (testarea conditiei de ciclare)<\/span><\/p>\n

    7.3. INSTRUCTIUNEA GO TO<\/b><\/u><\/span><\/p>\n

    Are ca efect intreruperea secventei curente si continuarea executiei de la instructiunea care este specificata dupa <\/span>go to<\/b><\/span>.<\/span><\/p>\n

    Observatie.<\/b><\/span> Instructiunile de salt se utilizeaza rar in C++ deoarece incalaca principiile programarii structurate, pentru abandonarea executiei unui ciclu se utilizeaza in general functiile <\/span>exit()<\/b><\/span> sau <\/span>return<\/b><\/span>.<\/span><\/p>\n

    E. TIPURI DE DATE STRUCTURATE<\/b><\/span><\/span><\/p>\n

    1. TABLOURI<\/b><\/u><\/span><\/p>\n

    1.1. TABLOURI IN C++<\/b><\/u><\/span><\/p>\n

    Tabloul este o lista de elemente de acelasi tip plasate succesiv intr-o zona de memorie.<\/span><\/p>\n

    Tablo<\/span>urile por fii : <\/span>simple (vector)<\/b><\/span> sau <\/span>multiple<\/b><\/span> (matrice)<\/b><\/span><\/p>\n

    Exemple:<\/b><\/span><\/p>\n

    – int v[10] ;<\/b><\/span> am declarat un vector cu <\/span>10<\/b><\/span> componente de <\/span>tip intreg<\/b><\/span> care au indici intre <\/span>0<\/b><\/span> si <\/span>9 , v[0], v[1],………v[9]<\/b><\/span><\/p>\n

    – float a[10], b[20] ;<\/b><\/span> am declarat doi vectori <\/span>a<\/b><\/span> si <\/span>b<\/b><\/span> care au <\/span>10<\/b><\/span> respectiv <\/span>20 <\/b><\/span>de componente de tip <\/span>real<\/b><\/span><\/p>\n

    – int a[10][20] ;<\/b><\/span> am declarat o matrice cu <\/span>10 linii <\/b><\/span>si <\/span>20 coloane<\/b><\/span> cere se adreseaza astfel:<\/span><\/p>\n

    a[0][0], a[0][1], a[0][2],………..a[9][19]<\/b><\/span>.<\/span><\/p>\n

    Un tablou poate fi <\/span>initializat<\/b><\/span> cu un set de valori astfel:<\/span><\/p>\n

    – int a[5]={-2,4,8,1,9} ;<\/b><\/span><\/p>\n

    – int b[3][4]={ {11,12,13,14}, {21,22,23,24}, {31,32,33,34} } ;<\/b><\/span><\/p>\n

    Exemplul1. Afisarea unei matrici cu componentele declarate initial.<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    int a[3][3]={11,12,13,21,22,23,31,32,33};<\/b><\/span><\/p>\n

    int i,j;<\/b><\/span><\/p>\n

    for(i=0;i<3;i++){<\/b><\/span><\/p>\n

    for(j=0;j<3;j++)<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    cout<<a[i][j]<<‘ ‘;<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    cout<<endl;<\/b><\/span><\/p>\n

    } <\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    Rezultatul programului va fii afisarea urmatoarei matrici:<\/span><\/p>\n

    11 12 13<\/b><\/span><\/p>\n

    21 22 23<\/b><\/span><\/p>\n

    31 32 33<\/b><\/span><\/p>\n

    Exemplul2. Se introduce numarul de linii <\/span>m<\/b><\/span> si numarul de coloane <\/span>n <\/b><\/span>ale unei matrici, se intoduc elementele matricii apoi se afiseaza matricea creata.<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    int i,j,m,n,a[10][10];<\/b><\/span><\/p>\n

    clrscr();<\/b><\/span><\/p>\n

    cout<<“Introduceti numarul de linii”<<” “<<“n=”;cin>>m;<\/b><\/span><\/p>\n

    cout<<“Introduceti numarul de coloane”<<” “<<“n=”;cin>>n;<\/b><\/span><\/p>\n

    cout<<“Intoduceti elementele”<<endl;<\/b><\/span><\/p>\n

    for(i=1;i<=m;i++) {<\/b><\/span><\/p>\n

    for(j=1;j<=n;j++) {<\/b><\/span><\/p>\n

    cout<<“a[“<<i<<j<<“]=”, cin>>a[i][j];<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    cout<<“Matricea intodusa are forma:”<<endl<<‘\\t'<<‘\\t'<<‘\\t'<<‘\\t’;<\/b><\/span><\/p>\n

    for(i=1;i<=m;i++){<\/b><\/span><\/p>\n

    for(j=1;j<=n;j++) {<\/b><\/span><\/p>\n

    cout<<a[i][j]<<‘ ‘;<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    cout<<endl<<‘\\t'<<‘\\t'<<‘\\t'<<‘\\t’;<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    Exemplul3. Se introduc valorile componentelor unui vector <\/span>a[100]<\/b><\/span> si se atribuie aceste valori componentelor vectorului <\/span>b[100]<\/b><\/span>.<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    int n,i,a[100],b[100];<\/b><\/span><\/p>\n

    clrscr();<\/b><\/span><\/p>\n

    cout<<“Introduceti numarul de componente n=”<<” “;cin>>n;<\/b><\/span><\/p>\n

    for(i=1;i<=n;i++)<\/b><\/span><\/p>\n

    { cout<<“a[“<<i<<“]=”;cin>>a[i];}<\/b><\/span><\/p>\n

    for(i=1;i<=n;i++) b[i]=a[i];<\/b><\/span><\/p>\n

    cout<<endl;<\/b><\/span><\/p>\n

    for(i=1;i<=n;i++) cout<<“b[“<<i<<“]=”<<b[i]<<‘\\t’;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    1.2. ALGORITMI FUNDAMANTALI CARE LUCREAZA CU VECTORI.<\/b><\/u><\/span><\/p>\n

    1.2.1. MAXIM, MINIM.<\/b><\/u><\/span><\/p>\n

    O variabila preia continutul primei componente a vectorului (<\/span>max=v[0]<\/b><\/span> sau <\/span>min=v[0]<\/b><\/span>), apoi o compara pe rind cu celelalte componente ale vectorului, iar in functie de conditia care se pune in program variabila va retine componenta cu valoare maxima sau componente cu valoare minima.<\/span><\/p>\n

    Pentru <\/span>maxim<\/b><\/span> :<\/span><\/p>\n

    max=v[0] ; if(v[i]>max) max=v[i]<\/b><\/span><\/p>\n

    Pentru<\/span> minim<\/b><\/span> ;<\/span><\/p>\n

    min=v[0] ; if(v[i]<min) min=v[i]<\/b><\/span><\/p>\n

    Exemplu. Se introduc valorile componentelor unui vector si se afiseaza valoarea maxima si valoarea minima.<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    int max,min,n,i,v[100];<\/b><\/span><\/p>\n

    cout<<“Introduceti numarul de elemente n=”; cin>>n;<\/b><\/span><\/p>\n

    for(i=1;i<=n;i++)<\/b><\/span><\/p>\n

    {cout<<“v[“<<i<<“]=”;cin>>v[i];}; <\/b><\/span><\/p>\n

    max=v[0];<\/b><\/span><\/p>\n

    for(i=1;i<=n;i++) if(v[i]>max) max=v[i] ;<\/b><\/span><\/p>\n

    cout<<“Valoarea maxima citita este”<<” “<<max<<endl;<\/b><\/span><\/p>\n

    min=v[0];<\/b><\/span><\/p>\n

    for(i=1;i<=n;i++) if(v[i]<min) min=v[i];<\/b><\/span><\/p>\n

    cout<<“Valoarea minima citita este”<<” “<<min; <\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    1.2.2. ELEMENTE DISTINCTE.<\/b><\/u><\/span><\/p>\n

    Se citeste un vector cu <\/span>n componente<\/b><\/span> si se decide daca numerele citite sunt distincte (nu exista doua numere egale) sau daca nu sunt distincte (exista doua numere egale).<\/span><\/p>\n

    Pentru a rezolva problema se procedeaza astfel:<\/span><\/p>\n

    – o variabila <\/span>i<\/b><\/span> retine indicele <\/span>primei componente<\/b><\/span><\/p>\n

    – o variabila <\/span>j<\/b><\/span> retine indicele <\/span>urmatoarelor componente<\/b><\/span><\/p>\n

    Ex: cand <\/span>i=1 j=2,3,……..n<\/b><\/span><\/p>\n

    cand <\/span>i=2 j=3,4,……..n<\/b><\/span><\/p>\n

    cand <\/span>i=n j=n-1<\/b><\/span><\/p>\n

    – se initializeaza o variabila <\/span>gasit<\/b><\/span> cu valoarea logica <\/span>0<\/b><\/span><\/p>\n

    –<\/b><\/span>– daca sunt gasite doua valori egale variabilei <\/span>gasit<\/b><\/span> i se atribuie vloarea logica <\/span>1<\/b><\/span><\/p>\n

    Exemplu.<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    int v[10],i,j,n,gasit;<\/b><\/span><\/p>\n

    cout<<“introduceti numarul de elemente n=”<<” “; cin>>n;<\/b><\/span><\/p>\n

    for(i=1;i<=n;i++)<\/b><\/span><\/p>\n

    { cout<<“v[“<<i<<“]=”; cin>>v[i]; }<\/b><\/span><\/p>\n

    gasit=0;<\/b><\/span><\/p>\n

    for(i=1;i<=n ;i++)<\/b><\/span><\/p>\n

    for(j=i+1;j<=n ;j++)<\/b><\/span><\/p>\n

    if(v[i]==v[j]) gasit=1;<\/b><\/span><\/p>\n

    if(gasit) cout<<“Numerele nu sunt distincte”;<\/b><\/span><\/p>\n

    else cout<<“Numerele sunt distincte”;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    } <\/b><\/span><\/p>\n

    1.2.3. MULTIMI.<\/b><\/u><\/span><\/p>\n

    In cadrul unei multimi un element<\/span>apare o singura data<\/b><\/span> (o multime nu poate avea 2 valori egale). Elementele unei multimi sunt memorate intr-o variabila de tip vector.<\/span><\/p>\n

    Aplicatii:<\/b><\/span><\/p>\n

    Exemplul 1. Se citeste o multime <\/span>A <\/b><\/span>care contine <\/span>n<\/b><\/span> elemente numere intregi ,<\/span> <\/b>se citeste un numar intreg <\/span>e , <\/b><\/span>se verifica daca numarul <\/span>e<\/b><\/span> apartine multimii <\/span>a.<\/b><\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    int A<\/b><\/span>[10],n,e,i,j,gasit;<\/b><\/span><\/p>\n

    clrscr();<\/b><\/span><\/p>\n

    cout<<“Introduceti numarul de elemente n a multimii”<<” “<<“n=” ; cin>>n;<\/b><\/span><\/p>\n

    for(i=1;i<=n;i++) { cout<<“A[“<<i<<“]=”; cin>>A[i]; }<\/b><\/span><\/p>\n

    cout<<“Introduceti numarul considerat”<<” “<<“e=”; cin>>e;<\/b><\/span><\/p>\n

    gasit=0;<\/b><\/span><\/p>\n

    for(i=1;i<=n;i++)<\/b><\/span><\/p>\n

    for(j=i+1;j<=n;j++)<\/b><\/span><\/p>\n

    if(A<\/b><\/span>[i]==e) gasit=1;<\/b><\/span><\/p>\n

    if(gasit) cout<<“Numarul”<<” “<< e<<” apartine multimii”;<\/b><\/span><\/p>\n

    else cout<<“Numarul”<<” “<<e<<” nu apartine multimii”;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    Exemplul2. Se citeasc multimile <\/span>A <\/b><\/span>si <\/span>B<\/b><\/span> si se afiseaza multimea <\/span>C<\/b><\/span> unde <\/span>C = A- B<\/b><\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    int A[10],B[10],C[10],m,n,i,j,z,k,gasit;<\/b><\/span><\/p>\n

    clrscr();<\/b><\/span><\/p>\n

    cout<<“Specificati numarul de elemente a multimii A”<<” “<<“m=”; cin>>m;<\/b><\/span><\/p>\n

    cout<<“Specificati numarul de elemente a multimii B”<<” “<<“n=”; cin>>n;<\/b><\/span><\/p>\n

    cout<<“Introduceti elementele multimii A”<<endl;<\/b><\/span><\/p>\n

    for(i=1;i<=m;i++) { cout<<“A[“<<i<<“]=”; cin>>A[i];};<\/b><\/span><\/p>\n

    cout<<“Introduceti elementele multimii B”<<endl;<\/b><\/span><\/p>\n

    for(j=1;j<=n;j++) { cout<<“B[“<<j<<“]=”; cin>>B[j];};<\/b><\/span><\/p>\n

    k=0;<\/b><\/span><\/p>\n

    for(i=1;i<=m;i++)<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    gasit=0;<\/b><\/span><\/p>\n

    for(j=1;j<=n;j++)<\/b><\/span><\/p>\n

    if(A[i]==B[j])gasit=1;<\/b><\/span><\/p>\n

    if(!gasit) C[k++]=A[i];<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    cout<<“A-B”<<” “<<“={“<<” “;<\/b><\/span><\/p>\n

    for(i=0;i<k;i++) cout<<C[i]<<” “; cout<<“}” ;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    Algoritmul de rezolvare este urmatorul:<\/b><\/span><\/p>\n

    Pentru fiecare element din multimea <\/span>A<\/b><\/span> se face testul daca apartine sau nu multimii <\/span>B<\/b><\/span>.<\/span> <\/b>Daca <\/span>nu apartine<\/b><\/span> este adaugat unei multimi <\/span>C<\/b><\/span> care initial este vida (variabila <\/span>k<\/b><\/span> cu valoare initiala <\/span>0<\/b><\/span> retine indicele componentei din <\/span>C<\/b><\/span> care va memora urmatorul element ce se adauga multimii <\/span>C<\/b><\/span>. In final se tipareste multimea <\/span>C<\/b><\/span>.<\/span><\/p>\n

    Exemplul3. Se citesc multimile <\/span>A<\/b><\/span> si <\/span>B<\/b><\/span> si se afiseaza multimea <\/span>C<\/b><\/span> unde <\/span>C=AUB<\/b><\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    int A[10],B[10],C[10],m,n,i,j,<\/b><\/span>k,gasit;<\/b><\/span><\/p>\n

    clrscr();<\/b><\/span><\/p>\n

    cout<<“Specificati numarul de elemente a multimii A”<<” “<<“m=”; cin>>m;<\/b><\/span><\/p>\n

    cout<<“Specificati numarul de elemente a multimii B”<<” “<<“n=”; cin>>n;<\/b><\/span><\/p>\n

    cout<<“Introduceti elementele multimii A”<<endl;<\/b><\/span><\/p>\n

    for(i=1;i<=m;i++) { cout<<“A[“<<i<<“]=”; cin>>A[i];};<\/b><\/span><\/p>\n

    cout<<“Introduceti elementele multimii B”<<endl;<\/b><\/span><\/p>\n

    for(j=1;j<=n;j++) { cout<<“B[“<<j<<“]=”; cin>>B[j];};<\/b><\/span><\/p>\n

    k=0;<\/b><\/span><\/p>\n

    for(i=1;i<=m;i++)<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    gasit=0;<\/b><\/span><\/p>\n

    for(j=1;j<=n;j++)<\/b><\/span><\/p>\n

    if(A[i]==B[j])gasit=1;<\/b><\/span><\/p>\n

    if(!gasit) C[k++]=A[i];<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    cout<<“AU<\/b><\/span>B”<<” “<<“={“<<” “;<\/b><\/span><\/p>\n

    for(j=1;j<=n;j++) cout<<B[j]<<” “;<\/b><\/span><\/p>\n

    for(i=0;i<k;i++) cout<<C[i]<<” “; cout<<“}” ;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    Algoritmul de rezolvare este urmatorul:<\/b><\/span><\/p>\n

    Se stie ca <\/span>AUB = BU(A – B)<\/b><\/span> sau <\/span>AUB=AU(B – A)<\/b><\/span><\/p>\n

    Se determina multimea <\/span>A-B <\/b><\/span>la fel ca in cazul precedent, apoi se listeaza multimea <\/span>B<\/b><\/span> si in continuare multimea <\/span>A – B<\/b><\/span>.<\/span><\/p>\n

    Exemplul4. Se citesc multimile <\/span>A<\/b><\/span> si <\/span>B<\/b><\/span> si se listeaza multimea <\/span>C<\/b><\/span> unde <\/span>C=A\u2229B<\/b><\/span><\/p>\n

    Algoritmul de rezolvare este urmatorul:<\/b><\/span><\/p>\n

    Pentru fiecare element din multimea <\/span>A<\/b><\/span> se face testul daca apartine sau nu multimii <\/span>B<\/b><\/span>.<\/span> <\/b>Daca <\/span> apartine<\/b><\/span> este adaugat unei multimi <\/span>C<\/b><\/span> care initial este vida (variabila <\/span>k<\/b><\/span> cu valoare initiala <\/span>0<\/b><\/span> retine indicele componentei din <\/span>C<\/b><\/span> care va memora urmatorul element ce se adauga multimii <\/span>C<\/b><\/span>. In final se tipareste multimea <\/span>C<\/b><\/span>.<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    int A[10],B[10],C[10],m,n,i,j,<\/b><\/span>k,gasit;<\/b><\/span><\/p>\n

    clrscr();<\/b><\/span><\/p>\n

    cout<<“Specificati numarul de elemente a multimii A”<<” “<<“m=”; cin>>m;<\/b><\/span><\/p>\n

    cout<<“Specificati numarul de elemente a multimii B”<<” “<<“n=”; cin>>n;<\/b><\/span><\/p>\n

    cout<<“Introduceti elementele multimii A”<<endl;<\/b><\/span><\/p>\n

    for(i=1;i<=m;i++) { cout<<“A[“<<i<<“]=”; cin>>A[i];};<\/b><\/span><\/p>\n

    cout<<“Introduceti elementele multimii B”<<endl;<\/b><\/span><\/p>\n

    for(j=1;j<=n;j++) { cout<<“B[“<<j<<“]=”; cin>>B[j];};<\/b><\/span><\/p>\n

    k=0;<\/b><\/span><\/p>\n

    for(i=1;i<=m;i++)<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    gasit=0;<\/b><\/span><\/p>\n

    for(j=1;j<=n;j++)<\/b><\/span><\/p>\n

    if(A[i]==B[j])gasit=1;<\/b><\/span><\/p>\n

    if(gasit) C[k++]=A[i];<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    cout<<“AnB”<<” “<<“={“<<” “;<\/b><\/span><\/p>\n

    for(i=0;i<k;i++) cout<<C[i]<<” “; cout<<“}” ;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    Exemplul5. Se citesc multimile <\/span>A<\/b><\/span> si <\/span>B <\/b><\/span>si se listeaza <\/span>C<\/b><\/span> unde <\/span>C=A X B<\/b><\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    int m,n,i,j;<\/b><\/span><\/p>\n

    char A[10],B[10];<\/b><\/span><\/p>\n

    clrscr();<\/b><\/span><\/p>\n

    cout<<“Specificati numarul de elemente a multimii A”<<” “<<“m=”; cin>>m;<\/b><\/span><\/p>\n

    cout<<“Specificati numarul de elemente a multimii B”<<” “<<“n=”; cin>>n;<\/b><\/span><\/p>\n

    cout<<“Introduceti elementele multimii A”<<endl;<\/b><\/span><\/p>\n

    for(i=1;i<=m;i++) { cout<<“A[“<<i<<“]=”; cin>>A[i];};<\/b><\/span><\/p>\n

    cout<<“Introduceti elementele multimii B”<<endl;<\/b><\/span><\/p>\n

    for(j=1;j<=n;j++) { cout<<“B[“<<j<<“]=”; cin>>B[j];};<\/b><\/span><\/p>\n

    cout<<“AXB”<<” “<<“={“<<” “;<\/b><\/span><\/p>\n

    for(i=1;i<=m;i++)<\/b><\/span><\/p>\n

    for(j=1;j<=n;j++) cout<<“(“<<A[i]<<“,”<<B[j]<<“)”<<” “; cout<<“}” ;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    1.2.4. METODE DE SORTARE<\/b><\/u><\/span><\/p>\n

    Se aplica pentru <\/span>sortarea<\/b><\/span> unor valori citite in ordine <\/span>crescatoare<\/b><\/span> sau <\/span>descrescatoare<\/b><\/span>.<\/span><\/p>\n

    a) Sortarea prin selectarea minimului(maximului).<\/b><\/u><\/span><\/p>\n

    – se determina minimul dintre toate valorile retinute incepand cu <\/span>pozitia 1<\/b><\/span> si acesta este trecut pe <\/span>pozitia1<\/b><\/span> prin interschimbarea continuturilor dintre cele 2 componente<\/span><\/p>\n

    – se determina minimul dintre valorile ratinute incepand cu <\/span>pozitia 2<\/b><\/span> si acesta este trecut pe <\/span>pozitia 2 <\/b><\/span>prin interschimbarea continuturilor dintre cele 2 componente<\/span><\/p>\n

    ………………………………………………<\/span><\/p>\n

    – se determina minimul dintre valorile retinute incepand cu <\/span>penultima pozitie<\/b><\/span> si acesta este trecut pe <\/span>penultima pozitie<\/b><\/span>.<\/span><\/p>\n

    Exemplul1. Se citeste o multime de numere si se listeaza valorile in ordine crescatoare si in ordine descrescatoare<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    int a[10],n,i,j,k,min,m;<\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    clrscr();<\/b><\/span><\/p>\n

    cout<<“Introduce numarul elementelor”<<” “<<“n=”;cin>>n;<\/b><\/span><\/p>\n

    for(i=1;i<=n;i++) { cout<<“a[“<<i<<“]=”;cin>>a[i];};<\/b><\/span><\/p>\n

    for(i=1;i<=n-1;i++)<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    min=a[i];k=i;<\/b><\/span><\/p>\n

    for(j=i+1;j<=n;j++)<\/b><\/span><\/p>\n

    if(a[j]<min)<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    min=a[j];<\/b><\/span><\/p>\n

    k=j;<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    m=a[k];<\/b><\/span><\/p>\n

    a[k]=a[i];<\/b><\/span><\/p>\n

    a[i]=m;<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    cout<<“Listez numerele in ordine crescatoare”<<endl;<\/b><\/span><\/p>\n

    for(i=1;i<=n;i++) cout<<a[i]<<” “;<\/b><\/span><\/p>\n

    cout<<endl<<“Listez numerele in ordine descrescatoare”<<endl;<\/b><\/span><\/p>\n

    for(i=n;i>=1;i–)cout<<a[i]<<” “;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    b) Sortarea prin interschimbare <\/b><\/u><\/span><\/p>\n

    Se parcurge variabila intr-un ciclu <\/span>do while<\/b><\/span> inversand continuturile componentelor care nu sunt in ordine crescatoare(descrescatoare)<\/span><\/p>\n

    Exemplu: Fie situatia initiala:<\/span><\/p>\n\n\n\n\n\n<\/colgroup>\n\n\n
    \n

    3<\/b><\/span><\/p>\n<\/td>\n

    		\n

    1<\/b><\/span><\/p>\n<\/td>\n

    		\n

    4<\/b><\/span><\/p>\n<\/td>\n

    		\n

    2<\/b><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

    A[1] A[2] A[3] A[4]<\/span><\/p>\n

    Algoritmul este urmatorul:<\/span><\/p>\n

    –<\/b><\/span> se efectueaza <\/span>prima parcurgere<\/b><\/span> si se schimba A[1] cu A[2] (deoarece 3 > 1) si A[3] cu A[4] (deoarece 4 > 2), vectorul va arata astfel:<\/span><\/p>\n\n\n\n\n\n<\/colgroup>\n\n\n
    \n

    1<\/b><\/span><\/p>\n<\/td>\n

    		\n

    3<\/b><\/span><\/p>\n<\/td>\n

    		\n

    2<\/b><\/span><\/p>\n<\/td>\n

    		\n

    4<\/b><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

    A[1] A[2] A[3] A[4]<\/span><\/p>\n

    – se efectueaza <\/span>a doua parcurgere<\/b><\/span> si se schimba A[2] cu A[3] (deoarece 3 > 2), iar vectorul va arata astfel:<\/span><\/p>\n\n\n\n\n\n<\/colgroup>\n\n\n
    \n

    1<\/b><\/span><\/p>\n<\/td>\n

    		\n

    2<\/b><\/span><\/p>\n<\/td>\n

    		\n

    3<\/b><\/span><\/p>\n<\/td>\n

    		\n

    4<\/b><\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

    A[1] A[2] A[3] A[4]<\/span><\/p>\n

    – se efectueaza <\/span>a treia parcurgere<\/b><\/span> dar deoarece numerele sunt in ordine crescatoare algoritmul se incheie <\/span><\/p>\n

    Exemplu:<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    int a[10],n,i,k,temp,gasit;<\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    clrscr();<\/b><\/span><\/p>\n

    cout<<“Introduce numarul de elemente”<<” “<<“n=”;cin>>n;<\/b><\/span><\/p>\n

    for(i=1;i<=n;i++) {cout<<“a[“<<i<<“]=”;cin>>a[i];};<\/b><\/span><\/p>\n

    do<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    gasit=0;<\/b><\/span><\/p>\n

    for(i=1;i<=n-1;i++)<\/b><\/span><\/p>\n

    if(a[i]>a[i+1])<\/b><\/span><\/p>\n

    {temp=a[i] ; a[i]=a[i+1]; a[i+1]=temp; gasit=1;}<\/b><\/span><\/p>\n

    } while(gasit);<\/b><\/span><\/p>\n

    cout<<“Listez numerele in ordine crescatoare”<<endl;<\/b><\/span><\/p>\n

    for(i=1;i<=n;i++) cout<<a[i]<<” “;<\/b><\/span><\/p>\n

    cout<<endl<<“Listez numerele in ordine descrescatoare”<<endl;<\/b><\/span><\/p>\n

    for(i=n;i>=1;i–)cout<<a[i]<<” “;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    1.3 APLICATII CARE LUCRE<\/b><\/u><\/span>AZA CU MATRICI.<\/b><\/u><\/span><\/p>\n

    1.3.1 INTERSCHIMBAREA A DOUA LINII INTRE ELE SAU A DOUA COLOANE<\/b><\/u><\/span><\/p>\n

    Pentru a interschimba 2 variabile intre ele utilizam o a treia variabila de manevra care am denumit-o <\/span>temp<\/b><\/span> si inca doua variabile <\/span>x<\/b><\/span> si <\/span>y<\/b><\/span> carora le atribuim ca valori numerele liniilor sau a coloanelor care dorim sa le interschimbam intre ele.<\/span><\/p>\n

    a) <\/b>Interschimbarea a 2 linii<\/b><\/span><\/p>\n

    for(j=1;j<=n;j++) {<\/b><\/span><\/p>\n

    temp=a[x][j]; <\/b><\/span><\/p>\n

    a[x][j]=a[y][j]; <\/b><\/span><\/p>\n

    a[y][j]=temp ;<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    b)<\/b><\/span> Interschimbarea a <\/span>2 coloane<\/b><\/span><\/p>\n

    for(i=1;i<=n;i++)<\/b><\/span> {<\/b><\/span><\/p>\n

    temp=a[i][x];<\/b><\/span><\/p>\n

    a[i][x]=a[i][y]; <\/b><\/span><\/p>\n

    a[i][y]=temp ;<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    Exemplu. Schimbarea a <\/span>2 coloane<\/b><\/span> a unei matrici<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    int i,j,m,n,a[10][10],x,y,temp;<\/b><\/span><\/p>\n

    clrscr();<\/b><\/span><\/p>\n

    cout<<“Introduceti numarul de linii”<<” “<<“n=”;cin>>m;<\/b><\/span><\/p>\n

    cout<<“Introduceti numarul de coloane”<<” “<<“n=”;cin>>n;<\/b><\/span><\/p>\n

    cout<<“Intoduceti elementele”<<endl;<\/b><\/span><\/p>\n

    for(i=1;i<=m;i++) {<\/b><\/span><\/p>\n

    for(j=1;j<=n;j++) { cout<<“a[“<<i<<j<<“]=”, cin>>a[i][j];}}<\/b><\/span><\/p>\n

    cout<<“Matricea intodusa are forma:”<<endl;<\/b><\/span><\/p>\n

    for(i=1;i<=m;i++){<\/b><\/span><\/p>\n

    for(j=1;j<=n;j++) {cout<<a[i][j]<<‘ ‘; } cout<<endl; }<\/b><\/span><\/p>\n

    cout<<endl; <\/b><\/span><\/p>\n

    cout<<“Introduceti numerele coloanelor care doriti sa le interschimbati”<<endl;<\/b><\/span><\/p>\n

    cout<<“x=”;cin>>x;cout<<“y=”;cin>>y;<\/b><\/span><\/p>\n

    for(i=1;i<=n;i++) { temp=a[i][x]; a[i][x]=a[i][y]; a[i][y]=temp ; }<\/b><\/span><\/p>\n

    cout<<endl;<\/b><\/span><\/p>\n

    cout<<“Noua matrice are forma:”<<endl;<\/b><\/span><\/p>\n

    for(i=1;i<=m;i++){<\/b><\/span><\/p>\n

    for(j=1;j<=n;j++){ cout<<a[i][j]<<‘ ‘; } cout<<endl;}<\/b><\/span><\/p>\n

    getch(); }<\/b><\/span><\/p>\n

    1.3.2. SPIRALA<\/b><\/u><\/span><\/p>\n

    Se citeste o matrice patratica (numarul de linii=numarul de coloane=<\/span>n<\/b><\/span>). Se cere sa se afiseze elementele tabloului in ordinea rezultata prin parcurgerea acestuia in spirala, incepand cu primul element din linia 1 in sensul acelor de ceasornic.<\/span><\/p>\n

    2. SIRURI DE CARACTERE<\/b><\/u><\/span><\/p>\n

    2.1. Citirea \/ scrierea sirurilor de caractere.<\/b><\/u><\/span><\/p>\n

    Inainte de citirea unui sir de caractere acesta trebuie declarat. Pentru a <\/span>declara un sir de<\/b><\/span> caractere<\/b><\/span> se utilizeaza functia:<\/span><\/p>\n

    char <\/b><\/span>nume sir[nr.elemente sir] <\/span><\/p>\n

    Exemplu: <\/span>char sir1[100]<\/b><\/span> – sa declarat sirul cu numele <\/span>sir1<\/b><\/span> care poate lista <\/span>100 caractere<\/b><\/span><\/p>\n

    Pentru <\/span>citirea sirurilor de caractere<\/b><\/span> se utilizeaza functia:<\/span><\/p>\n

    cin.get(<\/b><\/span>vector de caractere, int nr, char=’\\n’<\/span>)<\/b><\/span><\/p>\n

    Observatie.<\/b><\/span> Dupa tastarea unui sir de caractere , la apasarea tastei <\/span>Enter<\/b><\/span> se intrerupe citirea . Daca dorim sa introducem mai multe siruri de caractere se utilizeza <\/span>cin.get()<\/b><\/span> astfel<\/span><\/p>\n

    char s1[20],s2[20];<\/b><\/span><\/p>\n

    cin.get(s1,20];<\/b><\/span><\/p>\n

    cin.get();<\/b><\/span><\/p>\n

    cin.get(s2,20);<\/b><\/span><\/p>\n

    cout<<s1<<endl<<s2;<\/b><\/span><\/p>\n

    Daca ar lipsii functia <\/span>cin.get()<\/b><\/span> a doua citire nu ar putea fi efectuata, deoarece la apasarea tastei <\/span>Enter <\/b><\/span>in memorie este pastrat caracterul <\/span>‘\\n’<\/b><\/span> , fapt care duce la intreruperea citirii. <\/span><\/p>\n

    Exemplu: <\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main() {<\/b><\/span><\/p>\n

    char s1[20],s2[20];<\/b><\/span><\/p>\n

    cin.get(s1,20); cin.get(); cin.get(s2,20);<\/b><\/span><\/p>\n

    clrscr();<\/b><\/span><\/p>\n

    cout<<s1<<endl<<s2;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    Observatie. <\/b><\/span>Se pot scrie mai multe siruri de cuvinte daca declaram <\/span>o matrice de tip char<\/b><\/span><\/p>\n

    char a[10][<\/b><\/span>20] <\/b><\/span>se pot scrie <\/span>10 siruri<\/b><\/span> cu cate <\/span>20 caractere fiecare sir (fara spatiu)<\/b><\/span><\/p>\n

    Exemplu:<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    #include<string.h><\/b><\/span><\/p>\n

    void main(){<\/b><\/span><\/p>\n

    char a[10][20]; int n,i;<\/b><\/span><\/p>\n

    cout<<“Nr.cuvinte “;cin>>n;<\/b><\/span><\/p>\n

    for(i=0;i<n;i++) cin>>a[i];clrscr(); for(i=0;i<n;i++) cout<<a[i]<<endl;<\/b><\/span><\/p>\n

    getch();}<\/b><\/span><\/p>\n

    2.2. Functii si algoritmi care lucreaza cu siruri de caractere.<\/b><\/u><\/span><\/p>\n

    Pentru a utiliza functiile care lucreaza cu sirurile de caractere trebuie inclusa directiva<\/span><\/p>\n

    #include<string.h><\/b><\/span><\/p>\n

    2.2.1. Functia strle<\/b><\/u><\/span>n.<\/b><\/u><\/span><\/p>\n

    Are rolul de a returna lungimea unui sir(fara a lua in considerare caracterul nul).<\/span><\/p>\n

    Forma generala : <\/span>strlen(<\/b><\/span>nume sir<\/span>);<\/b><\/span><\/p>\n

    Exemplu: Se citeste un sir de caractere si se afiseaza numarul de caractere a sirului<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    #include<string.h><\/b><\/span><\/p>\n

    void main() {<\/b><\/span><\/p>\n

    char s1[100];<\/b><\/span><\/p>\n

    cin.get(s1,100);<\/b><\/span><\/p>\n

    cin.get();<\/b><\/span><\/p>\n

    cout<<“Sirul citit are”<<” “<<strlen(s1)<<” “<<“caractere”;<\/b><\/span><\/p>\n

    getch(); }<\/b><\/span><\/p>\n

    2.2.2 Functia strcpy.<\/b><\/u><\/span><\/p>\n

    Forma generala:<\/span>strcpy(<\/b><\/span>destinatie,sursa<\/span>)<\/b><\/span><\/p>\n

    Functia are roluil de a <\/span>copia <\/b><\/span>sirul de la adresa <\/span>sursa<\/b><\/span> la adreasa <\/span>destinatie<\/b><\/span>.<\/span><\/p>\n

    Exemplu: <\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    #include<string.h><\/b><\/span><\/p>\n

    void main() {<\/b><\/span><\/p>\n

    char s1[20]=”Limbalul Turbo C++”,s2[20]=”Limbajul C++”;<\/b><\/span><\/p>\n

    strcpy(s1,s2);<\/b><\/span><\/p>\n

    cout<<s1;<\/b><\/span><\/p>\n

    getch(); }<\/b><\/span><\/p>\n

    2.2.3. Functia strcat.<\/b><\/u><\/span><\/p>\n

    Forma generala:<\/span>strcat(<\/b><\/span>destinatie,sursa<\/span>)<\/b><\/span><\/p>\n

    Funtia are rolul de a <\/span>adauga<\/b><\/span> sirului de la adresa <\/span>destinatie<\/b><\/span> sirul de la adresa <\/span>sursa<\/b><\/span><\/p>\n

    Exemplu:<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    #include<string.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    char s1[20]=”Limbaj<\/b><\/span>ul Turbo C++”,s2[20]=” si Limbajul C++”;<\/b><\/span><\/p>\n

    strcat(s1,s2);<\/b><\/span><\/p>\n

    cout<<s1;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    2.2.4. Functia strncat<\/b><\/u><\/span><\/p>\n

    Forma generala:<\/span>strncat(<\/b><\/span>destinatie,sursa,n)<\/span><\/p>\n

    Functia adauga sirului <\/span>destinatie<\/b><\/span> primii <\/span>n <\/b><\/span>octeti ai sirului <\/span>sursa<\/b><\/span><\/p>\n

    Exemplu:<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    #include<string.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    char s1[20]=”Limbaj<\/b><\/span>ul Turbo C++”,s2[20]=” si Limbajul C++”;<\/b><\/span><\/p>\n

    strncat(s1,s2,5);<\/b><\/span><\/p>\n

    cout<<s1;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    2.2.5. Functia strchr<\/b><\/u><\/span><\/p>\n

    Forma generala: <\/span>strchr(<\/b><\/span>nume sir, ‘ caracter ‘ <\/span>)<\/b><\/span><\/p>\n

    Functia cauta in sirul <\/span>nume sir<\/b><\/span> caracterul <\/span>caracter<\/b><\/span> si returneaza subsirul care incepe cu prima aparitie a caracterului citit<\/span><\/p>\n

    Exemplu<\/span>l1: se va lista Turbo C++<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    #include<string.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    char s1[20]=”Limbajul Turbo C++”;<\/b><\/span><\/p>\n

    cout<<strchr(s1,’T’);<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    Exemplul2: Se tipareste indicele primei aparitii a caracterului ‘u’<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    #include<string.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    char s1[20]=”Limbajul Turbo C++”;<\/b><\/span><\/p>\n

    cout<<strchr(s1,’u’)-s1;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    Returneaza valoarea <\/span>6<\/b><\/span><\/p>\n

    2.2.6. Functia strrchr<\/b><\/u><\/span><\/p>\n

    Returneaza adresa ultimei aparitii a caracterului cautat <\/span>strrchr(<\/b><\/span>sir, ‘caracter’ <\/span>)<\/b><\/span><\/p>\n

    char s1[20]=”Limbajul Turbo C++”;<\/b><\/span><\/p>\n

    cout<<strrchr(s1,’u’)-s1;<\/b><\/span><\/p>\n

    Returneaza valoarea <\/span>10<\/b><\/span><\/p>\n

    2.2.7. Functia strcmp<\/b><\/u><\/span><\/p>\n

    Forma generala <\/span>strcmp(<\/b><\/span>sir1, sir2 <\/span>)<\/b><\/span><\/p>\n

    Functia are rolul de a compara 2 siruri de caractere si va returna valoarea:<\/span><\/p>\n

    < 0 <\/b><\/span>daca <\/span>sir1<sir2<\/b><\/span><\/p>\n

    = 0 <\/b><\/span>daca <\/span>sir1=sir2<\/b><\/span><\/p>\n

    > 0<\/b><\/span> daca <\/span>sir1>sir2<\/b><\/span><\/p>\n

    Exemp<\/span>lu1. Se compara sirul <\/span>a <\/b><\/span>cu sirul <\/span>b <\/b><\/span>si se listeaza relatia dintre cele 2 siruri astfel:<\/span><\/p>\n

    –<\/b><\/span> daca primele <\/span>n <\/b><\/span>caractere sunt identice se compara caracterele <\/span>n+1<\/b><\/span><\/p>\n

    – <\/b><\/span>daca caracterul <\/span>n+1<\/b><\/span> al sirului <\/span>a <\/b><\/span>este situat alfabetic inaintea cracterului <\/span>n+1<\/b><\/span> al sirului <\/span>b<\/b><\/span> se afiseaza <\/span>a<b<\/b><\/span><\/p>\n

    – <\/b><\/span>daca caracterul <\/span>n+1<\/b><\/span> al sirului <\/span>a <\/b><\/span>este situat alfabetic dupa cracterul <\/span>n+1<\/b><\/span> al sirului <\/span>b<\/b><\/span> se afiseaza <\/span>a>b<\/b><\/span><\/p>\n

    – <\/b><\/span>daca primul caracter al sirului <\/span>a<\/b><\/span> este situat alfabetic inaintea primului caracter al sirului <\/span>b <\/b><\/span>se afiseaza <\/span>a<b indiferent de lungimea celor 2 siruri<\/b><\/span><\/p>\n

    – <\/b><\/span>daca primul caracter al sirului <\/span>a<\/b><\/span> este situat alfabetic dupa primul caracter al sirului <\/span>b <\/b><\/span>se afiseaza <\/span>a>b indiferent de lungimea celor 2 siruri<\/b><\/span><\/p>\n

    Exemplul1:<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    #include<string.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    char a[20],b[20];<\/b><\/span><\/p>\n

    int semn;<\/b><\/span><\/p>\n

    cout<<“Introduceti sirul a: “; cin>>a;<\/b><\/span><\/p>\n

    cout<<“Introduceti sirul b: “; cin>>b;<\/b><\/span><\/p>\n

    semn=strcmp(a,b);<\/b><\/span><\/p>\n

    if(semn<0) cout<<“a < b”;<\/b><\/span><\/p>\n

    else<\/b><\/span><\/p>\n

    if(semn>0) cout<<“a > b”;<\/b><\/span><\/p>\n

    else cout<<“a = b”;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    Exemplul2. Se citesc <\/span>n <\/b><\/span>cuvinte si se <\/span>ordoneaza <\/b><\/span> alfabetic <\/span>crescator<\/b><\/span> si <\/span>descrescator<\/b><\/span>.<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    #include<string.h><\/b><\/span><\/p>\n

    void main(){<\/b><\/span><\/p>\n

    char a[100][10],temp[10];<\/b><\/span><\/p>\n

    int i,n,gasit;<\/b><\/span><\/p>\n

    cout<<“Introduceti numarul de persoane “; cin>>n;<\/b><\/span><\/p>\n

    cout<<“Scrie numele persoanelor”<<endl; <\/b><\/span><\/p>\n

    for(i=0;i<n;i++) cin>>a[i];<\/b><\/span><\/p>\n

    do<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    gasit=0;<\/b><\/span><\/p>\n

    for(i=0;i<n-1;i++) if(strcmp(a[i],a[i+1])>0)<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    strcpy(temp,a[i]);<\/b><\/span><\/p>\n

    strcpy(a[i],a[i+1]);<\/b><\/span><\/p>\n

    strcpy(a[i+1],temp);<\/b><\/span><\/p>\n

    gasit=1;<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    while(gasit);<\/b><\/span><\/p>\n

    cout<<“Ordinea alfabetica <\/b><\/span>crescatoare a persoanelor scrise este:”<<endl;<\/b><\/span><\/p>\n

    for(i=0;i<n;i++) cout<<a[i]<<endl;<\/b><\/span><\/p>\n

    cout<<“Ordinea alfabetica <\/b><\/span>descrescatoare a persoanelor scrise este:”<<endl;<\/b><\/span><\/p>\n

    for(i=n;i>=0;i–<\/b><\/span>) cout<<a[i]<<endl;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    2.2.8. Functiile strlwr <\/b><\/u><\/span>si <\/u><\/span>struwr<\/b><\/u><\/span><\/p>\n

    strlwr(<\/b><\/span>s1<\/span>)<\/b><\/span> – <\/span>converteste<\/b><\/span> toate literele sirului s1 in <\/span>litere mici<\/b><\/span><\/p>\n

    struwr(<\/b><\/span>s2<\/span>) – converteste <\/b><\/span>toate literele sirului s2 in <\/span>litere mari<\/b><\/span><\/p>\n

    Exemplu:<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    #include<string.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    char a[100]=”este acesta un sir?”, b[100]=”Acest Lucru Nu Ma Deranjeaza”;<\/b><\/span><\/p>\n

    cout<<strupr(a)<<endl<<strlwr(b); <\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    2.2.9. Functia <\/b><\/u><\/span>strstr<\/b><\/u><\/span><\/p>\n

    Forma generala: <\/span>strstr(<\/b><\/span>sir1,sir2<\/span>)<\/b><\/span><\/p>\n

    Functia identifica daca sirul <\/span>sir2<\/b><\/span> este subsir al sirului <\/span>sir1<\/b><\/span><\/p>\n

    2.2.10. Functia strcspn<\/b><\/u><\/span><\/p>\n

    Forma generala: <\/span>strcspn(<\/b><\/span>s1,s2<\/span>)<\/b><\/span><\/p>\n

    Functia returneaza <\/span>numarul caracterelor<\/b><\/span> din sirul <\/span>s1<\/b><\/span> care <\/span>nu se gasesc<\/b><\/span> in sirul <\/span>s2<\/b><\/span><\/p>\n

    2.2.11. Functia spn<\/b><\/u><\/span><\/p>\n

    Forma generala: <\/span>strspn(<\/b><\/span>s1,s2<\/span>)<\/b><\/span><\/p>\n

    Functia returneaza <\/span>numarul caracterelor<\/b><\/span> din sirul <\/span>s1<\/b><\/span> care <\/span>se gasesc <\/b><\/span>in sirul <\/span>s2<\/b><\/span><\/p>\n

    2.2.12. FUNCTII UTILIZATE PENTRU CONVERSIA VALORILOR NUMERICE IN SIR<\/b><\/u><\/span><\/p>\n

    La utilizarea acestor functii se introduce directiva <\/span>#include<stdlib.h><\/b><\/span><\/p>\n

    a) Functia atof<\/b><\/span> – converteste un sir catre tipul <\/span>double<\/b><\/span><\/p>\n

    b) Functia atold<\/b><\/span> – converteste un sir catre tipul <\/span>long double<\/b><\/span><\/p>\n

    Exemplu:<\/span><\/p>\n

    #include <stdlib.h><\/b><\/span><\/p>\n

    #include <iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main() {<\/b><\/span><\/p>\n

    float f;<\/b><\/span><\/p>\n

    char *str = “12345.67”;<\/b><\/span><\/p>\n

    f = atof(str);<\/b><\/span><\/p>\n

    cout<<“string = “<<str<<endl<<“float = “<< f;<\/b><\/span><\/p>\n

    getch(); }<\/b><\/span><\/p>\n

    \n

    c) Functia atoi<\/b><\/span> – converteste un sir catre tipul <\/span>int<\/b><\/span><\/p>\n

    d) Functia atol<\/b><\/span> – converteste un sir catre tipul <\/span>long<\/b><\/span><\/p>\n

    Exemplu:<\/span><\/p>\n

    #include <stdlib.h><\/b><\/span><\/p>\n

    #include <iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    int n;<\/b><\/span><\/p>\n

    char *str = “12345.67”;<\/b><\/span><\/p>\n

    n = atoi(str);<\/b><\/span><\/p>\n

    cout<<“string = “<<str<<endl<<“float = “<< n;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    \n

    e) Functia ecvt<\/b><\/span> – converteste <\/span>o valoare dubla<\/b><\/span> catre <\/span>un sir<\/b><\/span><\/p>\n

    f) Functia itoa<\/b><\/span> – converteste <\/span>o valoare de tip intreg<\/b><\/span> catre<\/span> un sir<\/b><\/span><\/p>\n

    g) Functia ltoa<\/b><\/span> – converteste o valoare de tip <\/span>long int<\/b><\/span> catre <\/span>un sir<\/b><\/span><\/p>\n

    3. TIPUL INREGISTRARE<\/b><\/u><\/span><\/p>\n

    3.1. Inregistrari simple.<\/b><\/span><\/p>\n

    Pentru gruparea variabilelor de mai multe tipuri utilizate pentru o inregistrare se foloseste:<\/span><\/p>\n

    struct <\/b><\/span>nume structura<\/span><\/p>\n

    { tip variabila nume variabila, nume variabila ;<\/b><\/span><\/p>\n

    tip variabila nume variabila;<\/b><\/span><\/p>\n

    } <\/b><\/span>lista variabile;<\/span><\/p>\n

    \n

    Un exemplu de <\/span>stuctura<\/b><\/span>:<\/span><\/p>\n

    struct elev<\/b><\/span><\/p>\n

    { char nume[15],prenume[20];<\/b><\/span><\/p>\n

    int telefon;<\/b><\/span><\/p>\n

    float media;<\/b><\/span><\/p>\n

    }inr1,inr2;<\/b><\/span><\/p>\n

    \n

    Exemplu:<\/span><\/p>\n

    #include <stdlib.h><\/b><\/span><\/p>\n

    #include <iostream.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    struct elev<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    char nume[15],prenume[20],clasa[10];<\/b><\/span><\/p>\n

    int tel;<\/b><\/span><\/p>\n

    float med; <\/b><\/span><\/p>\n

    } inr;<\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    cout<<“Nume “;cin>>inr.nume;<\/b><\/span><\/p>\n

    cout<<“Prenume “;cin>>inr.prenume;<\/b><\/span><\/p>\n

    cout<<“Telefon “;cin>>inr.tel;<\/b><\/span><\/p>\n

    cout<<“Clasa “;cin>>inr.clasa;<\/b><\/span><\/p>\n

    cout<<“Media generala “;cin>>inr.med;<\/b><\/span><\/p>\n

    cout<<“Am citit:”<<endl<\/b><\/span><\/p>\n

    <<inr.nume<<” “<<inr.prenume<<endl<\/b><\/span><\/p>\n

    <<inr.tel<<endl<\/b><\/span><\/p>\n

    <<inr.clasa<<endl<\/b><\/span><\/p>\n

    <<inr.med;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    3.2. Inregistrari imbricate<\/b><\/span><\/p>\n

    Un tip structurat de inregistrare contine in interiorul sau alt tip structurat de inregistrare.<\/span><\/p>\n

    Exemplu de inregistrare imbricata:<\/span><\/p>\n

    struct elev1<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    char nume[15],prenume[20];<\/b><\/span><\/p>\n

    struct<\/b><\/span><\/p>\n

    { int clasa;<\/b><\/span><\/p>\n

    float note[20];<\/b><\/span><\/p>\n

    } sit1,sit2;<\/b><\/span><\/p>\n

    int varsta;<\/b><\/span><\/p>\n

    };<\/b><\/span><\/p>\n

    \n

    Tipul structurat <\/span>elev1<\/b><\/span> subordoneaza , pe langa alte tipuri, doua structuri <\/span>sit1 <\/b><\/span>si <\/span>sit2<\/b><\/span>.<\/span><\/p>\n

    3.3. Inregistrari cu structura variabila<\/b><\/span><\/p>\n

    Se utilizeaza cand inregistrarile nu au format fix ci <\/span>un format variabil.<\/b><\/span><\/p>\n

    F. FISIERE<\/b><\/span><\/span><\/p>\n

    Fisierul este o colectie de date de acelasi fel stocate pe un suport extern<\/span> care are un mune si o extensie (al carei nume este in functie de tipul fisierului).Ex: nume.exe (fisier executabil) ; nume.dbf (fisier baza de date,utilizat in fox), etc.<\/span><\/p>\n

    1. FISIERE TEXT<\/b><\/span><\/p>\n

    Aceste fisiere se caracterizeaza prin urmatoarele:<\/span><\/p>\n

    – <\/b><\/span>datele sunt memorate sub forma unei succesiuni de caractere<\/span><\/p>\n

    – <\/b><\/span>caracterele sunt memorate in codul ASCII<\/span><\/p>\n

    –<\/b><\/span> fisierul se termina cu caracterul <\/span>EOF<\/b><\/span><\/p>\n

    –<\/b><\/span> este format din una sau mai multe linii care se termina cu caracterul <\/span>newline (\\n)<\/b><\/span><\/p>\n

    –<\/b><\/span> o variabila speciala numita <\/span>pointer<\/b><\/span> retine intotdeauna un octet al fisierului<\/span><\/p>\n

    \n

    1.1. Citiri \/ scrieri cu format<\/b><\/u><\/span><\/p>\n

    Acestea sun caracterizate prin:<\/span><\/p>\n

    – <\/b><\/span>latime – <\/span>width – <\/b><\/span>se utilizeaza la scriere si are rolul de a stabili numarul de caracatere utilizate pentru afisarea unei date;<\/span><\/p>\n

    – <\/b><\/span>precizie<\/span> – precision –<\/b><\/span> se utilizeaza la scriere atunci cand se foloseste o variabila reala, stabileste numarul de zecimale care vor fi afisate pentru valoare;<\/span><\/p>\n

    – <\/b><\/span>caracterul de umplere<\/span> – fill – <\/b><\/span>se utilizeaza la scriere in cazul in care data propriuzisa ocupa mai putini octeti decat latimea si precizeaza caracterul care se afiseaza in spatiile neocupate;<\/span><\/p>\n

    – <\/b><\/span>alinierea <\/span>– left <\/b><\/span>sau<\/span> right – <\/b><\/span> se utilizeaza cand data ocupa mai putin decat latimea si se precizeaza unde anume sa fie afisata <\/span>– stanga <\/b><\/span>sau<\/span> drepta –<\/b><\/span><\/p>\n

    –<\/b><\/span> salt sau nu peste caractere albe – se utilizeaza la citire<\/span><\/p>\n

    \n

    * <\/b><\/span>Pentru formatarea citirii \/ scrierii se utilizeaza varibilele:<\/b><\/u><\/span><\/p>\n

    precision , wihth, fill<\/b><\/span><\/p>\n

    Accesul la aceste varibile se face cu ajutorul unor functii speciale numite <\/span>manipulatori.<\/b><\/span> Pentru a le putea utiliza in program trebuie inclusa directiva <\/span>#<iomanip.h> <\/b><\/span><\/p>\n

    Manipulatorii sunt inclusi in expresiile de citire\/scriere astfel:<\/span><\/p>\n

    – setw (<\/b><\/span>int<\/span>) – <\/b><\/span>stabileste latimea <\/span>int<\/b><\/span> pe care este afisata variabila<\/span><\/p>\n

    – setprecision(<\/b><\/span>int<\/span>) – <\/b><\/span>stabileste numarul de zecimale <\/span>int<\/b><\/span> care sunt afisate<\/span><\/p>\n

    – setfill(<\/b><\/span>char)<\/span> – <\/b><\/span>stabileste caracterul de umplere <\/span>char<\/b><\/span> a pozitiilor ramase libere<\/span> <\/b><\/p>\n

    Exemplu.<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<iomanip.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    double a=0.123456789;<\/b><\/span><\/p>\n

    cout<<setw(20)<<setfill(‘$’)<<setprecision(2)<<a;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    \n

    Afisarea se poate face pe <\/span>20 pozitii<\/b><\/span> ; pe pozitiile ramase libere se afiseaza caracterul <\/span>$<\/b><\/span> , variabila <\/span>a <\/b><\/span> va fi afisata cu <\/span>2 zecimale<\/b><\/span>.<\/span> <\/b><\/p>\n

    *<\/b><\/span>Pentru formatarea intrarilor \/ iesirilor se utilizeaza variabila:<\/b><\/u><\/span><\/p>\n

    flags <\/b><\/span>care utilizeaza comenzile:<\/span><\/p>\n

    – skipws<\/b><\/span> – sunt sarite caracterele albe care preced valoarea ce trebuie citita<\/span><\/p>\n

    \u00ad<\/span>– left<\/b><\/span> – datele se tiparesc aliniate la stanga<\/span><\/p>\n

    – right<\/b><\/span> – datele se tiparesc aliniate la dreapta<\/span><\/p>\n

    – internal<\/b><\/span> – se fiseaza semnaul la stinga si numarul la drepta<\/span><\/p>\n

    – dec<\/b><\/span> – conversie in zecimal<\/span><\/p>\n

    – oct<\/b><\/span> – conversie in octal<\/span><\/p>\n

    – hex<\/b><\/span> – conversie in hexazecimal<\/span><\/p>\n

    – showbase<\/b><\/span> – afisarea indicatorului de baza<\/span><\/p>\n

    – showpoint<\/b><\/span> – forteaza afisarea punctului zecimal<\/span><\/p>\n

    – uppercase<\/b><\/span> – in cazul afisarii in hexazecimal se vor utiliza literele mari (A,B,..F)<\/span><\/p>\n

    – showpos<\/b><\/span> – valorile afisate sunt precedate de semn<\/span><\/p>\n

    – scientific<\/b><\/span> – afisarea valorilor se face prin utilizarea formei stiintifice (1e-8)<\/span><\/p>\n

    – fixed<\/b><\/span> – afisarea valorilor se face prin utilizarea formai normale<\/span><\/p>\n

    Variabila <\/span>flags<\/b><\/span> se utilizeaza in doua moduri:<\/span><\/p>\n

    setiosflags(<\/b><\/span>masca<\/span>)<\/b><\/span> – pentru setarea bitilor accesati<\/span><\/p>\n

    resetiosflags(<\/b><\/span>masca<\/span>)<\/b><\/span> – pentru resetarea bitilor accesati<\/span><\/p>\n

    Pentru a avea acces la comanzile cu care lucreaza <\/span>flags<\/b><\/span> numele lor vor fi precedate de <\/span>ios::<\/b><\/span><\/p>\n

    masca este formata din una sau mai multe grupe de comenzi de forma:<\/span><\/p>\n

    ios::comanda<\/b><\/span> separate intre ele de operatorul logic <\/span>|<\/b><\/span> (SAU-pe biti)<\/span><\/p>\n

    Exemplu de masca:<\/span><\/p>\n

    (ios::internal | ios::showpos | ios::right)<\/b><\/span><\/p>\n

    \n

    Exemplu:<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<iomanip.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    #include<math.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    double a,b,c,d,e,f;<\/b><\/span><\/p>\n

    cout<<“Introduceti primul numar “<<” “<<“a=”;cin>>a;<\/b><\/span><\/p>\n

    cout<<“Introduceti al doilea numar “<<” “<<“b=”;cin>>b;<\/b><\/span><\/p>\n

    c=a\/b;<\/b><\/span><\/p>\n

    d=a*b;<\/b><\/span><\/p>\n

    e=sqrt(d);<\/b><\/span><\/p>\n

    f=d*d;<\/b><\/span><\/p>\n

    cout<<endl;<\/b><\/span><\/p>\n

    \n

    cout<<“Rezultatul impartirii “<<” “<<“a : b =”<\/b><\/span><\/p>\n

    <<setw(100)<<setfill(‘ ‘)<<setprecision(10)<\/b><\/span><\/p>\n

    <<setiosflags(ios::left|ios::showpos|ios::fixed)<<c;<\/b><\/span><\/p>\n

    cout<<endl;<\/b><\/span><\/p>\n

    \n

    cout<<“Rezultatul inmultirii “<<” “<<“a x b =”<\/b><\/span><\/p>\n

    <<setw(100)<<setfill(‘ ‘)<<setprecision(10)<\/b><\/span><\/p>\n

    <<setiosflags(ios::left|ios::showpos|ios::fixed)<<d;<\/b><\/span><\/p>\n

    cout<<endl;<\/b><\/span><\/p>\n

    \n

    cout<<“Radicalul inmultirii este “<<” “<\/b><\/span><\/p>\n

    <<setw(100)<<setfill(‘ ‘)<<setprecision(20)<\/b><\/span><\/p>\n

    <<setiosflags(ios::left|ios::showpos|ios::fixed)<<e;<\/b><\/span><\/p>\n

    cout<<endl;<\/b><\/span><\/p>\n

    \n

    cout<<“Patratul inmultirii este “<<” “<\/b><\/span><\/p>\n

    <<setw(100)<<setfill(‘ ‘)<<setprecision(20)<\/b><\/span><\/p>\n

    <<setiosflags(ios::left|ios::showpos|ios::fixed)<<f;<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    1.2. Declararea fisierelor text memorate pe suport magnetic.<\/b><\/u><\/span><\/p>\n

    Cand se lucreaza cu fisiere pe suport magnetic in program trebuie inclusa directiva:<\/span><\/p>\n

    #include<fstream.h><\/b><\/span> <\/b>daca utilizam acesta directiva poatei fi scoasa <\/span><iostream.h><\/b><\/span><\/p>\n

    Pentru a lucra usor asupra fisierelor<\/span>sunt definite comenzile:<\/span><\/p>\n

    – in<\/b><\/span> – deschide fisierul pentru citire<\/span><\/p>\n

    – out<\/b><\/span> – deschide fisierul pentru scriere<\/span><\/p>\n

    – ate<\/b><\/span> – salt la sfirsitul fisierului dupa deschiderea acestui<\/span><\/p>\n

    – app<\/b><\/span> – deschide fisierul pentru a scrie la sfirsitul lui<\/span><\/p>\n

    – trunc <\/b><\/span>– daca fisierul care se deaschide exista in locul lui se creaza altul<\/span><\/p>\n

    – nocreate<\/b><\/span> – daschide fisierul daca acesta exista (nu se creaza altul)<\/span><\/p>\n

    – noreplace<\/b><\/span> – daca fisierul exista el poate fi deschis numai pentru consultare<\/span><\/p>\n

    – binary<\/b><\/span> – fisier binar. Se utilizeaza constructorul inplicit al clasei <\/span>ofstream();<\/b><\/span> apoi se utilizeaza metoda <\/span>open<\/b><\/span> in forma generala<\/span><\/p>\n

    \n

    Inainte de a lucra cu un fisier acesta trebuie declarat. Forma generala a declaratiei:<\/span><\/p>\n

    fstream <\/b><\/span>nume_logic<\/span>(“<\/b><\/span>nume_fizic<\/span>“<\/b><\/span> , <\/b><\/span>mod_de_deschidere<\/span>)<\/b><\/span><\/p>\n

    Exemplu1: Declar un fisier cu numele fizic <\/span>fis.txt<\/b><\/span> care se va gasi in <\/span>radacina (c:\\\\)<\/b><\/span> , cu numele logic <\/span>f<\/b><\/span> , fisierul este declarat in vedera crearii lui <\/span>(ios::out)<\/b><\/span><\/p>\n

    fstream f(“c:\\\\fis.txt”,ios::out);<\/b><\/span><\/p>\n

    Exemplul2. Declar doua fisiere, unul (<\/span>f<\/b><\/span>) pentru citire si celalat (<\/span>g<\/b><\/span>) pentru scriere<\/span><\/p>\n

    fstream f(“c:\\\\fis1.txt”,ios::in), g(“c:\\\\fis2.txt”,ios::out);<\/b><\/span><\/p>\n

    In cazul in care numele fisierului trebuie citit de la tastatura declaratia fisierului trebuie sa contina numele sau si trebuie plasata dupa citirea sirului respectiv astfel:<\/span><\/p>\n

    char <\/b><\/span>nume_fisier<\/span>[20] ;<\/b><\/span><\/p>\n

    cout<<“Numele fisierului este “;cin>><\/b><\/span>nume_fisier <\/span>;<\/b><\/span><\/p>\n

    fstream f(<\/b><\/span>nume_fisier<\/span>, ios::out);<\/b><\/span><\/p>\n

    Dupa deschiderea si prelucrarea unui fisier acesta trebuie inchis astfel:<\/span><\/p>\n

    nume_fisier<\/span>.close()<\/b><\/span> , in cazul nostru <\/span>f.close()<\/b><\/span><\/p>\n

    Exemplu de creare a unui fisier de tip text in c:\\ :<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<fstream.h><\/b><\/span><\/p>\n

    #include<iomanip.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    fstream f(“c:\\\\fis.txt”,ios::out);<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    1.3. Prelucrarea fisierelor de tip text<\/b><\/u><\/span><\/p>\n

    Prelucrarea unui fisier se face dupa urmatorul algoritm:<\/span><\/p>\n

    while(<\/b><\/span>daca nu este sfirsit de fisier<\/span>)<\/b><\/span><\/p>\n

    { <\/b><\/span><\/p>\n

    citeste <\/span>;<\/b><\/span><\/p>\n

    prelucreaza <\/span>;<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    Pentru a preciza sfirsitul de fisier care se testeaza in paranteza de dupa <\/span>while<\/b><\/span> se scrie:<\/span><\/p>\n

    !<\/b><\/span> nume_fisier<\/span>.eof()<\/b><\/span><\/p>\n

    Atentie! Functia eof() nu citeste ci doar testeaza daca anterior a fost detectat sfarsitul de fisier<\/b><\/span><\/p>\n

    Exemple de programe:<\/span><\/p>\n

    Exemplul1<\/b><\/span>. Creez un fisier <\/span>fis.txt<\/b><\/span> in <\/span>d:\\<\/b><\/span> cu intrare de la tastatura (scriu in el de la tastatura).In acest exemplu nu sunt scrise caracterele albe(deci intre cuvintele scrise nu este spatiu.<\/span>Ca sa termin scrierea apas consecutiv tastele CTRL+Z<\/b><\/span> (echivalent cu EOF)<\/span><\/p>\n

    \n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<fstream.h><\/b><\/span><\/p>\n

    #include<iomanip.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    fstream f(“d:\\\\fis.txt”,ios::out);<\/b><\/span><\/p>\n

    char x;<\/b><\/span><\/p>\n

    while(cin>>x) f<<x;<\/b><\/span><\/p>\n

    f.close();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    \n

    Exemplul2<\/b><\/span>. Creez acelasi fisier dar for fi scrise si caracterele albe. Aceasta sa realizat deoarece a fost introdusa comanda <\/span>resetiosflags(ios::skipws)<\/b><\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<fstream.h><\/b><\/span><\/p>\n

    #include<iomanip.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    fstream f(“d:\\\\fis.txt”,ios::out);<\/b><\/span><\/p>\n

    char x;<\/b><\/span><\/p>\n

    while(cin>>resetiosflags(ios::skipws)>>x) f<<x;<\/b><\/span><\/p>\n

    f.close();<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    Exemplul3.<\/b><\/span> Afisez fisierul creat la exemplul2<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<fstream.h><\/b><\/span><\/p>\n

    #include<iomanip.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    fstream f(“d:\\\\fis.txt”,ios::in);<\/b><\/span><\/p>\n

    char x;<\/b><\/span><\/p>\n

    while(f>>resetiosflags(ios::skipws)>>x) cout<<x;<\/b><\/span><\/p>\n

    f.close();<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    \n

    Exemplul4<\/b><\/span>.<\/b><\/span> Scriu la sfirsitul fisierului creat la exemplul2<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<fstream.h><\/b><\/span><\/p>\n

    #include<iomanip.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    fstream f(“d:\\\\fis.txt”,ios::app);<\/b><\/span><\/p>\n

    char x;<\/b><\/span><\/p>\n

    while(cin>>resetiosflags(ios::skipws)>>x) f<<x;<\/b><\/span><\/p>\n

    f.close();<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    \n

    Exemplul5.<\/b><\/span> Creez un fisier al carui nume il dau de la tastatura si scriu in el.<\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<fstream.h><\/b><\/span><\/p>\n

    #include<iomanip.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    char fisier<\/b><\/span>[10];<\/b><\/span><\/p>\n

    cout<<“Numele fisierului este “;cin>>fisier;<\/b><\/span><\/p>\n

    fstream f(fisier,ios::out<\/b><\/span>);<\/b><\/span><\/p>\n

    char x;<\/b><\/span><\/p>\n

    while(cin>>resetiosflags(ios::skipws)>>x) f<<x;<\/b><\/span><\/p>\n

    f.close();<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    \n

    Observatie: Cand scriu numele fisierului trebuie sa specific si locatia lui astfel:<\/b><\/span><\/p>\n

    c:\\<\/b><\/span>nume_fisier<\/span>.txt <\/b><\/span>sau <\/span>d:\\<\/b><\/span>nume_fisier<\/span>.txt<\/b><\/span><\/p>\n

    \n

    Exemplul6. <\/b><\/span>Cuvantul “FINISH” se adauga la sfarsitul fisierului creat la exemplul2.<\/span><\/p>\n

    #include<string.h><\/b><\/span><\/p>\n

    #include<fstream.h><\/b><\/span><\/p>\n

    #include<stdlib.h><\/b><\/span><\/p>\n

    #include<iomanip.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    fstream f(“d:\\\\fis.txt”,ios::in|ios::out);<\/b><\/span><\/p>\n

    char c[100];<\/b><\/span><\/p>\n

    f>>resetiosflags(ios::skipws)>>c ;cout<<c;<\/b><\/span><\/p>\n

    f.seekp(0,ios::end);<\/b><\/span><\/p>\n

    strcpy(c,”FINISH”);<\/b><\/span><\/p>\n

    f<<resetiosflags(ios::skipws)<<c;<\/b><\/span><\/p>\n

    f.close();<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    \n

    & <\/b><\/span>Functia: nume_fisier<\/span>.seekp(0,ios::end)<\/b><\/span> – pozitioneaza pointerul in fisierul precizat<\/span><\/p>\n

    – primul parametru reprezinta pozitia pointerului<\/span><\/p>\n

    – al doilea parametru reprezinta reperul in raport de care este calculata pozitia<\/span><\/p>\n

    Sunt definite trei constante:<\/span><\/p>\n

    end<\/b><\/span> – sfarsit de fisier<\/span><\/p>\n

    beg<\/b><\/span> – inceput de fisier<\/span><\/p>\n

    cur<\/b><\/span> – pozitia curenta in fisier<\/span><\/p>\n

    &<\/b><\/span> Functia : nume_fisier<\/span>.tellp()<\/b><\/span> – returneaza pozitia pointerului la un moment dat.<\/span><\/p>\n

    \n

    Exemplul7.<\/b><\/span> Se convertesc primele <\/span>n<\/b><\/span> numere naturale in <\/span>octal<\/b><\/span> si <\/span>hexazecimal<\/b><\/span><\/p>\n

    #include<iostream.h><\/b><\/span><\/p>\n

    #include<fstream.h><\/b><\/span><\/p>\n

    #include<iomanip.h><\/b><\/span><\/p>\n

    #include<conio.h><\/b><\/span><\/p>\n

    void main()<\/b><\/span><\/p>\n

    {<\/b><\/span><\/p>\n

    fstream f(“C:\\\\numere.txt”,ios::out,ios::in);<\/b><\/span><\/p>\n

    int i,n;<\/b><\/span><\/p>\n

    cout<<“Introduce num<\/b><\/span>arul n= “;cin>>n;<\/b><\/span><\/p>\n

    for(i=1;i<=n;i++) {<\/b><\/span><\/p>\n

    f<<setw(10)<<oct<<i;<\/b><\/span><\/p>\n

    f<<setw(10)<<dec<<i;<\/b><\/span><\/p>\n

    f<<setw(10)<<setiosflags(ios::uppercase)<<hex<<i<<endl;<\/b><\/span><\/p>\n

    };<\/b><\/span><\/p>\n

    f.close();<\/b><\/span><\/p>\n

    getch();<\/b><\/span><\/p>\n

    }<\/b><\/span><\/p>\n

    \n

    2. Fisiere binare.<\/b><\/u><\/span><\/p>\n

    Caracteristici:<\/span><\/p>\n

    –<\/b><\/span> fisierele sunt alcatuite din mai multe inregistrari de acelasi tip (<\/span>int<\/b><\/span> , <\/span>struct<\/b><\/span>, etc)<\/span><\/p>\n

    – <\/b><\/span>datele sunt memorate in format intern, iar fisierele se termina tot cu <\/span>EOF<\/b><\/span><\/p>\n

    –<\/b><\/span> pentru deschiderea unui fisier binar se utilizeaza <\/span>ios::binary<\/b><\/span><\/p>\n

    –<\/b><\/span> fisierele lucreaza cu variabile de tip <\/span>pointer.<\/b><\/span> O astfel de variabila retine o anumita adresa a unei alte variabile. Ea se declara in felul urmator:<\/span><\/p>\n

    int a, *adr_a=&a<\/b><\/span> , <\/b><\/span>variabila <\/span>*adr_a<\/b><\/span> a fost initializata cu adresa variabilei <\/span>a<\/b><\/span><\/p>\n

    Variabila <\/span>*adr_a <\/b><\/span>este de tip <\/span>poiner<\/b><\/span><\/p>\n

    Pentru a obtine <\/span>adresa<\/b><\/span> unei variabile , variabila este precedata de operatorul <\/span>&<\/b><\/span><\/p>\n

    Daca <\/span>avem o variabila <\/span>a <\/b><\/span>de tip <\/span>int*<\/b><\/span> si o variabila <\/span>b<\/b><\/span> de tip <\/span>float* <\/b><\/span> nu este permisa atribuire de tipul <\/span>a=b<\/b><\/span> , aceasta atribuire se poate face astfel <\/span>a=(int*)b<\/b><\/span><\/p>\n

    –<\/b><\/span> scrierea unei variabile de tip pointer <\/span>adr_p <\/b><\/span>intr-un fisier se face utilizand:<\/span><\/p>\n

    nume_fisier<\/span>.write((char*)<\/b><\/span> adr_p<\/span>,sizeof(<\/b><\/span>p<\/span>))<\/b><\/span><\/p>\n

    –<\/b><\/span> citirea unei variabile de tip poiter<\/span> adr_p<\/b><\/span> dintr-un fisier se face utilizand:<\/span><\/p>\n

    nume_fisier<\/span>.read((char*)<\/b><\/span>adr_p<\/span>,sizeof(p))<\/b><\/span><\/p>\n

    Prin aceste comenzi de fapt se <\/span>scrie<\/b><\/span> respectiv <\/span>citeste<\/b><\/span> continutul variabilei <\/span>p<\/b><\/span> , numarul de caractere scrise sau citite fiind date de lungimea variabilei <\/span>p<\/b><\/span> prin comanda <\/span>sizeof(p)<\/b><\/span>.<\/span><\/p>\n


    \n