Documente Academic
Documente Profesional
Documente Cultură
PCLP
PCLP
Limbajul C – creat în 1972 la Bell Laboratories , având ca obiectiv principal dezvoltarea unui
limbaj care să fie utilizat pentru implementarea sistemului de operare UNIX.
Caracteristici:
- produce programe eficiente
- portabil
- set puternic de operatori
- flexibilitate în programare
- oferă facilităţi specifice limbajelor de asamblare
- limbaj de programare structurat
Limbajul C++ - extensie a limbajului C -permite programarea orientată spre obiecte (obiectuală)
main( )–funcţia rădăcină, este prezentă în orice program C şi execuţia programului începe
automat cu ea. Ea poate întoarce un rezultat întreg (int) sau nici un rezultat (void).
Cel mai simplu program C++ :
Programul este corect, deşi nu execută nimic.
void main() Pornind de la el, scriem orice program,
{ adăugând instrucţiuni între cele două acolade
(corpul funcţiei). Cele două paranteze rotunde
} () se ataşează oricărei funcţii. Între ele se scriu
opţional anumiţi parametrii.
1
Obs:
1) Este permis ca tipul funcţiei să lipsească:
main( )
{
}
În acest caz se presupune că funcţia întoarce un rezultat întreg şi la compilare, deoarece ea nu
întoarce nici un rezultat, se va primi un avertisment.
2) În exemplul următor:
Main( )
{
}
programul va da eroare de sintaxă deoarece limbajul face distincţie între litere mari şi mici.
3) Următoarele exemple sunt corecte şi identice (nu are importanţă nici plasarea cuvintelor pe linie,
nici spaţiile dintre ele):
main( ) { }
main ( )
{ }
main ( ) {
}
2
2. Identificatori şi cuvinte cheie (rezervate) – o succesiune de litere, cifre sau caracterul
underscore (‘ _ ‘) cu restricţia ca primul caracter să nu fie cifră. Cu ajutorul lor se asociază nume
constantelor, variabilelor, funcţiilor, etc.
Exemplu: i, j1, un_numar, _id Contraexemplu: a#b, 1ab, xy&, -plus
3. Separatori şi comentarii
Ex nr.1:
#include<iostream.h>
/* functia main este functia principala, cu care
incepe executarea programului */
void main( )
{
/* Urmeaza instructiunea prin care se
afiseaza un text */
cout<<"Prima aplicatie!";
} // sfarsitul functiei main
4
Tipuri de date
Orice variabilă, înainte de a fi utilizată, trebuie declarată prin precizarea tipului ei.
tip de date o mulţime de valori pe care sunt definite anumite operaţii.
Limbajul C++ conţine următoarele tipuri standard (cunoscute de către limbaj fără a fi definite în
cadrul programului):
Tipuri întregi:
1. unsigned char – caracter fără semn - ocupă 8 biţi şi ia valori între 0 şi 28 - 1
2. char –caracter - ocupă 8 biţi şi ia valori între -27 şi 27 - 1
3. unsigned int – întreg fără semn - ocupă 16 biţi şi ia valori între 0 şi 216 - 1
4. int – întreg scurt - ocupă 16 biţi şi ia valori între -215 şi 215 - 1
5. unsigned long – întreg lung fără semn - ocupă 32 de biţi şi ia valori între 0 şi 232 - 1
6. long - întreg lung cu semn - ocupă 32 de biţi şi ia valori între - 231 şi 231 - 1
Tipuri reale:
Variabilele de tip real reţin numere cu zecimale. În locul virgulei, în C++ se foloseşte punctul.
1. float - ocupă 32 de biţi şi ia valori între 3.4 x 10-38 şi 3.4 x 1038
2. double - ocupă 64 de biţi şi ia valori între 1.7 x 10-308 şi 1.7 x 10308
3. long double - ocupă 80 de biţi şi ia valori între 3.4 x 10-4932 şi 1.1 x 104932
5
2) În urma execuţiei următorului program:
#include <iostream.h>
void main()
{
int a; char b;
a = 20; b = ‘n’;
cout<<b<<a+b ;
}
se va afişa ‘n’ şi numărul 130 deoarece se adună codul caracterului ‘n’, care este 110, cu numărul.
3) În C++ nu există tipul logic. În C++, o variabilă care reţine o valoare diferită de 0 este TRUE
(adevarată), iar una care reţine valoarea 0 este FALSE (falsă).
4) În C++ este admis tipul void, cu semnificaţia de “nimic” sau “ orice tip”,în funcţie de context.
Constante
Constantă: entitate a cărei valoare rămâne neschimbată pe durata existenţei sale. Ea are un tip şi o
valoare.
Pentru a defini o constantă se foloseşte declaraţia const care are forma:
const [tip] nume = valoare ;
1. Constante întregi:
- zecimale (în baza 10). Exemple: 5, 345, 32, -12
- octale (în baza 8). O succesiune de cifre octale 0 – 7 precedată de un 0 nesemnificativ.
Exemple: 0345 reţine numărul 345(8) .
- hexazecimale (în baza 16). O succesiune de cifre hexazecimale precedată de 0x sau 0X.
Exemple: 0x2B3 reţine numărul 2B3(16) .
6
Cifrele hexazecimale se obţin extinzând cifrele zecimale cu literele mici sau mari de la A la F:
2. Constante caracter:
Acestea se trec între două caractere apostrof: ‘a’, ‘A’, ‘3’ .O constantă caracter are ca valoare codul
ASCII al caracterului pe care-l reprezintă. Ea are tipul int.
De exemplu pentru ‘a’ se memorează 97, iar pentru ‘A’ se memorează 65.
O altă modalitate de declarare a constantelor caracter este sub formă de secvenţe escape. O secvenţă
escape începe cu caracterul backslash (\).
Fie, de exemplu, constanta caracter ‘c’ care are codul 99(10) = 143(8) = 63(16) .
Aceasta poate fi scrisă echivalent : ‘\143’ sau ‘\x63’ . În cazul reprezentării în baza 16 se foloseşte
precedată de caracterul ‘x’.
Ex:
Programul următor va tipări de 4 ori caracterul ´c´ :
#include <iostream.h>
void main()
{
char x1 = 99 , x2 = ‘\143’ , x3 = ‘\x63’, x4 = ‘c’ ;
cout<<x1<<x2<<x3<<x4 ;
}
Rolul secvenţelor escape este acela de a da posibilitatea declarării caracterelor care nu se pot tasta.
De exemplu, caracterul backspace (codul 8(10)) poate fi declarat ‘\10’ sau ‘\x8’ , iar caracterul
newline (codul 10(10)) poate fi declarat ‘\12’ sau ‘\xa’ .
7
Obs: Dat fiind un număr întreg (scris într-o bază oarecare b1), pentru scrierea lui într-o altă bază (b2)
se împarte succesiv numărul scris în baza b1 la noua bază până când se obţine câtul 0; Reprezentarea
în noua bază se obţine prin scrierea resturilor (reprezentate în noua bază) în ordinea inversă obţinerii
lor şi multiplicarea cu puterea corespunzătoare a bazei care este egală cu rangul operaţiei.
3. Constante reale:
- au o parte întreagă (ce poate fi vidă); în acest caz devine o constantă zecimală.
- au o parte fracţionară (ce poate fi vidă numai dacă partea întreagă este prezentă); aceasta este
formată din: caracterul "." (punct) urmat de o succesiune de cifre zecimale.
- au un exponent (poate lipsi); începe cu E sau e, apoi + sau - (opţional) urmat de un şir de cifre
zecimale; E sau e exprimă o putere a lui 10.
Ex:
Constantă reală Valoare Constantă reală Valoare
12. 12 25e4 25x10^4
123.4 123.4 .1E-5 0.1x10^(-5)
.67 0.67 -123.456e2 -123.456x10^2=-12345.6
Obs: Implicit acestea sunt memorate utilizând tipul double. Se poate forţa ca acestea să fie
memorate sub tipul float adăugând sufixele f sau F sau sub long double adăugând l sau L.
Ex: -144.5 se memorează sub formă double
-144.5f se memorează sub formă float
-144.5L se memorează sub formă long double
8
4. Constante şir de caractere:
Se declară între două caractere “. Funcţiile de prelucrare sunt în biblioteca string.h.
Ex: “acesta este un text”
Obs: Pe lângă mecanismul cunoscut de declarare a constantelor (cu ajutorul lui const) în C++ mai
avem posibilitatea de declarare cu ajutorul directivei preprocesorului, #define:
#define nume expresie
Aceste constante rămân valabile până la sfârşitul programului, până la redefinirea lor sau până la
întâlnirea directivei #undef.
Ex:
1) #include <iostream.h>
#define pi 3.14
#define text “valoarea aproximativa a lui pi este”
main()
{
cout<<text<<pi;
}
2) Se poate defini o constantă cu ajutorul uneia deja definită (programul următor va tipări 3.14):
#include <iostream.h>
#define pi 3.14
#define alt_pi pi
main()
{
cout<<alt_pi ;
}
9
Expresii
expresie - formată dintr-un operand sau mai mulţi, legaţi prin operatori.
La scrierea unei expresii se pot folosi operatori din aceeaşi clasă sau din clase diferite. La evaluarea
expresiilor trebuie să se ţină seama de priorităţile operatorilor care aparţin diferitelor clase de
operatori, de asociativitatea operatorilor de aceeaşi prioritate (ordinea aplicarii operatorilor
consecutivi de aceeaşi prioritate) şi de regula conversiilor implicite.
Obs:
1) Operatorul ‘ / ’ acţionează în mod diferit în funcţie de operanzi:
a) dacă ambii sunt de tip întreg, rezultatul este întreg şi are semnificaţia de împărţire întreagă
b) dacă cel puţin unul din operanzi este de unul din tipurile reale, rezultatul este real, deci se
efectuează împărţirea obişnuită.
2) Operatorul ‘ % ’ (restul împărţirii întregi) acţionează numai asupra operanzilor de tip întreg.
Ex: Expresia 7%3 are ca valoare 1.
Expresia -7%3 are ca valoare -1. deoarece -7 = (-2)*3 + (-1)
3) La evaluarea expresiilor, în cazul în care un operator se aplică la doi operanzi de tipuri diferite, se
aplică următoarea regulă (a conversiilor implicite):
- orice operand de tipul char şi unsigned char este convertit către tipul int.
- dacă un operand este de tipul unsigned long, atunci şi celălalt se converteşte către tipul unsigned
long.
- dacă un operand este de tipul long, atunci şi celălalt se converteşte către tipul long.
- dacă un operand este de tipul float, atunci şi celălalt se converteşte către tipul float.
- dacă un operand este de tipul double, atunci şi celălalt se converteşte către tipul double.
- dacă un operand este de tipul long double, atunci şi celălalt se converteşte către tipul long double
Ex:
1) Fie declaraţiile:
int a = 5; char b = 6; float c = 9;
Atunci expresia a + b + c are rezultatul 20.0
11
2) Programul următor va tipări 97:
#include <iostream.h>
void main()
{
int a = 0; char b = ‘a’ ;
cout << a+b;
}
Exerciţii:
Realizaţi rularea următoarelor programe:
#include <iostream.h>
void main()
{
char c1, c2;
c1=’a’; c2 = c1 + 1;
cout<<c2;
}
#include <iostream.h>
void main()
{
int i;
char a,b;
a = ‘x’; i=a; b=i;
cout<<b;
}
#include <iostream.h>
void main()
{
char c ;
int i1, i2;
i1=300; c=i1; i2=c;
cout<<i2 ;
}
12
Operatori relaţionali
<, >, <=, >=
Deoarece în C++ nu există valorile logice TRUE şi FALSE, rezultatul unei operaţii logice este 1 în
cazul în care inegalitatea e respectată şi 0 în caz contrar.
Ex:
3 > 5 rezultatul este 0
3<5 rezultatul este 1
Operanzii pot fi constante, variabile, funcţii.
Operatori de egalitate
= =, ! =
Ca şi în cazul operatorilor relaţionali, se returnează 0 sau 1 în funcţie de modul în care este
respectată sau nu egalitatea .
Operanzii pot fi constante, variabile, funcţii.
Obs: Deoarece rezultatul operaţiilor logice este 1 sau 0, se pot găsi ca operanzi în cadrul unor
expresii aritmetice.
Ex:
a = ((1<2)+(3!=5))*2 după aceasta a = ((1) + ((1))*2 = 4
a = (2<3) = = (2!=8) după aceasta a = (1) = = (1) deci a = 1
a = 5= =6 după aceasta a = 0 deoarece 5 este diferit de 6
Operatori logici
! negare logică : dacă operandul este o valoare 0, rezultatul este 0, altfel este 1
&& şi logic: dacă ambii operanzi sunt 0, rezultatul este 1, altfel este 0
sau logic: dacă cel puţin unul din operanzi este o valoare 0, rezultatul este 1, altfel este 0
Ex:
(2+3*3)&&(!0) rezultatul este 1 pentru că ambii operanzi sunt 0
(2-2) (0) rezultatul este 0 pentru că nici un operand nu este 0
!(1+3*3) rezultatul este 0 pentru că operandul este 0
!!3 rezultatul este 1
!(3>4) rezultatul este 1 pentru că operandul este 0
13
Obs: Deoarece operatorii logici aplicaţi unor operanzi produc valorile 0 sau 1, apelul lor poate apare
ca operanzi în cadrul unor operaţii aritmetice:
Ex:
a = (!(3 < 4) + (3 && 4 ) * ( !0 )+( 3 4))
= (!(1) + (1)*(1) + (1))
=(0+1+1)
=2
~ 0 =1 0 & 0 =0 0 0 =0 0 ^ 0 =0
~ 1 =0 0 & 1 =0 0 1 =1 0 ^ 1 =1
1 & 0 =0 1 0 =1 1 ^ 0 =1
1 & 1 =1 1 1 =1 1 ^ 1 =0
Ex:
7 & 3 = 3 deoarece: 7 00000111 &
3 00000011
00000011 3
7 3 = 7 deoarece: 7 00000111
3 00000011
00000111 7
14
Operatorul << deplasează către stânga conţinutul tuturor biţilor operandului din stânga sa, cu un
număr de poziţii egal cu valoarea reţinută de al doilea operand. Poziţiile rămase libere în dreapta,
vor reţine valoarea 0.
Obs: a << n este echivalent cu a * 2n
Ex:
8 << 3 = 64 deoarece: 8 00001000
deplasare cu 3 poziţii la stânga
01000000 64
Operatorul >> deplasează către dreapta conţinutul tuturor biţilor operandului din stânga sa, cu un
număr de poziţii egal cu valoarea reţinută de al doilea operand. Poziţiile rămase libere în stânga, vor
reţine valoarea 0.
Obs: a >> n este echivalent cu a / 2n
Ex:
7 >> 2 = 1 deoarece: 7 00000111
deplasare cu 2 poziţii la dreapta
00000001 1
Operatorul de atribuire
- atriburi simple - sintaxa v = expresie
compuse - sintaxa: v = v1 = v2 = ..... = vn = expresie
15
Operatorul ‘ , ‘ virgulă
se utilizează în situaţii în care într-un anumit punct al unui program este necesar să se realizeze un
calcul complex exprimat prin mai multe expresii.
Expresiile se evaluează pe rând, de la stânga la dreapta. Întreaga expresie (care cuprinde cele n
expresii separate prin virgulă ) va avea ca rezultat şi tip valoarea şi respectiv tipul, obţinute în urma
evaluării ultimei expresii.
Ex: declaraţiile: expresia c = a = b + 3 , a = c + 2, b = b + 3 se evaluează astfel:
int a = 5, b = 7; b + 3 = 10; a = 10 ; c = 10.0 ;
float c; a = 10 + 2 = 12;
b = 7 + 3 = 10 ;
expresia în ansamblu este de tipul int şi produce valoarea 10
Operatorul condiţional
se utilizează în situaţia în care există două variante de obţinere a rezultatului în funcţie de
îndeplinirea unei condiţii.
17
Operatorul de conversie explicită (cast) sau de forţare a tipului
folosit, atunci când e nevoie, în cadrul unor expresii, pentru ca anumiţi operanzi să intre în calcul
convertiţi aşa cum dorim şi nu implicit.
Forma: (tip_conversie) operand
astfel, valoarea operandului se converteşte spre tip_conversie .
Ex: float a; a = (float) 5; a = 5.000000
int b; b = (int) 5.35; b=5
int c; c = (int) (3.78 + 7); c = 10
float d; d = (float) (1/2) d = 0.000000
float d; d = 1/(float) 2 d = 0.500000
float d; d = 5+((float)3+4) d = 12.000000
Instrucţiuni
Instrucţiunea expresie
Forma: expresie;
Instrucţiunea compusă
succesiune de instrucţiuni incluse între acolade, precedate eventual de declaraţii de variabile locale.
Forma: {
declaraţii şi definiţii locale blocului
instrucţiuni
}
Ex: presupunem că într-un punct al programului trebuie permutate valorile variabilelor a şi b:
{ Obs: după execuţia ultimei
int aux; instrucţiuni a instrucţiunii
compuse, variabila aux nu
aux = a; a = b; b = aux; mai este definită!
}
18
Instrucţiunea IF
Forme: if (expresie) instrucţiune;
if (expresie) instrucţiune1;
else instrucţiune2;
Funcţionare: se evaluează expresia din paranteze. Apoi, în primul caz, dacă expresia are valoarea
diferită de 0 (adevărat) se execută instrucţiune. Altfel, se trece la instrucţiunea următoare
instrucţiunii if. În al doilea caz, dacă expresia are valoarea diferită de 0 (adevărat) se execută
instrucţiune1 şi apoi se trece la instrucţiunea următoare instrucţiunii if; altfel, se execută
instrucţiune2 şi apoi se trece la instrucţiunea următoare instrucţiunii if.
Obs:
1) Înainte de cuvântul cheie else nu se pune ’;’ dacă instrucţiune1 este o instrucţiune compusă,
altfel se pune obligatoriu.
2) Ramurile instrucţiunii if pot conţine la rândul lor alte instrucţiuni if (se numesc if-uri imbricate).
Exemplu de program ce exemplifică folosirea unei instrucţiuni if în corpul altei instrucţiuni if.
Se citesc trei variabile reale x, y , z. Să se calculeze:
x+y, z>0
e= x*y, z=0
x-y, z<0
#include <iostream.h>
void main()
{
double x,y,z,e;
cout<<”x=”;cin>>x; cout<<”y=”;cin>>y; cout<<”z=”;cin>>z;
if (z>0) e=x+y;
else if (z= =0) e= x*y; // se poate scrie şi if (!z)
else e = x-y;
cout<<e;
}
19
Instrucţiunea SWITCH
permite selecţia unei variante din mai multe posibile.
Forma: switch (expresie)
{
case c1: secvenţă instrucţiuni1; break;
case c2: secvenţă instrucţiuni2; break;
............................................................
case cn: secvenţă instrucţiunin; break;
[default: secvenţă instrucţiunin+1];
}
Funcţionare: se evaluează expresia. Dacă aceasta produce o valoare egală cu ci, se execută secvenţă
instrucţiunii şi se trece la instrucţiunea următoare instrucţiunii switch, altfel se execută secvenţă
instrucţiunin+1.
În absenţa alternativei default, dacă valoarea expresiei nu coincide cu valoarea nici uneia dintre
constantele c1, c2, ……, cn , instrucţiunea switch nu are nici un efect şi se trece la execuţia
instrucţiunii următoare.
k=2; k=2;
switch ((k-1)*3)) switch(3<4)
{ {
case 4-1 : k=k+1; case 1 : k++;
case (5-3)%2 : k=k+2; case (3<=5)&&(2>3) : k=k+2;
default: : cout<<”sfarsit”; case ‘a’ : k--;
} default: : cout<<”10”;
}
20
k=’a’; k=’a’;
switch (k+1) switch(k<’4’)
{ {
case ‘d’ : k=k+1; case ‘d’<=’9’ : k++;
case ‘1’ : k=k+2; case ‘1’>=’4’ : k=k+2;
default: : cout<<1; default :;
} }
Exemplu de program care citeşte un număr natural şi precizează dacă el reprezintă codul ASCII al
unui caracter alfanumeric (literă mică, literă mare, cifră), în acest caz afişându-se şi caracterul:
#include <iostream.h>
void main()
{
int n, a=0;
cin>>n;
if ((n>=97)&&(n<=122)) a=1;
else if ((n>=65)&&(n<=90)) a=2;
else if ((n>=48)&&(n<=57)) a=3;
swich(a)
{
case 1 : cout<<n<<”e codul ASCII al literei mici”<< (char) n;
case 2 : cout<<n<<”e codul ASCII al literei mari”<< (char) n;
case 3 : cout<<n<<”e codul ASCII al cifrei”<< (char) n;
default : cout<<n<<” nu e codul ASCII al unui caracter alfanumeric”;
}
}
21
Instrucţiunea WHILE
instrucţiune ciclică ce defineşte o structură repetitivă condiţionată anterior.
Forma: while(expresie)
instrucţiune;
Funcţionare: se evaluează expresie; Dacă valoarea obţinută este diferită de 0, se execută instrucţiune
şi se revine la pasul anterior, iar dacă se obţine o valoare egală cu 0, se trece la următoarea
instrucţiune din cadrul programului.
Obs: 1) Instrucţiunea care depinde de expresia de la while poate să nu se execute niciodată. Aceasta
se întâmplă atunci când după evaluarea expresiei se obţine valoarea 0.
Ex: a=1; b=a+1;
Încă de la început condiţia este
while(a>=2) falsă şi deci expresia având
valoarea 0, instrucţiunea nu se
{
execută niciodată.
a+=b;
b++;
}
2) Instrucţiunea care depinde de expresia de la while poate să se execute de o infinitate de ori.
Aceasta se întâmplă atunci când expresia are valoarea diferită de 0 întotdeauna.
Ex: a=1; b=b+1;
Condiţia nu devine falsă
while(a<=2)
niciodată şi deci instrucţiunea
{ se execută de o infinitate de ori.
b+=a;
b++;
}
3) Dacă după expresie se pune ‘;’, avem două situaţii :
- dacă condiţia este adevărată, se intră în ciclu infinit
- dacă condiţia este falsă se execută următoarea instrucţiune din program
Ex: a=1; b=b+1;
ciclu infinit
while(a<=2);
{
a--;
b++;
}
22
Ex: a=1; b=b+1;
while(a>=2); se execută următoarea
instrucţiune din program
{
a--;
b++;
}
23
Instrucţiunea DO WHILE
instrucţiune ciclică ce defineşte o structură repetitivă condiţionată posterior.
Forma: do
instrucţiune
while(expresie);
Instrucţiunea FOR
instrucţiune ciclică ce defineşte structura repetitivă condiţionată anterior, cu număr cunoscut de paşi.
unde exp1, exp2, exp3 sunt expresii: exp1 iniţializare, exp2 testare, exp3 reiniţializare (incrementare)
for(int i=1;i<=10;i++); /* deoarece dupa for am pus ‘;’ in ciclu nu se va executa nici o*/
cout<<i<<” “; /* instructiune, iar valoarea tiparita pentru i va fi 11 */
Instrucţiunea BREAK
produce ieşirea forţată din cel mai interior ciclu while, do-while, for, care o conţine sau din
instrucţiunea switch.
Forma: break;
Ex: Programele următoare determină, folosind instrucţiunile for, respectiv while, primul număr
divizibil cu 11:
#include <iostream.h> #include <iostream.h>
main() main()
{ {
int m=0, i=1; int m, i;
while (!m) for (i=1; ; i++)
{ if (i%11= =0) {
if (i%11= =0) { m=i;
m=i; break;
break; }
} cout<<m;
i++; }
}
cout<<m;
}
25
Instrucţiunea CONTINUE
produce saltul la testul de continuare în cazul instrucţiunilor while şi do-while sau saltul la expresia
de incrementare, în cazul instrucţiunii for.
Forma: continue;
Ex: 1) Programul următor realizează descompunerea în factori primi ai unui număr natural n citit de
la tastatură, sub forma factor exponent:
#include <iostream.h>
main()
{
int n, d, exp;
cout<<”n=”; cin>>n;
for (d = 2; ; d++)
{ /* descompune n in factori primi */
if (n % d != 0) continue; /* nu se imparte, se trece la urmatorul posibil factor */
exp = 0;
do /* repeta de cate ori d este factor */
exp++;
while ((n /= d) % d = = 0);
cout<< d<<” ”<< exp; /* scrie factorul curent si exponentul respectiv*/
if (n = = 1) break; /* am terminat */
}
}
2) Programul următor afişează, folosind instrucţiunea for, elementele impare dintre 1 şi 100:
#include <iostream.h>
main()
{
int i;
for(i=1;i<=100;i++)
{
if (i%2= =0) continue;
cout<<i<<” ”;
}
}
26
Instrucţiunea GOTO
produce saltul la instrucţiunea prefixată de eticheta al cărei nume se află după cuvântul cheie go to.
unde eticheta este un identificator al instrucţiunii cu care se continuă execuţia programului. Ea are
forma:
eticheta: instrucţiune;
Obs: 1) instrucţiunea goto se utilizează rar deoarece încalcă principiile programării structurate.
2) etichetele sunt locale în corpul funcţiei în care sunt definite şi astfel o instrucţiune goto
poate realiza un salt numai la o instrucţiune din corpul aceleiaşi funcţii în care ea este utilizată. Deci
o instrucţiune goto nu poate face salt din corpul unei funcţii la o instrucţiune din corpul altei funcţii.
3) în absenţa instrucţiunii goto, se poate realiza acelaşi lucru folosind un indicator (semnal) şi
efectuând o serie de teste asupra lui.
Funcţii matematice
27
În matematică definirea unei funcţii presupune definirea domeniului de definiţie, al
codomeniului şi a legii de corespondenţă pentru funcţia respectivă. În C++ o astfel de definiţie se
realizează prin definirea prototipului funcţiei respective.
Funcţiile sunt apelate cu un număr de parametrii efectivi. Parametrii de apel ai unei funcţii şi
tipul ei (natura rezultatului întors) sunt conţinuţi de prototipul funcţiei respective.
Prototipurile funcţiilor din acelaşi domeniu se găsesc grupate într-un fişier header. Astfel,
pentru folosirea funcţiilor matematice, trebuie inclus în fişierul sursă al programului fişierul math.h.
Funcţia fabs - întoarce |x| (modulul lui x), unde x este un număr real.
forma: double fabs(double x);
Funcţia labs - întoarce |x| (modulul lui x), unde x este un întreg lung
forma: long int labs(long int x);
28
forma: double atan(double x);
Obs: această funcţie este utilă în scrierea unui număr complex z = x+iy cu x, y∈ R, sub formă
e x ex
Funcţia sinh – calculează funcţia sinus hiperbolic sh(x): R R, sh(x)=
2
forma: double sinh(double x);
e x ex
Funcţia cosh – calculează funcţia cosinus hiperbolic ch(x): R R, ch(x)=
2
forma: double cosh(double x);
e x ex
Funcţia tanh – calculează funcţia tangent hiperbolic tanh(x): R R, th(x)=
e x ex
forma: double tanh(double x);
Funcţia log 10– calculează funcţia lg(x): R*+ R, unde lg(x)= log10(x)
forma: double log10(double x);
Setarea generatorului de numere aleatoare într-un anumit punct se face cu funcţia srand:
forma: void srand (unsigned n);
Apelul funcţiei srand cu valoarea 1 duce la reiniţializarea generatorului.
Ex 1): Programul următor tipăreşte 10 numere aleatoare întregi cuprinse între 0 şi 99:
#include <iostream.h>
#include <stdlib.h>
main( )
{
int i;
randomize( );
for (i=0;i<10;i++) cout<<rand( ) % 100<<’ ‘;
}
Obs: Dacă în program înlocuim randomize() cu srand(n), pentru valoarea fixată a lui n, la rulări
succesive ale programului, seria celor 10 numere va fi întotdeauna aceeaşi.
Ex 2): Programul următor tipăreşte 10 numere aleatoare cuprinse între două valori întregi citite:
#include <iostream.h>
#include <stdlib.h>
main( )
{
int a,b,i;
cout<<”a=”; cin>>a; cout<<”b=”; cin>>b;
randomize( );
for (i=0;i<10;i++) cout<<rand( ) % (b-a)+a<<’ ‘;
}
Tablouri
30
Tabloul reprezintă o colecţie de variabile de acelaşi tip referite prin acelaşi nume.
pot fi unidimensionale
multidimensionale
la declarare trebuie precizate tipul datelor din tablou
numele tabloului
numărul de componente ale tabloului declarat
ocupă o zonă contiguă de memorie, primul element se află la adresa mai mică
Obs: Deoarece în limbajul C nu există un tip predefinit string (şir de caractere) ca în alte limbaje de
programare, eventuale variabile de acest tip vor fi tablouri de caractere.
Tablouri unidimensionale
Se declară după structura: Selectarea unui element de tablou:
tip_baza nume_tablou[dimensiune]; nume_tablou[indice],
31
Obs: la declarare vectorii pot fi iniţializaţi. Valorile cu care se iniţializează sunt valori ale tipului de
bază tip_baza şi sunt trecute între acolade şi separate prin virgule.
Ex:1) int v[4]={1,2,3,4};
float u[3]={4e-3, 3.1, -5};
2) #include <iostream.h>
main( )
{
int i, v[4]={2,4,6,8};
for(i=0;i<=3;i++)
cout<<v[i]<<” “;
}
Tablouri multidimensionale
Tablourile cele mai des utilizate sunt tablourile cu un indice şi cele cu doi indici. Se pot defini însă
şi tablouri cu mai mult de doi indici.
Forma generală de declarare a unui tablou cu n indici este:
Obs: 1) Indicele din dreapta este cel care variază primul iar cel din stânga ultimul pentru ca
elementele din listă să ocupe, unul câte unul, poziţiile componentelor din tablou.
2) Tablourile cu mai mulţi indici nu sunt eficiente la utilizare din cauza memoriei pe care o
necesită (şi care se alocă odată cu declararea lor). Memoria ocupată de tablou este:
dimensiune1* dimensiune2*.... dimensiunen*sizeof(tip_baza).
3) Logica în care este memorat un tablou t cu n dimensiuni este următoarea:
tabloul n-dimensional se memorează ca un vector alcătuit din dimensiune1
componente, fiecare dintre acestea fiind un tablou cu n-1 dimensiuni;
fiecare tablou (n-1)-dimensional se memorează ca un vector alcătuit din dimensiune2
componente, fiecare dintre acestea fiind un tablou cu n-2 dimensiuni, etc.
32
Ex: fie tabloul: int t[2][3][4]. Acest tablou tridimensional se memorează ca un vector cu două
componente, fiecare dintre acestea fiind un tablou cu două dimensiuni. Fiecare astfel de tablou e
memorat ca un vector cu 3 componente, fiecare dintre ele fiind un vector cu 4 componente de tip int.
1 2
1 2 3 1 2 3
1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4
2) #include <iostream.h>
main( )
{
int a[4][2]={{1,2},{3,4},{5,6},{7,8}};
for(int i=0;i<=3;i++)
{
for(int j=0;j<=1;j++)
cout<<a[i][j]<<” “;
cout<<endl;
}
}
Obs: Un tablou poate fi definit ca o constantă astfel:
const tip_baza nume_const[dimensiune1] [dimensiune2 ]....[dimensiunen]={c1,…cn};
unde c1,…cn – constante de tipul tip_baza , cel mult atâtea câte elemente are tabloul, adică
dimensiune1*.... *dimensiunen
Ex: const int a[2][3]={1,2,3,4,5,6}; a[0][0]=1; a[0][1]=2; a[0][2]=3;
a[1][0]=4; a[1][1]=5; a[1][2]=6;
33
Tablouri bidimensionale(matrice)
Limbajul C++ conţine tipuri standard (predefinite): întregi, reale
definite de utilizator prin utilizarea declaraţiei typedef:
typedef tip nume;
34
Subprograme
Definiţie: Un subprogram este o secvenţă de instrucţiuni care rezolvă o anumită sarcină şi care
poate fi descrisă separat. Ea poate fi repetată în cadrul unui program de un număr de ori şi executată
numai în funcţie de anumite condiţii.
Funcţiile comunică prin argumente: ele primesc ca parametri (argumente) datele de intrare,
efectuează prelucrările descrise în corpul funcţiei asupra acestora şi pot returna o valoare (rezultatul,
datele de ieşire).
Dacă tip ≠ void, deci funcţia întoarce o valoare prin numele său, corpul funcţiei trebuie să
conţină obligatoriu instrucţiunea return expresie; expresia de la return este chiar valoarea
returnată de funcţie şi trebuie să aibă acelaşi tip cu tipul returnat de funcţie.
lista parametrii formali – enumerare ce conţine tipul şi numele fiecărui parametru cu care funcţia
lucrează formal; ei nu reprezintă valori concrete; se concretizează la execuţie, prin apelurile funcţiei.
Obs: 1) În C++ nu se pot defini funcţii imbricate, adică definirea unei funcţii în corpul altei funcţii.
2) De obicei, orice funcţie se apelează după ce a fost definită. Dacă definirea se face după
apel, înaintea apelului trebuie să existe declaraţia funcţiei (prototipul funcţiei).
Declaraţia funcţiei (cuprinde antetul funcţiei) şi informează compilatorul asupra tipului, numelui
funcţiei şi a listei parametrilor formali. Declaraţiile funcţiilor se numesc prototipuri şi sunt
constituite din antetul funcţiei:
La apel, se atribuie parametrilor formali valorile parametrilor efectivi, după care se execută
instrucţiunile din corpul funcţiei. La revenirea din funcţie, controlul este redat funcţiei apelante, şi
execuţia continuă cu instrucţiunea următoare instrucţiunii de apel, din funcţia apelantă.
36
Parametrii declaraţi în antetul unei funcţii sunt numiţi formali, pentru a sublinia faptul că ei
nu reprezintă valori concrete, ci numai ţin locul acestora pentru a putea exprima procesul de calcul
realizat prin funcţie. Ei se concretizează la execuţie prin apelurile funcţiei.
Parametrii folosiţi la apelul unei funcţii sunt parametri reali, efectivi, concreţi, iar valorile
lor vor fi atribuite parametrilor formali, la execuţie.
Utilizarea parametrilor formali la implementarea funcţiilor şi atribuirea de valori concrete
pentru ei, la execuţie, reprezintă un prim nivel de abstractizare în programare - abstractizare prin
parametrii. Acest mod de programare se numeşte programare procedurală .
Obs: 1) în cazul în care funcţia returnează o valoare, apelul funcţiei poate constitui un operand
într-o expresie (apelul funcţiei intervine într-o expresie)
2) între parametrii formali şi cei efectivi(actuali) trebuie să existe o bijecţie care să păstreze
ordinea şi tipul.
3) parametrii actuali trebuie să fie variabile declarate sau constante.
4) lista parametrilor formali este vidă atunci când nu se face schimb de informaţie cu restul
programului sau când acest schimb se face cu ajutorul variabilelor globale.
37
■ segmentul corespunzător codului executabil - conţine biţii corespunzători instrucţiunilor
programului şi funcţiile de bibliotecă ce sunt adăugate programului.
1) Tipul variabilei
4) Durata de viaţă statică - are alocat spaţiu în tot timpul execuţiei programului
timpul în care locală - are alocat spaţiu în timpul în care se execută instrucţiunile
variabila respectivă blocului respectiv
are alocat spaţiu în
memoria internă dinamică - alocarea şi dezalocarea spaţiului necesar variabilei respective
se face de către programator (prin operatori sau funcţii speciale)
Astfel, în C++ , în funcţie de atributele pe care le au, variabilele pot fi împărţite în:
- locale
- globale
- dinamice
38
Variabile
globale locale
- Se declară în afara corpului oricărei funcţii - Se declară în corpul funcţiilor: în orice
- Atribute: bloc (instrucţiune compusă) a acestora
1) clasa de memorare: segmentul de date - Atribute:
2) vizibilitatea: pot fi utilizate de toate funcţiile 1) clasa de memorare: segmentul de stivă
care urmează în textul sursă declaraţiei 2) vizibilitatea: la nivelul blocului la care au
variabilei respective fost declarate
3) durata de viaţă: statică 3) durata de viaţă: atâta timp cât durează
execuţia blocului respectiv
Exemplul următor foloseşte variabila cu numele Exemplul următor ilustrează faptul că după
nr. Fiind accesibilă din oricare din 2 funcţii fiecare apel, variabilele locale sunt dezactivate:
prezente în program, valoarea variabilei globale
nr este schimbată pe rând din ambele funcţii:
#include<iostream.h>
void f ( )
{
# include<iostream.h> int a=3,b=a;
int nr =10; cout<<a<<” “<<b<<endl;
void f1 (void) a++;b++;
{ }
cout<<”nr=”<<nr; main ( )
nr*=2; f( ); //3 3
} f( ); //3 3
void f2 (void) }
{
cout<<”nr=”<<nr;
nr+=2; Exemplul următor ilustrează faptul că dome-
} niul de vizibilitate al unei variabile locale
void main (void) este blocul în care se găseşte declaraţia sa:
{
cout<<”nr=”<<nr; //10 # include<iostream.h>
nr ++; void f ( )
f1(); //11 {
f2 ( ); //22 int a=1,b=a;
cout<<”nr=”<<nr; //24 cout<<a<<” “<<b<<endl;
} {
int a=2,b=a;
cout<<a<<” “<<b<<endl;
{
int a=3,b=a;
cout<<a<<” “<<b<<endl;
}
cout<<a<<” “<<b<<endl;
}
cout<<a<<” “<<b<<endl;
}
main( ) se va afişa: 1 1
{ f( ); } 2 2
3 3
2 2
39 1 1
Obs: 1) În blocuri diferite se pot declara variabile cu acelaşi nume.
2) Dacă o variabilă locală are acelaşi nume cu o variabilă globală, atunci se va lua în
considerare declararea cea mai apropiată de locul utilizării.
Transmiterea parametrilor
#include<iostream.h> #include<iostream.h>
int a, b; int a, b;
void interschimb(int x, int y) void interschimb(int& x, int& y)
{ {
int aux = x; int aux = x;
x=y; x=y;
y=aux; y=aux;
} }
void main( ) void main( )
{ {
cin>>a>>b; cin>>a>>b;
interschimb (a,b); interschimb (a,b);
cout<<a<<b; //a si b nu vor fi permutati cout<<a<<b; //a si b vor fi permutati
} }
Obs: La transmiterea parametrilor prin valoare, ca parametrii efectivi pot apare expresii sau nume
de variabile.
La transmiterea parametrilor prin referinţă, ca parametri efectivi nu pot apare expresii, ci
doar nume de variabile.
Transmiterea prin valoare a tablourilor permite ca funcţiile să întoarcă noile valori ale
acestora (care au fost atribuite în funcţii) – deoarece numele tabloului este un pointer către
componentele lui. Prin valoare se transmite acest nume şi cu ajutorul acestuia accesăm
componentele tabloului.
40
Exemplu: în programul următor, funcţia vector iniţializează vectorul transmis ca parametru, iar în
funcţia main( ) se va afişa rezultatul.
#include<iostream.h>
void vector(int a[10])
{
for (int i=0;i<10;i++) a[i]=i;
}
main( )
{
int x[10];
vector(x);
for (int i=0;i<10;i++)cout<<x[i]<<” “;
}
41
Exemplu: Se citeşte un vector cu n componente numere întregi. Se cere să se tipărească c.m.m.d.c.
al valorilor reţinute de vector.
Algoritmul de calcul:
1) Calculăm c.m.m.d.c. pentru primele două componente ale vctorului – valoare ce va fi reţinută
de variabila cm.
2) Apoi, pentru fiecare componentă i, cu i =2, ..., n-1 se va calcula c.m.m.d.c. între valoarea
reţinută de cm şi cea reţinută de componenta i. c.m.m.d.c. va fi reţinut din nou de cm.
43
Funcţii de intrare/ieşire standard
Operaţiile de intrare/ieşire sunt operaţii care permit schimbul de date între un program şi un
dispozitiv periferic.
Funcţiile din biblioteca compilatorului C/C++ utilizate mai frecvent pentru operaţiile de I/E
sunt: - pentru intrare: getch, getche, gets, scanf, sscanf ;
- pentru ieşire: putch, puts, printf, sprintf.
la care se mai adaugă macrourile getchar pentru intrare şi putchar pentru ieşire.
Funcţiile getch şi getche au prototipuri în <conio.h> şi sunt folosite pentru preluarea unui
singur caracter din codul ASCII, de la tastatură. Ambele sunt funcţii fără parametri, iar getch() preia
caracterul fără ecou (fără tipărirea lui pe ecran), în timp ce getche() preia caracterul cu ecou; ambele
funcţii returnează caracterul citit de la tastatură. Caracterele citite cu aceste funcţii sunt preluate
imediat după apăsarea tastei corespunzătoare caracterului respectiv.
Apelul funcţiilor getch şi getche conduce la aşteptarea apăsării unei taste. Apelul acestor
funcţii se face sub forma:
getch( ); sau getche( );
Obs: Funcţia getch() este frecvent folosită în programele C pentru a bloca fereastra utilizator până la
apăsarea unei taste.
Ex 1:
#include <conio.h>
main() /* citeşte fără ecou un caracter imprimabil ASCII, îl afişează şi aşteaptă acţionarea unei taste;
programul se termină după acţionarea unei taste*/
{
putch(getch());
getch();
}
44
Ex 2:
#include <conio.h>
main() /* citeşte fără ecou un caracter imprimabil ASCII, îl afişează, trece cursorul pe linia
următoare şi aşteaptă acţionarea unei taste; programul se termină după acţionarea unei taste*/
{
putch(getch());
putch(‘\n’); /* se apelează funcţia putch cu codul caracterului newline */
getch();
}
Funcţia gets are prototip în stdio.h şi are ca efect citirea cu ecou de la terminalul standard a
unui şir de caractere ale codului ASCII, la adresa specificată drept parametru al funcţiei. Din funcţie
se revine la:
- citirea caracterului ’\n’ (newline), caracter care este transformat în caracterul ‘\0’ (null).
În acest caz funcţia returnează adresa de început a zonei de memorie în care se păstrează
caracterele;
- citirea sfârşitului de fişier (CTRL/Z), funcţia returnând valoarea zero.
Funcţia puts are prototip în stdio.h şi are ca efect afişarea la terminalul standard a unui şir de
caractere corespunzând codului ASCII de la adresa transmisă ca parametru. Caracterul ‘\0’ este
interpretat ca ‘\n’. Funcţia returnează codul ultimului caracter afişat sau –1 în caz de eroare.
Ex 3:
#include <stdio.h>
void main() /* se tipăresc la ieşirea standard şiruri de caractere preluate de la tastatură. Terminarea
introducerii datelor se face tastând caracterul EOF prin apăsarea simultană a tastelor
Ctrl şi Z. */
{
char rand[100];
while(gets(rand)!=NULL)
puts(rand);
printf("\n");
}
45
Obs: În programul de mai sus, NULL este un nume penru o constantă simbolică folosită adesea în
locul întregului zero. În acest exemplu, constanta NULL poate fi înlocuită cu '\0'.
Funcţia scanf are rolul de a introduce date tastate de la terminalul standard sub controlul unor
formate. Datele introduse sunt convertite din formatele lor externe în formate interne şi sunt păstrate
la adresele specificate la apel. Datele introduse se termină cu apăsarea tastei ENTER.
Câmpul controlat de format începe cu primul caracter curent care nu este alb şi se termină, după caz:
a) la caracterul după care urmează un caracter alb;
b) la caracterul care nu corespunde tipului de conversie;
c) la caracterul la care se ajunge la lungimea maximă a câmpului.
Datele se citesc efectiv după apăsarea tastei ENTER. Adresa unei variabile se specifică prin
&nume_variabilă.
46
Literele care definesc tipul conversiei sunt:
Funcţia printf are prototip în stdio.h şi este folosită pentru afişarea unor date pe ecranul
terminalului standard sub controlul unor formate. Datele sunt convertite din format intern în
formatul extern specificat.
Apelul funcţiei printf se face printr-o construcţie de forma:
printf("control",arg1,arg2,.....,argn);
unde arg1, arg2,...,argn sunt variabile sau expresii ale căror valori se tipăresc în conformitate cu
specificatorii de format prezenţi în parametrul "control" al funcţiei.
Parametrul control este un şir de caractere care defineşte textele şi formatele datelor care se
scriu. În mod concret, acest şir precizează transformările (conversiile) datelor care se afişează pe
monitor şi se reprezintă o succesiune de caractere, inclusiv secvenţe escape şi specificatori de
format.
Numărul specificatorilor din parametrul control trebuie să fie egal cu numărul argumentelor
funcţiei, adică cu numărul variabilelor şi/sau expresiilor ale căror valori se tipăresc şi trebuie de
asemenea să corespundă tipului acestora.
Un specificator de format conţine:
- caracterul %;
- opţional caracterul minus -, care specifică încadrarea datei în stânga câmpului (datele
tipărite se încadrează într-un câmp - un anumit număr de caractere ; implicit încadrarea se
face în dreapta);
47
- opţional un număr zecimal, care defineşte dimensiunea minimă a câmpului în care se
afişează data;
- opţional un punct urmat de un număr zecimal, care specifică precizia de afişare a datei,
adică numărul de cifre zecimale sau numărul de caractere care se scriu dacă data este un
şir de caractere;
una sau două litere, care definesc tipul conversiei.
Litera d se foloseşte pentru afişarea valorilor variabilelor de tip întreg, în sistemul de numeraţie
zecimal.
48
Ex 6:
...
int a;
a = 46;
...
printf("%d",a); 46
printf("\n%8d",a); 46
printf("\n%-8d",a); 46
printf("\n%05d",a); 00046
printf("\n*%-6d*",a); *46 *
printf("\n%d",a/7); 6
printf("\n%10.3f",a/7.0); 6.571
Litera o se foloseşte pentru afişarea valorilor variabilelor de tip întreg, în sistemul de numeraţie
octal.
Ex 7:
……. 5910 = 738 şi 17510 = 2578
int a = 59; 59
…….. 73
printf("%d",a); 257
printf("\n%o",a);
printf("\n%9o",175);
Literele x şi X se folosesc pentru convertirea şi afişarea valorilor unor variabile de tip întreg în
sistemul de numeraţie hexazecimal. Dacă se foloseşte litera x în specificatorul de format, atunci
pentru afişarea numărului hexazecimal vor fi folosite cifrele 0,1,...,9,a,b,c,d,e,f, iar dacă se foloseşte
litera X, atunci pentru afişarea numărului hexazecimal se vor folosi cifrele 0,1,...,9,A,B,C,D,E,F, cu
observaţia că în zecimal, A=10, B=11, C=12, D=13, E=14 şi F=15.
Ex 8:
…………
printf("%x",33); 21 3310 = 2116 şi 7410 = 4a16
printf("\n%X",33); 21
printf("\n%x",74); 4a
printf("\n%X",74); 4A
printf("%6x",74); 4a
49
Ex 8:
…………..
int a = 1234, b = 345;
……………
printf("\nzecimal: %-10d%10Xhexa",a,a); 1234 4D2hexa
printf("\n%-6x",2345); 929
printf("\n%-9s%-9s%-9s\n","zecimal","octal","hexa"); zecimal octal hexa
printf("%-9d%-9o%-9X",b,b,b); 345 531 159
Litera f este folosită pentru conversia la tipul float şi afişarea valorilor cu 6 cifre zecimale.
Ex 9:
…………..
float a = 1.234 1.234000
…………… 1.234
printf("%f",a);
printf("\n%-10.3f",a);
Ex 10:
#include <stdio.h>
#include <conio.h>
main( )
{
int a;
float b,c;
printf(“\nIntroduceţi o valoare întreagă a=”);
scanf(“%5d”,&a);
printf(“\nIntroduceţi o valoare reală b=”);
scanf(“%5f”,&b);
c=a+b;
printf(“\nValoarea c=a+b este: %6.3f\n”,c);
getch();
}
50
RECURSIVITATE
1.Factorial
n! = 1*2*3*….*n => n! = (n-1)!*n
int n; }
int fact(int n) void main()
{ {cin>>n;
if(n= =0)return 1; cout<<fact(n);
else return fact(n-1)*n; }
51
2. Sa se implementeze urmatoarele relatii de recurenta:
a) progresia aritmetica: an = an-1 + r
int n, a0, r;
int pa(int n)
{if(n= =0)return a0;
else return pa(n-1)+r;
}
void main()
{
cin>>n>>a0>>r;
cout<<pa(n);
}
int n,b0,q;
int pg(int n)
{
if(n= =0)return b0;
else retunr pg(n-1)*q;
}
void main()
{
cin>>n>>b0>>q;
cout<<pg(n);
}
52
3. Sirul lui Fibonacci : 1,1,2,3,5,8,13,21, ………….
iterativ:
a=1;b=1;i=3;
cin>>n;
while(i<=n){c=a+b;
a=b;
b=c;
i++;
}
cout<<c;
recursiv:
definim functia: fib(n) = 1, n=1
1, n=2
fib(n-1) +fib(n-2), n>=3
int n;
int fib(int n)
{
if ( n= =1)return 1;
else if ( n= =2)return 1;
else return fib(n-1) + fib(n-2);
};
void main()
{
cin>>n;
cout<<fib(n);
}
53
4.Sa se calculeze Ckn in 2 moduri:
a)
n!
Cnk =
k !( n- k )!
int n,k,c;
int fact(int n)
{
if(n= =0)return 1;
else return fact(n-1)*n;
}
void main()
{
cin>>n>>k;
c = fact(n)/(fact(k)*fact(n-k));
cout<<c;
}
b)
int n,k;
int cmb(int n,int k)
{
if(k= =0)return 1;
else if(k= =n)return 1;
else return (cmb(n-1,k-1)+cmb(n-1,k));
}
void main()
{cin>>n>>k;
cout<<cmb(n,k);
}
54
4. Sa se afle c.m.m.d.c. a doua numere a si b:
6. Sa se afle:
55
a) suma cifrelor unui numar natural n:
int n;
int nr(int n)
{
if ( n= =0)return 0;
else return 1+nr(n/10);
};
void main()
{
cin>>n;
cout<<nr(n);
}
int m, n;
int ack(int m, int n)
{
if ( m= =0) return n+1;
else if (n = =0) return ack(m-1,1);
else return ack(m-1, ack(m,n-1));
};
void main()
{
cin>>m>>n;
cout<<ack(m,n);
}
8. Sa se calculeze functia lui Manna-Pruelli ( cu x citit):
57
f(x) = x -1, x >= 12
f(f(x+2)), x < 12
int x;
int f(int x)
{
if ( x>=12) return x-1;
else return f(f(x+2));
};
void main()
{
cin>>x; cout<<f(x);
}
58
a) S = 1 +2 + 3 + ………. +n
S(n -1)
int n;
int S(int n)
{
if ( n= =0)return 0;
else return S(n -1) + n;
};
void main()
{
cin>>n;
cout<<S(n);
}
59
int n;
int S(int n)
{
if ( n= =1)return 0;
else return S(n -1) + (n-1)*n;
};
void main()
{
cin>>n;
cout<<S(n);
}
int n;
int S(int n)
{
if ( n= =0)return 0;
else return S(n -1) + (float) n/((n+1)*(n+2));
};
void main()
{
cin>>n;
cout<<S(n);
}
60