Documente Academic
Documente Profesional
Documente Cultură
Limbajul C PT Incapatori
Limbajul C PT Incapatori
CUPRINS
CUPRINS...........................................................1 CAP.1 ELEMENTE DE BAZ ALE LIMBAJULUI C............................7 1.1 Structura unui program C .........................................................................7 1.2 Vocabularul limbajului...............................................................................7 1.3 Tipuri de date...............................................................................................8 1.4 Directive preprocesor..................................................................................9 1.5 Exerciii i teste gril.................................................................................10 CAP.2 TIPURI FUNDAMENTALE DE DATE ......................................11 2.1 Prezentarea tipurilor.................................................................................11 2.2 Constante....................................................................................................13 Exemple : 123.4 12e6 -111.2 ..........................................................14
2.3 Variabile.....................................................................................................15 2.4 Exerciii i teste gril.................................................................................15 CAP.3 FUNCII DE INTRARE/IEIRE STANDARD............................18 3.1 Clasificarea funciilor de intrare/ieire...................................................18 3.2 Funciile getch i getche............................................................................18 3.3 Funcia putch.............................................................................................19
3.4 Macrourile getchar i putchar..................................................................19 3.5 Funciile gets i puts..................................................................................20 3.6 Funcia printf.............................................................................................22 3.7 Funcia scanf..............................................................................................25 3.8 Exerciii i teste gril.................................................................................28 CAP.4 OPERATORII LIMBAJULUI C..................................................35 4.1 Precedena operatorilor............................................................................35 4.2 Operatorul de atribuire simpl................................................................36 4.3 Operatori aritmetici..................................................................................37 4.4 Operatorii relaionali................................................................................39 4.5 Operatori logici..........................................................................................39 4.6 Operatorii la nivel de bit...........................................................................40 4.7 Operatori compui de atribuire...............................................................44 4.8 Operatorul de conversie explicit (cast)..................................................46 4.9 Operatorul sizeof.......................................................................................46 4.10 Operatorii de adresare............................................................................47 4.11 Operatorul condiional............................................................................47 4.12 Operatorul virgul..................................................................................47 4.13 Exerciii i teste gril...............................................................................48
CAP.5 STRUCTURI DE CONTROL N LIMBAJUL C.........................56 5.1 Instruciunea vid.....................................................................................56 5.2 Instruciunea expresie..............................................................................56 5.3 Instruciunea compus.............................................................................57 5.4 Instruciunea if.........................................................................................58 5.5 Funcia standard exit...............................................................................60 5.6 Instruciunea while...................................................................................62 5.7 Instruciunea for.......................................................................................64 5.8 Instruciunea do-while.............................................................................66 5.9 Instruciunea continue.............................................................................69 5.10 Instruciunea break................................................................................70 5.11 Instruciunea switch...............................................................................72 5.12 Instruciunea goto...................................................................................76 5.13 Funciile standard sscanf i sprintf........................................................77 5.14 Header-ul ctype.h...................................................................................80 Macro de verificare........................................................................................80 5.15 Funcii matematice uzuale.....................................................................81 Valoarea returnat.........................................................................................81 5.16 Exerciii i teste gril...............................................................................82 CAP.6 TABLOURI.................................................................................93 6.1 Declararea tablourilor.............................................................................93
Exemple:........................................................................................................93 6.2 Iniializarea tablourilor...........................................................................94 6.3 Prelucrri elementare ale vectorilor......................................................94 6.3.1 Citirea elementelor unui vector.............................................................95 6.3.2 Determinarea elementului minim/maxim............................................95 6.3.3 Determinarea primului element cu o anumit proprietate................95 6.3.4 Determinarea ultimului element cu o anumit proprietate................96 6.3.5 Eliminarea tuturor elementelor cu o anumit proprietate.................96 6.3.6 Eliminarea elementului din poziia k dat (1<=k<=n)........................97 6.3.7 Inserarea unui element y n poziia k dat (1<=k<=n)........................97 6.3.8 Permutarea circular cu o poziie spre stnga....................................97 6.3.9 Permutarea circular cu o poziie spre dreapta..................................97 6.3.11 Algoritmul de cutare binar..............................................................99 6.3.12 Interclasarea vectorilor......................................................................100 6.4 Prelucrri elementare ale matricilor.....................................................100 6.4.1 Citirea elementelor unei matrici.........................................................101 6.4.2 Tiprirea elementelor unei matrici.....................................................102 6.4.3 Determinarea elementului maxim/minim..........................................102 6.4.4 Identificarea elementelor specifice unei matrici ptratice................102 6.5 Exerciii i teste gril...............................................................................103
...........................................................................................................111 CAP.7 POINTERI...............................................................................112 7.1 Variabile pointer.....................................................................................112 7.2 Aritmetica pointerilor............................................................................114 7.3 Legtura pointer tablou......................................................................116 7.4 Exerciii i teste gril...............................................................................122 CAP.8 IRURI DE CARACTERE......................................................130 8.1 Folosirea irurilor....................................................................................130 8.2 Tablouri de iruri....................................................................................131 8.3 Funcii standard pentru prelucrarea irurilor de caractere...............131 8.3.1 Lungimea unui ir de caractere..........................................................132 8.3.2 Copierea unui ir de caractere............................................................132 8.3.3 Concatenarea irurilor de caractere...................................................134 8.3.4 Compararea irurilor de caractere.....................................................135 8.3.5 Cutarea n iruri de caractere...........................................................136 8.4 Exemple de utilizare a funciilor standard............................................136 8.5 Funcii pentru conversii de date.............................................................139 8.6 Exerciii i teste gril...............................................................................141 CAP.9 STRUCTURI............................................................................148
9.1 Definirea tipurilor structur..................................................................148 9.2 Iniializarea structurilor.........................................................................150 9.3 Operaii permise asupra structurilor....................................................151 9.4 Exerciii i teste gril...............................................................................153 CAP.10 EXPLOATAREA FIIERELOR ...........................................156 10.1 Noiunea de fiier...................................................................................156 10.2 Deschiderea unui fiier..........................................................................156 10.3 nchiderea unui fiier............................................................................157 10.4 Funcia de verificare a sfritului unui fiier......................................157 10.5 Funcii de citire/scriere caractere........................................................158 10.6 Funcii de citire/scriere pe iruri de caractere....................................159 10.7 Funcii de citire/scriere cu format........................................................163 10.8 Funcii de citire/scriere a fiierelor pe blocuri de octei....................163 10.9 Funcii pentru aflarea poziiei curente i schimbarea ei.................................................................................................164 10.10 Exerciii i texte gril...........................................................................164 RSPUNSURI LA TESTELE GRIL..................................................170 BIBLIOGRAFIE...................................................................................172
constante : sunt valori fixe reprezentnd caractere, iruri de caractere, numere ntregi sau raionale delimitatori : reprezint simboluri care separ entitile (spaiu, tab etc) . Observaie : limbajul C face distincie ntre literele mici i mari, deci identificatorul n este diferit de identificatorul N.
Variabilele sunt datele care i pot modifica valoarea pe parcursul execuiei programului. Orice variabil are asociat un nume i o zon de memorie care va fi prelucrat binar conform unor reguli specifice de interpretare a tipurilor de date. Observaie : orice variabil trebuie declarat nainte de utilizarea sa. Tipurile de date pot fi predefinite (puse la dispoziie de limbaj) sau derivate (definite de utilizator ). O alt clasificare posibil este urmtoarea : simple (scalare), care la un moment dat conin o singur valoare de un anumit tip compuse, care la un moment dat conin mai multe valori de acelai tip sau de tipuri diferite pointeri, care conin adrese de memorie ale unor entiti
10
5. Definirea corect a unei constante simbolice numit TRUE , care are valoarea 1 este : a) int TRUE=1; b) #define TRUE=1; c) #define TRUE 1; d) #define TRUE 1 6. Definirea corect a unei constante numit GST cu valoarea .125 este : a) #define GST 0.125 b) GST .125; c) float GST=0.125; d) #define GST .125 7. Care din numele de variabile de mai jos nu este valid ? a) go4it b) go_cart c) 4season d) _what 8. Definii o constant simbolic PI cu valoarea 3.14: a) #define 3.14 PI; b) #define float PI 3.14; c) #define float PI=3.14; d) #define PI 3.14 e) #define PI=3.14
11
12
char c=a; // a are codul ASCII 97 int i=65; // 65 este codul ASCII pentru A printf(%c,c+1); // este afisat b printf(%d,c+2); // este afisat 99 printf(%c,i+3); // este afisat D n C, fiecare caracter este memorat pe un octet de memorie (8 bii). Fie declaraia: char c=a; Putem gndi c c este memorat pe un octet 0 1 1 0 0 0 0 1 astfel: 7 6 5 4 3 2 1 0 Fiecare celul reprezint un bit i fiecare bit este numerotat (ncepnd cu cel mai puin semnificativ). Biii care formeaz un octet sunt fie on, fie off, aceste stri fiind reprezentate prin 1 i respectiv 0. Aceasta ne conduce s gndim fiecare octet din memorie ca un ir de 8 cifre binare (se mai numesc iruri de bii). Astfel, variabila c poate fi gndit ca irul de bii 01100001. Mai general, fiecare cuvnt main poate fi gndit ca un numr binar. n acest fel valoarea lui c este numrul: 011000012=1*26+1*25+0*24+0*23+0*22+0*21+1*20=9710 (n baza 10) Limbajul C pune la dispoziie trei tipuri referitoare la caractere: char signed char unsigned char De obicei, tipul char este echivalent cu signed char. Fiecare din aceste trei tipuri se memoreaz pe un octet (deci poate ine 256 de valori distincte). Pentru signed char, valorile sunt ntre 128 i 127, iar pentru unsigned char ntre 0 i 256. Tipul de date int Tipul de date int este cel mai folosit tip din limbajul C. Acest tip, mpreun cu alte tipuri integrale (cum ar fi char, short i long) este desemnat pentru lucrul cu valori ntregi reprezentabile pe o main. n matematic, numerele naturale sunt 0,1,2,...,care mpreun cu cele negative (corespunztoare) formeaz numerele ntregi. Pe o main, se pot reprezenta (folosind un tip integral) numai o submulime finit a acestor numere. De obicei, un cuvnt se memoreaz pe un cuvnt main. Anumite calculatoare folosesc cuvinte de 2 octei (16 bii), altele de 4 octei (32 bii). Presupunem c lucrm pe un calculator care lucreaz pe 4 octei. Aceasta implic c un cuvnt are 32 de bii, deci poate ine 2 32 valori distincte. Jumtate sunt folosite pentru reprezentarea numerelor negative i cealalt jumtate pentru cele pozitive: -231,-231+1,,-2,-1,0,1,2,.,231-1 Dac lucrm pe un calculator unde memorarea unui cuvnt se face pe 2 octei, atunci putem memora 216 valori distincte. Valoarea cea mai mare a tipului int este dat de constanta de sistem MAXINT. Evident cea mai mic valoare va fi MAXINT-1. Dac se ncearc, de exemplu, adunarea a dou numere i se depete aceast valoare, atunci se va primi un mesaj integer overeflow.
13
De obicei, tipul short se memoreaz pe 2 octei i tipul long pe 4. Astfel, pe mainile n care cuvintele au 4 octei, lungimea tipului int este aceeai cu lungimea tipului long, iar pe mainile n care cuvintele au 2 octei, lungimea tipului int este egal cu lungimea tipului short. Constantele predefinite MAXSHORT i MAXLONG (n unele implementri LONG_MAX) caracterizeaz lungimea acestor tipuri. De obicei, MAXSHORT=215 i MAXLONG=231. Astfel, dac x este o variabil de tip short, atunci: - MAXSHORT<=x<=MAXSHORT-1 Dac t este o variabil de tip long, atunci: -MAXLONG<=t<=MAXLONG-1 n ceea ce privete tipul unsigned, acesta este memorat pe acelai numr de octei ca i tipul int. Dac u este o variabil de tip unsigned, atunci: 0<=u<=2*MAXINT-1 Tipuri reale Limbajul C ofer trei tipuri reale: float, double i long double. Variabilele de acest tip vor putea pstra valori reale, cum ar fi: 0.001, 2.0, 3.14159. Aceast notaie se numete notaie zecimal deoarece conine punctul zecimal. Mai exist i notaia exponenial: 1.234567e5 corespunde cu 1.234567*105=123456.7. Pe majoritatea mainilor, tipul float se memoreaz pe 4 octei, iar tipul double pe 8 octei. Asta nseamn c o variabil de tip float poate avea 6 zecimale, iar o variabil de tip double poate avea 15 zecimale. Astfel, o variabil de tipul float are forma: 0,d1d2d3d4d5d6*10n, unde 38<=n<=38 Asemntor, o variabil de tip double are forma: 0,d1d2......d15*10n, unde 308<=n<=308 Astfel, instruciunea x=123.45123451234512345; // 20 de cifre semnificative va implica atribuirea lui x a valorii 0.123451234512345*103 // 15 cifre semnificative Uzual, pentru variabilele de tip long double se aloc mai mult memorie (10 octei), sunt ns compilatoare care trateaz acest tip exact ca i double. Observaie: Limbajul C pune la dispoziie operatorul sizeof pentru determinarea numrului de octei necesari memorrii unui obiect. Cu ajutorul lui putei afla ct memorie aloc compilatorul cu care lucrai pentru fiecare din tipurile de date prezentate.
2.2 Constante a) Constante ntregi : pot fi exprimate n bazele 8, 10 sau 16 . Constantele n baza
8 au ntotdeauna prima cifr 0, iar cele n baza 16 au prefixul 0x sau 0X.
Limbajul C/C++ pentru nceptori Exemple : 0172 /* are 0 n fa, este considerat n baza 8 */ 120 /* este considerat implicit n baza 10 */ 0x78 /* are 0x, este considerat n baza 16 */ Constantele de tip long au adugat la sfrit litera l sau L . Exemplu : 1L 1000000L 581l Pentru constantele unsigned se adaug la sfrit u sau U . Exemplu : 0u 12000u 20000lu
14
b) Constante caracter : sunt reprezentate de unul sau mai multe caractere ncadrate ntre apostrofuri . Exemple : X 1 \n \t % Pentru a putea utiliza anumite caractere speciale se folosesc secvenele de evitare prezentate n tabelul de mai jos : Secvena \0 \a \b \f \n \r \t \v \\ \ \ Valoare hexazecimal 0 0x07 0x08 0x0C 0x0A 0x0D 0x09 0x0B 0x5C 0x27 0x22 Caracter ASCII NULL BELL BS FF LF CR HT VT \ Semnificaia terminator de ir generator de sunet back space sfrit de linie linie nou salt la nceputul rndului tab orizontal tab vertical back slash apostrof ghilimele
Exemple :
15
2.3 Variabile
Declaraia unei variabile are sintaxa : tip_baz list_variabile_declarate; Lista poate fi format din una sau mai multe variabile separate ntre ele prin virgul. O variabil poate s includ n declaraie i iniializarea sa. Exemple : int n, k=0; float media; char c=65; unsigned long int f; double salar;
b) 8 bii d) 32 bii
5. Care este valoarea maxim a unui tip de date cu semn exprimat pe 8 bii ? a) (2 la puterea 8) minus 1
Limbajul C/C++ pentru nceptori A6) 0x5 caracter B6)constant ir de caractere A2 B1, A3 B5, A5 B6, A6 B3 A2 B1, A3 B5, A5 B5, A6 B3 A2 B1, A3 B5, A5 B6, A6 B3 A2 B1, A3 B5, A5 B6, A3 B5, A5 B6, e) 3), 4), 5). 6), 8)
16
a) A1 B2,
A4 B1,
b) A1 B2,
A4 B4, c) A1 B2, A4 B4, d) A1 B2, A4 B4, A6 eronat e) A1 B2, A2 B1, A4 B1, A6 eronat
11. Care dintre urmtoarele declaraii de variabile declar corect o variabil x ce poate memora valori reale? a) float x; b) double x; c) unsigned float x; d) x:float; e) x:double; 12. Care dintre liniile de program de mai jos realizeaz iniializarea corect a variabilei x la declararea sa? a) int x==2; b) x:int=2; c) int x=2; d) int x 2; e) x=2:int; 13. Care dintre variabile vor avea valori ntregi dup execuia secven de program urmtoare? int a=3, b, c; float x=-11.23; char d; b=x; d=A; c=M-N; a) variabila x b) variabila c c) variabila d d) variabila a e) variabila b 14. Considerm variabilele a, b, c, d i e. Alegei varianta corect a declaraiilor, astfel nct atribuirile urmtoare s nu fie nsoite de conversii care s modifice valorile atribuite. a=3; b=8; c=2.1; d=-3.5; e=B; a) float a,b,c.d; char e; b) int a,b,c,d; char e; c) int a,b,e; float c,d; d) int a,b; float c,d;
8. Care dintre urmtoarele valori sunt constante flotante scrise corect? 1) 2307.98 2) +54.3 3) 20.07 4) 198. 5) .13 6) 1.9 E4 7) +2.7E+3 8) 2.e+4 a) 1), 2), 3), 6), 7) b) c) d) e) toate mai puin 5) toate toate mai puin b) primele cinci
9. Care dintre valorile de mai jos sunt constante ntregi scrise corect? a) 123 b) 17 c) +843 d) 0154 e) --67 10. Care dintre construciile de mai jos reprezint constante tip caracter? 1) 2) \ 3) a 4) 5) \\ 6) \13 7) a 8) a) 2), 3) ,8) b) toate c) toate mai puin 5) si 6) d) 2), 3), 4), 8)
Limbajul C/C++ pentru nceptori char e; e) int c,d; char e; float a,b; a) b) c) d) litera:=char; char litera; litera: char; character litera;
17
15. O declaratie de genul : int i=7.3; va avea urmatorul efect : a) semnalarea unei erori din partea compilatorului b) va atribui lui i valoarea 7.3 i va semnala un avertisment din partea compilatorului c) va modifica tipul variabilei i d) va atribui lui i valoarea 7 16. Declaraia corect pentru definirea unui ntreg numit suma este : a) suma:integer; b) integer suma; c) int suma; d) suma int; 17. Declaraia corect pentru definirea unei variabile caracter numit litera este :
18. Definirea corect a unei variabile numit bani care poate fi utilizat pentru a memora valori reale simpl precizie este : a) bani: real; b) real bani; c) float bani; d) bani float; 19. Definirea corect a unei variabile ntregi numit total iniializat cu zero este : a) total: integer=0; b) total=0, int; c) int total=0; d) int=0 , total; 20. Ce numr este echivalent cu 4e3: a) 4000 b) 400 c) .004 d) .0004
18
19
automat pe ecran caracterul tastat. Ambele funcii nu au parametri i se pot apela ca operanzi n expresii. La apelarea lor se vizualizeaz fereastra utilizator i se ateapt tastarea unui caracter. Programul continu dup tastarea caracterului. Funciile getch i getche au prototipurile n fiierul conio.h, deci utilizarea lor implic includerea acestui fiier.
20
standard. Se pot citi numai caractere ale codului ASCII, nu i caractere corespunztoare tastelor speciale. Prin intermediul macroului getchar caracterele nu se citesc direct de la tastatur. Caracterele tastate la terminal se introduc ntr-o zon tampon pn la acionarea tastei Enter. n acest moment, n zona tampon, se introduce caracterul de rnd nou (newline) i se continu execuia lui getchar. Se revine din funcie returnndu-se codul ASCII al caracterului curent din zona tampon. La un nou apel al lui getchar se revine cu codul ASCII al caracterului urmtor din zona tampon. La epuizarea tuturor caracterelor din zona tampon, apelul lui getchar implic tastarea la terminal a unui nou set de caractere care se rencarc n zona tampon. Un astfel de mod de desfurare a operaiei de citire implic o anumit organizare a memoriei i accesului la caractere, organizare care conduce la noiunea de fiier. n general, prin fiier se nelege o mulime ordonat de elemente pstrate pe suporturi de memorie extern. Elementele unui fiier se numesc nregistrri. Cu toate c fiierele sunt n general pstrate pe discuri, este util s se considere organizate n fiiere chiar i datele care se tasteaz sau se afieaz la terminal. n acest caz nregistrarea este un rnd afiat la terminal sau succesiunea de caractere tastat la terminal i terminat la apsarea tastei Enter. Fiierele conin o nregistrare special care marcheaz sfritul de fiier. Aceast nregistrare se realizeaz la tastatur prin secvene speciale, spre exemplu tastnd <Ctrl>+Z al crui ecou este ^Z. Macroul getchar returneaz valoarea constantei simbolice EOF (End of File) la ntlnirea sfritului de fiier. Aceast constant este definit n fiierul stdio.h i n general are valoarea 1. Macroul getchar se apeleaz fr parametri i de obicei este un operand al unei expresii : getchar();. Macroul putchar afieaz un caracter al codului ASCII. El returneaz codul caracterului afiat sau 1 la eroare. Se poate apela cu : putchar(expresie); Valoarea expresiei reprezint codul ASCII al caracterului care se afieaz. Exemplu : S se scrie un program care citete un caracter folosind macroul getchar, l afieaz folosind macroul putchar i trece cursorul pe linia urmtoare. #include<stdio.h> #include<conio.h> void main() { clrscr(); putchar(getchar()); putchar(\n); getch(); }
21
ecou i se pot citi numai caracterele codului ASCII. Funcia are ca parametru adresa de nceput a zonei de memorie n care se pstreaz caracterele citite. De obicei, acest zon de memorie este alocat unui tablou unidimensional de tip char. Deoarece numele unui tablou are ca valoare adresa de nceput a zonei de memorie alocat, rezult c numele unui tablou poate fi utilizat ca parametru al funciei gets. n felul acesta, caracterele citite se vor pstra n tabloul respectiv. Funcia gets returneaz adresa de nceput a zonei de memorie n care s-au pstrat caracterele. La ntlnirea sfritului de fiier (<Ctrl>+Z) se returneaz valoarea zero. Zero nu reprezint o valoare posibil pentru gets i de aceea, ea poate fi folosit pentru a semnala sfritul de fiier. De obicei, valoarea returnat de gets nu se testeaz fa de zero, ci fa de constanta simbolic NULL definit n fiierul stdio.h. Rezult c dac tab este declarat prin : char tab[255]; atunci apelul : gets(tab); pstreaz n tab succesiunea de caractere tastat de la terminal n linia curent. Totodat, caracterul newline se nlocuiete cu NUL (\0). Funcia puts afieaz la terminalul standard un ir de caractere ale codului ASCII. Dup afiarea irului respectiv, cursorul trece automat pe o linie nou (deci caracterul NUL se nlocuiete cu newline). Funcia are ca parametru adresa de nceput a zonei de memorie care conine caracterele de afiat. n cazul n care irul de caractere care se afieaz se pstreaz ntr-un tablou unidimensional de tip char, drept parametru se poate folosi numele acestui tablou. Funcia puts returneaz codul ultimului caracter al irului de caractere afiat (caracterul care precede NUL) sau 1 la eroare. Dac tab are declaraia de mai sus i el pstreaz un ir de caractere, atunci apelul : puts(tab); afieaz la terminalul standard irul respectiv de caractere i apoi trece cursorul pe linia urmtoare. Funciile gets i puts au prototipurile n fiierul stdio.h. Exemplu : S se scrie un program care citete de la intrarea standard numele i prenumele unei persoane, afieaz iniialele personei respective pe cte un rnd, fiecare iniial fiind urmat de un punct. #include<stdio.h> #include<conio.h> void main() { char nume[30]; char prenume[30]; clrscr(); gets(nume); gets(prenume); putchar(nume[0]); putchar(.); putchar(prenume[0]); putchar(.); puts(\nPentru a termina programul actionati o tasta ); getch(); }
22
Expresiile afiate se pot alinia la stnga sau la dreapta i se poate fora afiarea semnului astfel : semnul plus afieaz explicit semnul expresiei semnul minus aliniaz expresia afiat la stnga absena oricrui semn semnific alinierea expresiei afiate la dreapta Pentru numerele ntregi i pentru irurile de caractere se poate specifica un numr care nseamn spaiul folosit pentru afiare. Dac spaiul necesar este mai mic
23
sau egal cu numrul specificat, atunci se vor afia suplimentar spaii (sau zerouri, dac numrul este precedat de cifra 0) pn la completarea spaiului de afiare. Pentru numerele reale se pot specifica, opional, semnul pentru aliniere i dou numere separate prin punct. Primul precizeaz dimensiunea total de afiare, iar al doilea precizia, adic numrul de zecimale afiate. n cazul irurilor de caractere, specificarea a dou numere separate prin punct indic faptul c primul numr reprezint numrul de caractere din ir care se vor afia, iar al doilea reprezint limita superioar de tiprire, completarea fcndu-se cu spaii la dreapta sau stnga, n funcie de modul de aliniere. Poate apare fenomenul de trunchiere a irului afiat n cazul n care dimensiunea acestuia depete limita inferioar. n cazul unui numr ntreg, al doilea numr indic o completare la stnga cu zerouri pn se ajunge la dimensiunea de afiare specificat. n format se pot utiliza i modificarii de tip h i l, corespunztoare lui short, respectiv long. Dac h este urmat de un d,i,o,u,x sau X, atunci aceasta este o specificare de conversie relativ la short int sau unsigned short int Dac l este urmat de d,i,o,u,x sau X, atunci specificarea de conversie se aplic unui argument long int sau unsigned long int. Modificatorul L poate fi urmat de e,E,f,g sau G i atunci specificarea de conversie se aplic unui argument long double. Exemple: Valoarea datei 3.14159265 123.672 3.14159265 123.672 -123.672 3.14159265 123.672 Specificator %5f %7f %7.2f %10.1f %10.1f %10.0f %10.0f Afiare 3.141593(rotunjire prin adaos la 6 zecimale) 123.672000(completare cu 0 la 6 zecimale) 3.14(rotunjire prin lips la 2 zecimale) 123.7(rotunjire prin adaos la o zecimal) -123.7(rotunjire prin adaos la o zecimal) 3(rotunjire prin lips; nici o zecimal) 124(rotunjire prin adaos; nici o zecimal)
Numrul zecimalelor se definete prin precizia indicat n specificatorul de format. Dac ea este absent atunci se afieaz 6 zecimale. Ultima cifr afiat este rotunjit prin lips sau prin adaos. Exemple: Valoarea datei 3.14159265 123.672 Specificator %e %e Afiare 3.141593e+00 1.236720e+02
Limbajul C/C++ pentru nceptori 123.672 0.673 123.672 %.1E %E %.0E 1.2E+02 6.73000E-01 1E+02
24
Numrul zecimalelor se definete prin precizia indicat n specificatorul de format. Dac ea este absent atunci se afieaz 6 zecimale. Ultima cifr afiat este rotunjit prin lips sau prin adaos. Exponentul ncepe cu litera e dac specificatorul de format se termin cu e i cu E dac el se termin cu E. Urmeaz un semn plus sau minus dac exponentul este negativ. Dup semn se afl un ntreg zecimal de cel puin dou cifre. Exemplul 1: Folosirea afirii cu format pentru numere ntregi #include<stdio.h> void main() { int nr=4321; printf(\n nr=%d,nr); // nr=4321 printf(\n nr=%-d*,nr); // nr=4321* printf(\n nr=%6d,nr); // nr= 4321 ,completare cu spaii la stnga printf(\n nr=%-6d*,nr); // nr=4321 * ,aliniere la stnga i completare // cu spaii la dreapta printf(\n nr=%6.8d,nr); // nr=00004321 ,completare cu 0 pn la precizia 8 printf(\n nr=%-6.8d*,nr); // nr=00004321* ,analog,nu conteaz modul de // aliniere } Exemplul 2 : Folosirea afirii cu format pentru numere reale #include<stdio.h> #include<conio.h> void main() { double x=123.01234567; clrscr(); printf(\n x=%f,x); // x=123.012346 ,rotunjire prin adaos la 6 zecimale printf(\n x=%-f*,x); // x=123.012346* ,analog dar cu aliniere la stmga printf(\n x=%16f,x); // x= 123.012346 ,rotunjire prin adaos la 6 // zecimale si completare cu spatii la stnga pn // la 16 caractere printf(\n x=%-16f*,x); // x=123.012346 * ,analog alinierea la // stnga
25
printf(\n x=%.10f,x); // x=123.0123456700 ,completare cu 0 pn la 10 // zecimale printf(\n x=%-.10f*,x); // x=123.0123456700* ,analog, alinierea nu are efect printf(\n x=%12.4f,x); // x= 123.0123 , rotunjire prin lips la 4 // zecimale si completare cu spaii la stnga pn // la 12 caractere printf(\n x=%-12.4f*,x); // x=123.0123 * ,analog,alinierea se face la // dreapta getch(); } Exemplul 3 : Folosirea afirii cu format pentru irurile de caractere #include<stdio.h> void main() { char s[]="Luna rosie!"; printf("%s\n",s); // Luna rosie!,lungimea campului 11 implicit printf("%-s*\n",s); // Luna rosie!*,analog,alinierea nu are efect printf("%3s*\n",s); // Luna rosie!*, analog,dimensiunea 3 se ignora printf("%.6s*\n",s); // Luna r* ,se afiseaza conform preciziei doar 6 // caractere printf("%11.8s*\n",s); // Luna ros*,se afiseaza conform preciziei 6 // caractere si se completeaza la stanga cu 3 spatii // pana la dimensiunea 11 printf("%-11.8s*\n",s); // Luna ros *,analog,dar alinierea fiind la // stanga,completarea cu 3 spatii se face la dreapta }
26
citete din fiierul standard de intrare stdio o secven de cmpuri de intrare, caracter cu caracter, pn la terminarea introducerii cmpurilor i apsarea tastei <Enter> ; formateaz fiecare cmp conform formatului specificat n lista de formate. Din caracterele citite se calculeaz valori numerice sau literale, conform tipului fiecrei variabile, dimensiunilor de format specificate i a separatorilor de cmpuri predefinii (spaiu, tab i enter) sau impui explicit ; valorile astfel construite sunt stocate la adresele variabilelor specificate ca argumente ; Ordinea formatelor variabilelor trebuie s coincid cu ordinea listei adreselor variabilelor n care se face citirea. Fiecare variabil care se dorete a fi citit trebuie corelat cu un format specific. Observaie :Indiferent de formatul folosit, la ntlnirea unui spaiu n introducerea datelor, este terminat citirea variabilei. Pentru funcia de citire scanf trebuie folosit operatorul adres &. Pentru variabilele citite cu aceast funcie trebuie precizate adresele la care se stocheaz n memoria calculatorului valorile variabilelor. Funcia va introduce valorile citite direct la acele adrese. Singurul caz n care nu este obligatorie folosirea operatorul adres pentru citirea valorii unei variabile cu funcia scanf este citirea unui ir de caractere . Observaie : citirea cu ajutorul funciei scanf a irurilor de caractere care conin spaii este imposibil. n cazul n care formatul specificat este necorespunztor, rezultatul obinut poate fi neprevzut. Valoarea ntoars de scanf n caz de succes, este numrul de variabile care au fost citite corect. Dac nu a fost citit nici o variabil (de exemplu s-a introdus un ir n loc de un numr ) funcia ntoarce valoarea 0. Dac apare o eroare naintea oricrei citiri i asignri, funcia returneaz EOF (constant de sistem avnd valoarea ntreag 1). Specificatorii de format ai funciei scanf() sunt prezentai n tabelul urmtor: Cod %c %d %i %e %f %g %o %s %x %p %n %u Semnificaie Citete un caracter Citete un ntreg zecimal Citete un ntreg zecimal Citete un numr float Citete un numr float Citete un numr float Citete un numr octal fr semn Citete un ir de caractere Citete un numr hexazecimal fr semn Citete un pointer Argumentul asociat primete o valoare ntreg egal cu numrul de caractere deja citite Citete un numr ntreg fr semn
27
n specificatorul de format pot s apar i modificatori de tip. Modificatorul h, care poate precede caracterele de conversie d,i,o,u,x sau X, precizeaz c valoarea convertit trebuie memorat ca un short int sau unsigned short int. Modificatorul l, poate precede caracterele de conversie d,i,o,u,x,X, caz n care valoarea trebuie memorat ca un long int sau unsigned long int, sau poate precede caracterele e,E,f,g,G, caz n care valoarea trebuie memorat ca un double. Modificatorul L poate precede numai caracterele e,E,f,g,G i precizeaz c valoarea convertit trebuie memorat ca un long double. O caracteristic foarte interesant a funciei scanf() este numit scanset. Un specificator scanset se poate crea prin includerea unei liste de caractere n interiorul unor paranteze drepte. Spre exemplu, iat un specificator scanset coninnd literele ABC : %[ABC]. Cnd scanf() ntlnete un specificator scanset, se ncepe citirea caracterelor i depozitarea lor ntr-un tablou punctat de argumentul corespunztor. Citirea va continua ct timp caracterul citit face parte din scanset. n momentul n care caracterul citit nu face parte din scanset, funcia scanf() oprete citirea pentru acest specificator i avanseaz la urmtorul specificator din irul de control. Folosind semnul n scanset se specific un domeniu. De exemplu, urmtorul specificator se refer la literele de la A la Z : %[A-Z]. Uneori cnd scansetul este mare, este mai uor s specificm ceea ce nu face parte din scanset. Pentru a realiza acest lucru, setul trebuie precedat de semnul ^. De exemplu, [^0123456789]. Cnd scanf() ntlnete acest scanset, va citi orice caracter exceptnd cifrele de la 0 la 9. Se poate suprima asignarea unui cmp punnd un asterisc imediat dup semnul %. Aceast proprietate este foarte util cnd introducem informaii care conin i caractere de care nu avem nevoie. De exemplu, dndu-se : int j,k; scanf(%d%*c%d,&j,&k); i datele de intrare sub forma : 555-2345, scanf() va asigna valoarea 555 variabilei j, va nltura semnul i va asigna valoarea 2345 variabilei k. Iat un exemplu de scanset care accept caractere litere mici i litere mari. ncercai s introducei cteva litere, apoi orice alt caracter i apoi din nou litere. Dup ce apsai tasta Enter numai literele introduse naintea caracterelor care nu au fost litere vor fi coninute n str. #include<stdio.h> void main() { char str[80]; printf(Introduceti litere si apoi orice altceva\n); scanf(%[a-zA-Z],str); printf(%s,str);
28
} Dac dorii s citii un ir coninnd spaii folosind funcia scanf(), va trebui s utilizai scansetul urmtor: #include<stdio.h> void main() { char str[80]; printf(Introduceti litere si spatii\n); scanf(%[a-zA-Z ],str); printf(%s,str); } Se pot specifica de asemenea semne de punctuaie, simboluri i cifre, astfel c, virtual, se poate citi orice tip de ir. Programul urmtor ilustreaz efectul pe care l are prezena unor caractere non-spaiu n irul de control. El ne permite s introducem o valoare zecimal, cifrele din stnga punctului zecimal sunt asignate unei variabile ntregi, iar cele din dreapta punctului zecimal sunt asignate unei alte variabile ntregi. #include<stdio.h> void main() { int j,k; printf(Introduceti un numar zecimal : ); scanf(%d.%d,&j,&k); printf(stanga:%d\t dreapta:%d,j,k); } Observaie : Dac este posibil apariia erorilor la introducerea datelor, este necesar ca imediat dup apariia unei erori s folosim una din funciile : fflush(stdin); - pentru golirea buffer-ului fiierului standard de intrare fflushall(); - pentru golirea tuturor buffer-elor fiierelor Exemple : char a[20]; int n; scanf(%[A-Z]s,a); /*citete un ir format numai din litere mari */ scanf(%[a-zA-Z]s,a); /* citete un ir format din litere mari si mici */ scanf(%3d,&n); /* citete un numr ntreg de cel mult trei cifre */
Limbajul C/C++ pentru nceptori 1. S se determine ce tiprete urmtoarea instruciune : unsigned n=100; printf("%04x",n); a) 0100 b) 100 c) 0064 c) A10 2. Ce face secvena ? float n=16; printf("%x",n+1); a) afieaz numrul n baza 16 b) d eroare de compilare deoarece nu am folosit o variabil la scriere c) chiar dac nu este semnalat nici o eroare la compilare, nu se afieaz valoarea dorit, deoarece nu am folosit un specificator de format adecvat 3. Fie declaraiile : int n;long double x; char s[100]; Care din secvenele urmtoare sunt corecte pentru citirea variabilelor ? a) scanf("%i%s %lg",&n,&s,&x); b) scanf("%d %s %Lg",&n,&s,&x); c) scanf("%d %s %Lg",&n,s,&x); d) scanf("%d %c %lf",&n,&s,&x); e) scanf("%d %",&n,&s,&x); 4. Fie declaraia : char s[20]; Care din secvenele de mai jos citesc corect un ir de caractere s ? a) scanf("%c",s); b) scanf("%c",&s); c) d) e) f) scanf("%s",s); scanf("%s",&s); scanf("%",s); scanf("",s);
29
5. Fie declaraia : char str[80]; Care din urmtoarele secvene vor face citirea unui ir de maxim 80 caractere care s nu conin caracterul . ? a) scanf("%[.]s",str); b) scanf("%[^.]s",str); c) scanf("%80[^.]s",str); d) scanf("%80[^.]c",str); e) scanf("%80[.^]s",str); 6. Fie declaraia : char s[100]; Care din urmtoarele secvene va face citirea unui ir de caractere care s conin numai cifre? a) scanf("%[0123456789]", s); b) scanf("%s",s); c) scanf("%[^0-9]s",s); d) scanf("%[09]s",s); e) scanf("%[0-9]s",s); f) scanf("%['0'-'9']",s); g) scanf("%['0'...'9']",s); 7. Cum putem introduce un numr x ntreg de maxim 4 cifre care s nu conin cifra 0? a) scanf(%4d,&x); b) scanf(%4[^0]s,x); c) scanf(%04d,&x); d) scanf(%d0,&x); 8. Fie declaraiile : int a, b, c; i apelul: scanf("%2d%3d%4d",&a,&b,&c);
Limbajul C/C++ pentru nceptori Care va fi valoarea variabilelor dup introducere, dac la intrare se tasteaz 123456? a) a=123 , b=345 , c=56 b) a=12 , b=345 , c=6 c) a=123456 , b=0 , c=0 9. Ce se ntmpl dac se folosete secvena urmtoare ? int m, n; scanf("%d,%d",&m,&n); a) obinem eroare la compilare pentru c n interiorul formatului s-a pus virgul b) nu apar erori la compilare; deoarece n interiorul formatului s-a pus virgul, nu se vor citi corect numerele c) nu apar erori la compilare; deoarece s-a pus virgul, numerele introduse trebuie separate prin virgul d) nu apar erori la compilare; pentru numerele introduse poate fi folosit orice secven delimitatoare 10. Fie secvena urmtoare : int a; char str[20]; scanf("%i", &a); fflush(stdin); gets(str); Datele de intrare se introduc astfel : 100 abcd Ce se ntampl dac scoatem funcia fflush din secvena anterioar ? a) este semnalat eroare la compilare
30
b) nu se mai citete de pe
linia a doua irul "abcd", acesta lund valoarea ""(ir vid) ambele date sunt citite corect, numrul lund valoarea 100 iar irul valoarea "abcd"
c)
11. Fie urmtoarele declaraii de variabile: int a; float x; char m; Care dintre instruciunile de mai jos realizeaz citirea corect a variabilelor a,x i m? a) scanf(%d %f %c,&a,&x,&m); b) scanf(%d,%f,%c,a,x,m); c) scanf(%f.%d.%c,&a,&x,&m); d) scanf(a=%d,x=%f,c=%c, a,x,m); e) scanf(a=%d\nx=%f\nc= %c\n, &a,&x,&m); 12. Fie declaraiile: int a=34; float x=6.25; Precizai care dintre instruciunile de afiare urmtoare trebuie executat astfel nct s se afieze pe ecran rndul de mai jos: 34##:#6.250 unde prin # am simbolizat caracterul spaiu. a) printf(\n%4d:%-10f,a,x); b) printf(\n%-4d:%6.3f,a,x); c) printf(\n%6d:%10f,a,x);
Limbajul C/C++ pentru nceptori d) printf(\n%-d:%-.3f,a,x); e) printf(\n%d:%f,a,x); 13. Dac de la tastatur se introduce caracterul a, iar codurile literelor mici sunt succesive, ncepnd cu 97, ce afieaz programul urmtor? #include<stdio.h> #include<conio.h> void main() { char c, p; p=getchar(): int n=p+259; c=n; putchar(c); } a) 356 b) a c) d d) 100 e) programul este greit 14. Care dintre secvenele de mai jos nu conin erori i afieaz cuvintele Program i simplu unul sub altul (fiecare pe cte un rnd) ? a) { printf(Program); printf(\nsimplu); } b) { printf(Program\n); printf(simplu); } c) { printf(Program\nsimplu); printf(\n); } d) { printf(Program);
31
printf(simplu\n); } e) nici unul dintre programele anterioare 15. Funciile getchar(), getch() i getche() citesc de la tastatur un caracter. Ce deosebiri exist ntre cele trei funcii ? a) funciile getchar i getche realizeaz citire cu ecou, iar getch citete caracterul fr ecou b) funcia getchar citete caracterul cu ecou, iar funciile getche i getch realizeaz citirea fr ecou c) funciile getchar i getch preiau caracterul numai dup apsarea tastei ENTER d) funciile getchar i getche preiau caracterul de ndat ce a fost tastat, fr s mai atepte confirmarea cu ENTER e) toate cele trei funcii au prototipul n headerul conio.h 16. char x=A; putchar(x); putchar(x+1); Referindu-ne la codul de mai sus i presupunnd c funcia putchar ia ca argument un ntreg, ce vom avea la ieire dup execuie ? a) BA b) A66 c) AB
Limbajul C/C++ pentru nceptori d) Se va genera o avertizare la compilare i execuia nu este cea ateptat 17. Unde scrie funcia printf() ? a) stdout b) stdio c) stdin d) stderr 18. Cs a fun language! Selectai codul care va produce ieirea de mai sus: a) printf(Cs a\fun\ language!\n); b) printf(Cs a \fun\language!); c) printf(Cs a\n fun language!\n ); d) printf(Cs a\n \fun\ language!\n); 19. short int x; /*presupunem c x este pe 16 bii*/ Care este numrul maxim care poate fi tiprit folosind printf(%d\n,x), presupunnd c x este declarat aa cum am artat mai sus ? a) 127 b) 255 c) 32767 d) 65536 20. Fie secvena : printf(\n%10.0f,x); Pentru x=3.14159265 se va afia : a) 3 b) 3.14 c) 3.1415 d) 3.141593 Pentru x=123.672 se va afia : a) 1.2E+02 1.236E+02 c) 123E+02 d) 1E+02
32
b)
22. Fie secvena : printf(\n*%15.10S*,x); Pentru x=program c++, se va afia : a) * program c+* (5 spaii n fa) b) *program c++* c) *program c* d) * program c++* (4 spaii n fa) 23. Fie secvena : printf(\n*%07d*,x); Pentru x=123, se va afia : a) *0000123* b) *123* c) * 123* d) *123 * 24. Fie secvena : printf(\n%.4e,x); Pentru x=-123.5e20, se va afia : a) 1.2350e+22 b) 1.235e+22 c) 12.3500e+21 d) 1.2350e+20 25. Care este efectul apelului funciei printf(%x,a), unde a este o variabil de tip ntreg de valoare 0xAF5 : a) 0xAF5 b) 5365 c) AF5 d) valoarea binar a variabilei a 26. Care este efectul urmtorului program : #include <stdio.h> #include <conio.h> void main(void) {
Limbajul C/C++ pentru nceptori putchar(getche()A+a); printf(\n); } a) citete i afieaz un caracter b) citete o liter mare i afieaz litera mic cores-punztoare c) citete o liter mic i afieaz litera mare cores-punztoare d) citete un caracter 27. Se definete constanta simbolic SIR astfel: #define SIR EXAMEN ADMITERE Efectul apelului lui printf(%10.6s,SIR) este urmtorul : a) EXAMEN ADMITERE b) EXAMEN (4 spaii in fa) c) EXAMEN (4 spaii dup) d) EXAMEN ADM 28. Care este efectul apelului funciei printf(%o,a) unde a este o variabil de tip ntreg de valoare 0xAF5 : a) 05365 b) 0xAF5 c) AF5 d) 5365 29. Se d urmtorul program : #include <stdio.h> void main() { double x; scanf(%lf,&x); printf(%e,d); } Efectul acestui program este :
33 un cu i cu
a) citete i afieaz numr real b) citete un numr exponent i l afieaz c) citete un numr real afieaz valoarea sa exponenial d) afieaz un numr real
30. Care este efectul instruciunii printf(%u,x) unde x este o variabil de tip ntreg de valoare 0xAF25 : a) 20669 b) AF25 c) 44837 d) 0xAF25 31. Care este efectul apelului funciei printf(%x,b) unde b este o variabil de tip ntreg de valoare 0x12ABC : a) 12AB b) 12ABC c) 0x12ABC d) 2ABC 32. Care este efectul apelului functiei printf(%lx,b) unde b este o variabil de tip ntreg n dubl precizie de valoarea 0x12ABC : a) 0x12ABC b) 12ABC c) ABC d) 012ABC 33. Fie urmtorul program : #include <stdio.h> main() { int k; scanf(%d,&k); printf(%x,k); } n urma lansrii n execuie a programului, valoarea lui k introdus va fi 65. Care va fi rezultatul afiat ? a) 65 b) 41 c) 32 d) 60
Limbajul C/C++ pentru nceptori 34. Precizai care sunt valorile afiate, dac se vor citi n ordinea indicat valorile numerice 5 2 -3: { int a, b; scanf(%d%d %d,&a,&b,&a); printf(%d,a); printf(%d\n,b); printf(%d,a+b); } a) 5 2 7 b) 3 2 -1 c) 5 2 7 d) exist erori de sintax 35. Care sunt valorile tiprite de programul urmtor : void main(void) { int a,b; a=5; b=13; printf(%d+%2d=%2d,a,b, a+b); } a) a+b=a+b b)5+13=18
34
c)5+13:2=18:2 d) a+b:2=a+b:2 36. Scriei o instruciune care afieaz valoarea variabilei ntregi total : a) printf(%s\n,total); b) printf(%d\n,total); c) printf(%s\n,total); d) printf total; 37. Scriei o instruciune care citete un caracter i-l memoreaz n variabila litera : a) scanf(litera); b) scanf(litera); c) scanf litera; d) scanf(%c,&litera); 38. Scriei o instruciune care afieaz valoarea unei variabile de tip real value cu trei zecimale exacte : a) printf(value:3); b) printf(%.3f\n,value) ; c) printf(%s\n,value:3 ); d) printf %.3f,value;
35
3. Operatori de multiplicare 4. Adunare , scdere 5. Deplasri 6. Relaionali 7. Egalitate 8. 9. 10. 11. 12. 13. Op. condiional 14. Operatori de atribuire
36
Atribuire sum , diferen Atribuire SI , SAU EXCLUSIV , SAU (bit) Atribuire cu deplasare stnga/dreapta Evaluare expresie1 , expresie2 Valoarea rezultatului este expresie2. .
15. Virgula
Cei din prima categorie au prioritatea maxim. Precedena descrete cu ct crete numrul categoriei din care face parte operatorul. Operatorii din aceeai categorie au acelai grad de preceden. Ordinea de evaluare a operaiilor este de la stnga la dreapta, cu excepia operatorilor unari (categoria 2), a operatorului condiional (categoria 13) i a operatorilor de atribuire (categoria 14) care au ordinea de evaluare de la dreapta la stnga. Totui ordinea de efectuare a operaiilor nu este ntotdeauna perfect determinat. Se poate face o reorganizare a expresiilor pentru a obine un cod mai eficient, dar ordinea de efectuare a operaiilor nu este strict definit. n funcie de context, acelai operator poate avea semnificaii diferite. Spre exemplu operatorul & (ampersand) poate fi considerat ca : - operatorul binar SI pe bii (a & b) - operatorul unar, adresa unui operand (&a) Semnificaia depinde de numrul de argumente folosite, unul sau dou .
37
n plus, atribuirea nsi are o valoare, i anume valoarea variabilei din stnga dup memorarea coninutului valorii expresiei. Datorit acestui efect, rezult n final o valoare a expresiei de atribuire care poate fi folosit direct ntr-o alt atribuire. De aceea este permis atribuirea multipl. Exemplul 2 : int i,j,k ; i=j=k=1; care este echivalent cu secvena : k=1; j=k; i=j; Se observ o mai bun compactare a codului surs n primul caz, de folosire a atribuirii multiple. Toate cele trei variabile au dup atribuire valoarea 1. Exemplul 3: int i,j,k; j+1=i; i=1+j=k; Ambele instruciuni de atribuire sunt incorecte, pentru c j+1 nu este o variabil. Exemplul 4: Considerm instruciunile: b=2; c=3; a=b+c; unde toate variabilele sunt de tipul int. Folosind faptul c = este un operator, putem condensa la: a=(b=2)+(c=3); Explicaia este c expresia de asignare b=2 atribuie valoarea 2 att variabilei c, ct i instruciunii ntregi.
38
int i; float x; i=7./2; /* i=3 pentru c 3.5 real este convertit la tipul ntreg al lui i */ X=7./2; /* x=3.5 pentru c x este de tip real */ n concluzie, rezultatul este convertit la tipul variabilei din membrul stng al atribuirii. Exemplul 3: n operaiile cu constante conteaz dac ele sunt de tip ntreg sau real. int i,j; i=5/2+7/2; /* rezultatele mpririi dintre dou numere ntregi sunt convertite tot la numere ntregi i i=2+3=5 */ j=5./2+7/2.; /* rezultatele mpririi dintre un numr real i un numr ntreg sunt numere reale,2.5+3.5=6.0 ,deci j=6 */ Spre deosebire de ceilali operatori aritmetici, operatorii de incrementare i decrementare sunt specifici limbajelor de asamblare. Ei sunt mult mai rapizi, efectul lor constnd n mrirea/micorarea variabilei cu 1 n modul urmtor : - ++var sau var++ : variabila var este mrit cu o unitate, n primul caz, nainte de utilizarea ei (preincrementare), iar n al doilea caz, dup utilizarea ei (postincrementare ) - --var sau var-- : variabila var este micorat cu o unitate, n primul caz, nainte de utilizarea ei (predecrementare), iar n al doilea caz, dup utilizarea ei (postdecrementare) Are importan dac operatorii de incrementare i decrementare se folosesc la stnga sau la dreapta variabilei. Exemplul 4: int i,j=7; i=j++; /* i=7 , j=8 */ sau i=++j; /* i=8 , j=8 */ Exemplul 5: int a=2,b=3,c,d; c=d=(a++ +1)b--; /* a=3 , b=2 , d=0 , c=0 */ Exemplul 6: Fie declaraiile i iniializrile: int a=1,b=2,c=3,d=4; Atunci avem: Expresie Expresie echivalenta parantezata Valoare a*b/c (a*b)/c 0 a*b%c+1 ((a*b)%c)+1 3 ++a*b-c-((++a)*b)-(c--) 1 7 - -b*++d 7-((-b)*(++d)) 17
39
Exemplul 3: Presupunem c avem declaraiile: int i=1,j=2,k=3; Atunci : Expresie i==j i!=j i+j+k==-2*-k Expresie echivalenta j==i j!=i ((i+j)+k)==((-2)*(-k)) Valoare 0 1 1
40
Exemplul 1: Dou forme echivalente pentru verificarea egalitii lui x cu 0. x==0 sau !x Exemplul 2 : Mai multe variante de verificare a condiiei ca x i y s fie ambii 0. a) x==0 && y==0 b) !x && !y c) !(x!=0||y!=0) d) !(x||y) Exemplul 3: Presupunem c avem declaraiile: int i=7,j=7; double x=0.0,y=999.9; Atunci: Expresie Expresie echivalenta Valoare !(i-j)+1 (!(i-j))+1 2 !i-j+1 ((!i)-j)+1 -6 !!(x+3.3) !(!(x+3.3)) 1 !x*!!y (!x)*(!(!y)) 1 Exemplul 4: Presupunem c avem declaraiile: int i=3,j=3,k=3; double x=0.0,y=2.3; Atunci: Expresie Expresie echivalenta i&&j&&k (i&&j)&&k x||i&&j-3 x||(i&&(j-3)) i<j&&x<y (i<j)&&(x<y) i<j||x<y (i<j)||(x<y)
Valoare 1 0 0 1
41
Operatorul ~ se numete operator de complement pe bit. Acesta inverseaz reprezentarea irului de bii, adic 0 devine 1 i 1 devine 0. Exemplu: Fie declaraia: int a=1571; //nr.ntreg cu semn reprezentatat, de exemplu, pe 2 octei Reprezentarea intern binar a lui a pe 2 octei este 00010100 00110011 Expresia ~a este: 11101011 11001100 Aceasta are valoarea ntreag -5172. Observaie: Reamintim n continuare cum se calculeaz valoarea unui numr pozitiv, respectiv negativ (n memoria calculatorului). Fie declaraia int a; Considerm reprezentarea sa intern binar pe 2 octei: b15 b14
14
b1
b0
a = b j 2 j
j =0
Dac b15=1, considerm reprezentarea n baza 2 a complementului lui a (~a): t15 t14 t1 t0
~ a = b j 2 j
j =0
14
-a=~a+1 a=-(~a+1) Complementul fa de 2 ale lui 0 i 1 sunt speciale. Astfel valoarea 0 are toi biii 0, pe cnd valoarea 1 are toi biii 1.
42
Observaie: Dac maina pe care lucrai reprezint tipul int ca long int pe 4 octei, raionamentul se aplic identic pe 32 de bii. Operatorii <<, respectiv >>, sunt numii operatori de deplasare pe bii la stnga, respectiv la dreapta. Ei au sintaxa : a<<n /* echivalent cu a*2n */ a>>n /* echivalent cu a/2n */ Exemplul 1: int t=1,j=6,k,n; t=1<<j; /* t=1*26 */ k=t>>2; /* k=26/22=24 */ n=t&k; /* n=0 pentru c t i k nu au nici un bit de pe aceeai poziie egal cu 1 */ Exemplul 2: Fie declaraia char c=Z; Expresie c c<<1 c<<4 c<<15 Reprezentare 01011010 10110100 10100000 00000000 Actiune nedeplasat deplasare la stanga cu 1 deplasare la stanga cu 4 deplasare la stanga cu 15
Chiar dac valoarea lui c se memoreaz pe un octet, ntr-o expresie aceasta ia tipul int. Deci valoarea expresiilor c<<1, c<<4 i c<<15 se memoreaz pe 2 octei. Operatorul de deplasare la dreapta >> nu este chiar simetric cu <<. Pentru expresiile integrale fr semn, din stnga se va deplasa 0, iar pentru cele cu semn 1. Presupunem c avem declaraiile: int a=1<<15; //intreg cu semn unsigned b=1<<15; //intreg fara semn Expresie a a>>3 b b>>3 Reprezentare 10000000 00000000 11110000 00000000 10000000 00000000 00010000 00000000 Actiune nedeplasat deplasare la dreapta cu 3 nedeplasat deplasare la dreapta cu 3
Ca valoare zecimal, a>>3 este 4096, iar b>>3 este 4096, lucru care este n concordan cu noiunea de numr negativ i pozitiv din matematic. Observaie: Dac operandul din dreapta a operatorului de deplasare este negativ sau are o valoare care este egal sau depete numrul de bii folosii pentru reprezentarea intern a operandului din stnga, atunci comportarea este nedefinit. Exemplul 3:
43
Tabelul de mai jos ilustreaz regulile de preceden (+ este mai prioritar) i asociativitatea (de la stnga la dreapta) referitoare la operatorii de deplasare. Presupunem c avem declaraiile unsigned a=1,b=2; Expresie a<<b>>1 a<<1+2<<3 a+b<<12*a>>b Expresie echivalent (a<<b)>>1 (a<<(1+2))<<3 ((a+b)<<(12*a))>>b Reprezentare 00000000 00000010 00000000 01000000 00001100 00000000 Valoare 2 64 3072
Exemplul 4: Fie constanta 0u, o constant ntreag de tip unsigned care se reprezint pe 16 bii, deci este practic reprezentat ca 16 de 0. Operaia ~(0u) neag cei 16 bii de 0 care vor lua valoarea 1, deci se va obine valoarea 216-1=65535. Exemplul 5: Presupunem c avem declaraiile i iniializrile: int a=3333,b=7777; Expresie a b a & b a ^ b a | b ~(a | b) (~a & ~b) Reprezentare 00001101 00000101 00011110 01100001 00001100 00000001 00010011 01100100 00011111 01100101 11100000 10011010 11100000 10011010 Valoare 3333 7777 3073 4964 8037 -8038 -8038
Exemplul 6: Operatorii | i & pot fi folosii pentru a seta(face 1) sau terge (face 0) anumite cmpuri de bii. (k&1<<j)>>j ; /* determin valoarea bitului de pe poziia j */ k=k&~(1<<j); /* seteaz bitul de pe poziia j la 0 */ k=k|1<<j; /* seteaz bitul de pe poziia j la 1 */ k=k^1<<j; /* complementeaz bitul de pe poziia j */ Exemplul 7: Programul determin numrul format prin extragerea a n bii consecutivi dintr-un numr dat x ncepnd cu poziia p. #include<stdio.h> void main() { int n,p,x; printf(numarul : ); scanf(%d,&x); printf(numarul de biti : ); scanf(%d,&n); printf(pozitia : ); scanf(%d,&p); printf(numarul este : %d, (x>>p)&~(~0<<n)); } n partea stng a operatorului & se elimin primii p bii prin deplasarea la dreapta. Pentru a extrage cei n bii, se realizeaz n partea dreapt un filtru, setnd primii n bii pe 1 i tergndu-i pe ceilali.
44
Exemplul 8: O masc este o constant sau o variabil folosit pentru extragerea biilor dorii dintr-o alt variabil sau expresie. Din moment ce constanta int 1 are reprezentarea pe bii 000000000 00000001, aceasta poate fi folosit pentru determinarea bitului cel mai nesemnificativ dintr-o expresie int folosind o construcie de forma expresie & 1. Fie declaraia int j; atunci expresia j&1 are valoarea 0 dac j este par i valoarea 1, dac j este impar. Dac dorim s gsim valoarea unui anume bit dintr-o expresie, putem folosi o masc care are 1 n acea poziie i 0 n rest. De exemplu, putem folosi expresia 1<<2 pentru a vedea al treilea bit (numrnd de la dreapta). Expresia (v&(1<<2)) are valoarea 1 sau 0 dup cum este al treilea bit din v. Alt exemplu de masc este valoarea constant 255 (adic 28-1). Ea are reprezentarea 00000000 11111111. Deoarece doar octetul din dreapta este 1, atunci expresia v &255 va ntoarce o valoare egal cu octetul din dreapta al variabilei v. Spunem c 255 este o masc pentru octetul din dreapta. Exemplul 9: Un caz concret de utilizare a operaiilor la nivel de bit este cel al reprezentrii mulimilor de valori. Astfel, s presupunem c dorim s inem evidena literelor majuscule dintr-un ir de caractere introduse de la consol. n acest scop se poate folosi cte un singur bit pentru a codifica absena (0) sau prezena (1) fiecrei litere. Deoarece alfabetul latin este format din 26 litere, pentru a pstra evidena tuturor majusculelor trebuie s folosim o variabil (m) de tip long (32 de bii). Dintre cei 32 de bii din reprezentarea variabilei vom utiliza numai 26, informaia referitoare la o liter oarecare x fiind pstrat n bitul din poziia Z-x. n absena majusculelor, toi biii fiind 0, condiia de mulime vid se exprim sub forma !m. Includerea n mulime a unei majuscule x se realizeaz prin intermediul atribuirii: m=m|(1L<<Z-x) Se remarc utilizarea constantei 1L, de tip long. Dac n locul ei s-ar fi utilizat constanta 1 (implicit de tipul int ), atunci informaiile referitoare la primele 10 litere din alfabet nu ar fi fost actualizate, deoarece rezultatul deplasrii la stnga, cu mai mult de 15 bii, a unei valori de tip int este nul. Verificarea prezenei n mulime a caracterului x se poate realiza n urmtoarele dou variante : m&(1L<<Z-x) sau (m>>Z-x)&1
45
5 combinaii cu operatori aritmetici : += , - = , *= , /= , %= 5 combinaii cu operatori pe bii : |= , &= , ^= , <<= , >>= Executarea unei instruciuni care folosete operatori compui de atribuire este mult mai rapid deoarece compilatorul, cunoscnd c primul operand i rezultatul au aceeai locaie de memorie, folosete un numr mai mic de operaii, avnd nevoie de un timp de execuie mai mic dect atribuirea n cazul general. Exemplul 1: Folosirea operatorului de aflare a restului . int k=6,j=5; k%=j; /* k=6%5=1 */ Exemplul 2: Folosirea operatorului de deplasare pe bii . int k=7,j=3; k<<=j; /* k=k*23=7*8=56 */ Exemplul 3 : Folosirea operatorului de deplasare la dreapta pe bii i apoi a operatorului aritmetic de adunare. int a=3,b=5,c; a+=b>>=c=2; /* c=2 , b=5/22=1 , a=3+1=4 */ Exemplul 4 : Folosirea operatorului SAU EXCLUSIV pentru interschimbarea valorilor a dou variabile. unsigned int k=6,j=9; k^=j^=k^=j; Exemplul 5 : Folosirea operatorului I pe bii . long k; k&=~k; /* k=0 , indiferent de valoarea sa iniial */ Exemplul 6 : unsigned short k; short j; k|=~k; /* k=216-1=65535 , indiferent de valoarea sa anterioar */ j|=~j; /* dac j este cu semn, atunci valoarea sa devine 1 */ Exemplul 7: int k; k^=k; /* k=0 , indiferent de valoarea sa anterioar */ Exemplul 8: int k=-25; k<<=2; /* k= -25*22= -100 */ Exemplul 9: Expresia de asignare j*=k+3; este echivalent cu j=j*(k+3); i nu cu j=j*k+3; Exemplul 10:
Limbajul C/C++ pentru nceptori Fie declaraiile: int i=1,j=2,k=3,m=4; Expresie i+=j+k j*=k=m+5 Expresie echivalenta i+=(j+k) j*=(k=(m+5)) Expresie echivalenta i=(i+(j+k)) j=(j*(k=(m+5)))
46
Valoare 6 18
47
48
a=i,i+=j; /* a=7 , i=10 */ sau i+=j,a=i; /* i=10 , a=10 */ Exemplul 2: double x, y, temp; (x>y)?(temp=x, x=y, y=temp):y ; /* are ca efect ordonarea cresctoare a variabilelor x i y; ca rezultat se obine cea mai mare dintre valorile x i y */
erau
Limbajul C/C++ pentru nceptori Care din expresiile urmtoare determin octetul inferior al variabilei n ? a) n%256 b) n>>4 c) n & 0xFF d) (n<<4)>>4 e) n>>8 f) (n<<8)>>8 8. Fie definiiile : unsigned m=0xF0F,n=0xF0F0; char format[]="\n n=%4x"; S se gseasc care vor fi valorile afiate dup urmtoarele operaii : a) printf(format,m); b) printf(format,n); c) printf(format,~m); d) printf(format,~n); e) printf(format m|n); f) printf(format,m&n); g) printf(format,m^n); 9. Evaluai rezultatul i corectitudinea urmtoarelor secvene : int i=1,j=2,k=-7; double x=0.0,y=2.5; a) -i-5*j>=k+1 b) 3<j<5 c) i+j+k==-2*j d) x/!!y e) x&&i||j-3 10. Ce valoare vor avea variabilele x si y dup secvena de instruciuni ? int x=7,y; y=x<<=2; a) 32 b) 28 c) 64 11. S se determine care din urmtoarele expresii sunt corecte : a) z=x++==4||y--<5; b) a=x==y==z; 12. Realizai cu ajutorul operatorului condiional "?" urmatoarele operaii : a) determinarea valorii absolute a unui numr x
49
b) determinarea minimului n valoare absolut a dou numere c) determinarea maximului a trei numere 13. Ce face urmtorul program ? #include<stdio.h> main() { int i,j; scanf("%d% d" ,&i ,&j); printf("\n i=%d , j=%d", i, j); i=i-j , j=j+i , i=j-i; printf("\n i=%d , j=%d", i, j); } a) realizeaz un calcul algebric oarecare b) adun valorile absolute ale lui i i j c) interschimb valorile varia-bilelor i i j 14. Care din cele trei expresii sunt echivalente ntre ele ? a) 1<<n+1; b) 1<<(n+1) c) (1<<n)+1 15. Fie expresia : (int) (sqrt(n)) Are importan folosirea perechii de paranteze rotunde pentru tipul int ? Dar pentru sqrt(n) ? 16. S se transcrie sub form de expresii de atribuire expresiile de mai jos : a) y=2x3-8x2+7x-1 b) y=(ax+b)/(cx+d) c) a=max(x+y,x-y) d) m=max(3x2+1,6x-20) e) x=1, 5a3-2, 8a2+3, 7a-1
Limbajul C/C++ pentru nceptori f) x=a*b*c-(a-b)(a-c)+(b-c) g) dac (x+y)!=0 atunci z=x/(x+y) altfel z=0 17. S se transcrie sub form de expresie de atribuire : a) y=|2x+10| b) a=max(x,y,z) c) dac x>y si x>z atunci u=v, altfel u=v/2 d) dac x>y sau x>z,atunci p=a+b,altfel p=a-b e) dac nici una din condiiile i>j, i>k, i>n nu are loc, atunci x=a, altfel x=b f) dac c are ca valoare codul ASCII al unui caracter alb, atunci i se mrete cu 1, altfel se micoreaz cu 1 g) dac a>b>1 i a<10, atunci x=a/b, altfel x=100 h) dac c are ca valoare un cod diferit de codul caracterelor albe, atunci i=x+y, altfel i=x-y i) dac valorile variabilelor a,b si c pot reprezenta lungimile laturilor unui triunghi, atunci x are ca valoare perimetrul acestui triunghi, altfel are valoarea 0. 18. Fie declaraia : int x,i,j; S se scrie o expresie care are ca valoare ntregul format cu j bii din x , ncepnd cu al i-lea bit. 19. double x=1/2.0+1/2; printf(x=%.2f\n,x);
50
Ce se va tipri dup execuia codului de mai sus ? a) x=0.00 b) x=0.25 c) x=0.50 d) x=0.75 20. Care va fi valoarea lui i dup execuia urmtoarelor instruciuni : i=4; i=i?18:2; a) 4 b) 18 c) 2 d) 9 21. Se declar variabila unsigned int a=0x3FF Care este valoarea expresiei a>>3 ? a) 3FF b) 0xBF c) 0x7F d) 0x3FC 22. Se dau int a=0,b=1,c=2; Valoarea variabilei cp din expresia: cp=rez=a+b+c>c&&b*c<a+b*c este : a) 1 b) 0 c) 2 d) 1.5 23. Se d variabila b=0xFF10 de tip unsigned int i expresia b>>3. Efectul acestei expresii este : a) 1FF2 b) valoarea binar a varia-bilei b c) 0xFF13 d) 0x1FE2 24. Se dau variabilele de tip ntreg a=0x125,b=0455,c=293,d=0xAF, x,y i expresia x=y=(a==b&a==c)^d. Variabilele x si y au valoarea : a) AF b) 0257 c) 10101111 d) 0xAF 25. Fie expresia de mai jos : (x>-1) && !(x>1)||(x>=5) Intervalul selectat este :
51
a) b) c) d)
32. Fie secvena de cod : int x=1*2+4/4+3%5; Valoarea lui x este : a) se va genera eroare b) 3 c) 6 d) 5 33. Presupunnd urmtoarea secven de cod : int a=5,b=2; float c=a/b; Care va fi valoarea lui c ? a) 2.5 b) 2 c) 3 d) 1 34. Avem urmtorul program : int main() { float x, y, z; x=1.3; y=1.2; z=x%y; return 0; } La sfritul programului variabila z va avea valoarea : a) 0.1 b) 0 c) 1 d) programul genereaz eroare la compilare 35. Fie secvena : double x,y; . x=9; y=3(x-10); .. Care afirmaie este adevarat : a) y=-3 b) y=3 c) eroare la compilare deoarece lipsete operator d) eroare la compilare deoarece nu se poate scdea un double 36. Urmrii secvena de mai jos i precizai valoarea variabilei y: int a, b=3; int x=2;
26. Care este intervalul descris de expresia logic de mai jos ? (x<=-2)|| (x>-1)&&!(x>=1)||(x>5) a) x (- , -2] (-1,1] [5, ) b) x (- ,-2] [-1,1] (5, ) c) x(- ,-2] (-1,1] [5, ) d) x (- ,-2] (-1,1) (5, ) 27. Care din urmtorii relaionali este invalid ? a) == b) <> c) < operatori d) >
28. Care din urmtorii operatori are prioritatea cea mai mic ? a) == b) + c) d) ! 29. Dup execuia secvenei de cod, ce valoare va avea variabila z ? int z; int x=5; int y=-10; z:=x--y; a) 10 b) 5 c) 5 d) 15 30. Ce rezultat va produce operaia : 0xB & 0x5 a) 0xE b) 0xF c) 0x1 d) 0x8 31. Fie relaia 4/5|3+4%5&3. Care este rezultatul evalurii ei ? a) 4 b) 3 c) 1 d) 1
52
37. tiind c n conformitate cu standardul ASCII literele mari au codurile succesive ncepnd cu 65, precizai care dintre variabilele x, y, z i u vor avea valoarea 2 la finele execuiei programului de mai jos. void main() { int x=-3, y=1, z=2, u; x++; y+=2; z-=1+sqrt(y+2); // radical de ordin doi u=A-C; } a) x b) y c) z d) u e) nici una 38. Se consider variabilele ntregi x,y i z, fiind cunoscute valorile x=4 i y=2. Care dintre expresiile de mai jos are valoarea 0 ? a) x+y>x%y+1 b) z=(x-y!=0) c) x-2*y=0 d) !x e) x && y 39. tiind c a, b, c, d, x sunt variabile reale cu a<=b i c<=d, scriei sub form de expresie : x [a, b] sau x [c, d]. a) (x>=a||x<=b)&&(x>=c||x<=d) b) ((x>=a)&&(x<=b))||((x>=c)&& (x<=d)) c) (!(x<a)&&!(x>b))||(! (x<c)&&
!(x>d)) d) ((x>=a)|| (x<=b))&&((x>=c)|| (x<=d)) e) (x>=a && x<=b) || (x>=c && x<=d) 40. Fie declaraiile de variabile: int x=4, z=13; float z; Care dintre instruciunile de mai jos nu atribuie corect valoarea 8.5 variabilei z? a) z=(x+y)/2.; b) z=((float)x+y)/2: c) z=(x+y.)/2; d) z=(x+y)/(float)2; e) z=(float)(x+y)/2; 41. Ce afieaz programul urmtor, dac valoarea citit de la tastatur este 2 ? #include<stdio.h> void main() { int x,y,z; scanf(%d, &x); y=--x; y+=3; z=x-2*y++; printf(%d, z++); } a) 9 b) 8 c) 7 d) 6 e) 5 42. Fie trei variabile ntregi a, b, x. Precizai care dintre expresiile condiionale de mai jos nu este o transcriere corect a enunului: dac numrul y este pozitiv, atunci x ia valoarea lui a, n caz contrar x ia valoarea lui b.
Limbajul C/C++ pentru nceptori a) b) c) d) e) x=(y>0) ? a : b; x=y>0 ? b: a; x=!y>0 ? b : a; y>0 ? x=a :x=b; !(y>0) ? x=b : x=a; } a) 2 b) 8 c) 51 d) 56 e) programul este greit
53
43. Ce valoare afieaz programul urmtor ? #include<stdio.h> void main() { int x=5, y; y=(sizeof(x-1)== sizeof(int)) ? sizeof(x) : sizeof(3); printf(%d, y); } a) 3 b) 1 c) 2 d) 4 e) programul este eronat 44. Ce valori va afia programul urmtor ? #include<stdio.h> void main() { int a=10, b=6, c=4, d; d=(c=a-6, a=b%c, b+=a, a/2); printf(\n%d %d %d %d, a,b,c,d); } a) 0 16 6 5 b) 2 8 4 1 c) 4 2 8 1 d) 6 0 16 5 e) alte valori 45. Ce valoare afieaz programul de mai jos ? #include<stdio.h> void main() { int a=3, b=2, n=4, x; x=(a<<n) + (a&b) + (n|b); printf(%d, x);
46. Fie variabilele ntregi a=1,b=2,c=3,d=4. Care dintre construciile de mai jos sunt expresii scrise corect, cu valoarea 0 ? a) !d b) a+b<d c) a*b+c d) a=b<c e) (a<b)!=(b<c) 47. Pentru care dintre seturile de valori ale variabilelor x, y, z de mai jos expresia (x<y)<((z!=x)<((z-y)<x)) are valoarea 1? a) x=3; y=5; z=4 b) x=4; y=3; z=4 c) x=3; y=4; z=3 d) x=5; y=4; z=3 e) x=5; y=5; z=5 48. Care dintre urmtoarele expresii au valoarea 1 dac i numai dac valorile variabilelor ntregi x i y sunt numere pare ? a) x-y==2 b) x*y%4==0 c) (x+y)%2==0 d) y%x==2 e) (x%2==0)&&(y%2==0) 49. Care dintre urmtoarele expresii sunt adevrate dac i numai dac valorile variabilelor x i y sunt numere naturale consecutive ? a) x-y==1 b) (x==1)&&(y==2) c) (x-y==1)&&(y-x==1) d) y==x+1 e) (x-y==1)||(y-x==1) 50. Se consider urmtoarele declaraii de variabile : int a,b,e; float c,d;. Care dintre
Limbajul C/C++ pentru nceptori instruciunile de mai jos sunt incorecte? a) a=a*b; b) e=a<c; c) b=a+a/b; d) d=(a+b)/2; e) c*d=a-b; 51. Fie variabilele x,y,z de tipul int, fiind cunoscute valorile iniiale x=3, y=5. Care dintre instruciunile de mai jos trebuie executat astfel nct, dup execuie, valoarea variabilei z s fie 21? a) z=2*x+3*y--; b) z=2*x+3*--y; c) z=2*x--+3*y; d) z=2*--x+3*y; e) z=2*x+3*y; 52. Fie trei variabile ntregi a,b,x. Scriei cu ajutorul unei expresii condiionale enunul dac x nu aparine [a,b] , atunci x ia valoarea lui a, n caz contrar x ia valoarea lui b. a) x=((x<a)||(x>b))? a : b; b) x=(x<a||x>b)? a : b; c) x=((x<a)&&(x>b))? a : b; d) x=(x<a)||(x>b)? b : a; e) (x<a)||(x>b))? (x=a) : (x=b); 53. tiind c n standardele ASCII caracterele liter mare au codurile succesive ncepnd cu 65, deducei ce valoare va afia programul urmtor. #include<stdio.h> void main() { int x,y,z,p; char m,n; m=C; n=A; x=m; y=2*m-n; z=3; p=x<y?(y<z ? z:y): (z<x?x:z); printf(\n%d, p); } a) 1 e) 0 b) 3 c) 69
54 d) 67
54. tiind c valorile de tipul int se memoreaz pe 2 octei, iar cele de tipul float pe 4 octei, de cte ori va afia programul urmtor valoarea 2? #include<stdio.h> void main() { int x; char c; x=A; printf(%d, sizeof(x)); c=A; printf(%d,sizeof(c)); printf(%d,sizeof(float)2); x=sizeof(int); x=++x/2; printf(%d, x==2); } a) nici o data b) o data c) de 2 ori d) de 3 ori e) de 4 ori 55. Ce valori afieaz programul urmtor ? #include<stdio.h> void main() { int x=10,y=6, m, n, p; n=(m=x++, y++, p=x+y); printf(\n%d %d %d, m,n,p); } a) 10 18 16 b) 11 18 18 c) 10 18 18 d) 11 18 17 e) 10 18 17 56. Ce valoare putem introduce la citirea variabilei y, astfel nct programul de mai jos s tipreasc 1 ? #include<stdio.h> void main() {
Limbajul C/C++ pentru nceptori int x=2, y, z; scanf(%d, &y); z=y+3*x++; printf(\n%d, (z%2==0&&x>=1)?1:0); } a) 2 b) 3 c) 4 d) orice valoare par e) orice valoare impar 57. Fie variabilele a,b,c de tipul int, cu valorile a=11, b=5, c=7. Care dintre expresiile de mai jos are valoarea 1? a) (a|~b)&1 b) (~a&b)|1 c) (a&~b)|1 d) (a&b)|~1 f) (~a|b)&1
55
58. Precizai valoarea pe care o va avea variabila c n urma execuiei programului de mai jos: #include<stdio.h> void main() { char c=d; int n=99; c=n+1=c-1; } a) d b)c c) b d) NULL e) atribuirea este greit
56
57
// transform litera mic n litera mare coresp. Este o instruciune de apel a funciei putch. Exemplul 4: double a; a++; Este o instruciune expresie, care mrete valoarea lui a cu unu. Exemplul 5: double a; ++a; Are acelai efect ca i instruciunea expresie din exemplul precedent. Observaie : Nu orice expresie urmat de punct i virgul formeaz o instruciune expresie efectiv. De exemplu construcia a; dei este o instruciune expresie, ea nu are nici un efect. Exemplul 6 : S se scrie un program care citete valorile variabilelor a, b, c, d, x de tip double i afieaz valoarea expresiei (a*x2+b*x+c)/(a*x2+b*x+d) dac numitorul este diferit de 0 i 0 n caz contrar. #include<stdio.h> #include<conio.h> void main() { double a,b,c,d,x; doube y,z,u; clrscr(); printf(a=); scanf(%lf,&a); printf(b=); scanf(%lf,&b); printf(c=); scanf(%lf,&c); printf(d=); scanf(%lf,&d); printf(x=); scanf(%lf,&x); y=a*x*x; z=b*x; u=y*x+z+d; printf(exp=%g\n,u ?(y+z+c)/u:u); getch(); }
58
Exemplu : Presupunem c ntr-un anumit punct al programului este necesar s se permute valorile variabilelor ntregi a i b. Aceasta se poate realiza astfel : { int t; t=a;a=b;b=t; } Variabila t este definit din momentul n care controlul programului ajunge la prima instruciune din instruciunea compus (t=a;). Dup execuia ultimei instruciuni a instruciunii compuse, variabila t nu mai este definit (nu mai ocup memorie). Instruciunea compus se utilizeaz unde este necesar prezena unei instruciuni, dar procesul de calcul din punctul respectiv este mai complex i se exprim prin mai multe instruciuni. n acest caz instruciunile respective se includ ntre acolade pentru a forma o instruciune compus. Acest procedeu de a forma o instruciune compus din mai multe instruciuni se utilizeaz frecvent n construirea structurilor alternative i ciclice.
5.4 Instruciunea if
Are urmtoarele formate : format1 : if(expresie) instruciune; format2: if(expresie) instruciune1; else instruciune2; La ntlnirea instruciunii if nti se evalueaz expresia din paranteze. Apoi, n cazul formatului 1, dac expresia are valoarea diferit de zero (adic true) se execut instruciune, altfel se trece n secven la instruciunea urmtoare instruciunii if. n cazul formatului 2, dac expresia are o valoare diferit de zero, atunci se execut instruciune1 i apoi se trece n secven la instruciunea aflat dup instruciune2, altfel (condiia este zero, adic false) se execut instruciune2. n mod normal, n ambele formate, dup execuia instruciunii if se ajunge la instruciunea urmtoare ei. Cu toate acestea, este posibil i o alt situaie cnd instruciunile din compunerea lui if definesc ele nsele un alt mod de continuare a execuiei programului. Deoarece o instruciune compus este considerat ca fiind un caz particular de instruciune, rezult c instruciunile din compunerea lui if pot fi instruciuni compuse. De asemenea, instruciunile respective pot fi chiar instruciuni if. n acest caz se spune c instruciunile if sunt imbricate. Exemplul 1: Se d funcia : y=3x2+2x-10, pentru x>0 i y=5x+10, pentru x<=0. S se scrie un program care citete valoarea lui x i afieaz valoarea lui y. #include<stdio.h> #include<conio.h> void main()
Limbajul C/C++ pentru nceptori { float x,y; clrscr(); scanf("%f",&x); if(x>0) y=3*x*x+2*x-10; else y=5*x+10; printf("x=%f\ty=%f\n",x,y); getch();
59
} Exemplul 2: S se scrie un program care citete valoarea lui x, calculeaz i afieaz valoarea lui y definit ca mai jos : y=4x3+5x2-2x+1 , pentru x<0 y=100 , pentru x=0 y=2x2+8x-1 , pentru x>0 #include<stdio.h> #include<conio.h> void main() { float x,y,a; clrscr(); scanf("%f",&x); a=x*x; if(x<0) y=4*x*a+5*a-2*x+1; else if(!x) y=100; else y=2*a+8*x-1; printf("x=%f\ty=%f\n",x,y); getch(); } Exemplul 3: S se scrie un program care citete valorile variabilelor nentregi a i b, calculeaz rdcina ecuaiei : ax+b=0 i afieaz rezultatul. #include<stdio.h> #include<conio.h> void main() { double a,b; clrscr(); if(scanf("%lf %lf",&a,&b)!=2) /* valideaz numrul coeficienilor reali citii */ printf("coeficienti eronati\n"); else if(a)
Limbajul C/C++ pentru nceptori printf("a=%g\tb=%g\tx=%g\n",a,b,-b/a); else if(!b) printf("ecuatie nedeterminata\n"); else printf("ecuatia nu are solutie\n");
60
getch(); } Programul de mai sus conine o instruciune if imbricat. Pentru a mri claritatea programelor se obinuiete s se decaleze spre dreapta (cu un tabulator) instruciunile din compunerea instruciunii if. n acest program s-a realizat test relativ la valorile tastate pentru a i b. Reamintim c funcia scanf() returneaz numrul argumentelor citite corect de la tastatur. Acest numr se folosete uzual pentru a valida corectitudinea citirii datelor de intrare. Astfel, dac funcia scanf() nu returneaz valoarea 2, nseamn c nu s-au tastat dou numere de la terminal. De aceea, n astfel de situaii se afieaz mesajul coeficieni eronai. Exemplul 4: S se scrie un program care citete coeficienii a,b,c,d,e,f ai unui sistem de dou ecuaii lineare cu dou necunoscute, determin i afieaz soluia acestuia atunci cnd are o soluie unic. #include<stdio.h> #include<conio.h> void main() { double a,b,c,d,e,f,x,y,det1,det2,det; clrscr(); //validarea citirii datelor de intrare if(scanf("%lf%lf%lf%lf%lf%lf",&a,&b,&c,&d,&e,&f)!=6) printf("coeficienti eronati\n"); else if(!(det=a*e-b*d)) printf("sistemul nu este determinat\n"); else { det1=c*e-b*f; det2=a*f-c*d; x=det1/det; y=det2/det; printf("x=%g\ty=%g\n",x,y); } getch(); }
61
i el se afl n fiierele header stdlib.h i process.h. La apelul acestei funcii au loc urmtoarele aciuni: se videaz zonele tampon (bufferele) ale fiierele deschise n scriere se nchid toate fiierele deschise se ntrerupe execuia programului Parametrul acestei funcii definete starea programului la momentul apelului. Valoarea 0 definete o terminare normal a execuiei programului, iar o valoare diferit de 0 semnaleaz prezena unei erori (terminarea anormal a execuiei programului). n concluzie, putem apela funcia exit pentru a termina execuia unui program, indiferent de faptul c acesta se termin normal sau din cauza unei erori. Exemplu : S se scrie un program care citete valorile variabilelor a,b,c, calculeaz i afieaz rdcinile ecuaiei de gradul 2 : ax2+bx+c=0. #include<stdio.h> #include<conio.h> #include<math.h> #include<stdlib.h> void main() { double a,b,c,d,delta; clrscr(); printf("coeficientul lui x patrat : "); if(scanf("%lf",&a)!=1) { printf("coeficientul lui x patrat eronat\n"); exit(1); /* terminare la eroare*/ } printf("coeficientul lui x : "); if(scanf("%lf",&b)!=1) { printf("coeficientul lui x eronat\n"); exit(1); } printf("termenul liber : "); if(scanf("%lf",&c)!=1) { printf("termenul liber eronat\n"); exit(1); } // afieaz coeficienii citii printf("a=%g\tb=%g\tc=%g\n",a,b,c); if(!a && !b && !c) { printf("ecuatie nedeterminata\n"); exit(0); /* terminare fr erori*/ } if(!a&&!b) { printf("ecuatia nu are solutie\n"); exit(0); }
Limbajul C/C++ pentru nceptori if(!a) { printf("ecuatie de gradul 1\n"); printf("x=%g\n",-c/b); exit(0); } delta=b*b-4*a*c; d=2*a; if(delta>0) { printf("ecuatia are doua radacini reale si distincte\n"); delta=sqrt(delta); printf("x1=%g\tx2=%g\n",(-b+delta)/d, (-b-delta)/d); exit(0); } if(!delta) { printf("ecuatia are radacina dubla\n"); printf("x=%g\n",-b/d); exit(0); } printf("radacini complexe\n"); delta=sqrt(-delta)/d; d=-b/d; printf("x1=%g+i(%g)\n",d,delta); printf("x2=%g-i(%g)\n",d,delta); getch();
62
63
s fie o instruciune compus care s conin instruciunea while. n acest caz se spune c instruciunile while respective sunt imbricate. Instruciunile din corpul unei instruciuni while pot s defineasc un alt mod de execuie a instruciunii while dect cel indicat mai sus. Astfel, se poate realiza terminarea execuiei instruciunii while fr a se mai ajunge la evaluarea expresiei din antetul ei. De exemplu, dac n corpul unei instruciuni while se apeleaz funcia exit, atunci se va termina execuia ciclului while, deoarece se ntrerupe chiar execuia programului. Despre instruciunea while se spune c este o instruciune ciclic condiionat anterior. Exemplul 1: S se scrie un program care calculeaz i afieaz valoarea polinomului p(x)=3x2-7x-10 pentru x=1,2,.,10. #include<stdio.h> #include<conio.h> void main() { int x; clrscr(); x=1; while(x<=10) { printf("x=%d\tp(x)=%d\n",x,3*x*x-7*x-10); x++; } getch(); } Exemplul 2: S se scrie un program care citete un ir de ntregi separai prin caractere albe i afieaz suma lor. Dup ultimul numr se va tasta un caracter alb urmat de un caracter nenumeric (de exemplu, caracterul sfrit de fiier <Ctrl>+Z, o liter, etc.), iar dup aceea se va aciona tasta Enter. #include<stdio.h> #include<conio.h> void main() { int i,s=0; clrscr(); while(scanf("%d",&i)==1) s+=i; printf("suma=%d\n",s); getch(); } Exemplul 3: S se scrie un program care citete un ntreg n [0,170], calculeaz i afieaz pe n!. Avem: n!=1*2*3*..*n , pentru n >0 i 0!=1 , prin definiie. #include<stdio.h> #include<conio.h> #include<stdlib.h> void main() { int n,i; double f; //n! este o valoare f.mare care nu poate fi memorat
Limbajul C/C++ pentru nceptori //ntr-un ntreg clrscr(); printf("n="); //validarea datelor de intrare if(scanf("%d",&n)!=1) { printf("nu s-a tastat un intreg\n"); exit(1); } if(n<0 || n>170) { printf("n nu apartine intervalului [0,170]\n"); exit(1); } f=1.0; i=2; while(i<=n) f*=i++; printf("n=%d\tn!=%g\n",n,f); //formatul %g va tipri f fr zecimalele //nesemnificative, deci ca un ntreg getch(); }
64
65
exp3; } Aceast echivalare nu are loc ntr-un singur caz i anume atunci cnd, n corpul instruciunii se utilizeaz instruciunea continue. Reciproc, orice instruciune while poate fi scris cu ajutorul unei instruciuni for n care exp1 i exp3 sunt vide. Astfel, instruciunea while(exp) instruciune; este echivalent cu instruciunea for(; exp ;) instruciune; . O instruciune for de forma for(; ;) instruciune; este valid i este echivalent cu instruciunea : while(1) instruciune;. Un astfel de ciclu se poate termina prin alte mijloace dect cel obinuit, cum ar fi instruciunea de revenire dintr-o funcie, un salt la o etichet etc. Din cele de mai sus rezult echivalena celor dou cicluri while i for. Se recomand folosirea instruciunii for n ciclurile n care sunt prezente prile de iniializare i reiniializare, aa numitele cicluri cu pas. Exemplul 1: S se scrie un program care citete ntregul n din intervalul [0,170], calculeaz i afieaz pe n! . #include<stdio.h> #include<conio.h> #include<stdlib.h> void main() { int n,i; double f; //n! este o valoare f.mare care nu poate fi memorat //ntr-un ntreg clrscr(); printf("n="); //validarea datelor de intrare if(scanf("%d",&n)!=1) { printf("nu s-a tastat un intreg\n"); exit(1); } if(n<0 || n>170) { printf("n nu apartine intervalului [0,170]\n"); exit(1); } for(f=1.0,i=2;i<=n;i++) f*=i; printf("n=%d\tn!=%g\n",n,f); //formatul %g va tipri f fr zecimalele //nesemnificative, deci ca un ntreg getch(); } Exemplul 2: Urmtorul program continu s cicleze pn cnd este tastat litera q. n loc s verifice variabila de control a ciclului, instruciunea for verific dac de la tastatur a fost introdus caracterul q. #include<stdio.h>
Limbajul C/C++ pentru nceptori #include<conio.h> void main() { int i; char ch; clrscr(); ch=a; for(i=0;ch!=q;i++) { printf(pas: %d\n,i); ch=getche(); } getch();
66
} n acest caz, testul de condiie care controleaz ciclul nu are nimic n comun cu variabila de control a ciclului. Variabila ch a primit o valoare iniial pentru a ne asigura c ea nu conine accidental chiar litera q n momentul n care programul ncepe execuia. Exemplul 3: O alt variant a lui for este aceea c scopul su poate fi gol ca n programul urmtor: #include<stdio.h> #include<conio.h> void main() { char ch; clrscr(); for(ch=getche();ch!=q;ch=getche()); printf(\n am gasit pe q); getch(); } Instruciunea care asigneaz lui ch o valoare a fost mutat n interiorul ciclului. Aceasta nseamn c atunci cnd ciclul pornete, este apelat funcia getche(). Apoi valoarea lui ch este testat mpreun cu q, se execut inexistentul corp al lui for i apoi are loc o nou apelare a funciei getche() n seciunea de incrementare a ciclului. Acest proces se repet pn cnd utilizatorul introduce litera q. Scopul lui for poate fi gol deoarece limbajul C admite instruciunea vid.
67
while(expresie); Instruciunea se execut n felul urmtor : se execut instruciune, se evalueaz expresie; dac aceasta are o valoare diferit de 0 (true) atunci se revine la execuia instruciunii, altfel (expresia are valoarea 0) se trece n secven, la instruciunea urmtoare instruciunii do-while. Se observ c n cazul acestei instruciuni nti se execut instruciune i apoi se testeaz condiia de repetare a execuiei ei. Instruciunea do-while este echivalent cu secvena : instructiune; while(expresie) instruciune; n cazul instruciunii do-while corpul ciclului se execut cel puin o dat, spre deosebire de cazul instruciunii while i for, cnd este posibil s nu execute niciodat. Exemplul 1: S se scrie un program care afieaz factorii primi ai unui numr ntreg nenegativ introdus de la tastatur. #include<stdio.h> #include<conio.h> void main() { unsigned n,d=2,e; clrscr(); printf("\nIntroduceti numarul : "); scanf("%u",&n); printf(" Desc. in factori primi este :\n"); do { e=0; //puterea factorului d while(!(n%d)) { n=n/d; e++; } if(e) printf("%d ^ %d\n",d,e); //afiseaza factorul i puterea lui d=d+((d==2) ?1:2); //dac d=2,se trece la d=3, altfel se trece la //urmtorul factor impar cu d+2 }while(n>1); getch(); } Exemplul 2: Faptul c ciclul do execut ntotdeauna corpul ciclului cel puin o dat face ca el s fie perfect pentru a valida rspunsurile utilizatorului, spre exemplu n cazul procesrii opiunilor unui meniu. Programul urmtor va repeta ciclul de citire a opiunii pn cnd utilizatorul va introduce un rspuns valid: #include<stdio.h> #include<conio.h> void main()
68
} Exemplul 3: Ciclul do este folositor n special cnd programul ateapt s se produc un anumit eveniment. De exemplu, urmtorul program ateapt ca utilizatorul s tasteze litera q. Programul conine o singur apelare a funciei getche(). #include<stdio.h> #include<conio.h> void main() { char ch; clrscr(); do{ ch=getche(); } while(ch!=q); printf(\n am gasit pe q); getch(); }
clrscr(); printf(Doriti : \n); printf(Adunare,Scadere,Multiplicare,Impartire? \n); //validarea opiunii utilizatorului do{ printf(Introduceti prima litera : ); ch=getche(); printf(\n); }while(ch!=A && ch!=S && ch!=M && ch!=I); //cnd utilizatorul a introdus opiunea corect, se //pot procesa opiunile din meniu printf(Introduceti primul numar : ); scanf(%f,&a); printf(Introduceti al doilea numar : ); scanf(%f,&b); if(ch==A) printf(%f,a+b); else if(ch==S) printf(%f,a-b); else if(ch==M) printf(%f,a*b); else if(b) printf(%f,a/b); getch();
69
Exemplul 4: Funcia kbhit() din header-ul conio.h este foarte folositoare cnd dorim s permitem utilizatorului s ntrerup o rutin fr s l form s rspund la un mesaj. De exemplu, programul urmtor afieaz o tabel cu procentul 5% aplicat unor valori care se incrementeaz cu 20. Programul continu s afieze tabela pn cnd utilizatorul apas o tast sau pn cnd a fost atins valoarea maxim. #include<stdio.h> #include<conio.h> void main() { double amount; amount=20.0; printf(Apasati o tasta pentru stop.\n); do{ printf(valoarea:%lf,procent:%lf\n,amount ,amount*0.05); if(kbhit()) break; amount=amount+20; }while(amount<10000); }
70
} } Instruciunea continue este folosit rareori, nu pentru c folosirea ei nu ar fi o practic bun, ci pentru c aplicaiile n care ar putea fi utilizat sunt mai rare. Exemplul 2: O bun utilizare a lui continue este aceea de a porni din nou o secven de instruciuni atunci cnd apare o eroare. De exemplu, programul urmtor calculeaz suma total a numerelor introduse de utilizator. nainte de a aduna o valoare la suma total, el verific dac numrul a fost introdus corect. Dac numrul nu a fost introdus corect, pornete din nou ciclul, folosind instruciunea continue. #include<stdio.h> #include<conio.h> void main() { int i, total; char ch; clrscr(); total=0; do{ printf(numarul urmator(0 pentru stop): ); scanf(%d,&i); printf(Este %d corect ? (Y/N) ,i); ch=getche(); printf(\n); if(ch==N) continue; //numr incorect,se reia citirea total+=i; //numr corect,se adaug la sum }while(i); //citirea se ncheie la i=0 printf(Totalul este %d\n,total); getch(); }
71
void main() { long m,n; long a,b; long r; clrscr(); do { printf("primul numar="); if(scanf("%ld",&m)==1 && m>0) break; //valoarea citit este corect,ieim din ciclul de //citire printf("nu s-a tastat un intreg pozitiv\n"); //valoare incorect, se reia citirea } while(1); do { printf("al doilea numar="); if(scanf("%ld",&n)==1 && n>0) break; //valoarea citit este corect,ieim din ciclul de //citire printf("nu s-a tastat un intreg pozitiv\n"); //valoare incorect, se reia citirea } while(1); a=m; b=n; do // algoritmul lui Euclid { r=a%b; if(r) { a=b; b=r;} }while(r); printf("(%ld,%ld)=%ld\n",m,n,b); getch();
} Exemplul 2: Instruciunea break permite ieirea dintr-un ciclu, din oricare punct din interiorul su. Cnd instruciunea break este ntlnit n interiorul unui ciclu, acesta se va termina imediat, iar controlul va trece la instruciunea ce urmeaz dup ciclu. De exemplu, programul urmtor afieaz numai numerele de la 1 la 10. #include<stdio.h> #include<conio.h> void main() { int i; clrscr(); for(i=1;i<100;i++) { printf(%d,i); if(i==10) break; //oprirea forta a ciclului la i=10
72
} Exemplul 3: Instruciunea break poate fi folosit cu oricare din cele trei cicluri ale limbajului. ntr-un ciclu pot exista oricte instruciuni break. n general, se recomand ca instruciunea break s fie utilizat pentru scopuri speciale i nu ca ieire normal din ciclu. Instruciunea break este utilizat n cicluri n care o condiie special poate cauza oprirea imediat a ciclului. Spre exemplu, n programul urmtor, apsarea unei taste poate opri execuia programului: #include<stdio.h> #include<conio.h> void main() { int i; char ch; clrscr(); for(i=1;i<10000;i++) if(!(i%6)) { printf(%d Mai doriti ? (Y/N): ,i); ch=getche(); if(ch==N) break; //oprirea ciclului la cererea utilizatorului printf(\n); } getch(); }
73
c1,c2,,cn sunt constante integrale sir_1,sir_2,..sir_n,sir sunt succesiuni de instruciuni Instruciunea switch cu formatul de mai sus se execut astfel : Se evalueaz expresia dintre parantezele rotunde Se compar pe rnd valoarea expresiei cu valorile constantelor c1,c2,,cn. Dac valoarea expresiei coincide cu una din constante, s zicem cu ci, atunci se execut secvena sir_i, apoi se trece la instruciunea urmtoare instruciunii switch, adic la instruciunea aflat dup acolada nchis care termin instruciunea. Dac valoarea respectiv nu coincide cu nici una din constantele c1,c2,.cn, atunci se execut succesiunea de instruciuni sir din default i apoi se trece la instruciunea urmtoare instruciunii switch. Menionm c este posibil s nu se ajung la instruciunea urmtoare instruciunii switch n cazul n care succesiunea de instruciuni selectat pentru execuie (sir_i sau sir) va defini ea nsi un alt mod de continuare a execuiei programului (de exemplu, execuia instruciunii de revenire dintr-o funcie, saltul la o instruciune etichetat etc.). Succesiunile sir_1,sir_2,..,sir_n se numesc alternativele instruciunii switch. Alternativa sir este opional, deci ntr-o instruciune switch secvena default : sir poate fi absent. n acest caz, dac valoarea expresiei nu coincide cu valoarea nici uneia dintre constantele c1,c2,.. ..cn, atunci instruciunea switch nu are nici un efect i se trece la execuia instruciunii urmtoare. Instruciunea switch de mai sus este echivalent cu urmtoarea instruciune if imbricat : if(expresie==c1) sir_1 else if(expresie==c2) sir_2 else if(expresie==c3) sir_3 else if .. else if(expresie==cn) sir_n else sir; Instruciunea break de la sfritul fiecrei alternative permite ca la ntlnirea ei s se treac la execuia instruciunii urmtoare instruciunii switch. Se obinuiete s se spun c instruciunea break permite ieirea din instruciunea switch.
74
Instruciunea break poate fi utilizat numai n corpurile ciclurilor i n alternativele instruciunii switch. Prezena ei la sfritul fiecrei alternative nu este obligatorie. n cazul n care instruciunea break este absent la sfritul unei alternative, dup execuia succesiunii de instruciuni din compunerea alternativei respective se trece la execuia succesiunii de instruciuni din alternativa urmtoare a aceleai instruciuni switch. Adic, dac o instruciune switch are formatul : switch(expresie) { case c1: sir_1 case c2: sir_2 } atunci ea este echivalent cu urmtoarea secven : if(expresie==c1) { sir_1 sir_2 }else if(expresie==c2) sir_2; Exemplul 1: Urmtorul program recunoate numerele 1,2,3 i 4 i afieaz numele cifrei introduse. #include<stdio.h> void main() { int i; printf(Introduceti un intreg intre 1 si 4 : ); scanf(%d,&i); switch(i) { case 1 : printf(unu); break; case 2 : printf(doi); break; case 3 : printf(trei); break; case 4 : printf(patru); break; default: printf(numar necunoscut); } } Exemplul 2: Instruciunile switch sunt deseori folosite pentru a procesa comenzi meniu. De exemplu, programul urmtor: #include<stdio.h> #include<conio.h> void main() { float a,b; char ch;
Limbajul C/C++ pentru nceptori clrscr(); printf(Doriti :\n); printf(Adunare,Scadere,Multiplicare, Impartire?\n); //validarea opiunii introduse do{ printf(Introduceti prima litera : ); ch=getche(); printf(\n); }while(ch!=A && ch!=S && ch!=M && ch!=I); printf(Introduceti primul numar : ); scanf(%f,&a); printf(Introduceti al doilea numar : ); scanf(%f,&b); //procesarea comenzii de meniu switch(ch) { case A: printf(%f,a+b);break; case S: printf(%f,a-b);break; case M: printf(%f,a*b);break; case I: if(b) printf(%f,a/b);break; } getch();
75
} Exemplul 3: Instruciunile asociate unui case pot s lipseasc. Aceasta permite ca dou sau mai multe case s execute aceleai instruciuni fr s fie nevoie de duplicarea lor. Iat un program care clasific literele n vocale i consoane: #include<stdio.h> #include<conio.h> void main() { char ch; clrscr(); printf(Introduceti o litera : ); ch=getche(); switch(ch) { case a: case e: case i: case o: case u: printf(\n este o vocala);break; default : printf(\n este o consoana); } }
76
77
} . }
/* secvena de tratare a erorii */ divzero: printf(..); .. n absena instruciunii goto se poate realiza acelai lucru folosind un indicator i o serie de teste realizate asupra lui.
78
Funcia sscanf realizeaz, ca i funcia scanf, conversii din formatul extern n format intern. Deosebirea const c de data aceasta caracterele nu sunt citite din zona tampon corespunztoare tastaturii, ci ele provin dintr-un ir de caractere definit de primul parametru al funciei sscanf. Aceste caractere pot ajunge n irul respectiv n urma apelului funciei gets. n felul acesta, apelul funciei scanf poate fi nlocuit prin apelul funciei gets urmat de apelul funciei sscanf. Astfel de nlocuiri sunt utile cnd dorim s eliminm eventualele erori aprute la tastarea datelor. Funcia sscanf, ca i funcia scanf, returneaz numrul cmpurilor convertite corect conform specificatorilor de format prezeni n sintax. La ntlnirea unei erori, ambele funcii i ntrerup execuia i se revine din ele cu numrul de cmpuri tratate corect. Analiznd valoarea returnat, se poate stabili dac au fost prelucrate corect toate cmpurile sau a survenit eroare. n caz de eroare se poate reveni pentru a introduce corect datele respective. n acest scop este necesar s se elimine caracterele ncepnd cu cel din poziia eronat. n cazul n care se utilizeaz secvena: gets(....); sscanf(....); abandonarea caracterelor respective se face automat reapelnd funcia gets. n cazul utilizrii funciei scanf este necesar s se avanseze pn la caracterul linie nou aflat n zona tampon ataat tastaturii sau s se videze zona respectiv prin funcii speciale. n exerciiile urmtoare vom folosi secvenele formate din apelurile funciei gets urmate de apelurile lui sscanf. O astfel de secven se apeleaz repetat n cazul n care se ntlnesc erori n datele de intrare. Exemplul : char tab[255]; int zi,luna,an; .. gets(tab); sscanf(tab,%d %d %d,&zi,&luna,&an); Amintim c funcia gets returneaz valoarea NULL la ntlnirea sfritului de fiier. Funciile sscanf i sprintf au prototipurile n fiierul stdio.h. Exemplu: S se scrie un program care citete msurile a,b,c ale laturilor unui triunghi, calculeaz i afieaz aria triunghiului respectiv folosind formula lui Heron. #include<stdio.h> #include<conio.h> #include<stdlib.h> #include<math.h> void main() { double a,b,c,p; char tab[255];
79
clrscr(); do /* citete msurile laturilor triunghiului */ { do /* citete pe a */ { printf("a="); if(gets(tab)==NULL) { printf("s-a tastat EOF\n"); exit(1); } if(sscanf(tab,"%lf",&a)==1 && a>0) break; /* se iese din ciclul pentru citirea lui a */ printf("nu s-a tastat un numar pozitiv\n"); printf("se reia citirea lui a\n"); }while(1); do /* citete pe b */ { printf("b="); if(gets(tab)==NULL) { printf("s-a tastat EOF\n"); exit(1); } if(sscanf(tab, "%lf", &b)==1 && b>0) break; /* se iese din ciclul pentru citirea lui b */ printf("nu s-a tastat un numar pozitiv\n"); printf("se reia citirea lui a\n"); }while(1); do /* citete pe c */ { printf("c="); if(gets(tab)==NULL) { printf("s-a tastat EOF\n"); exit(1); } if(sscanf(tab,"%lf",&c)==1 && c>0) break; /* se iese din ciclul pentru citirea lui c */ printf("nu s-a tastat un numar pozitiv\n"); printf("se reia citirea lui a\n"); }while(1); p=(a+b+c)/2; if(p-a>0 && p-b>0 && p-c>0) break; /* a,b,c pot fi laturile unui triunghi */ printf("a=%g\tb=%g\tc=%g\t",a,b,c); printf("nu pot fi laturile unui triunghi\n"); }while(1); printf("aria=%g\n",sqrt(p*(p-a)*(p-b)*(p-c))); getch(); }
80
Valoarea 1 cnd caracterul este : o liter sau cifr o liter o cifr n baza 10 un caracter de control un caracter valid ASCII un caracter tipribil un caracter tipribil mai puin spaiul o liter mic o liter mare un caracter de punctuaie spaiu,tab,CR,LF,tab vertical,form-feed o cifr n baza 16 Face conversia unui caracter : n liter mare. Spre deosebire de macroul _toupper care modific orice caracter, dac caracterul ch nu este liter mic, funcia l ntoarce nemodificat n liter mic. Spre deosebire de macroul _tolower care modific orice caracter, funcia ntoarce caracter nemodificat dac nu este liter mare.
Exemplul: Transformarea literelor unui ir n litere mari. #include<stdio.h> #include<ctype.h> void main() { int i; char t[255]; scanf(%s,t);
81
Exemplu: Calculul valorii unui polinom. #include<stdio.h> #include<math.h> // polinomul: x5-2x3-6x2+15x-1 void main() { double a[]={-1.0,15,-6.0,-2.0,0,1.0};
82
// coeficienii polinomului in ordinea cresctoare a // puterilor double x,rez; printf(x=); scanf(%lf,&x); rez=poly(x,5,a); printf( val. polinomului pentru x=%lg este %lg\n,x,rez); } Funciile trigonometrice au argumente de tip real care trebuie specificate n radiani. Cele mai utilizate funcii implementate sunt : Sintaxa funciei double sin(double x); double cos(double x); double tan(double x); double asin(double x); double acos(double x); double atan9double x); double atan2(double y, double x); double sinh(double x); double cosh(double x); double tanh(double x); Numele funciei Sinus Cosinus Tangent Arc sinus Arc cosinus Arc tangent Arc tangenta lui y/x Sinusul hiperbolic Cosinusul hiperbolic Tangenta hiperbolic Valoarea returnat Real ntre 1 i 1 Real ntre 1 i 1 Real Real ntre - /2 i /2 Real ntre 0 i Real ntre - /2 i /2 Real ntre 0 i Real Real real
Limbajul C/C++ pentru nceptori putchar(1); d) if(!(x%2==0||y%2==0)) putchar(1); e) if(!(x%2==0)&&!(y%2==0)) putchar(1); 3. Ce va afia programul urmtor, dac de la tastatur se introduc n ordine numerele 5, 7 i 8? #include<stdio.h> void main() { int x,y,z,m; scanf(%d %d %d, &x,&y,&z); m=(x+y+z)/3; switch(m) { case 1,2,3,4: { printf(Corigent); break; } case 5,6: { printf(Mediocru); break; } case 7,8,9: { printf(Bine); break; } case 10: { printf(Foarte bine); break; } default: printf(Eroare); } } a) Corigent b) Mediocru c) Satisfctor d) Foarte bine e) Eroare
83
4. Precizai ce se va afia n urma execuiei secvenei de program de mai jos pentru n=5 (s,n i k sunt variabile ntregi). s=0; k=1; while(k<=n) { s+=k; k+=2; } printf(s=%d, s); a) s=4 b) s=16 c) s=9 d) s=15 e)s=0 5. Care dintre secvenele de program de mai jos calculeaz corect factorialul numrului natural n ? 1) p=1; for(i=1; i<=n; i++) p=p*i; 2) p=1; i=1; while(i<=n) p=p*i++; 3) p=1; i=1; do{ p*=i; i=i+1; }while(i<=n); a) numai 1) b) numai 2) c) numai 3) d) 1) i 3) e) toate 6. Care trebuie s fie valoarea variabilei ntregi m, astfel nct urmtoarea secven de program s afieze exact un caracter A ? x=5; do{ putchar(A); x++; }while(x>m); a) 12 b)5 c)6 d) 4 e)1 7. Se consider secvena de program de mai jos, n care toate variabilele sunt ntregi. Pentru n=3, care va fi
Limbajul C/C++ pentru nceptori valoarea variabilei p dup execuia secvenei ? p=1; for(i=1; i<=n; i++) { s=0; for(j=1; j<=i; j++) s+=j; p*=s; } a) 180 b) 18 c) 9 d) 216 e) 1 8. Precizai ce se va afia n urma execuiei programului urmtor pentru x=179 ? #include<stdio.h> void main() { int c,s; long d,x; scanf(%ld, &x); d=x; s=0; while(d) { c=d%10; s+=c; d=d/10; } printf(%d, s); } a) 16 b) 18 c)17 d) 0 e) 971 9. Considerm programul urmtor : #include<stdio.h> void main() { short int m,x; m=-1; while((scanf(%d,&x)== 1)&& x) if(x>m) m=x; printf(%d, m); } Precizai ce valoare va afia programul, dac irul de numere citit
84
de la tastatur este 2, 5, -32000, 33000, 0. a) 1 b) 0 c) 33000 d) 2 e) 5 10. Pentru ce valoare a variabilei m, secvena de program de mai jos reprezint o bucl infinit ? int n=10, m; do{ while(n>0) n--; }while(n!=m); a) 10 b) orice valoare de 10 c) 0 d) orice valoare de 0 e) orice valoare ntreag 11. Ce valoare va afia programul urmtor pentru n=12 ? #include<stdio.h> void main() { int i,n,s; scanf(%d, &n); for(s=0,i=2; i<n/2; !(n%i)?s+=i++: i++); printf(%d,s); } a) 0 b) 9 c) 12 d) 78 e) programul conine erori 12. Dac de la tastatur se introduc, n ordine, numerele 2,7,3,8,5,5, ce valoare va afia secvena urmtoare ? int a, b, nr=0; do{ scanf(%d %d,&a,&b); }while((b!=a) ? ++nr : 0); printf(%d, nr); a) 0 b) 1 c) 2 d) 3 e) 4 13. int i=0; int j=6;
Limbajul C/C++ pentru nceptori if(i!=0) && (j/i!=1) j=i; i+=4; j+=i; Pentru codul de mai sus alegei comportamentul corect : a) va genera eroare la rulare b) j=4 c) j=0 d) j=10 14.
85
A) for(exp1;exp2;exp3)
instructiune; este echivalent cu exp1; while(exp2) { instructiune; exp3;} B) for( ;exp; ) instructiune; este echivalent cu while(exp) instructiune; C) for( ; ; ) instructiune; este echivalent cu while(1) instructiune; Care din echivalenele de mai sus sunt eronate: a) nici una b) A,B c) B,C d) A,C 15. Fie secvena : do{ scanf(%c,&c); if (c>=a && c<=z) i++; } while(c!=EOF); Care din urmtoarele afirmaii este adevrat : a) se numr cte caractere litere mici sunt citite b) se numr cte caractere sunt citite c) se numr cte caractere litere mari sunt citite d) nici una
16. Se d o secven de program n care toate variabilele sunt de tip ntreg. n urma execuiei programului ce conine aceast secven, ce valori capt variabilele d i s ? a=8; b=c=1; d=s=0; i=3; do{ i++; if(a>0) if(b>1) if(c>1) d=a; else d=a+b; else d=a+b+c; s+=i+d; } while(i>5); a) d=8 s=12 b) d=9 c) d=10 s=13 d) d=10
s=12 s=14
17. Se consider secvena de program: void main(void) { int x=1; float z, y=0.96; x+=y; z=sqrt(x); printf(%f,z); } Valoarea afiat este : a) 1.46 b) 1.000000 c) 1 d) programul conine erori de sintax 18. Fie secvena de cod prezentat mai jos : i=1; while(n) i=i*(n--); atunci aceasta : a) calculeaz n! b) calculeaz in c) calculeaz ni d) se cicleaz la infinit
Limbajul C/C++ pentru nceptori printf(\n); 19. Fie secvena de cod prezentat mai jos : i=1; while(n--) i=i*2; atunci aceasta : a) calculeaz 2n b) calculeaz i2 c) calculeaz n2 d) se cicleaz la infinit 20. Scriei o bucl care afieaz secvena : 1 22 333 4444 55555 a) for(loop==1;loop<=5; looop++) { for(loop1==1; loop1<=loop;loop1++) printf(%d,loop1); printf(\n); } b) for(loop=1;loop<=5; loop++) { for(loop1=1; loop1<=loop;loop1++) printf(%d,loop); printf(\n); } c) for(loop=1;loop<=5; loop++) { for(loop1=1; loop1<=loop;loop1++) printf(%d,loop1); printf(\n); } d) for(loop=5;loop>0;loop--) { for(loop1=1; loop1<=loop;loop1++) printf(%d,loop1); }
86
21. Referitor la secvena de cod de mai jos, ce valoare va avea variabila contor dup execuia ei ? int x=3, contor=0; while((x-1)) { ++ contor; x--; } a) 0 b) 1 c) 2 d) 3 22. Ce realizeaz urmtoarea secven : scanf(%d,&x,&y,&z); if(x<=y); x=x+z; y=y+z; else z=x+y; a) citete trei numere i calculeaz suma lor b) citete trei numere i calculeaz produsul lor c) este greit d) z devine minimul dintre x si y 23. Care secven de program realizeaz o repetiie la infinit : I) do while(1); II) do while(0); III) do while(i%1<2); a) doar I b) doar II c) doar III d) doar I i III 24. Se d codul : int x=4, a=2; int b=4, c=8; if(x==b) x=a; else x=b; if(x!=b) c=c+b;
Limbajul C/C++ pentru nceptori else c=c+a; printf(c=%d\n,c); Ce se va afia dup execuia codului de mai sus ? a) c=4 b) c=8 c) c=10 d) c=12 25. Se d urmtoarea secven de cod: int i, j=0; for(i=1;i<11;i+=2) { j++; if(i==7) break; } Care va fi valoarea final a lui j ? a) 3 b) 4 c) 5 d) 7 26. Se d urmtoarea secven de cod: int i, j, k; i=1; j=1; k=2; while(i<6) { k=k+i;i++; j=j+k; if(k==3) j--; else if(j==8) break; } printf(%d--%d--%d,i,j,k); Ce va afia codul de mai sus ? a) 112 b) 233 c) 385 d) 4168 27. Se d codul : int a=3, b=0; while(a) { b=b++; a=b; } Ce valoare va avea b ? a) 1 b) 3 c) 0 e) nedefinit pentru c va fi o bucl infinit 28. Fie secvena de cod : #include<stdio.h> void main(void) { int i,y,x=6; y=x; while(1) { y--; x=x*y; if(y==0) break;
87
} Ce numr va fi afiat pe ecran la terminarea execuiei acestui cod ? a) 720 b) programul va rula la infinit c) 0 d) 6 29. Fie secvena de cod : int x; int y=1; for(x=0;x<=30;x++) { y=y+1; if(x<5) continue; if(x>5) break; y=y+x; } Dup execuia codului anterior, ce valoare va avea y ? a) 486 b) 31 c) 13 d) 496 30. Fie urmtorul program : int main() { int i; for(i=1;i<65535;i++); printf(i=%d\n,i); } a)valoarea afiat este i=65535 b)valoarea afiat este i=65534 c)valoarea afiat este i=32766 d)programul nu este corect deoarece este depit domeniul de valori 31. n urma execuiei secvenei de program de mai jos, pentru care dintre tripletele de valori ale variabilelor a, b, c, date mai jos, se va afia valoarea 1?
} printf(%d,x);
Limbajul C/C++ pentru nceptori x=1; if(!(a<=b)||!(a<=c)) { if(b>=c) printf(%d\n,-x); } else if(b<c) printf(%d\n,x); a) a=3, b=2, c=4 b) a=2, b=3, c=4 c) a=4, b=3, c=2 d) a=2, b=4, c=3 e) a=4, b=2, c=3 32. Se consider programul urmtor: #include<stdio.h> void main() { int a,b,c,d,i; scanf(%d %d,&a,&b); if(a>b) { c=a; a=b; b=c; } d=0; for(i=a;i<=b;i++) if(i%2==0) d++; printf(%d,d); } Ce valoare se afieaz pentru a=33 i b=18 ? a) 8 b) 7 c) 0 d) 16 e) 33 33. Fie urmtorul program: #include<stdio.h> void main() { int x,y,m,n,a,b; a=b=2; //(1) m=(x=a+3,y=b-1,y++,y+x); //(2) if(a&&x>y) printf(%d,m);//(3) if(x-y>a&&x>y||!m) //(4) putchar(1);
88
else putchar(0); if((n=x>y)==0)||(--x==4)) //(5) printf(%d,x--); } n timpul execuiei programului se pot spune urmtoarele: a) atribuirea din linia (1) este eronat b) instruciunea din linia (2) este eronat c) n urma execuiei liniei (3) nu se afieaz nici o valoare d) n urma execuiei liniei (4) se afieaz valoarea 1 e) n urma execuiei liniei (5) se afieaz valoarea 4 34. Dac de la tastatur se introduce numrul 22, cte valori distincte va afia programul urmtor? #include<stdio.h> #include<math.h> void main() { int x,n,i; for(scanf(%d,&n),i=1;; x=sqrt(i), printf(%d,x),i++) if(i>n) break; } a) nici una b) 1 c) 2 d) 3 e) 4 35.Precizai de cte ori se va afia valoarea 1 n timpul execuiei programului urmtor, dac a=3,b=4 i x=5. #include<stdio.h> void main() { int a,b,x; scanf(%d%d%d, &a,&b,&x);
Limbajul C/C++ pentru nceptori if(!((x<=a)&&(x>=b))) putchar(1); if(!(x<=a||x>=b)) putchar(1); if(!(x<=a)&&!(x>=b)) putchar(1); if(!(x<=a)||!(x>=b)) putchar(1); } a) nici o dat b) o dat c) de dou ori d) de trei ori e) de patru ori 36. Dac n timpul execuiei programului de mai jos n va primi valoarea 232213, care vor fi n final valorile variabilelor f1, f2 i f3 ? #include<stdio.h> void main() { long n; unsigned f1,f2,f3,c; scanf(%ld,&n); f1=f2=f3=0; do{ c=n%10; n=n/10; switch(c) { case 1: { f1++; break; } case 2: { f2++; break; } case 3: { f3++; break; } } }while(n!=0); printf(%u %u %u, f1,f2,f3); } a) f1=1,f2=1,f3=1 b) f1=1,f2=2,f3=2 c) f1=1,f2=3,f3=2 d) f1=2,f2=1,f3=3 e) f1=3,f2=2,f3=1
89
37.Pentru n=7, care dintre secvenele de program de mai jos trebuie executat astfel nct, la finele execuiei, valoarea variabilei p s fie 48 ? a) p=1; i=2; while(i<=n) { p*=i;i+=2;} b) p=1; i=1; while(i<n/2) {i++;p=p*(2*i+1); } c) p=1; i=1; while(i<=n/2) {p=p*(2*i);i++; } d) p=1; i=0; while(i<n) { i+=2;p*=i; } e) nici una dintre secvenele anterioare 38. Precizai care dintre urmtoarele secvene de instruciuni atribuie variabilei ntregi x valoarea n2, cu n numr natural. a) x=1; for(j=1;j<3;j++) x*=n; b) x=1; for(j=1;j<=n;j++) x*=2; c) x=1; j=0; while(j<2) x*=n; j++; d) x=1; j=0; do{ j++; x*=n; }while(j<2); e) x=n*n; 39. Precizai care dintre urmtoarele secvene de instruciuni atribuie variabilei ntregi x valoarea 10n, cu n numr natural. a) x=10; for(j=1;j<=n;j++)x*=i; b) x=1; for(j=n;j>0;j--) x*=10; c) x=1; j=1; do{
Limbajul C/C++ pentru nceptori x*=10; j++; }while(j<n); d) x=1; j=0; while(j<=n) { j++; x*=i;} e) nici una dintre variantele anterioare 40. Deducei ce valoare se va afia n urma execuiei secvenei de program de mai jos, dac valorile variabilei x citite de la tastatur sunt n ordine 3,2,4,3,5,10,20,0. scanf(%d,&x); nr=0; do{ y=x; scanf(%d,&x); if(x==2*y) nr++; }while(x!=0); printf(%d,nr); a) 0 b) 1 c) 2 d) 3 e) 4 41. Care dintre urmtoarele secvene de nstruciuni atribuie variabilei ntregi u valoarea primei cifre a numrului natural reprezentat de variabila x ? a) u=x; while(u>=10) u=u%10; b) while(x>=10) x=x/10; u=x; c) u=x/10; d) u=x%10; e) nici una din variantele anterioare 42. Care dintre urmtoarele secvene de instruciuni atribuie variabilei ntregi u valoarea ultimei cifre a numrului natural reprezentat de variabila x ? a) while(x>=10) x=x/10; u=x; b) u=x; while(u>=10) u=u%10; c) u=x%10; d) u=x/10; e) toate rioare variantele
90 ante-
43. Fie secvena de program urmtoare, n care ok este o variabil de tipul int, iar x este un numr natural. ok=0; for(j=2;j<x;j++) if(x%j==0) ok=1; printf(%d,ok); Secvena afieaz 1 dac: a) numrul x are cel puin un divizor propriu b) numrul x nu are nici-un divizor propriu c) toate numerele naturale mai mici ca n, fr 0 i 1, sunt divizori proprii ai lui x d) numrul x are cel mult un divizor propriu e) nici una dintre variantele de mai sus 44. Se consider secvenele de program de mai jos. Pentru n=4, precizai care dintre secvene afieaz, n urma execuiei, irul de numere: 1,2,2,3,3,3,4,4,4,4 . a) for(j=1;j<=n;j++) for(k=1;k<=n;k++) printf(%2d,j); b) for(j=1;j<=n;j++) for(k=1;k<=j;k++) printf(%2d,j); c) for(j=1;j<=n;j++) for(k=1;k<=n;k++) printf(%2d,k); d) for(j=1;j<=n;j++) for(k=1;k<=j;k++) printf(%2d,k); e) for(k=1;k<=n; k++)
Limbajul C/C++ pentru nceptori for(j=1;j<=n;j++) printf(%2d,j); 45. Fie secvena de program urmtoare: s=0; for(j=3;j<=n;j+=3) s+=j; Se dau mai jos cinci triplete de numere, fiecare astfel de triplet reprezentnd un set de valori pentru variabila de intrare n. Care dintre aceste triplete au proprietatea c pentru toate cele trei valori ale lui n din triplet se obine aceeai valoare a lui s? a) (3,5,6) b) (6,7,8) c) (10,11,12) d) (6,9,12) e) (15,16,17) 46. Considernd c toate variabilele sunt ntregi, ce valoare se afieaz dup execuia secvenei de mai jos ? s=0;t=0;x=3;i=1;y=1;z=1; do{ if(x>0) if(y>1) if(z>2) t=x; else t=x+y; else t=x+y+z; s+=i+t; i++; }while(i>7); a) 1 b) 5 c) 6 d) 51 e) 63 47. Care dintre irurile de valori date n variantele de rspuns trebuie introduse de la tastatur n timpul execuiei programului urmtor, astfel nct s se declaneze un ciclu infinit ? #include<stdio.h> void main() { int x,y; while(scanf(%d,&x)==1 &&
91
} a) b) c) d) e)
scanf(%d,&y)==1 && (x||y)) do{ y--; printf(*%d *%d,x,y); }while(x!=y); 2,7,3,8,0,0 2,5,4,4,0,0 1,3,6,2,0,0 2,4,5,8,0,0 0,0
48. Pentru programul urmtor, care dintre afirmaiile de mai jos sunt adevrate ? #include<stdio.h> void main() { int s,x; for(s=0,x=1;0;s+=x, scanf(%d,x)) if(!x) break; printf(%d,s); } a) dac de la tastatur se introduc, n ordine, numerele 2,3,4 i 5, atunci programul va afia suma numerelor citite, adic 14 b) dac prima valoare introdus de la tastatur este 0, atunci ciclul se ncheie i se afieaz valoarea 1 c) ciclul este eronat: nu se poate face o citire n linia for d)instruciunea if este eronat e) din cauz c lipsete expresia care d condiia de continuare, ciclul for se va executa la infinit
Limbajul C/C++ pentru nceptori 49. Care dintre secvenele de mai jos afieaz corect irul cifrelor impare 97531 n aceast ordine ? a) for(j=9;j>=1;j--) printf(%d,j--); b) for(j=0;j<=9;j++) printf(%d,9-j++); c) for(j=9;j-->=1;) printf(%d%d,j,j--); d) j=10;
92
93
Cap.6 Tablouri
6.1 Declararea tablourilor
Un tablou reprezint un tip structurat de date care ocup o zon de memorie continu,cu elemente componente de acelai tip. n cadrul tabloului un element este n mod unic identificat prin poziia ocupat n cadrul structurii. Aceast poziie este definit prin unul sau mai muli indici sau indeci, din acest motiv tablourile numinduse variabile indexate. Declararea unui tabou se face cu sintaxa : tip nume[dim_1][dim_2]..[dim_n]; unde : - tip este tipul elementelor componente ale tabloului. Acesta poate fi un tip predefinit sau definit de utilizator - nume este numele variabilei tablou - dim_1, dim_2,..,dim_n sunt numere ntregi pozitive care exprim dimensiunile tabloului Pentru a utiliza un element din tablou se folosete sintaxa : nume[index_1][index_2][index_n] fiecare index respectnd condiia index_i { 0,,dim_i-1}. Un tablou unidimensional se numete vector, iar un tablou bidimensional se numete matrice . Exemple: char s[100]; int x[25]; long double a[10][15]; Observaii: - primul element dintr-un vector va avea indexul 0, iar ultimul element stocat va avea indexul dim-1 - primul element dintr-o matrice va avea indexul (0,0), iar ultimul va avea indexul (dim_1-1,dim_2-1) - dimensiunile tabloului trebuie s fie expresii constante - compilatorul nu face verificri pentru depirea dimensiunii tabloului - pentru alocarea unui tablou sunt necesari nr_elemente*sizeof(tip) octei, unde tip este tipul de baz al tabloului - atribuirea tablourilor nu poate fi fcut direct Exemplu : int x[10],y[10]; x=y; /*operaie ilegal*/
94
95
int a[MAX]; int n; /* dimensiunea real citit la intrare */ Secvena tipic de validare a dimensiunii unui vector este urmtoarea: do{ printf(n=); scanf(%d,&n); if(n<=0||n>MAX) printf(dimensiune incorecta\n); }while(n<=0||n>MAX);
96
proprietatea cerut sau pn cnd epuizm elementele vectorului. De exemplu, determinarea primului element nul dintr-un vector se realizeaz cu secvena: f=-1; for(j=0;j<n;j++) if(!a[j]) { f=j; break; } Verificnd valoarea variabilei f decidem dac n vectorul exist cel puin un element cu proprietatea cerut (f=indicele acestuia) sau nici unul (f =-1).
97
98
Prin aceast operaie, elementele din poziiile 1,2,,n-1 se deplaseaz cu o poziie spre dreapta, iar elementul din poziia n ajunge n poziia 1. Vectorul nu i modific dimensiunea: aux=a[n-1]; /* salvm temporar ultimul element */ for(j=n-1;j>=1;j--) a[j]=a[j-1]; /*deplasm elementele spre dreapta */ a[0]=aux; /* mutm elementul n prima poziie */
99
ajunge cel mai mic element din vector (n cazul ordonrii cresctoare). Se compar apoi al doilea element cu toate elementele de dup el etc. La ultimul pas se compar numai ultimele dou elemente. Secvena corespunztoare de program este : for(i=0; i<n-1; i++) /* elementul care se compar */ for(j=i+1;j<n;j++) /* elem. de dup el cu care se compar */ if(a[i]>a[j]) /* pentru ordonare cresctoare */ { aux=a[i]; a[i]=a[j]; a[j]=aux; /* interschimbm elementele */ }
100
101
int a[MAXLIN][MAXCOL]; int m,n; /* numrul real de linii, respectiv coloane */ do{ printf(numarul de linii=); scanf(%d,&m); if(m<=0 || m>MAXLIN) printf(dimensiune eronata\n); }while(m<=0 || m>MAXLIN); do{ printf(numarul de coloane=); scanf(%d,&n); if(n<=0 || n>MAXCOL) printf(dimensiune eronata\n); }while(n<=0 || n>MAXCOL); Pentru o matrice ptratic maniera uzual de declarare i validare a dimensiunii este urmtoarea: #define DIM 8 int a[DIM][DIM]; int n; /* dimensiunea real a matricii */ .. do{ printf(dimensiunea matricii=); scanf(%d,&n); if(n<=0 || n>DIM) printf(dimensiune eronata\n); }while(n<=0 || n>DIM); Este bine de tiut c memorarea matricilor se face pe linii (ordine lexicografic), adic compilatorul rezerv pentru matrice o zon contigu de memorie de dimensiune MAXLIN*MAXCOL*sizeof(tip), unde tip este tipul de baz al matricii, adic tipul elementelor componente. Primele MAXCOL locaii din aceast zon sunt pentru elementele din prima linie (de indice 0), chiar dac nu toate sunt folosite, urmtoarele MAXCOL locaii sunt rezervate pentru elementele din a doua linie (de indice 1) etc. Practic, n memorie, matricea este liniarizat sub forma unui vector cu MAXLIN*MAXCOL elemente, unele din aceste elemente putnd fi neutilizate. Raionamentul se aplic identic pentru matricile ptratice, numrul de elemente fiind DIM*DIM (dimensiunea matricii). n continuare, vom considera cazul general al matricilor dreptunghiulare, secvenele de instruciuni trebuind modificate corespunztor pentru a lucra corect cu matricile ptratice (m=n=dimensiunea matricii).
102
Deoarece memorarea matricilor se face pe linii, elementele se citesc pe linii, adic indicele de coloan se modific mai rapid dect indicele de linie. Secvena corespunztoare de program este urmtoarea: for(i=0;i<m;i++) /* indicele de linie */ for(j=0;j<n;j++) /* indicele de coloan */ { printf(a[%d,%d]=,i,j); scanf(%d,&a[i][j]); }
103
Diagonala principal cuprinde elementele din colul stnga sus pn n colul dreapta jos, adic mulimea: DP={aij| i=j, i=0,..n-1}={a00, a11, a22, .,an-1n-1} unde n este dimensiunea real a matricii. Diagonala secundar cuprinde elementele din colul dreapta sus pn n colul stnga jos, adic mulimea: DS={aij|i=0,1,n-1 , j=n-1,n-2,0, i+j=n-1}={a0n-1, a1n-2,..,an-10} Jumtatea superioar cuprinde elementele de deasupra diagonalei principale (fr cele de pe DP), adic mulimea: JS={aij | i=0,1,n-2 , j=i+1,,n-1} Jumtatea inferioar cuprinde elementele de sub diagonala principal (fr elementele de pe DP), adic mulimea: JI={aij | i=1,2,.n-1 , j=0,1,i-1} Un element a[i][j] din JS are drept simetric elementul a[j][i] din JI. Astfel, transpusa unei matrici ptratice (matricea care are liniile drept coloane i reciproc) se poate genera uor interschimbnd toate elementele din JS cu simetricele lor din JI aa cum se vede n secvena de mai jos: for(i=0; i<n-1; i++) for(j=i+1; j<n; j++) { aux=a[i][j]; a[i][j]=a[j][i]; a[j][i]=aux; }
} a) 0 d) 3
3. Care dintre secvenele de program de mai jos calculeaz corect suma primelor n elemente ale unui vector s ? a) s=0; for(i=0;i<n;i++) s+=v[i]; b) s=0; i=0; while(i<n) { s+=v[i]; i++;} c) s=0; i=0; do{ s+=v[i]; i++;
Limbajul C/C++ pentru nceptori }while(i<n-1); d) toate e) nici una 4. Deducei care vor fi elementele vectorului v dup execuia secvenei de program urmtoare: int n,k,x,v[7]={5,14,-3,8,1}; n=5; x=v[0]; for(k=1;k<n;k++) v[k-1]=v[k]; v[n-1]=x; a) (-1,5,14,-3,8,0,0) b) (14,-3,8,-1,0,0,5) c) (14,-3,8,-1,5,0,0) d) (0,0,5,-3,14,-1,8) e) (0,0,-1,14,-3,8,5) 5. Cte elemente ale vectorului v vor avea valoarea 9 dup execuia programului de mai jos? #include<stdio.h> void main() { int v[]={0,1,2,0,4,5,6}; int i=0,x=9; do{ v[i++]=x; }while(i<6 && v[i]); } a) nici unul b) unul c) dou d) trei e) toate 6. Fie programul urmtor : void main() { int i,j,m,n,p, a[10][10],b[6]; m=2; n=3; p=6; i=0; while(i<p) b[i++]=i; for(i=0;i<m;i++) for(j=0;j<n;j++) a[i][j]=b[3*i+j]; }
104
n urma execuiei sunt posibile urmtoarele situaii: a) programul nu funcioneaz din cauz c declaraia matricei este eronat b) valorile vectorului b sunt 0,1,2,3,4,5 c) valorile vectorului b sunt 1,2,3,4,5,6 d) a[1][0] are valoarea 3 e) a[0][2] are valoarea 2 7. Se consider o matrice a cu n linii*n coloane i un vector v cu n elemente. Precizai care vor fi elementele vectorului v, dup execuia secvenei urmtoare: int nr, n, i, j, x, b[20]; int a[3][3]={{7,1,7},{-7,7,0}, {2,4,11}}; n=3; x=7; for(i=0;i<n;i++) { nr=0; for(j=0;j<n;j++) if(a[i][j]==x) nr++; b[i]=nr; } a) nedefinite b) v=(0,0,0) c) v=(1,2,3) d) v=(2,0,1) e) v=(2,1,0) 8. Se consider secvena de program urmtoare, n care a este o matrice cu n linii*n coloane i elemente numere ntregi, iar x este o variabil de tip ntreg. x=1; for(i=1;i<=n-1;i++) for(j=0;j<=i-1;j++) if(a[i][j]!=0) x=0; n urma execuiei secvenei, valoarea variabilei x va fi 1 dac:
Limbajul C/C++ pentru nceptori a) deasupra diagonalei principale exist cel puin un element egal cu 0 b) toate elementele de deasupra diagonalei principale sunt 0 c) toate elementele de sub diagonala principal sunt diferite de 0 d) toate elementele de sub diagonala principal sunt 0 e) sub diagonala principal exist cel puin un element diferit de 0 9. Fie urmtorul program: #include<stdio.h> void main() { int v[20], i, n, E; scanf(%d, &n); for(i=0;i<n;i++) v[i]=i%2 ?i:-i; for(E=1,i=0;i<n; E*=v[i++]); E++; printf(%d,E); } n urma execuiei sale sunt posibile urmtoarele situaii: a) expresia condiional din primul ciclu for este eronat din punct de vedere sintactic b) dac variabila n primete prin citire valoarea 6, atunci elementele vectorului v vor fi, n ordine (0,1,-2,3,-4,5) c) prezena caracterului ; dup al doilea ciclu for constituie o eroare
105
e)
10. Care dintre secvenele de program de mai jos afieaz corect elementele v[0], ......v[n-1] ale unui vector de ntregi ? a) i=0; while(i<n) {printf(%d,v[i]);i++;} b) i=0; while(i<n) {i++;printf(%d,v[i]);} c) i=0; do{ i++; printf(%d,v[i]); }while(i<n); d) i=0; do{ printf(%d,v[i]); i++ }while(i<n); e) nici una 11. Care dintre secvenele de mai jos afieaz corect produsul elementelor pare ale unui vector v[0],.......,v[n-1] cu n elemente ntregi ? a) p=1; for(j=1;j<=n;j++) if(v[j]%2==) p=p*v[j]; b) p=1; for(j=0;j<n;j++) if(v[j]/2==0) p=p*v[j]; c) p=0; for(j=0;j<n;j++)
Limbajul C/C++ pentru nceptori if(v[j]%2!=0) p=p*v[j]; d) p=1; for(j=0;j<n;j++) if(v[j]%2==0) p*=v[j]; e) p=0; for(j=0;j<n;j++) if(v[j]%2==0) p*=v[j]; 12. Care dintre afirmaiile de mai jos sunt adevrate pentru secvena de program urmtoare ? p=0; for(k=1;k<6;k++) if(v[k]>v[p]) p=k; printf(%d, p); a) secvena este corect din punct de vedere sintactic b) ciclul for are cinci pai c) dac elementele vectorului sunt 5,4,-11,9,-12,1, atunci programul afieaz valoarea 4 d) dac elementele vectorului sunt 3,-2,8,6,11,4, atunci programul afieaz valoarea 4 e) indiferent care ar fi elementele vectorului, secvena dat nu poate afia valoarea 0 13. Pentru secvena de program urmtoare, precizai care dintre afirmaiile de mai jos sunt adevrate: int j=0 , v[5]={1,1,1,1,1}; while(j<5&&v[j]&&!v[j]) {v[j]=0;j++;} a) expresia din while este eronat sintactic b) declaraia i iniializarea vectorului sunt corecte
106
c) dup
execuia secvenei toate elementele vectorului vor fi 1 d) dup execuia secvenei toate elementele vectorului vor fi 0 e) execuia secvenei va produce un ciclu infinit 14. Precizai care va fi efectul secvenei de program urmtoare, n care v[0],.....,v[n-1] este un vector cu n elemente ntregi. x=v[n-1]; for(k=n-1;k>0;k--) v[k]=v[k-1]; v[0]=x; a) deplaseaz toate elementele vectorului cu o poziie la dreapta b) deplaseaz toate elementele vectorului cu o poziie la stnga c) terge un element din vector prin deplasarea celor aflate naintea lui d) rotete circular vectorul cu o poziie e) nici una din variantele anterioare 15. Fie secvena de program urmtoare, n care v este un vector cu n elemente ntregi, iar p este o variabil ntreag: for(p=1,k=1;k<n;k++) if(v[k]==v[k-1]) p=0; printf(%d, p); Secvena afieaz 0 dac: a) toate elementele sunt distincte dou cte dou b) toate elementele sunt egale
Limbajul C/C++ pentru nceptori c) exist dou elemente consecutive distincte d) exist dou elemente consecutive egale e) nici una din variantele de mai sus 16. Ce valoare va fi afiat n urma execuiei programului urmtor? #include<stdio.h> void main() { int v[]={0,1,2,0,4,5,6}; int j=0,nr=0; do{ if(j==v[j]) nr++; }while(j<6&&v[j++]); printf(%d,nr); } a) 0 b) 1 c) 3 d) 5 e) programul intr n bucl infinit 17. Deducei care vor fi, n ordine, de la stnga la dreapta, elementele nenule ale vectorului a la sfritul execuiei secvenei de program urmtoare: int k, j=0; int v[7]={0,2,7,3,4,8,5}; int a[7]={0,0,0,0,0,0,0}; for(k=0;k<7;k++) if((v[k]%2==0)&&(k%2!=0)) { a[j]=v[k]; j++; } a) 2,4,8 b) 7,5 c) 2,8 d) 2,3,8 e) 7,3,5 18. Care parcurgere pe linii i coloane a unei matrici n*m este corect ? I) for(i=0;i<n;i++) for(j=0;j<m;j++) printf(%d,a[i][j]); II) for(j=1;j<m;j++)
107
for(i=1;i<m;i++) printf(%d,a[i][j]); III) for(i=0;i<n;i++) for(i=0;j<m;i++) printf(%d,a[i][j]); a) doar I b)doar II c) doar I si II d) doar I si III 19. Care din secvenele de calcul a mediei unui ir de n ntregi este corect ? I) int i,n,s; float med; s=0; for(i=0;i<n;i++) s+=a[i]; med=s/n; II) int i,n,s; float med; for(i=0,s=0;i<n;i++) s+=a[i]; med=(float)s/n; III) int i,n,; float med, s; s=0; for(i=0;i<n;i++) s+=a[i]; med=s/n; a) doar I b)doar II c) doar III d) doar II i III 20. Calculul mediei geometrice a unui ir de n ntregi este: I) int i,n, pr; float med; for(pr=1,i=0;i<n;i++) pr*=a[i]; med=sqrt(pr); II) int i,n, pr; float med; for(pr=1,i=0;i<n;i++) pr*=a[i]; med=pow(pr, 1/n);
Limbajul C/C++ pentru nceptori III) int i,n, pr; float med; for(pr=1,i=0;i<n;i++) pr*=a[i]; med=pow(pr, 1./n); a) doar I b) doar II c) doar III d) doar II i III 21. Ce secven calculeaz corect maximul unui ir cu n valori? I) for(max=0, i=0;i<n;i+ +;) if(a[i]>max) max=a[i]; II) max=a[0]; for(i=0;i<n;i++) if(a[i]>a[i++]) max=a[i]; III) max=a[0]; for(i=0;i<n;i++) if(a[i]>max) max=a[i]; a) doar I b) doar II c) doar III d) doar I i II 22. Fie X[1..n] si Y[1..n] vectori de ntregi. Care va fi valoarea lui Y[n] dup execuia secvenei: Y[1]=x[1]; for (i=2;i<n;i++) y[i]=y[i-1]+x[i]; a) x[n]+x[n-1] b) x[n] c) x[1]+x[2]+..+x[n] d) nici una din valorile indicate 23. Fie X[1..n] si Y[1..n] vectori de numere reale. Dup execuia secvenei de program : y[1]=-x[1]; for(i=2;i<n;i++) y[i]=y[i-1]*x[i];
108
elementul Y[n] exprim : a) x[1]*x[2]**x[n] b) x[1]*x[2]*.*x[n] c) (-1)n x[1]*..*x[n] d) nici una din valorile indicate 24. Fie V[1..n] vector de intregi . Secvena de program : i=1; for(i=1;i<=n/2;i++) { j=n-i; aux=v[i]; v[i]=v[j]; v[j]=aux; } are ca efect : a) inversarea ordinii elementelor n vector b) inversarea ordinii tuturor elementelor n vector numai cnd n este impar c) inversarea ordinii tuturor elementelor n vector numai cnd n este par d) nici una din variantele indicate 25. Se consider matricea ptratic A(mxm) . Fie secvena de program : x=a[0][m-1]; for(i=0;i<m;i++) if(x<a[i][m-i]) x=a[i][m-i]; Variabila x calculat exprim : a) valoarea maxim de pe diagonala principal b) valoarea maxim de pe diagonala secundar c) valarea maxim din ntreaga matrice d) alt valoare decat cele indicate
Limbajul C/C++ pentru nceptori 26. Fie matricea ptratic A(mxm) i secvena de program : x=a[0][0]; for(i=0;i<m;i++) { if(x<a[i][i]) x=a[i][i]; if(x<a[i][m-i-1]) x=a[i][m-i-1]; } Variabila x calculat reflect : a) valoarea cea mai mare de pe diagonale b) valoarea cea mai mare de pe diagonala principal c) valoarea cea mai mare de pe diagonala secundar d) alt valoare decat cele indicate 27. Fie matricea A(mxm) i secvena de program: s=1; for(i=0;i<m;i++) for(j=0;j<i;j++) s*=a[i][j]; Valoarea calculat s reflect : a) produsul valorilor de sub diagonala principal b) produsul valorilor de pe diagonala secundar c) produsul valorilor din ntreaga matrice d) alt valoare dect cele indicate 28. Fie o matrice A(nxn) citit de la tastatur . Atunci secvena de cod : i=0; m=a[0][0]; while(i<n) { for(j=0;j<n;j++) if(m<a[i][j]) m=a[i][j]; i++; }
109
a) calculeaz elementul maxim m dintre elementele matricii b) calculeaz elementul minim m dintre elementele matricii c) se cicleaz la infinit d) numr elementele matricii care sunt mai mari ca m 29. Fie secvena de cod de mai jos. Dac considerm ca date de intrare tabloul V1 de dimensiune n, atunci tabloul V0 va conine : for(i=0;i<n;i++) v0[n-i-1]=v1[i]; a) elementele lui V1 n ordine invers b) o parte din elementele lui V1 c) numai elem. impare ale lui V1 d) algoritmul depune elementele lui V1 n ordine invers numai dac n este impar 30. Fie urmtoarea secven de cod care primete o matrice M ptratic de dimensiune n la intrare : p=1; for(i=0;i<n;i++) p=p*m[i][i]-2; atunci aceasta realizeaz : a) produsul elementelor din matrice b) produsul elementelor de pe diagonala principal a matricii m c) o prelucrare a elementelor de pe diagonala principal a matricii m
Limbajul C/C++ pentru nceptori d) se cicleaz la infinit 31. Care este valoarea elementului tab[2][3] dup execuia secvenei de cod : int i,j; int ctr=0; int tab[4][4]; for(i=0;i<4;i++) for(j=0;j<4;j++) { tab[i][j]=ctr; ++ctr; } a) 7 b) 9 c) 11 d) 14 32. Ce face urmtoarea secven ? scanf(%d,&n); for(i=0;i<n;i++) scanf(%d,&a[i]); printf(\n%d,a[0]); for(i=1;i<n;i++) { ex=0; for(j=0;j<i;j++) if(a[i]==a[j]) ex=1; if(!ex) printf(%d,a[i]); } a) afieaz numerele dintrun ir care sunt n mai multe exemplare b) afieaz numerele cu apariie singular n ir c) afieaz numerele dintrun ir d) afieaz numerele impare dintr-un ir 33. Ce realizeaz secven de program? i=0; do { i++; a[i]=nr%2; nr/=2; }while(nr); n=i; urmtoarea
110
for(i=n;i>0;i--) printf(%d,a[i]); a) convertirea b10->b2 unui numr fracionar b) convertirea b10->b2 unui numr ntreg c) convertirea b10->b3 unui numr ntreg d) convertirea b10->b2 unui numr ntreg pozitiv
a a a a
34. Se d urmtoarea secven de cod: int y[5]={3,4,5,6,0}; Ce valoare conine y[3] ? a) 3 b) 5 c) 6 d) codul nu compileaz pentru c nu sunt destule valori 35. Se d codul : short t[4][3]= {{1},{2,3},{4,5,6}}; printf(%d\n,sizeof(t)); Presupunnd c tipul short este de lungime 2 octei, ce va afia codul de mai sus ? a) nu va compila pentru c nu sunt dai destui iniializatori b) 6 c) 12 d) 24 36. Fie secvena de cod : int x,i,t; int y[10]= {3,6,9,5,7,2,8,10,0,3}; while(1) { x=0; for(i=0;i<9;i++) if (y[i]>y[i+1]) { t=y[i]; y[i]=y[i+1]; y[i+1]=t;
Limbajul C/C++ pentru nceptori x++; } if(x==0) break; } Cum va arta vectorul dup execuia acestui cod ? a) programul va rula la infinit b) {0,2,3,3,5,6,7,8,9,10} b) {10,9,8,7,6,5,3,3,2,0} c) {3,6,9,5,7,2,8,10,0,3} 37. Exist greeli n secvena de calculare a mediei aritmetice? #include<stdio.h> #include<conio.h> void main(void) { int a[30],i,n=20; int s=0; float ma; for(i=0;i<n;i++) {
111
printf(\na[%d]=,i); scanf(%d,&a[i]);
a) nu, secvena este corect b) da, deoarece nu au fost citite toate elementele tabloului c) da, deoarece va fi afiat doar partea ntreag a rezultatului d) da, deoarece nu au fost citite corect toate elementele vectorului
112
Cap.7 Pointeri
7.1 Variabile pointer
n memoria intern, valorile variabilelor sunt stocate n locaii care sunt referite prin numere numite adrese. O locaie de memorie are asociat o adres unic. Cea mai mic entitate de memorie adresabil direct este bytul sau octetul. S presupunem variabila de tip ntreg a cu valoarea 7 ce ocup n memorie doi octei. Valoarea variabilei a, care este 7, ocup o locaie de memorie care se poate referi direct prin numele variabilei sau indirect prin adresa ei, adr(a). O variabil capabil s stocheze adresa unei alte variabile se numeste pointer. Limbajul C pune la dispoziie doi operatori pentru lucru cu adrese : - operatorul & cu rol de extragere a adresei unei variabile - operatorul * cu rol de extragere a coninutului zonei de memorie adresate de o variabil pointer Variabila pointer se definete n concordan cu un tip de dat. De exemplu, declaraia int *px; precizeaz c px este un pointer spre ntreg, adic variabila px este capabil s stocheze adresa unui ntreg. Operatorul * , n declaraie, are rolul de a exprima faptul c nu px este de tip ntreg ci coninutul de la adresa memorat n px este de tip ntreg. Deci px este un pointer la ntreg. Fie programul : #include<stdio.h> void main() { int x=5,*px; px=&x; printf(\nx=%d,x); printf(\nx=%d,*px); } n urma execuiei lui se va afia de dou ori valoarea variabilei x, adic 5. n primul caz s-a folosit adresarea direct a variabilei folosindu-se numele ei. n al doilea caz sa folosit adresarea indirect a variabilei, mai precis, s-a extras coninutul de la adresa ei (*px). Se observ c, n prealabil, adresa variabilei x a fost stocat n pointerul px. Pe lng definirea de pointeri spre tipurile fundamentale cum ar fi : float *py; - py este un pointer la float char *pc; - pc este un pointer la caracter exist posibilitatea definirii acestora i spre tipuri structurate de date. Astfel, declaraiile : int (*px)[10]; exprim faptul c px este un pointer la un vector cu 10 elemente de tip ntreg
113
int *pt[10]; exprim faptul c pt este un vectori de pointeri la ntregi. Este important ca pointerul s stocheze adresa unei variabile ce are un tip bine definit, pentru ca expresii de genul *pointer s se poat evalua corect Coninutul de la o adres poate fi de dimensiuni diferite, minim un octet. Avnd bine precizat tipul de dat referit de pointer, coninutul de la acea adres este extras n mod corect n funcie de mrimea n octei a tipului de dat respectiv. n exemplu, *px refer doi octei de la adresa stocat n px considernd c un ntreg se memoreaz pe 2 octei. Exist i pointerul generic, adic un pointer fr tip de dat asociat (spre void) ce se declar sub forma void *p. Acest tip de pointer este folosit mai mult pentru transferul i stocarea adreselor n cadrul programelor. Un alt aspect important ce ine de lucrul cu variabile pointer, care genereaz erori n munca de programare, se refer la faptul c se poate accesa coninutul unei variabile pointer numai dup ce pointerul refer o zon de memorie ce a fost alocat n prealabil. Se mai spune c, n acest caz, pointerul conine o adres valid . Prezentm dou moduri de ncrcare a unui pointer : a) cu adresa unei variabile anterior definit; n acest caz alocarea s-a fcut la momentul definirii variabilei : int a=30,*pa; pa=&a; b) prin alocare dinamic de memorie ce se face n momentul execuiei programului ; pentru realizarea unei astfel de operaii se poate folosi operatorul new. Forma general este : pointer=new tip; unde : - pointer reprezint variabila pointer ce urmeaz a se ncrca - tip reprezint un tip de date pentru care se face alocarea zonei de memorie; se folosete pentru a determina mrimea n octei a zonei de memorie ce urmeaz a se aloca i care este egal cu sizeof(tip) . Exemplu: int *pi; pi=new int; *pi=5; printf(\n%d,*pi); n cazul n care se dorete a se aloca o zon de memorie care s stocheze mai muli ntregi (nr) atunci se va folosi operatorul new n forma : pointer=new tip[nr]; unde : - tip este tipul de dat referit de pointer - nr reprezint numrul de elemente de tipul tip Mrimea n octei ce se va aloca se obine conform relaiei : nr*sizeof(tip) . Legat de acest operator, limbajul C pune la dispoziie i operatorul delete pentru dealocarea unei zone de memorie alocat n prealabil cu operatorul new. Forma de utilizare a operatorului este : delete pointer sau delete [nr]pointer unde : - pointer reprezint variabila pointer - nr reprezint numrul de elemente cu tipul referit de variabila pointer
114
Exemplu: Se va aloca dinamic o zon de memorie capabil s stocheze n valori double, dup care spaiul va fi dealocat. double *p; int n=5; p=new double[n]; delete [n]p; Memoria alocat dinamic i pstreaz coninutul pn cnd se dealoc n mod explicit n cadrul programului.
115
printf(\n Primul element=%lf,*pa); pa++; /* conine adresa urmtorului element din tablou , adic adresa lui a[1] */ printf(\n Al doilea element=%lf,*pa); 5) Operaia de adunare a unui ntreg la un pointer . Dac se adun variabila k la un pointer spre tipul TIP se obine o dres mai mare cu k*sizeof(TIP). Exemplu : double a[]={5.3,2.1,8.9,10},*pa; int i; pa=&a[0]; i=2; printf(\n %lf,*(pa+i)); /* se va afia al treilea element din vector adic 8.9 */ i=3; print(\n %lf,*(pa+i)); /* se va afia al patrulea element din vector adic 10 */ 6) Operaia de conversie ntre pointeri. Aceast operaie se face cu ajutorul operatorului de conversie explicit (cast). Pentru exemplificare vom prezenta o funcie ce are ca scop alocarea dinamic de memorie . Ea are prototipul : void *malloc(int); care se afl n header-ul alloc.h. Parametrul are ca scop dimensionarea zonei de memorie n octei i funcia returneaz adresa la care s-a alocat zona de memorie. Se observ c aceast funcie returneaz un pointer la void adic un pointer generic care nu poate fi folosit n cele mai multe operaii uzuale asupra pointerilor. De aceea, el trebuie convertit ntr-un pointer spre un tip de dat bine precizat. Pentru dealocarea zonei de memorie ce a fost alocat anterior cu funcia malloc, biblioteca limbajului pune la dispoziie funcia free care are prototipul : void free(void *); Parametrul funciei reprezint pointerul ncrcat printr-un apel al funciei malloc. n secvena : int *pa,n=5; pa=(int*)malloc(n*sizeof(int)); /* conversie n pointer spre ntreg */ free(pa); s-a alocat o zon de memorie capabil s stocheze 5 variabile de tip ntreg. Adresa zonei a fost stocat n variabila pointer spre ntreg pa. Dup ce s-au efectuat prelucrrile necesare asupra zonei de memorie i ea nu mai este necesar n program, atunci se elibereaz spaiul cu funcia free. 7) Operaia de scdere a doi pointeri necesit ca pointerii s fie spre acelai tip. Rezultatul reprezint numrul de elemente de tipul referit de pointer ce se afl ntre cele dou adrese. n cazul n care tipul de dat referit de pointer este TIP atunci diferena dintre doi pointeri (p1 i p2) se calculeaz dup relaia (p1p2)/sizeof(TIP).
116
Ca exemplu, se va scrie secvena de program care determin lungimea unui ir de caractere : char sir[50],*pc; printf(\n Dati sirul : );gets(sir); pc=&sir[0]; //adresa de nceput a irului while(*pc++); //parcurgem caracterele pn ajungem la terminatorul \0 printf(\n Lungimea sirului este %d,pc-sir-1); 8) Operaia de comparaie dintre pointeri se realizeaz folosind operatorii de egalitate i cei relaionali. Astfel, ca exemplu, se va prezenta secvena de traversare a unui vector n scopul afirii elementelor sale: int a[]={5,4,3,2,7}; int n=sizeof(a)/sizeof(int); /* numrul de elemente din vector*/ int *p1,*pc; //pc se ncarc cu adresa primului element,a[0] //p1 se ncarc cu adresa ultimului element,a[n-1] for(pc=&a[0],p1=&a[n-1];pc<=p1;pc++) printf(\n elementul %d,*pc); //se parcurg elem. tabloului prin incrementarea lui pc
117
Acelai concept se aplic tablourilor cu dou sau mai multe dimensiuni. O matrice poate fi privit ca un vector n care fiecare element este la rndul su un vector. De exemplu, presupunnd c a este un tablou de ntregi cu 10 linii i 10 coloane (a[10][10]), urmtoarele dou expresii sunt echivalente: a i &a[0][0]. Deasemenea, a[i] este adresa de nceput a liniei i, adic &a[i][0], conform regulii de calcul de la vectori. n continuare, elementul din linia 0 i coloana 4 poate fi referit n dou moduri: fie prin aplicarea de indeci, a[0][4], fie prin intermediul unui pointer *(a+4). n general, pentru orice tablou bidimensional, a[j][k] este echivalent cu una din formele : *(a+(j*numar_coloane)+k) *(a[j]+k) *(*(a+j)+k) Ca observaie, numele unui tablou este un pointer constant. O consecin este c aritmetica de pointeri ce se aplic acestui tip de pointer este mai restrns n sensul c, acest pointer nu-i poate modifica valoarea, adic nu este permis atribuirea direct ntre variabilele de tip tablou. O alt particularitate const n faptul c operatorul sizeof aplicat unui tablou ntoarce numrul de octei al ntregii zone ocupat de tablou. Pn acum s-a evideniat legtura dintre pointer i tablou n sensul c s-a definit un tablou i a fost exploatat prin intermediul pointerilor. Sensul este i reciproc, adic definind un pointer, zona de memorie alocat poate fi utilizat ca i cum ar fi numele unui tablou. Ca exemplu, se va defini o zon de memorie capabil a stoca n ntregi, apoi se va ncrca zona de memorie prin citire de la tastatur i se va calcula suma elementelor introduse. int *pa,n,s; printf(\n Nr. de elemente=); scanf(%d,&n); pa=(int*)malloc(n*sizeof(int)); //instruciunea este echivalent cu pa=new int[n] for(int i=0;i<n;i++) { printf(\n elem[%d]=,i+1); scanf(%d,&pa[i]); } for(i=s=0;i<n;i++) s+=pa[i]; printf(\n suma=%d,s); Se observ c elementele zonei de memorie referite de pointerul pa au fost accesate folosindu-se adresarea indexat pa[i] care este specific lucrului cu tablouri. Observaie: Aceast metod de alocare a memoriei necesar unui vector este extrem de eficient deoarece se va aloca exact cantitatea de memorie necesar numrului real de elemente al tabloului. Reamintim c n cazul alocrii statice de forma int a[100], compilatorul aloc memorie pentru 100 de ntregi, chiar dac n realitate programul va atuliza n execuie mult mai puine elemente.
118
Metoda de alocare se poate aplica fr probleme i n cazul matricilor. innd cont c o matrice este un vector de vectori i a[i] este adresa de nceput a liniei i, este necesar un pointer la pointer ca n exemplul urmtor: #include<stdio.h> #include<malloc.h> void main() { int **a,n,i,j,s=0; printf("n="); scanf("%d",&n); //dimensiunea matricii ptratice a=new int*[n]; //a se ncarc cu n pointeri la ntreg, fiecare //reprezentnd adresa de nceput a unei linii for(i=0;i<n;i++) a[i]=new int[n]; //fiecare a[i] se ncarc cu adresa a n ntregi din //linia i for(i=0;i<n;i++) for(j=0;j<n;j++) { printf("a[%d,%d]=",i,j); scanf("%d",&a[i][j]); //n continuare, a se folosete ca orice matrice //prin indici s+=a[i][j]; } printf("suma elementelor=%d\n",s); } n limbajul C, pointerii i tablourile sunt n strns legtur ei fiind de fapt interschimbabili. Dac folosii numele unui tablou fr index, generai de fapt un pointer ctre primul element al tabloului. Iat de ce nu este necesar nici un index atunci cnd are loc citirea unui ir folosind funcia gets(). Ceea ce este transferat funciei gets() nu este un tablou, ci un pointer. De fapt, n C nu se poate transfera un tablou unei funcii, ci numai un pointer ctre tablou. Funcia gets() folosete un pointer pentru a ncrca tabloul de caractere introdus de la tastatur. Exemplul 1: Deoarece numele unui tablou fr index este un pointer ctre primul element al tabloului, aceast valoare poate fi asignat unui alt pointer i prin aceasta devine posibil accesarea elementelor tabloului folosind pointerul aritmetic. S considerm urmtorul program: #include<stdio.h> int a[10]={1,2,3,4,5,6,7,8,9,10}; void main() { int *p; p=a; /* asigneaz lui p adresa de nceput a tabloului a */
Limbajul C/C++ pentru nceptori /* afiarea primelor trei elemente ale tabloului a */ printf(%d %d %d,*p,*(p+1),*(p+2)); /* afieaz acelai lucru */ printf(%d %d %d,a[0],a[1],a[2]);
119
} n acest caz, ambele instruciuni printf() afieaz acest lucru. Parantezele din expresii ca *(p+2) sunt necesare, deoarece operatorul * referitor la pointeri are o preceden mai mare dect operatorul +. Dac folosii un pointer pentru a accesa un tablou bidimensional, trebuie s executai manual ceea ce compilatorul face automat. De exemplu, n tabloul float balance[10][5];fiecare rnd are 5 elemente. Pentru a accesa balance[3][1] folosind un pointer de tip float, trebuie utilizat un fragment de forma: *(p+(3*5)+1); sau *(*(p+3)+1); n general, la tablourile multidimensionale este mai uoar folosirea indexrii numelui dect folosirea pointerului aritmetic. Exemplul 2: Un pointer se poate indexa ca i cnd ar fi un tablou. Urmtorul program este valid: #include<stdio.h> char str[]=Pointerii sunt puternici; void main() { char *p; int j; p=str; for(j=0;p[j];j++) /* ciclare pn la ntlnirea caracterului NULL */ printf(%c,p[j]); } Exemplul 3: Un pointer poate fi indexat numai dac el puncteaz un tablou. Dei urmtorul program este corect din punct de vedere sintactic, executarea lui va conduce probabil la blocarea calculatorului: char *p,ch; int i; p=&ch; for(i=0;i<10;i++) p[i]=A+i; ntruct ch nu este un tablou, pointerul p nu poate fi indexat. Dei un pointer punctnd un tablou poate fi indexat ca i cum ar fi un tablou, rareori se va proceda astfel, deoarece, n general, prin folosirea pointerilor aritmetici se obin programe mai rapide. Exemplul 4: n biblioteca ctype.h exist funciile toupper() i tolower() care transform literele mici n litere mari i invers. Urmtorul program cere utilizatorului s introduc un ir de caractere i apoi afieaz irul introdus mai nti cu litere mari i apoi cu litere mici. Versiunea urmtoare, pentru a accesa caracterele din ir, indexeaz numele tabloului. #include<stdio.h> #include<ctype.h>
120
#include<conio.h> void main() { char str[80]; int i; clrscr(); printf(Introduceti un sir : ); gets(sir); for(i=0;str[i];i++) str[i]=toupper(str[i]); puts(sir); /* afiarea cu litere mari */ for(i=0;sir[i];i++) str[i]=tolower(str[i]); puts(sir); /* afisarea cu litere mici */ getch(); } Exemplul 5: n varianta urmtoare este folosit un pointer pentru a accesa caracterele irului i este preferat de programatorii profesioniti deoarece incrementarea unui pointer este mai rapid dect indexarea unui vector. #include<stdio.h> #include<ctype.h> #include<conio.h> void main() { char str[80], *p; int i; clrscr(); printf(introduceti sirul: ); gets(str); p=str; //adresa de nceput a irului while(*p) *p++=toupper(*p); //pn cnd gsete \0 puts(sir); // afiarea cu litere mari p=str; while(*p) *p++=tolower(*p); puts(str); // afiarea cu litere mici getch(); } Exemplul 6: Un pointer poate fi i decrementat. Urmtorul program folosete un pointer pentru a copia coninutul unui ir n alt ir, n ordine invers: #include<stdio.h> #include<string.h> char str1[]=Pointerii sunt foarte utili; void main() { char str2[80],*p1,*p2; // p1 va puncta sfritul irului str1 p1=str1+strlen(str1)-1; p2=str2; // nceputul irului str2 while(p1>=str1) *p2++=*p1--; *p2=\0; //caracterul \0 incheie sirul str2, trebuie adgat n
121
} Exemplul 7: Limbajul C permite utilizarea irurilor constante (iruri de caractere scrise ntre ghilimele). Cnd compilatorul ntlnete un astfel de ir, l depune n tabela de iruri a programului i genereaz un pointer ctre el. De exemplu, programul urmtor citete iruri pn cnd este tastat irul stop : #include<stdio.h> #include<sting.h> char *p=stop; void main() { char str[80]; do{ printf(introduceti un sir : ); gets(str); }while(strcmp(p,str)); //ct timp str diferit de stop } Folosirea pointerilor ctre irurile constante poate fi foarte util cnd aceste constante sunt foarte lungi. De exemplu, s presupunem c, n anumite puncte ale sale, un program afieaz un mesaj. Pentru a tasta ct mai puin, trebuie aleas varianta de a iniializa un pointer ctre un ir constant i apoi, cnd trebuie afiat mesajul, s fie folosit acest pointer. char *p=Insert disk into drive A then press ENTER; .. printf(p); printf(p); . Un alt avantaj al acestei metode const n faptul c, dac mesajul trebuie modificat, schimbarea trebuie fcut o singur dat i toate referirile la mesaj vor reflecta modificarea fcut. Exemplul 8: Funcia gets() citete caracterele introduse de la tastatur pn cnd este apsat tasta Enter. Dac operaia se termin cu succes, gets() returneaz un pointer ctre nceputul irului. n cazul unei erori este returnat un pointer null. Programul urmtor arat cum poate fi folosit pointerul returnat de gets() pentru a accesa un ir care conine informaii de intrare. nainte de a folosi irul, programul verific dac nu au aprut erori de citire. #include<stdio.h> void main() { char str[80],*p; printf(Introduceti un sir :);
Limbajul C/C++ pentru nceptori p=gets(str); // dac p nu este null se afieaz irul if(p)printf(%s %s,p,str);
122
} Dac dorii s fii siguri c funcia gets() nu a lucrat cu erori, o putei plasa direct n instruciunea if ca n exemplul urmtor : #include<stdio.h> void main() { char str[80]; printf(Introduceti un sir : ); // dac pointerul ctre nceputul irului nu este null se produce afiarea if(gets(str)) printf(%s,str); }
5. Precizai ce tiprete programul urmtor : #include<stdio.h> long a[10]= {10,11,12,13,14,15,16,17, 18,19}; void main() { long *pi; for(pi=&a[0];pi<&a[10]; pi++) printf(\n%p:%ld, pi, *pi); } 6. Precizai ce face programul urmtor: #include<stdio.h> int a[10]= {10,11,12,13,14,15,16,17, 18,19}; void main() { int *pi; for(pi=a;pi<a+10;) printf(\n%p:%d,pi, ++*pi++); }
Limbajul C/C++ pentru nceptori 7. Fie declaraia : int a[10][10]; Care din expresiile urmtoare sunt echivalente? a) *a[i] b) **(a+i) c) *(*a+i) d) a[0][i] e) a[i][0] 8. Este corect char*s;gets(s); ? secvena if(x==y) putchar(1); else putchar(0); a) 2,10,2,1 b) 2,10,2,0 c) 5,7,5,0 d) 5,10,5,0 e) 5,10,5,1
123
9. Explicai care din instruciuni sunt greite n secvena urmtoare : char *s=Test C; *s=Ansi C; s=Ansi C; 10. Care dintre urmtoarele variante reprezint o declaraie corect a unei variabile x de tipul adres a unei variabile ntregi ? a) int x*; b) int *x; c) int x; e) int x&; d) int &x;
11. Se consider declaraia de variabile: int m, *x,*y; Care dintre urmtoarele atribuiri sunt corecte ? a) x=m; b) *x=*m; c) *y=*x; d) y=&m; e) y=x; 12. Fie declaraiile de variabile: int a=2,b; int *x,*y; Precizai ce valori se vor afia, n ordine, n urma execuiei secvenei de program de mai jos: x=&a; a=5; printf(%d, *x); b=a-2; y=&b; b+=(*y)+4; printf(%d, b); *y=*x; printf(%d, *y);
13. Se consider urmtoarea secven de program: int *q,**p,a=5,b=3; *p=&a; // (1) q=*p; // (2) b+=*(&(**p)); // (3) printf(%d %d,*q,b); Ce putei spune despre atribuirile (1), (2) i (3)? a) nici una dintre atribuiri nu este corect b) numai atribuirea (1) este corect c) numai atribuirile (1) i (2) sunt corecte d) toate sunt corecte i secvena afieaz de dou ori numrul 5 e) toate atribuirile sunt corecte i secvena afieaz numerele 5 i 8 14. Fie atribuirea : *y=&(*(&z)); Cum trebuie scrise corect declaraiile de variabile, astfel nct atribuirea s fie corect ? a) int *y,z; b) int y,*z; c) int y,**z d) int **y,z; e) int **y,*z; 15. Care dintre instruciunile (I),(II), (III),(IV) din programul urmtor sunt eronate? Precizai valorile obinute n cazul instruciunilor corecte. #include<stdio.h> void main() { const int x=3;
Limbajul C/C++ pentru nceptori int u,v; x=4; *(int*)&x=8; u=x; (III) // (I) // (II) //
124
v=*(int*)&x; // (IV) } a)I b)II c)III d)IV e) nici una 16. Alegei atribuirea corect din programul de mai jos: void main() { int a; void *p; p=(int*)&a; // (I) p=&a; // (II) p=(float*)&a;// (III) p=&(int*)a; // (IV) } a)I b)II c)III d) IV e) nici una 17. Fie declaraiile de variabile: int a=2,b,c=5; int *x,*y; Precizai ce valori se vor afia, n ordine, n urma execuiei secvenei de program de mai jos: x=&c; a+=*x; printf(%d,a); b=++a; y=&b; printf(%d,*y); x=y; printf(%d,(*x)++; a) 7,7,7 b) 7,8,9 c) 7,8,8 d) 7,7,8 e) 8,8,9 18. Fie un pointer x ctre ntreg. Care dintre instruciunile de ma jos
realizeaz corect alocarea dinamic a memoriei ? a) x=(int)malloc(sizeof(int* )); b) x=(int*)malloc(sizeof(int *)); c) x=(int*)malloc(sizeof(int )); d) *x=(int*)malloc(sizeof(in t)); e) *x=(int)malloc(sizeof(int *)); 19. Fie urmtoarele declaraii de variabile: int **a,*b,c; Care dintre expresiile de mai jos vor genera eroare la execuie? a) a=&(&c); b) b=&(**a); c) *a=&c; d)**a=&b; e) *b=**a+c; 20. Considerm declaraia: int **p; i atribuirea p=&q; Alegei varianta potrivit astfel nct atribuirea s aib sens. a) int q; b) int *q; c) int ***q; d) int &q; e) nici una 21. Precizai valoarea variabilei a ca urmare a execuiei programului urmtor: void main() { int a; char b=1; a=*(int*)&b; } a)1 b)97 c) neprecizat d) nici una e) programul este greit
Limbajul C/C++ pentru nceptori 22. Precizai care dintre instruciunile de atribuire de mai jos face ca x s primeasc valoarea 0: void main() { int a=1,b=2; float x; x=a/ *&b; // (I) x=(float) a/b; // (II) } a)I b)II c) ambele d) nici una e) programul este gresit 23. Care dintre instruciunile de tiprire vor afia aceeai valoare ? #include<stdio.h> void main() { int a=2,*p=&a; printf(%d\n,*p+1); printf(%d\n,*&p+1); printf(%d\n,*(p+1)); printf(%d\n,*(&p+1)); } a) prima i a doua b) a doua i a treia c) a doua i a patra d) nici una e) programul este eronat 24. n programul urmtor, care dintre cele patru instruciuni va tipri valoarea 11? #include<stdio.h> void main() { const int x=2,y=3; *(int*)&x=8; *(int*)&y=9; printf(%d\n,x+y); printf(%d\n, *(int*)&x+y; printf(%d\n, x+*(int*)&y;
125
printf(%d\n, *(int*)&x+*(int*)&y;
25. Fie programul urmtor: #include<stdio.h> void main() { int m[9],i; for(i=0;i<9;i++) m[i]=i; while(i>0) { i--; *(m+i)=-i; } } Care dintre afirmaiile de mai jos sunt adevrate ? a) ambele cicluri sunt greite b) numai primul ciclu este corect c) numai al doilea ciclu este corect d) ambele cicluri sunt corecte e) n cele dou cicluri, elementele vectorului vor primi valori egale n modul, dar de semne opuse 26. Se consider programul urmtor: #include<stdio.h> void main() { int a=5,b=-12,c=7,*v[3]; v[0]=&a; //(1) printf(%d\n,*v[0]);//(2) *(v+1)=&b; //(3) printf(%d\n,*(*(v+1))); //(4) 2[v]=&c; //(5) printf(%d\n,*v[2]);//(6)
Limbajul C/C++ pentru nceptori } a) declaraia vectorului este eronat b) atribuirile (1), (3) i (5) sunt toate corecte c) atribuirea (1) este corect, iar (3) i (5) sunt eronate d) atribuirile (1) i (3) sunt corecte, iar (5) este eronat e) programul este corect i afieaz valorile 5, -12, 7 27. Ce va afia programul urmtor? #include<stdio.h> void main() { int (*v)[3]; int u[]={10,11,12}; v=&u; printf(%d,(*v)[1]; } a) programul este eronat b) o adres de memorie oarecare, fr nici-o semnificaie c) valoarea ntreag 11 d) adresa de memorie la care se afl valoarea ntreag 11 e) adresa ncepnd cu care se gsete vectorul v n memorie 28. Se consider urmtoarea secven de program: int a[9][11],i,j; for(i=0;i<9;i++) for(j=0;j<11;j++) if(i==j) (*(a+i)) [j]=0; else *(*(a+i)+j)=i*j;
126
Precizai care dintre afirmaiile de mai jos sunt false: a) a[5][2] este 10 b) a[8][0] este 6 c) *(*(a+3)+3) este 0 d) programul conine erori de sintax e) matricea a este simetric fa de diagonala principal 29. Se consider urmtoarele declaraii de variabile: int q=6,d[3][4],(e[3]) [4],v[4]; int *a[3][4],(*b)[3][4], (*c[3])[4]; Care dintre atribuirile de mai jos sunt corecte? a) d[0][2]=e[1][3]; b) a[2][3]=&q; c) b=&d; d) c[2]=&v; e) toate atribuirile anterioare 30. Precizai ce valoare va afia programul urmtor: #include<stdio.h> void main() { int a[20][20],i,j,n=4; for(i=0;i<n;i++) for(j=0;j<n;j++) *(*(a+i)+j)=(i>j)? (j-i) : (j+i); int m=10; for(i=0;i<n;i++) for(j=0;j<n;j++) if(m>(*(a+i))[j]) m=a[i][j]; printf(%d,m); } a) 10 b)6 c) 3 d) 3 e) programul este eronat
Limbajul C/C++ pentru nceptori 31. Fie vectorul y cu patru elemente numere ntregi: int y[4]={0,1,2,3}; Care dintre urmtoarele instruciuni declar i iniializeaz corect un pointer ptr ctre vectorul y? a) int *(ptr[4])=&y; b) int (ptr*)[4]=&y; c) int (*ptr)[4]=&y; d) int ptr*[4]=&y; e) int *ptr[4]=&y; 32. Fie urmtorul program: #include<stdio.h> void main() { int u[4]={1,2,3,4}, v[4]={5,6,7,8}, w[4]={0,0,0,0}, i; int (*x)[4]=&u, (*y)[4]=&v, (*z)[4]=&w; for(i=0;i<4;i++) printf(%3d, (*z)[i]=(*x)[i]+(*y)[i]); } Care dintre afirmaiile de mai jos sunt adevrate? a) programul va afia patru adrese de memorie b) programul va afia, n ordine, valorile 6,8, 10,12 c) valoarea lui (*x)[2] este 3 d) valoarea lui (*y)[4] este 8 e) instruciunea de afiare din ciclu este eronat, din cauza folosirii operatorului de atribuire n funcia printf 33. Fie urmtorul program:
127
#include<stdio.h> void main() { int x[4]={1,2,3}, y[4]={4,5,6,7}, z[7]; int i,j; for(i=0;i<4;i++) *(z+i)=*(y+i); for(j=0;j<3;j++) *(z+i+j)=*(x+j); for(i=0;i<7;i++) printf(%d,*(z+i)); } Care vor fi valorile afiate n urma execuiei sale? a) 1,2,3,4,5,6,7 b) 7,6,5,4,3,2,1 c) 3,2,1,7,6,5,4 d) 4,5,6,7,1,2,3 e) programul este eronat 34. Fie secvena de instruciuni: int x[]={10,20,30,40,50}; int*ptr=x; printf(%d\n,*(ptr+2)); printf(%d\n,*(ptr)+2); Ce se va tipri dup executarea codului de mai sus? a) 30 30 b) 30 12 c) 12 12 d) 12 30 35. Fie secvena de instruciuni: int *array[3]; int(*ptr)[]=array; int x=2,y=3,z=4; Avnd n vedere codul de mai sus, cum vei realiza atribuirea celui de al doilea pointer din irul ptr ca s pointeze la valoarea lui y ? a) ptr[2]=&y; b) (*ptr)[1]=y; c) (*ptr)[1]=&y; d) (*ptr)[2]=&y;
Limbajul C/C++ pentru nceptori 36. Fie urmtoarea declaraie de variabile : int *p; int x,y; Atribuirea y=x+100; este echivalent cu secvena: a) p=&x; y=*p+100; b) y=*p+100; p=&x; c) p=&y; y=*p+100; d) p=&x; y=&p+100; 37. Fie urmtoarea declaraie de variabile : int *p; int x,y; Atribuirea x=y; este echivalent cu secvena : a) p=&x; *p=y; b) p=&y; *p=x; c) *p=x; p=&y; d) *p=y; p=&x; 38. Fie urmtoarea declaraie de variabile : int *p; int x,y; Instruciunea x++; este echivalent cu secvena : a) p=&x; (*p)++; b) p=*x; (&p)++; c) p=&x; *(p++); d) p=&x; *p++; 39. Fie urmtoarea declaraie de variabile : int *p; int x,y; p=&x; Atribuirea y=x*(x+1); este echivalent cu secvena : a) y=*p*((*p)++); b) y=*p*(*p++); c) y=*p**p++; d) y=(*p)*(*p++); 40. Fie urmtoarea variabile : declaraie de
128
int *p; int x=100,y; p=&x; n urma atribuirii y=*p*((*p)++); y va avea valoarea : a) 10100 b) 11000 c) 10001 d) 10000 41. Fie urmtoarea declaraie de variabile : int *p; int x=100, y; p=&x; n urma atribuirii y=*p+((*p)++); y va avea valoarea : a) 201 b) 102 c) 200 d) 202 42. Fie secvena : int t[5]={20,30,40,50,10}; int *p; int x; Atribuirea x=t[3]; este echivalent cu : a) p=t; x=*(p+3); b) p=&t[0]; x=*(p+2); c) p=*t; x=*p+3; d) p=t; x=*p+3; 43. Fie secvena : int t[5]={20,30,40,50,10}; int *p; int x; Atribuirea x=*(&t[0]+3); este echivalent cu : a) x=t[3]; b) x=t[4]; c) x=*(&t[2]); d) x=*(t+4); 44. Se consider secvena program: void main(void) { int *p, *q; p=(int*)malloc (sizeof(int)); q=(int*)malloc (sizeof(int)); *p=5; *q=3; *p=*q; if(p==q) *p+=1; printf(%d,*p); de
Limbajul C/C++ pentru nceptori } Care este valoarea afiat pentru p : a) 5 b) 3 c)6 d)4 45. Se d urmtoarea secvent de cod: int a[5]={1,2,3,4,5}; int *aPtr; aPtr=a; printf(element=%d\n, *(aPtr+2)); Ce va afia codul de mai sus dup execuie ? a) element=1 b) element=2 c) element=3 d) element=4
129
46. Se d codul: int *ptr; int y[10]; int i; for(i=0;i<10;i++) y[i]=i; ptr=y; ptr+=8; printf(ptr=%d\n, *ptr); Ce se va afia cnd codul este executat ? a) ptr=0 b) ptr=9 c) ptr=7 d) ptr=8
130
Limbajul C/C++ pentru nceptori { char str[80]; int j; printf(Introduceti un sir (< de 80 de caractere):\n); gets(str); printf(%s,str); // puts(sir);
131
Dac dup afiarea irului se dorete trecerea la o linie nou, se poate afia str dup cum urmeaz : printf(%s\n,str); Aceast metod folosete specificatorul de format %s urmat de caracterul linie nou i utilizeaz tabloul de caractere ca al doilea argument al funciei printf().
132
133
: char*. Se observ c parametrul sursa, care definete zona n care se afl irul ce se copiaz, este declarat prin modificatorul const. Aceasta deoarece funcia strcpy nu are voie s modifice irul care se copiaz. n schimb, parametrul dest nu este declarat cu parametrul const deoarece funcia strcpy modific zona spre care pointeaz dest (n ea se copiaz caracterele irului). Exemplul 1: char tab[]=Acest sir se copiaza; char t[sizeof(tab)]; /* are acelai numr de elemente ca i tab */ .. strcpy(t,tab); /* irul din tab se copiaz n zona alocat lui t */ Exemplul 2: char t[100]; strcpy(t,Acest sir se copiaza); // se copie la adresa t irul constat dat ca al doilea parametru Exemplul 3: char *p=Acest sir se copiaza; char t[100]; char *q; q=strcpy(t,p); irul pstrat n zona spre care pointeaz p se transfer n zona spre care pointeaz t. Valoarea lui t se atribuie lui q. Pentru a copia cel mult n caractere ale unui ir dintr-o zon de memorie n alta, se va folosi funcia de prototip : char *strncpy(char *dest , const char *sursa, unsigned n); Dac n>lungimea irului spre care pointeaz sursa, atunci toate caracterele irului respectiv se transfer n zona spre care pointeaz dest. Altfel se copiaz numai primele n caractere ale irului. n rest, funcia strncpy are acelai efect ca i strcpy. Exemplu: char *p=Acest sir se copiaza trunchiat; char t[10]; strncpy(t,p,10); /* se vor copia numai primele 10 caractere*/ Funcia strdup copiaz un ir ntr-o locaie nou creat i are prototipul : char *strdup(consr char *s); Funcia strdup face copierea unui ir n spaiul obinut prin apelul funciilor calloc sau malloc. Nu este deci necesar o apelare explicit a funciei de alocare. Dimensiunea spaiului alocat este egal cu lungimea irului+1 (caracterul \0). Utilizatorul este responsabil pentru eliberarea spaiului atunci cnd nu mai este nevoie de ir. Valoarea ntoars este pointerul la ir n caz de succes sau pointerul NULL cnd spaiul nu s-a putut aloca. Exemplu : #include<stdio.h> #include<string.h>
134
#include<malloc.h> //includere necesar pentru strdup void main() { char *dup, *string=Acest sir se copie; dup=strdup(string); //se duplic string printf(%s\n,dup); //se afieaz dublura free(dup); //se elibereaz explicit spaiul ocupat de dublur } Observm c nu a fost necesar apelul unei funcii de alocare prealabil a memoriei. Apelul funciei de eliberare, dup ce irul nu a mai fost utilizat, este necesar.
135
136
Pentru a limita compararea a dou iruri de caractere la primele cel mult n caractere ale lor, la comparare ignorndu-se diferena dintre literele mici i mari, se va folosi funcia de prototip : int strincmp(const char *s1, const char *s2, unsigned n);
137
#include<stdio.h> #include<conio.h> #include<string.h> void main() { int n,i,j; char s[100]; clrscr(); printf("Introduceti cuvantul : "); gets(s); n=strlen(s); for(i=0;i<n;i++) { for(j=i;j<n;j++) printf("%c ",*(s+j)); //tiprete caract. irului ncepnd din poziia j puts("\n"); } getch(); } 2. S se determine prima i ultima apariie a unui caracter ntr-un ir de caractere. #include<stdio.h> #include<conio.h> #include<string.h> void main() { char s[100],*ptr,c='e'; clrscr(); strcpy(s,"Test sir de caractere."); ptr=strchr(s,c); //caut prima apariie a lui c n s if(ptr) //pointer nenul { printf("Prima aparitie a car. %c este in pozitia %d\n",c, ptr-s); printf("Ultima aparitie a car.%c este pe pozitia %d\n",c, strrchr(s,c)-s); //scznd din adresa ultimei apariii a lui c //adresa de nceput a irului s obinem numrul de //caractere dintre cei doi pointeri adic poziia //ultimei apariii } else printf("Caracterul %c nu se afla in sir\n",c); getch(); } 3. Programul urmtor ilustreaz modul de folosire a funciei strstr : #include<stdio.h> #include<string.h> void main() {
Limbajul C/C++ pentru nceptori char *s1="c\\tc\\include",*s2="\include"; char *p; p=strstr(s1,s2); puts(p); //se afieaz include
138
5.
6.
139
#include<conio.h> #include<string.h> void main() { char in[100] , *p; clrscr(); puts("Introduceti linia : "); gets(in); /* strtok plaseaz terminatorul NULL la nceputul secvenei de cutare, la poziia gsit */ p=strtok(in, ",.!:;-? "); //gseste primul cuvnt i pune NULL dup el if(p) printf("%s\n", p); //afieaz primul cuvnt / /urmtoarele apeluri utilizeaz pointerul NULL ca prim parametru while(p) { p=strtok(NULL,",.!:;-? "); // caut i afieaz if(p) printf("%s\n", p); // urmtoarele cuvinte } getch(); }
Limbajul C/C++ pentru nceptori 123a45.67,a12345.67, 12345.a67}; for(j=0; j<6; j++) { n=atoi(s[j]); printf(sir=%s\n val=%d,s[j],n);
140
} } Valorile numerice tiprite sunt, n ordine: 12345 - a fost transformat ntregul ir 12345 - partea zecimal nu a fost luat n consideraie -7616 - numrul obinut a fost ntreg, dar nu s-a ncadrat n limitele impuse de tipul int 123 - s-a citit pn la primul caracter care nu era semn sau cifr 0 - primul caracter nu a fost cifr i conversia s-a oprit aici 12345 - caracterul a nu a avut nici o influen fiind dup punctul zecimal Funciile de conversie invers, din numr n ir de caractere , au sintaxele: char *itoa(int valoare, char *sir, int baza); char *ltoa)long valoare, char *sir, int baza); char *ultoa(unsigned long valoare, char *sir, int baza); Funciile ntorc valoarea obinut ntr-un ir terminat cu \0 i stocheaz rezultatul n ir. Parametrul valoare reprezint numrul ntreg care urmeaz a fi convertit. El poate avea att valori pozitive ct i negative n cazul funciilor itoa sau ltoa i numai valori pozitive pentru funcia ultoa. Parametrul sir reprezint adresa irului de caractere n care se va obine rezultatul conversiei. Parametrul baza reprezint baza aleas pentru conversie. Funcia itoa poate ntoarce un ir de pn la 17 caractere, iar ltoa un ir de pn la 33 de caractere (dac baza are valoarea 2). n caz de succes, funciile ntorc un pointer la irul obinut, n caz de eroare, este ntors irul vid. Al doilea set de conversie ntre numere i iruri de caractere este mai performant n privina detectrii erorilor dect primul. Funciile de conversie a unui numr real ntr-un ir de caractere au sintaxa: char *fcvt(double val, int nr_cif, int *dec, int *semn); char *ecvt(double val, int nr_cif, int *dec, int *semn); char *gcvt(double val, int ndec, char *buf); Parametrul val i nr_cif reprezint valoarea iniial i numrul de cifre care se doresc a fi obinute. Funciile vor ntoarce valoarea numrului n baza 10 stocat ca ir de caractere. Nu apare punctul zecimal. Pentru a obine informaii suplimentare despre conversie, variabilele semn, care reprezint semnul numrului, i dec, care reprezint numrul de cifre zecimale, vor fi transmise printr-o referin la ntreg. Pentru ecvt, variabila nr_cif reprezint numrul total de cifre, n timp ce pentru fcvt variabila nr_cif reprezint numrul de cifre ale prii zecimale. Funcia gcvt face suprimarea zerourilor inutile. Valoarea ntoars de ctre cele trei funcii este un pointer spre irul de caractere. Conversiile de la iruri de caractere la numere se fac cu funciile:
141
double strtod(const char *s, char **endptr); long strtol(const char *s, char **endptr, int baza); long strtoul(const char *s, char **endptr, int baza); Funcia strtod convertete un ir ntr-un numr real dubl precizie. irul iniial s trebuie s aib urmtoarea form: [ws] [s] [ddd] [.] [ddd] [fmt[s]ddd] n care ws reprezint spaii, s este semnul, ddd sunt cifre zecimale, iar fmt este e sau E pentru forma exponenial. Al doilea parametru endptr este un pointer la un ir de caractere i are rolul de a se poziiona la ultima poziie de citire corect din ir, pentru detectarea erorilor la conversie. Exemplu: #include<stdio.h> #include<stdlib.h> void main() { char sir[80],*s; double valoare; printf(numarul=); gets(sir); valoare=strtod(sir, &s); printf(sirul:%s numarul:%lf\n,sir,valoare); } Funciile strtol i strtoul convertesc un ir s care exprim un numr ntr-o baz precizat de al treilea argument, baza, ntr-un numr ntreg de tip long, respectiv de tip unsigned long. Este folosit deasemenea un pointer dublu la caractere pentru detectarea erorilor.
Limbajul C/C++ pentru nceptori b) irul b conine numai caracterul a c) n urma execuiei irurile a i b concid d) irul b conine numai caracterele din irul a ale cror coduri ASCII sunt numere pare e) irul b conine numai caracterele de rang par din a (al doilea, al patrulea etc.) 3. Fie programul urmtor: #include<stdio.h> #include<string.h> void main() { char s1[10], s2[10], s3[10]=SB; gets(s1); gets(s2); puts(s1+s2); //(1) if(strlen(s1)<strlen(s2)) putchar(1); //(2) if(s1>s3) putchar(1); else putchar(0);//(3) } Presupunem c, n timpul execuiei progra-mului, se introduc de la tastatur irurile s1=BR i s2=122035. Precizai dac sunt adevrate situaiile de mai jos: a) citirea de la tastatur este eronat b) instruciunea (1) va afia textul BR122035 c) instruciunea (2) va afia valoarea 1 d) n linia (3) se compar irurile s1 i s3 din punct de vedere alfabetic e) nici una dintre afirmaiile anterioare
142
4. Pentru programul urmtor precizai care dintre afirmaiile de mai jos sunt adevrate: #include<stdio.h> #include<string.h> void main() { char s[10]=-2B.2A5; int j,nr=0; for(j=0;j<strlen(s);j++) if(!(s[j]>=0&& s[j]<=9)) { s[j]=0; nr++; } printf(%d%s,nr,s);
} a) declararea irului este corect b) n ciclul for sunt parcurse corect caracterele irului s c) n ciclul for sunt nlocuite cu 0 cifrele din s d) condiia din linia if este eronat e) programul afieaz 40200205 5. Ne propunem s definim un vector care s aib dou elemente, ambele de tip ir de caractere. Fiecare ir trebuie s conin dou caractere, primul ab, iar al doilea cd. Scriei declaraia corect. a) char a[2][3]={ab,cd}; b) char a[2][2]={ab,cd}; c) char a[3][2]={ab,cd}; d) char a[3][3]={ab,cd}; e) char a[][3]={ab,cd};
Limbajul C/C++ pentru nceptori 6. Care dintre variantele de mai jos reprezint o declaraie corect a unui ir de caractere? a) char s[2]; b) char *s[20]; c) char *s; d) char s; e) char s[]; 7. Pentru programul urmtor, analizai corectitudinea afirmaiilor de mai jos: #include<stdlib.h> #include<stdio.h> void main() { char s1[4],s2[4]; long x; gets(s1); gets(s2); if(strcmp(s1,s2)<0) x=atol(s1); else if(!strcmp(s1,s2)) x=0; else x=atol(s2); printf(%ld, x); } a) condiiile din cele dou linii if sunt greite e) apelurile funciei atol sunt corecte f) dac de la tastatur se introduc irurile 98 i 123, atunci se va afia 98 g) dac de la tastatur se introduc irurile 123 i 135, atunci programul va afia irul 123 h) dac de la tastatur se introduc irurile ab i ac, atunci se va semnala un mesaj de eroare
143
8. tiind c, n conformitate cu standardul ASCII, codurile literelor mari sunt succesive ncepnd cu 65, ce va afia programul de mai jos? #include<stdlib.h> #include<string.h> #include<stdio.h> void main() { int x=20,e; char s[15]=ABC,t[15],u[15]; e=s[1]+s[2]; itoa(e,t,10); strcpy(u,t); strcat(s,u); puts(s); } a) nimic, irul s fiind vid b) ABC13 c) AB13 d) ABC133 e) ABC131 9. Ce ir de caractere va afia secvena urmtoare? char *s=abcdefg,*ptr; ptr=s; ptr+=4; puts(ptr); a) fg b) efg c) defg d) cdefg e) secvena este eronat 10. Ce va afia programul urmtor? #include<stdio.h> void main() { char *a[3]={abc,def,ghi}; char *p=&a[0][0]; printf(%s%c%c,a[1], a[2][1],*(p+5)); }
Limbajul C/C++ pentru nceptori a) abc d NULL b) abc d e c) def h NULL d) def h e e) programul va eroare de compilare
144
semnala
11. Ce va afia cea de-a doua instruciune de tiprire din programul de mai jos: #include<stdio.h> void main() { char a[12]=abcdefghij; char *p=a; int j; for(j=0;j<12;j++) *(p+j)=a[j]^j; printf(%s\n,p); for(j=0;j<12;j++) *(a+j)=p[j]^j; printf(%s, p); } a) nimic b) textul abcdefghij c) textul jihgfedcba d) o succesiune de caractere imprevizibil e) programul conine erori 12. Care dintre instruciunile programului de mai jos sunt eronate? #include<stdio.h> #include<string.h> void main() { char a[10],b[10];int k; // (1) scanf(%s %s,a,b); // (2) k=strlen(a)/2; // (3) a[k]=*; //(4) printf(%d,
strlen(a)<strlen(b));//(5) b=a; // (6) } a) declaraia de variabile din linia (1) b) citirea irurilor din linia (2) c) atribuirile din liniile (3) i (4) d) afiarea din linia (5) e) atribuirea din linia (6) 13. Precizai ce ir de caractere se va afia n urma execuiei programului urmtor: #include<stdio.h> #include<string.h> void main() { char s[20]=BorLanD C++ 3.1; int j; for(j=0;j<strlen(s);j++) if((s[j]>=A)&& (s[j]<=Z)) s[j]-=(A-a); puts(s); } a) BorLand C++ 3.1 b) bORlAND c++ 3.1 d) BORLAND C++ 3.1 d) borland c++ 3.1 e) Borland C++ 3.1 14. Care dintre cele trei instruciuni printf de mai jos tipresc irul bd? #include<stdio.h> void main() { char s[6][3]={ab,ac, ad,bc,bd,cd}; printf(%c%c,s[3][0], s[2][1]);
Limbajul C/C++ pentru nceptori printf(%s,s[3][0]+ s[2][1]); printf(%s,s[5]); } a) toate b) numai prima c) numai primele dou d) numai prima i a treia e) nici una 15. Ce va afia programul de mai jos? #include<stdio.h> void main() { char s[10]=AB6X92P3M, b[10]; int j=0,k=0; while(s[j]) if(j%2) b[k]=s[j++]; b[k]=0; puts(b); } a) BX23 b) A69PM c) B d) 3 e) nimic 16. Considernd declaraiile: char s[4]=123,t[4]; int x=123,y; Care din expresiile de mai jos au valoarea 0? a) atoi(s)!=x; b) itoa(x,t,10)==s; c) (y= =atoi(s))==x; d) x= =(atoi(itoa(x,t,10))); e) !strcmp(itoa(x,t,10),s); 17. Ce va afia programul urmtor? #include<stdlib.h> #include<stdio.h> #include<string.h> void main() { char s[12]=6789,t[12]=6, u[12]=89; long x=0; strcat(t,u);
145
if(strcmp(s,t)) x=atol(t); else x=atol(s); if(strcmp(s,u)>0) x=atol(u); printf(%ld, x); } a) 0 b) 6 c) 89 d) 689 e) 6789 18. Ce afieaz programul urmtor? #include<stdio.h> void main() { char *s1=EXEMPLU SIMPLU, *s2=SIMPLU; printf(\n%.8s%.6s,s1,s2);} a) b) c) d) e) EXEMPLU EXEMPLU SIMPLU EXEMPLU SIMPLU SIMPLU EXEMPLUSIMPLU SIMPLU
19. Ce afieaz programul urmtor? #include<stdio.h> void main() { char *s=123456789,*t,*u; u=&s[4],s+=3,t=&s[1]; printf(%d%d%d,u==s,u==t, s==t); } a)000 b)001 c)010 d)100 e)111 20. Care dintre instruciunile (1),.....(5) de mai jos sunt eronate? #include<stdio.h> #include<string.h> void main() { char *s1,*s2,*s3; int x; s1=test; //(1) scanf(%s,s2); //(2)
Limbajul C/C++ pentru nceptori s3=&s1; //(3) printf(%s,s1+s2);//(4) x=strlen(*s2); //(5) } a) 2,3 ,4 b) 2,3,4,5 c) 4,5 d) 3,5 e) 3,4,5 21. Fie programul: #include<stdio.h> void main() { char *s,*t,*u; int j,x; gets(s); for(x=0,j=0;s[j];t=&s[j], u=t+1,u[0]==t[0]? x=1:0,j++); printf(%d, x); } n urma execuiei programului, se va afia valoarea 0, dac: a) toate caracterele irului s sunt identice b) n irul s exist cel puin dou caractere succesive diferite c) n irul s exist cel mult dou caractere succesive identice d) n irul s exist cel puin dou caractere succesive identice e) n irul s nu exist dou caractere succesive identice 22. Considerm urmtoarele noiuni: A)vector de doi pointeri ctre caracter B)pointer ctre ir de dou caractere i urmtoarele declaraii de variabile: I) char *a[2]; II) char (*b)[2];
146
Precizai corespondenele corecte: a) A) cu I) i B) cu II) b) A) cu II) i B) cu I) c) nu exist corespondene d) B) nu are corespondent e) cele dou declaraii semnific acelai lucru 23. Ce afieaz programul de mai jos? #include<stdio.h> void main() { char *s[5]={012,345, 678,9AB,CDE}; char *t,*u; int j; t=&s[1][0]; printf(%d, (*(t+5)==s[2][1])); u=&s[3][0]+1; j=0; while(u[j]) printf(%c,u[j++]); } a)178 b)1AB c)078 d)0AB e)067 24. Ce afieaz programul de mai jos? #include<stdio.h> #include<string.h> void main() { char *s[10]={10,00,10, 10,01,11}; char *t=10; int i=0,j=i-1; while(s[i]) if(!strcmp(s[i++],t)) j=i; printf(%d, j); } a) 1 b) 0 c) 1 d) 3 e) 4 25. Se dau urmtoarele declaraii
Limbajul C/C++ pentru nceptori A)char *a[4][6]; B)char (*b[4])[6]; C)char (*c)[4][6]; D)char ((*d)[4])[6]; i urmtoarele noiuni: N1. vector de 4 elemente, fiecare element este un pointer ctre un vector de 6 caractere N2. pointer ctre matrice de caractere de 4 linii i 6 coloane N3. pointer ctre vector cu 4 elemente, fiecare fiind vector de 6 caractere N4. matrice de 4 linii i 6 coloane, fiecare element este pointer ctre caracter Precizai corespondena direct: a) (A,N1), (B,N2), (C,N3), (D,N4) b) (A,N4), (B,N1), (C,N2), (D,N3) c) (A,N4), (D,N2) d) (A,N2), (D,N1) (B,N1), (B,N3),
26. Cte erori conine programul urmtor ? void main() { char *(a[4][6]); char b; a[2][3]=*(b+2); a[3][2]=&b+3; *(4+a[2])=&b+1; *a[1][3]=b+3; } a) nici una b) una c) dou d) trei e) patru
148
Cap.9 Structuri
9.1 Definirea tipurilor structur
Limbajul C ofer programatorului posibilitatea de a grupa datele, date de tipuri diferite putnd fi prelucrate att individual ct i mpreun. Dac tabloul conine numai elemente de acelai tip, o structur este format din mai multe elemente de tipuri diferite. La rndul lor, structurile definite pot constitui elemente componente pentru formarea de noi tipuri de date (tablouri, structuri, uniuni) . Elementele componente ale unei structuri se numesc membri sau cmpuri . Sintaxa declarrii unei structuri este urmtoarea : struct [nume_tip_structura] { tip_1 lista_campuri_tip_1; tip_2 lista_campuri_tip_2; . tip_n lista_campuri_tip_n; } [lista_variabile_structura]; n declaraie poate lipsi precizarea numelui pentru tipul structurii sau a listei de variabile ns nu ambele simultan. n cazul n care lipsete numele tipului, spunem c variabilele au un tip anonim. Cmpurile componente ale unei structuri pot fi oricare din tipurile : - predefinite (ntreg, caracter, numr real) - definite de utilizator : scalari (cmpuri de bii , enumerare) sau compuse (tablouri, structuri, uniuni) Exemplul 1: Definirea datelor de baz pentru o persoan specificnd numele i vrsta. struct pers { char nume[35]; int an; }; S-a definit o structur de tip pers fr a fi folosit nici o variabil de tipul definit. Exemplul 2: Definirea unei structuri de tip angajat specificnd pe lng datele de baz (un cmp de tip structur pers) adresa, salariul i vechimea n munc. struct angajat { struct pers p; /* structura pers a fost definit anterior */ char adresa[50]; long salariu; int vechime; } persoana , firma[100]; struct angajat p[50];
149
Observm modul cum poate fi o structur folosit la rndul ei drept cmp al altei structuri. n acest caz, s-a definit o structur de tip angajat i variabilele de tip angajat : - variabila persoana - variabila firma de tip tablou de nregistrri n a doua declaraie, s-a folosit tabloul p de 50 de nregistrri de tipul angajat. Putem defini orice tip structur folosind typedef. Astfel, exemplul anterior se mai poate scrie : typedef struct { struct pers p; char adresa[50]; long salariu; int vechime; } ANGAJAT; ANGAJAT persoana , firma[100]; Am definit un tip de structur cu aceleai componente ca mai sus i variabilele persoana i firma cu aceeai semnificaie ca mai nainte. Se observ c nu mai este necesar precedarea tipului de structur de cuvntul cheie struct. Prin convenie, tipurile declarate cu typedef se scriu cu majuscule. Exemplul 3: Se definete o structur care grupeaz informaii, specificnd datele necesare fiei medicale a unui bolnav. typedef struct { int an , luna , zi} DATA; struct { struct pers p; DATA data_internarii; char adresa[50]; char boli[10][30]; } pacient[200]; n ultimul caz, nu s-a mai definit numele tipului structurii, ci doar tabloul de nregistrri pacient care conine 200 de nregistrri de tipul fielor medicale. Exemplul 4: n cazul n care un tablou este definit ca ultim cmp al unei structuri este acceptat omisiunea primei dimensiuni din tablou. Astfel, este acceptat declaraia : struct vector { int n; int dim[]; }; Exemplul 5: n implementrile limbajului C exist diferite structuri predefinite. Spre exemplu, pentru utilizarea numerelor complexe este definit n header-ele math.h i complex.h urmtoarea structur : struct complex { double x; double y; };
150
151
152
ps=&x; /* adresa indicat de ps este egal cu adresa lui x */ y=*ps; /* coninutul lui y devine egal cu coninutul structurii de la adresa pointat de ps */ Atribuirea coninutului unui pointer la o structur cu o structur de acelai tip se poate face astfel : *ps=y; Aceast atribuire este echivalent cu secvena : (*ps).inf=y.inf ; strcpy((*ps).nume,y.nume); Urmtoarele dou atribuiri sunt echivalente cu cele dou de dinainte : ps->inf=y.inf; strcpy(ps->nume,y.nume); Folosirea expresiei de tipul (*ps).inf este corect dar greoaie i neuzual. n locul ei este recomandat forma ps->inf . Exemplul 3: Tablourile nu pot fi atribuite direct. Totui, dac tabloul este membru al unei structuri, atunci atribuirea poate avea loc . #include<stdio.h> #include<stdlib.h> struct tablou {int x[10]}; void main() { struct tablou a={{1,1,1,1,1,1,1,1,1,1}} , b={{2,2,2,2,2,2,2,2,2,2}}; struct tablou *a1 , *b1; /* copierea direct a structurilor; are loc copierea direct a tabloului folosindu-l drept cmp al unei structuri */ b=a; /* se aloc spaiul necesar structurii i adresa spaiului alocat se stocheaz n pointerul la structur */ a1=(struct tablou*)malloc(sizeof(struct tablou)); *a1=a; b1=(struct tablou*)malloc(sizeof(struct tablou)); /* se copiaz coninutul structurii de la adresa indicat de pointerul a1 peste coninutul structurii indicate de pinterul b1 */ *b1=*a1; /* sau : *(struct tablou)b1=*(struct tablou)a1 */ } Observm c s-au putut face atribuirile directe cu tablouri care sunt cmpuri ale unei structuri, att ntre structuri, ct i ntre pointeri la structuri. n acest exemplu, toate structurile i coninutul pointerilor la structuri primesc valoarea structurii a. Exemplul 4: Se consider o grup de n studeni (n<=40), pentru fiecare dintre ei cunoscndu-se numele i media anual. Se cere s se afieze studenii n ordinea descresctoare a mediilor.
Limbajul C/C++ pentru nceptori #include<stdio.h> #include<conio.h> void main() { struct student { char nume[30]; float media; } aux , grupa[40]; int n,i,j; float media; clrscr(); /* citirea datelor */ printf("Numarul studentilor : ");scanf("%d",&n); puts("\n Introduceti datele studentilor :\n"); for(i=0;i<n;i++) { getchar(); printf("Numele :");gets(grupa[i].nume); printf("Media : ");scanf("%f",&media); grupa[i].media=media; } /* sortarea tabloului grupa descrescator dupa medie */ for(i=0;i<n-1;i++) for(j=i+1;j<n;j++) if(grupa[i].media<grupa[j].media) { aux=grupa[i]; grupa[i]=grupa[j]; grupa[j]=aux; } /* afisarea rezultatelor */ clrscr(); puts("Studentii ordonati desc. dupa medii :\n"); for(i=0;i<n;i++) printf("%30s%5.2f\n",grupa[i].nume, grupa[i].media); }
153
Limbajul C/C++ pentru nceptori 2. Fie structura : struct data { int zi, luna , an;}*d; Care este expresia logic a crei valoare arat c anul este sau nu bisect ? a) an%4==0 && an%100!=0 b) d.an%4==0 && d.an%100!=0 c) d.an%4==0 && d.an%100!=0 || d.an%400==0 d) d->an%4==0 && d->an%100!=0 || d->an%400==0 3. Linia de cod care declar o variabil structur numit total de tip sample este : a) type total: sample; b) struct total; c) struct sample total; d) declare total as type sample; 4. Linia de cod care asigneaz valoarea 10 cmpului loop din structura total (de tip sample), este : a) loop=10; b) total.loop=10; c) sample.total.loop=10; d) sample.loop=10; 5. Linia de cod care afieaz valoarea cmpului word din structura total (de tip sample), este : a) printf(%s,total); b) printf(%s,word); c) printf(%s,total-word); d) printf(%s,total.word); 6. Se d urmatoarea secven de cod : struct computer { int cpuSpeed; char cpuType[10];}; struct computer myComputer;
154
Referindu-ne la codul de mai sus, cum accesai primul caracter din cpuType? a) char c=myComputer.cpuType(0); b) char c=myComputer.cpuType; c) char c=myComputer[0].cpuType; d) char c=myComputer.cpuType[0]; 7. Fie secvena : typedef struct { long cust_id; char custName[50]; double balance; } CUSTOMER_REC; CUSTOMER_REC customer[50]; int i; /*mai jos in program*/ for(i=0;i<50;i++) { printf(%s\n,?????);} Ce ar trebui pus in locul ???? pentru a afia fiecare element custName n codul anterior : a) customer[i]->custName; b) customer.custName[i]; c) customer[i].custName; d) customer->custName[i]; 8. Fie declaraia: struct computer{ int cpuSpeed; char cpuType[10]; } comp[]= { {400,Pentium} , {266,PowerPC} , {333,Sparc} }; Se d irul de structuri de mai sus. Care dintre urmtoarele expresii va evalua numrul structurilor din ir (n cazul de fa este 3)?
155
c) sizeof(comp) d) sizeof(comp)/sizeof(*comp)
156
157
t fiierul este de tip text b fiierul este binar Se pot face combinaii cu opiunile de mai sus. De exemplu, deschiderea unui fiier text pentru citire se face cu opiunea rt. Crearea unui fiier binar pentru scriere este posibil prin wb. Nu conteaz ordinea n care sunt date literele n irul mod_deschidere. n caz de succes, funcia fopen returneaz un pointer la noul flux de comunicare deschis; altfel ntoarce pointerul NULL. Operaia de deschidere a unui fiier trebuie nsoit de verificarea reuitei respectivei operaii conform modelului de mai jos: if(identificator_fisier) instructiuni_operatie_reusita else instructiune_eroare_la_deschidere; Exemple: Fie declaraia FILE *f ; vom ncerca urmtoarele deschideri de fiiere: 1) f=fopen(test1.in,rt); Am deschis fiierul test1.in din directorul curent pentru citire n mod text. Litera t nu era necesar, modul text fiind modul de deschidere implicit al fiierelor n C. Dac fiierul nu exist, atunci funcia ntoarce NULL. O deschidere mai riguroas ar fi: if(!(f=fopen (test1.in,rt))) { printf(Eroare la deschiderea fisierului !); exit(1); } 2) f=fopen(test2.out,wb); Este deschis/creat fiierul test2.out din directorul curent n mod binar pentru scriere. 3) f=fopen(c:\\tc\\test3.bin,ab+); Este deschis fiierul test3.bin din directorul c:\tc n mod binar pentru citire/scriere fiind poziionat la sfritul fiierului.
10.3 nchiderea unui fiier Se poate face cu ajutorul funciilor: int fclose(FILE *f); care nchide fiierul specificat i returneaz 0 n caz de succes sau EOF n cazul apariiei unei erori int fcloseall(void); care nchide toate fiierele deschise i returneaz numrul total de fiiere pe care le-a nchis sau EOF la apariia unei erori
158
Pentru a verifica dac poziia curent de citire/scriere a ajuns la sfritul unui fiier se folosete funcia int feof(FILE *f); care ntoarce valoarea 0 dac poziia curent nu este la sfritul fiierului i o valoarea diferit de 0 dac poziia actual indic sfritul de fiier.
159
#include<ctype.h> #include<stdlib.h> void main() { FILE *f; int l,c,g; char ch; l=c=g=0; if(!(f=fopen(in.txt,r))) //operaia ntoarce pointer nul { printf(nu se poate deschide fisierul pentru citire); exit(1); } do{ ch=fgetc(f); //citete un caracter din fiier if(isalpha(ch)) l++; if(isdigit(ch)) c++; if(!isprint(ch)) g++; // caracterul nu este afisabil }while(ch!=EOF); //pn se ntlnete EOF printf(\n numarul de litere este %d,l); printf(\n numarul de cifre este %d,c); printf(\n numarul de caractere neafisabil este %d,g); fclose(f); }
160
void main() { FILE *f1,*f2; char linie[80]; f1=fopen(in.txt,r); f2=fopen(out.txt,w); do{ if(feof(f1)) break; //fiierul f1 s+a terminat fgets(linie,80,f1); //citete o linie din f1 fputs(linie,f2); //scrie linia n f2 }while(1); fcloseall(); } Exemplul 2: Afiarea unui fiier text pe ecran. La fiecare afiare a 22 de linii se va face o pauz, afiarea continund la apsarea unei taste. #include<stdio.h> void main() { FILE *f; char linie[80]; long n=0; // numara cate linii au fost citite f=fopen(in.txt,r); while(!feof(f)) { fgets(linie,80,f); printf(%s,linie); if(++n%22==0) getch(); } fclose(f); } Exemplul 3: Fiind dat un fiier, s se determine numrul de linii, linia de lungime maxim i lungimea fiierului (numrul de caractere utile). #include<stdio.h> #include<string.h> #include<stdlib.h> void main() { FILE *f; char linie[120]; int l,max=0; // lungimea celei mai lungi linii din fisier long nr=0,n=0; // nr-lungimea fisierului, n-numarul de linii f=fopen(in.txt,r); if(!f) //deschiderea ntoarce pointer nul { printf(fisierul nu exista); exit(1); } while(!feof(f)) { n++; //numr liniile fgets(linie,120,f);
161
//citete o linie din fiier l=strlen(linie); //afl lungimea liniei curente if(max<l) max=l;//actualizeaz lungimea maxim nr+=l; //actualizeaz nr. caracterelor citite din //fiier } printf(linia de lungime maxima :%d\n,max); printf(numarul de linii :%ld\n,n); printf(lungimea fisierului :%ld\n,nr); fclose(f); } Exemplul 4: Programul urmtor numr apariiile unui cuvnt ntr-un fiier text. Citirea acestuia se face linie cu linie. #include<stdio.h> #include<string.h> void main() { typedef char STRING[256]; STRING cuv,linie, FILE *f; char *p; int nr=0; f=fopen(in.txt,r); printf(cuvantul cautat : ); scaf(%s,cuv); while(!foef(f)) { fgets(linie,256,f); p=linie; while(p!=NULL) // mai sunt caractere in linie { p=strstr(p,cuv); // cauta cuvantul in sirul curent de //caractere if(p) // cuvantul apare in sirul curent) { nr++; // numarul aparitia cuvantului p++; // avansez la urmatorul caracter //din sir pentru a repeta cautarea } } } printf(numarul de aparitii: %d,nr); fclose(f); } Exemplul 5: Se consider un fiier text a crui nume se citete de la tastatur, format din iruri de caractere scrise fiecare pe cte o linie. Se cere s se sorteze liniile
162
fiierului n ordine alfabetic i s se scrie rezultatul ntr-un alt fiier al crui nume se citete de la tastatur. Rezolvare: Vom stoca irurile citite din fiier ntr-un tablou de iruri de caractere pe care l vom ordona. Vom scrie apoi elementele tabloului ordonat n fiierul de ieire. Fiecare ir citit din fisier va fi corectat prin eliminarea caracterului '\n' cu excepia ultimului ir citit din fiier, care nu conine acest caracter suplimentar. #include<stdio.h> #include<string.h> void main() { FILE *f; char sir[100][100],aux[100]; char nume[20]; int n=0,i=0,j; printf("numele fisierului de intrare: "); scanf("%s",nume); f=fopen(nume,"rt"); while(!feof(f)) { fgets(sir[i],100,f); //citim o linie din fiier if(!feof(f)) // nu este ultima linie din fisier sir[i][strlen(sir[i])-1]=0; // eliminam din sir '\n' i++; } n=i; fclose(f); for(i=0;i<n-1;i++) for(j=i+1;j<n;j++) if(strcmp(sir[i],sir[j])>0) { strcpy(aux,sir[i]); strcpy(sir[i],sir[j]); strcpy(sir[j],aux); } // scriem datele in fisierul de iesire printf("numele fisierului de iesire: "); scanf("%s",nume); f=fopen(nume,"wt"); for(i=0;i<n;i++) { fputs(sir[i],f); fputc('\n',f); } fclose(f); }
163
Limbajul C/C++ pentru nceptori { FILE *f; struct pers s; f=fopen(test.bin,wb); if(!f) { printf(fisierul nu se poate deschide); exit(1); } s.ani=40; strcpy(s.nume,Mihai Popescu); fwrite(&s,sizeof(s),1,f); // scrie structura s in fisier fclose(f);
164
Limbajul C/C++ pentru nceptori b) pentru a putea citi din fiier folosim atribut r la deschidere, iar pentru a scrie n fiier l deschidem cu atributul w c) pentru a testa dac nu sa ajuns la sfritul fiierului referit de pointerul f, vom scrie ! feof(f) d) pentru a nchide fiierul referit de pointerul f vom scrie close(f) e) nici una dintre afirmaiile de mai sus nu este adevrat 2. Se consider un fiier definit prin pointerul f, i care conine urmtoarele valori pe primele dou rnduri : 4 7 2.5 -6.23 # 8 Fie urmtoarele declaraii de variabile: FILE *f; int x,y; float a,b,d; char c; Care dintre secvenele de instruciuni de mai jos trebuie executate astfel nct toate variabilele declarate s primeasc valori citite din fiierul f ? a) fscanf(f,%d %f %d %f\n ,&x,&a,&y,&b); fscanf(f,%c %f,&c,&d); b) fscanf(f,%d %d %f %f\n, &x,&y,&a,&b); fscanf(f,%c %f,&c,&d); c) fscanf(f,%d %d %f %f\n, &x,&y,&b,&a); fscanf(f,%f %c,&d,&c); d) fscanf(%f %f %d %d\n, &b,&a,&y,&x,f); fscanf(%c %f,&c,&d,f); e) fscanf(%d %f %d %f\n, &x,&a,&y,&d,f); fscanf(%f %c,&d,&c,f);
165
3. n timpul execuiei programului urmtor sunt posibile urmtoarele situaii : #include<stdio.h> void main() { FILE *f; int x=1,s=0; f=fopen(suma.txt,r); while(!feof(f) && x) { fscanf(f,%d,&x); if(x%2) s+=x; } fclose(f); printf(\ns=%d,s); } a) programul este corect sintactic b) pentru a funciona citirea din fiier, acesta trebuie deschis n alt mod c) programul va intra ntrun ciclu infinit d) dac n fiier se gsesc, pe acelai rnd separate prin cte un spaiu, numerele 2 5 4 3 6 1 0 7, atunci programul va afia s=16 e) modul n care este nchis fiierul nu corespunde cu modul n care a fost deschis 4. Fie fiierul identificat prin descriptorul f, avnd urmtorul coninut: 5 2 3 4 6 7 8 Care dintre secvenele urmtoare de program S1, S2, S3 poate fi executat, astfel nct, n vectorul v s se citesc corect toate numerele din fiier ? //secventa S1 fscanf(f,%d,&n); for(i=0;i<n;i++)
Limbajul C/C++ pentru nceptori fscanf(f,%d,&v[i]); //secventa S2 j=0; while(!feof(f)) { fscanf(f,%d,&v[j]); j++; } n=j; //secventa S3 j=0; do{ fscanf(f,%d,&v[j]); j++;}while(!feof(f)); n=j-1; a) toate b) nici una c) numai S1 i S2 d) d) numai S2 i S3 e) numai S1 5. Ce numr se va gsi pe al patrulea rnd al fiierului 4.txt dup execuia programului urmtor ? #include<stdio.h> void main() { FILE *f; f=fopen(4.txt,w); int n=8,j=0, v[8]={1,3,8,5,0,6,7,4}; while(v[j]%2) j++; while(j<n) if(v[j++]) fprintf(f,%d\n,v[j]); fclose(f); } a) 5 b) 0 c) 6 d) 7 e) 4 6. Fie programul: #include<stdio.h> #include<math.h> void main() { FILE *f,*g; int e; char c1, c2;
166
f=fopen(1.txt,r); g=fopen(2.txt,r); e=1; do{ c1=fgetc(f); c2=fgetc(g); if(c1!=c2) e=0; }while(!(feof(f)|| feof(g))&&e); if(e) if(!(feof(f)&&feof(g)))e=0; fclose(f); fclose(g); printf(%d,e); } Programul de mai sus afieaz valoarea 1 dac: a) cele dou fiiere difer prin cel puin un caracter b) cele dou fiiere sunt identice c) n cele dou fiiere exist i caractere identice d) cele dou fiiere au acelai numr de caractere e) nici unul dintre cazurile de mai sus 7. Precizai care va fi coninutul fiierului g dup execuia programului urmtor, dac fiierul f conine pe fiecare linie o zi a sptmnii (luni, ..,duminica) : #include<stdio.h> #include<math.h> void main() { FILE *f,*g; int j=1; char s[11],c1,c2; f=fopen(7.txt,r); g=fopen(7_2.txt,w); while(j++<4) fgets(s,10,f); fprintf(g,%d ,j-1); fputs(s,g); fclose(f); fclose(g);
167
8. Fie programul urmtor: #include<stdio.h> void main() { FILE *f,*g; int a,x,s; f=fopen(in.txt,r); g=fopen(out.txt,w); scanf(%d,&a); while(!feof(f)) { s=0; while(s<a && !feof(f)) { fscanf(f,%d,&x); s+=x; } fprintf(g,%d,s); } fclose(f); fclose(g); printf(\n s=%d,s); } Dac de la tastatur se introduce valoarea 10, iar coninutul fiierului in.txt este 4 6 3 2 6 15 1 (pe aceeai linie), cte numere va scrie programul n fiierul out.txt ? a) nici unul b) unul c) dou d) trei e) patru 9. Cte numere se vor gsi n fiierul nr.txt dup execuia programului urmtor ? #include<stdio.h> void main() { int v[9]= {0,1,0,0,2,3,0,4,5}, j; FILE *f; f=fopen(nr.txt,w); j=0;
10. Deducei ce valoare va afia programul urmtor, tiind c n fiierul f se gsesc pe un rnd, separate prin spaii, numerele 1 3 0 0 2 -3 0 -4 -1 #include<stdio.h> #include<math.h> void main() { FILE *f; int s=1,j=0,a[20]; f=fopen(nr.txt,r); while(!feof(f)) { j++; fscanf(f,%d,&a[j]); if(a[j]) s*=abs(a[j]); } printf(\n%d,s); fclose(f); } a) 1 b) 72 c) 72 d) programul conine erori de sintax e) nu se pot citi corect numerele din fiier 11. Presupunnd c toate liniile fiierului g conin cel mult 100 de caractere, care este aciunea programului urmtor ? #include<stdio.h> void main() {
Limbajul C/C++ pentru nceptori FILE *f,*g; char s[101]; f=fopen(1.txt,a); g=fopen(2.txt,r); while(!feof(g)) { fgets(s,100,g); fputs(s,f); } fclose(f); fclose(g); fclose(f); printf(%d,s); } a) 0 b) 8 c) 20 d) 25 e)programul eronat
168
este
} a) nlocuiete coninutul fiierului g cu coninutul fiierului f b) nlocuiete coninutul fiierului f cu coninutul fiirului g c) concateneaz fiierul g la sfritul fiierului f d) concateneaz fiierul f la sfritul fiierului g e) nici unul dintre cazurile anterioare 12. Deducei ce valoare va afia programul de mai jos, dac fiierul text are urmtorul coninut: 3 3 1 2 3 4 5 6 7 8 9 #include<stdio.h> void main() { FILE *f; int i,j,m,n,s=0, a[20][20]; f=fopen(c.txt,r); fscanf(f, %d %d,&m,&n); for(i=0;i<m;i++) for(j=0;j<n;j++) { fscanf(f,%d,&a[i][j]); if((i+j)%2) s+=a[i][j]; }
13. Se d fiierul identificat prin descriptorul f, cu urmtorul coninut: 33 1 -45 18 6 Ce instruciune trebuie scris n loc de .. astfel nct programul urmtor s tipreasc 85? #include<stdio.h> void main(() { FILE *f; int x, y; f=fopen(v.txt,r); fseek(f,-6,2); fscanf(f,%d,&y); fscanf(f,%d,&x); printf(\n%d%d,x,y); fclose(f); } a) fseek(f,11,0); b)fseek(f,-2,2); c) fseek(f,3,1); d)fseek(f,2,1); e) fseek(f,-3,2); 14. Precizai ce nume se va gsi pe al cincilea rnd din fiierul p.txt dup execuia programului de mai jos: #include<stdio.h> #include<string.h> void main() { FILE *f; int i=0,j,k; char *aux; char *a[9]={Marius, Claudiu,3rei-Sud-Est, Daniel,Vasile,Dan,
Limbajul C/C++ pentru nceptori Sinacdu,2Pac}; while(a[i]) i++; for(j=0;j<i-1;j++) for(k=j+1;k<i;k++) if(strcmp(a[j],a[k])>0) { aux=a[j]; a[j]=a[k]; a[k]=aux;} k=0; f=fopen(p.txt,w); while(a[k]) fprintf(f,%s\n,a[k++]); fclose(f); } a) 2Pac b)Claudiu c) Dan d) Daniel e) Marius 15. Precizai care va fi coninutul fiierului b.txt dup execuia
169
programului urmtor, tiind c fiierul a.txt are urmtorul coninut: 11 2 13 4 15 6 17 8 19 #include<stdio.h> #include<math.h> void main() { FILE *f,*g; int v[10]; f=fopen(a.txt,r); g=fopen(b.txt,w); fread(v,8,1,f); fwrite(v,6,1,g); fclose(f); fclose(g); } a) 11 2 13 4 15 6 b) 1 2 2 4 1 6 c) 11 2 13 d) 11 2 1 e) un alt coninut dect cel indicat
170
6.5 Tablouri
Limbajul C/C++ pentru nceptori 1)c 11)d 21)c 32)b 2)d 3)a,b 4)c 5)d 6)b,d,e 7)e 8)d 12)a,b,d 13)b,c 14)d 15)b,d 16)b 17)c 22)c 23)b 24)d 25)d 26)a 27)a 28)a 33)d 34)c 35)d 36)b 37)c 9)b 18)a 29)a
7.4 Pointeri
7) b cu e, c cu d 10)b 11)c,d,e 12)d 16)a,b,c 17)c 18)c 19)a,d 20)b 21)c 25)d,e 26)b,e 27)c 28)a,c,e 29)e 30)d 34)b 35)b 36)a 37)a 38)a 39)a 40)a 45)c 46)d 13)e 22)a 31)c 41)a 14)d 15)a 23)d 24)b,c 32)b,c 33)d 42)a 43)a 44)b
9.4 Structuri
1)d 2)d 3)c 4)b 5)d 6)d 7)c 8)d
172
Bibliografie
1. Herbert Schildt - C manual complet, Editura Teora, Bucureti, 1998 2. Liviu Negrescu - Limbajul C,vol.I, II, Editura Albastr, Cluj-Napoca, 1997 3. Dorian Stoilescu - Manual de C/C++, Editura Radial, Galai, 1998 4. Damian Costea - Iniiere n limbajul C, Editura Teora, Bucureti, 1996 5. George-Daniel Mateescu, Pavel Florin Moraru - Limbajul C++, probleme i teste gril pentru liceu i bacalaureat, Editura Niculescu, Bucureti, 2001 6. Claudia Botez, Dumitru Ilinca - Teste de informatic, Editura Universitii Tehnice Ghe. Asachi, Iai, 2001