Limbaje de programare

Cuprins
Funcții C
Tipuri de date in C
Operatori și expresii in C
Conversii de tipuri
Constante numerice
Variabile
Bibliografie selectivă
Funcții C
Funcții:

Date de
Prelucrare date Rezultate
intrare

Un program citește date de intrare le prelucrează prin calcule (matematice) produce

(scrie) rezultate
În matematică, exprimăm calculele prin funcții: cunoaștem funcții predefinite (sin, cos,
etc.) definim funcții noi (pentru problema dată) combinăm funcțiile existente și cele
definite de noi le folosim într-o anumită ordine
La fel folosim funcțiile în programare
Funcții C
Elementul constructiv al unui program C = funcţia
Un program este constituit dintr-o mulţime de funcţii
O funcţie este o secţiune de program, identificată printr-un nume şi parametrizată,
construită folosind declaraţii, definiţii şi instrucţiuni de prelucrare
double sqrt(double x);
Atunci când este apelată, funcţia calculează un anumit rezultat sau realizează un
anumit efect
sqrt(4.0);
Funcții C
Funcţia main() este prezentă în orice program C.
Execuţia programului începe cu main().
Funcţia main() poate întoarce un rezultat întreg (int) sau nici un rezultat (void).
Un prim program scris in C:
int main(void)
{
return 0;
}
Aceste program nu face nimic.
În acest caz: funcția nu are parametri (void)
void e un cuvânt cheie pentru tipul vid (fără nici un element)
Funcții C
Un alt program scris in C:

#include <stdio.h>
int main( void )
{
printf("Hello world!\n");
return 0;
}
 Funcții C
Să analizăm puțin programul: #include <stdio.h>
int main( void )
Linia #include <stdio.h> se folosește pentru a include fișierul {
antet stdio. Fişierele antet au prin convenţie extensia .h printf("Hello world!\n");
Stdio.h conţine prototipurile unei serii de funcţii de intrare şi return 0;
ieşire folosite de majoritatea programelor C }

Fişierul de inclus este căutat într-o zonă standard de includere, în

care sunt memorate fişierele antet ale compilatorului C, dacă
numele este încadrat între paranteze unghiulare (< şi >), sau
căutarea se face în zona curentă de lucru, dacă este încadrat între
ghilimele(“)
Instrucţiunea printf() serveşte pentru afişarea la terminal (pe
ecran) a unor valori formatate
 Funcții C
Valoarea întoarsă de funcţia main() este în mod obişnuit 0, #include <stdio.h>
având semnificaţia că nu au fost întâlnite erori, şi se int main()
asigură prin instrucţiunea return 0. {
//acesta este un comentariu pe o linie
Limbajul C, permite de asemenea inserția de comentarii
Comentariile pot fi de două tipuri: printf("Hello world!\n");
◦ Pe o linie, caz in care comentariu începe cu simbolurile return 0;
//
/*acesta este un comentariu
◦ Pe mai multe linii, caz în care este delimitat prin /* şi
pe mai multe
*/
linii */
Comentariile prin explicaţii în limbaj natural, cresc }
claritatea programului
Nu se pot include comentarii în interiorul altor comentarii
Funcții C
Pe lângă funcția main, un program mai poate avea și alte funcții.
Putem:
◦ folosi funcții existente
◦ defini funcții noi
◦ compune funcții existente sau definite de noi
◦ alege ordinea în care dorim să le aplicăm
Funcții C
Calculul pătratului unui număr întreg.
Funcția matematică Funcția C

f: Z→Z int f ( int x)

f(x) = x2 {
return x∗x;
}
Definiția unei funcții este formată din:
◦ antetul funcției: int f (int x) - tipul returnat, numele funcției, tipul și numele
parametrilor

◦ corpul funcției: { return x*x; } – o listă de instrucțiuni între {} separate prin ;

Funcții C
Calculul pătratului unui număr real.
Funcția matematică Funcția C

g: R→R float g ( float x)

{
g(x) = x2
return x∗x;
}
Este vorba despre altă funcție matematică și despre altă funcție C.
Tipul parametrului și tipul returnat este diferit. Operația este diferită.
Funcții C
O funcție definită poate fi apelată oriunde în interiorul altei funcții.
Valoarea returnată de funcție poate fi folosită în alte expresii.
Apelul are loc ca în matematică: nume-functie(parametru1, parametru2, ...)
Exemple de apel (presupunem ca funcția f este deja definită):
f(2);
int h( int x , int y)
{
return f(x) + f(1+y) + f(2);
}
Funcții C
Exemple declarație funcție:
int suma(int x, int y);
void afisare_suma(int x, int y);

Exemple definiție funcție:

int suma(int x, int y)
{ return (x + y); }
void afisare_suma(int x, int y)
{ printf("Suma=%d", x + y); }

Exemple apel funcție:

s=suma(a,b);
afisare_suma(x,5);
Tipuri de date
Tip de date = o mulțime de valori alături de un set de operații permise de aceste
valori, la care se poate adăuga și un set de restricții de utilizare a operatorilor.
Numere întregi:
◦ N și Z sunt mulțimi infinite
◦ Spațiul de stocare este finit ⇒ numai submulțimi finite ale N și Z pot fi reprezentate
în programare
Tipuri întregi: short, int, long
Pentru numere naturale (fără semn): unsigned short, unsigned int, unsigned long
Tipuri de date
Numere reale:
◦ R este o mulțime densă (între oricare 2 numere reale există alt număr real)
◦ în programare, nu putem reprezenta decât numere reale cu o precizie finită
◦ tipuri reale: float (simplă precizie), double (dublă precizie)
Tipuri de date
Clasificare:
Tipurile pot fi tipuri fundamentale şi tipuri derivate.
Tipurile fundamentale (predefinite sau de bază) sunt:
◦ Tipul caracter (char)
◦ Tipuri întregi (int)
◦ Tipuri reale (float, double)
◦ Tipul vid (void)
◦ Tipurile enumerate (enum)
Tipuri de date
Tipurile derivate sunt construite pornind de la tipurile fundamentale.
Tipurile derivate sunt:
◦ tablourile
◦ pointerii
◦ structurile (sau înregistrările)
◦ uniunile (înregistrările cu variante)
Tipuri de date
Modificarea tipurilor de bază
Unele tipuri fundamentale de date pot fi precedate de diverşi modificatori
Un modificator se utilizează pentru a adapta un tip de bază la anumite situaţii
Modificatorii limbajului C sunt:
◦ signed
◦ unsigned
◦ long
◦ short
Acesti modificatori pot fi aplicaţi tipurilor char şi int iar modificatorul long poate fi
aplicat şi tipului double
Tipuri de date
Există următoarele echivalențe:
int = signed int
short = short int = signed short int
long = long int
unsigned = unsigned int
unsigned short = unsigned short int
unsigned long = unsigned long int
 Tip Dimensiune Interval valori
standard

char 1 byte [-128 ; 127] sau [0 ; 255]

Tipuri de date unsigned char 1 byte [0 ; 255]

signed char 1 byte [-128 ; 127]

Problemă: [-32 768 ; 32 767] sau

Pentru anumite tipuri, int 2 sau 4 bytes [-2 147 483 648 ; 2 147 483 647]
dimensiunea depinde de
arhitectura unsigned int 2 sau 4 bytes [0 ; 65 535] sau [0 ; 4 294 967 295]
Soluție:
- Folosirea operatorului sizeof() short 2 bytes [-32 768 ; 32 767]
pentru a afla dimensiunea unsigned short 2 bytes [0 ; 65 535]
efectivă
- Folosirea tipurilor definite în
long 4 bytes [-2 147 483 648 ; 2 147 483 647]
biblioteca stdint
unsigned long 4 bytes [0 ; 4 294 967 295]
stdint.h
Specificator tip Semn Numar de biți Octeți Valoare minimă Valoare maximă
int8_t Cu semn 8 1 −27 = −128 27 − 1 = 127

uint8_t Fără semn 8 1 0 28 − 1 = 255

int16_t Cu semn 16 2 −215 = −32 768 215 − 1 = 32 767

uint16_t Fără semn 16 2 0 216 − 1 = 65 535

int32_t Cu semn 32 4 −231 = −2 147 483 648 231 − 1 = 2 147 483 647

uint32_t Fără semn 32 4 0 232 − 1 = 4 294 967 295

−263 = 263 − 1 =
int64_t Cu semn 64 8
−9 223 372 036 854 775 808 9 223 372 036 854 775 807

264 − 1 =
uint64_t Fără semn 64 8 0
18 446 744 073 709 551 615
Operatori și expresii
Un operator este un simbol care arată ce operaţii se execută asupra unor
operanzi (termeni)
Un operand este o constantă, o variabilă, un nume de funcţie sau o subexpresie
a cărei valoare este prelucrată direct de operator sau suportă în prealabil o
conversie de tip
Operatorii, după numărul de operanzi asupra cărora se aplică pot fi: unari, binari
şi ternari
Operatori și expresii
În C există 45 de operatori diferiţi dispuşi pe 15 niveluri de prioritate
În funcţie de tipul operanzilor asupra cărora se aplică, operatorii pot fi:
aritmetici, relaţionali, binari, logici, etc.
Operatorii sunt împărţiţi în clase de precedenţă (sau de prioritate)
În fiecare clasă de precedenţă este stabilită o regulă de asociativitate, care indică
ordinea de aplicare a operatorilor din clasa respectivă: de la stânga la dreapta
sau de la dreapta la stânga în cazul în care operatorii sunt din aceeași clasă.
Precedenţă Operator Descriere Asociativitate
[] Indexare
Selecţie membru (prin
. şi -> structură, respectiv
1 stanga-dreapta
pointer)
Postincrementare/post
++ şi --
decrementare
! Negare logică
Complement faţă de 1
~
pe biţi
Preincrementare/prede
++ şi --
crementare
2 dreapta-stânga
+ şi - + şi - unari
* Dereferenţiere
& Operator adresă
(tip) Conversie de tip
sizeof() Mărimea în octeţi
Precedenţă Operator Descriere Asociativitate
* Înmulţire

/ Împărţire
3 stânga-dreapta

% Restul împărţirii
4 + şi - Adunare/scădere stânga-dreapta
Deplasare
5 << si >> stânga-dreapta
stânga/dreapta a biţilor
< Mai mic

6 <= Mai mic sau egal stânga-dreapta

> Mai mare
>= Mai mare sau egal
== Egal
7 stânga-dreapta
!= Diferit
Precedenţă Operator Descriere Asociativitate
8 & ŞI pe biţi stânga-dreapta

9 ^ SAU-EXCLUSIV pe biţi stânga-dreapta

10 | SAU pe biţi stânga-dreapta

11 && ŞI logic stânga-dreapta
12 || SAU logic stânga-dreapta

13 ?: Operator condiţional dreapta-stânga

Precedenţă Operator Descriere Asociativitate

= Atribuire

Atribuire cu
+= şi -=
adunare/scădere
Atribuire cu
*= şi /=
multiplicare/împărţire
14 dreapta-stânga
%= Atribuire cu modulo

&= si |= Atribuire cu ŞI/SAU

Atribuire cu SAU-
^=
EXCLUSIV
Atribuire cu deplasare
<<= şi >>=
de biţi
15 , Operator secvenţa stânga-dreapta
Operatori și expresii
Operatori aritmetici:
Operatorii aritmetici folosiţi în limbajul C sunt:
+ adunarea a două numere;
- scăderea a două numere;
* înmulţirea a două numere;
/ împărţirea a două numere (rezultatul împărţirii pentru reale, câtul împărţirii pentru întregi);
% modulo (restul împărţirii a două numere întregi);
++ incrementarea (mărirea unei valori cu o unitate);
-- decrementarea (micşorarea unei valori cu o unitate);
Operatori și expresii
În C:
◦ O expresie este o combinaţie de operanzi, separaţi între ei prin operatori.
◦ Operatorii aritmetici + - * și / au aceeași semnificație, asociativitate și precedență ca
în matematică.
◦ Toți operatorii sunt indicați explicit: în loc de 2n sau n(n + 1) trebuie scris 2*n și
respectiv n*(n+1)
◦ Parantezele ( ) se pot folosi pentru a grupa subexpresii în modul dorit.
4+6
Ex. se va scrie (4+6)/(3+2)
3+2
◦ Prin evaluarea unei expresii se obţine o valoare rezultat.
◦ Tipul valorii rezultat depinde de tipul operanzilor şi a operatorilor folosiţi. Astfel
operațiile cu întregi vor da ca rezultat întregi.
Operatori și expresii
Operația de împărțire diferă pentru operatorii întregi și cei reali, restul operațiilor aritmetice
fiind la fel.
Pentru operatorii reali împărțirea / se efectuează exact, iar pentru cei întregi are loc o
împărțire cu rest. Astfel, operatorul / aplicat întregilor va avea ca rezultat câtul împărțirii.
Operatorul % (modulo) se poate aplica doar pentru întregi și are ca rezultat restul împărțirii.
Ex. pentru:
9.0/ 2.0 => 4.5 9/2 => 4 9%2 => 1
9.0/-2.0 => -4.5 9/-2 => -4 9%-2 => 1
-9.0/2.0 => -4.5 -9/2 => -4 -9%2 => -1 (semnul restului este dat de
semnul deîmpărțitului)
Operatori și expresii start
Exemple:
x,y
Media a două numere reale:
medie : R×R→R medie(x,y) = (x + y)/2

rezultat=(a+b)/2

rezultat

stop
Operatori și expresii start
O variantă de implementare în C a mediei este:
x,y
double medie ( double x , double y)
{
return (x+y )/2;
}
rezultat=(a+b)/2

rezultat

stop
Operatori și expresii start
Exemple:
x
f : Z→Z f (x) = 2x + 1
va fi in C:

int f ( int x) rezultat=2*x+1

{
return 2∗x+1;
}

rezultat

stop
Conversii de tipuri
Conversii implicite
Ce se întâmplă cand avem o expresie cu operanzi de tipuri diferite?
Când un operator acționează asupra unor variabile de tipuri diferite, acestea sunt
convertite automat la un tip comun
În general conversiile automate, aduc un operand de la un tip cu un domeniu de valori mai
restrâns la un tip cu un domeniu de valori mai larg
Ex.
int x = 10; // declararea unei variabile x de tip intreg si initializarea acesteia cu valoarea 10
float z = x + 1.0; //in acest caz se face automat conversia lui x la tipul real
Conversii de tipuri
Conversii implicite

char

short int

int

unsigned int

long

unsigned long

float
double
Conversii de tipuri
Atenție: În cazul expresiilor prin care se poate pierde informație compilatorul va da doar
mesaje de avertisment (nu rezultă erori de compilare!).
Ex.
long x = 2147483646;
short y;
y = x;
Nu va rezulta o eroare de compilare in acest caz, dar valoarea lui y va fi alta decat cea a lui x
Conversii de tipuri
Conversii explicite
Se pot face conversii explicite, folosind următoarea sintaxă:
(tip) expresie
Ex.
int x=5, y=2;
float z;
z = x/y; //in acest caz z primeste valoarea 2.0
z = (float) x/y; //in acest caz z primeste valoarea 2.5
În al doilea caz se face o conversie explicită a lui x la tipul float
Constante numerice
Operanzii unei expresii pot fi reprezentați și de către constante numerice
Uneori avem nevoie să utilizăm în programul nostru astfel de constante
Tipul constantei este dat de modul în care scriem această constantă
Ex.
5 – întreg (int)
5.0 – real (double)
5L – întreg lung (long int)
5U – număr natural (unsigned int).
Constante numerice
Constantele întregi pot fi date in bazele:
◦ 10: 257, -65, +4928 - au prefix semnul sau nu au prefix
◦ 8: 0125, 0177 - conțin un 0 ca prefix
◦ 16: 0x1ac, 0XBF3 - conțin 0x sau 0X ca prefix
Constantele reprezentând:
◦ numere întregi lungi se scriu cu sufixul L: 125436L
◦ numere naturale (fără semn/ unsigned) se scriu cu sufixul U: 123U
◦ numere reale conțin fie punct (.) fie exponent (ex. 1e-2)
Sufixele U și L pot fi aplicate și constantelor ce reprezintă numere în baza 8 sau 16
 Zona rezervată Argumente pe linie de comandă
și variabile de mediu

Variabile Stiva

Pe scurt despre organizarea memoriei

unui program: …
◦ Atunci când rulam un program, acesta
se încarcă într-un mod organizat în
memoria operativă (RAM).
Heap
◦ Memoria dedicată programului
cuprinde mai multe zone bine definite.
◦ Avem o zonă dedicată pentru codul Date
Segmentul de date
executabil
◦ Avem o altă zonă dedicată pentru date

Segmentul de cod Cod executabil

Variabile
De cele mai multe ori, în cadrul programelor pe care le scriem nu efectuăm operații
doar asupra unor constante.
Astfel, utilizăm date pe care le stocam într-o zonă de memorie și pe care le prelucrăm
ulterior.
Pentru a accesa într-un mod facil datele dintr-o zonă de memorie se definesc și se
utilizează variabile.
O variabilă reprezintă un nume dat unei zone de memorie, în care se stochează date de
un anumit tip.
Fiecare variabilă are un tip asociat.
Variabile
Utilizarea unei variabile presupune:
◦ Rezervarea unei zone de memorie de dimensiune potrivită
◦ Asocierea acesteia cu un identificator (nume) pentru a putea accesa valoarea stocată în acea
zonă de memorie
O variabilă se declară astfel:
tip identificator;
Identificatorul este în acest caz numele variabilei

Exemple:
int x:
int x=5; //aici x primește o valoare inițială
Variabile
Reguli pentru denumirea unei variabile:
◦ Numele unei variabile este alcătuit din caractere alfanumerice și simboluri
speciale ca _
◦ Numele unei variabile nu poate începe cu o cifră
◦ Nu pot face parte din numele unei variabile spațiile libere
◦ Cuvintele cheie nu pot constitui nume de variabile
◦ Limbajul C, face diferență între majuscule (litere mari) și minuscule (litere
mici)

Observație: X și x desemnează două variabile diferite.

Variabile
Declarația unei variabile:
◦ trebuie făcută înainte de utilizarea acesteia în program.
◦ specifică interpretarea și atribuitele identificatorului folosit (numele și tipul
variabilei).
Definiția este o declarație care specifică complet identificatorul respectiv.
Definiția unei variabile are în plus ca efect alocarea memoriei.
Se pot declara mai multe variabile cu același tip de bază:
int a, b;
float x,y=2.0,z;
Variabile - Domeniu de vizibilitate
Domeniul de vizibilitate al unui identificator = partea din program unde poate fi
utilizat
Parametrii și variabilele declarate în interiorul unei funcții (variabile locale):
◦ au ca domeniu de vizibilitate corpul funcției
◦ au durata de memorare automată (create la apelul funcției, distruse la încheierea
apelului)
◦ au valoare inițială nedefinită, dacă declarația nu specifică inițializare
Variabilele declarate în exteriorul oricărei funcții (variabile globale):
◦ vizibilitate din punctul de declarare până la sfârșitul fișierului
◦ au durata de memorare egală cu cea a programului
◦ sunt inițializate o singură dată cu o valoare dată explicit în declarație sau cu 0.
 Zona rezervată

Variabile - Domeniu de vizibilitate Stiva

Variabilele locale:
◦ se declară în interiorul funcției …
◦ se rețin pe stivă

Variabilele globale: Heap

◦ se declară în exteriorul oricărei funcții

◦ se rețin în segmentul de date
Segmentul de date

Segmentul de cod
Variabile - Domeniu de vizibilitate
int m, n, p; float x, y, z; /* m1, n1, p1, x1, y1, z1 */
int f(int n, int x)
{ /* n2, x2: alt n, alt x */
int i; float y = 1; /* i1, y2 */
m = p; p = n; /* m1 = p1; p1 = n2; */
return z += x + y; /* z1 += x2 + y2 */
}
Variabile – Atribuirea unei valori
Scopul atribuirii este de a modifica valoarea memorată într-o variabilă.
Sintaxa:
nume-variabila = expresie;
Exemple:
int a = 2 , b=3, c ;
c=a+b;
Observație: ”=” reprezintă în acest caz operatorul de atribuire, nu cel de
egalitate matematică (care se notează ”==” ) !
Variabile – Atribuirea unei valori start

Exemple: x
Funcția pătrat definită în acest curs, poate
fi scrisă și în modul următor:
int f ( int x)
int patrat { patrat=x*x
◦ este o variabilă locală a cărei valoare va fi int patrat;
returnată de funcție patrat = x∗x;
return patrat;
◦ nu este necesar să fie inițializată cu o
} patrat
valoare constantă, deoarece i se atribuie
valoarea x*x, înainte să fie returnată sau
utilizată în alte expresii
stop
Variabile – Atribuirea unei valori
Atribuirea unei valori are ca efecte:
◦ Evaluarea expresiei din dreapta operatorului
◦ Atribuirea valorii rezultate, variabilei din stânga operatorului
Exemple:
c = sqrt(2);
n = n-1;
r = r * n;
Atribuirea în lanț:
a = b = x+3 (a și b primesc aceeași valoare)
Variabile – Atribuirea unei valori
O variabilă se poate modifica doar prin atribuire.
NU se modifică prin alte expresii (excepție fac operatorii ++ și --), sau transmisă
ca parametru (prin valoare)!
n + 1;
sqr(x);
calculează dar NU modifică!
n = n + 1;
x = sqr(x);
modifică (prin atribuire)
Variabile – Atribuirea unei valori
Există și operatori care combină operația de atribuire cu unele operații aritmetice:

Clasa de precedenţă Operator Descriere Asociativitate

Postincrementare/
1 ++ şi -- stânga-dreapta
postdecrementare
Preincrementare/
2 ++ şi -- dreapta-stânga
predecrementare
14 Atribuire cu
+= şi -= dreapta-stânga
adunare/scădere
Atribuire cu
*= şi /= multiplicare/ dreapta-stânga
împărţire
%= Atribuire cu modulo dreapta-stânga
Variabile – Atribuirea unei valori
Echivalențe:
x++  x=x+1  x+=1 Diferențe:
• operatorul postincrementare folosește înainte
x--  x=x-1  x-=1 valoarea variabilei și apoi o incrementează;
x+=3  x=x+3 • operatorul preincrementare înainte incrementează
valoarea și apoi o folosește
x-=3  x=x-3
x*=3  x=x*3
x/=3  x=x/3
x%=3  x=x%3
Variabile – Exemple de utilizare
Un program care include funcția de #include <stdio.h>
calcul al pătratului unui număr int f(int x)
întreg, discutată în acest curs, {
poate fi: return x*x;
}
int main()
{
int z = 2, y;
y = f(z);
printf("Rezultatul este %d\n", y); //afisarea rezultatului
return 0;
}
Variabile – Exemple de utilizare
Afișarea valorii unei variabile de tip int:
printf (”%d” , 9); //observație %d !!
Afișarea valorii unei variabile de tip float:
printf (”%f ” , 4.55); //observație %f !!
Pentru a afișa valoarea unei expresii, printf ia două argumente:
◦ un șir de caractere (specificator de format): %d pentru întregi, %f pentru reali
◦ expresia, de tip compatibil cu cel indicat prin specificatorul de format
printf (”%d” , 9);
printf (”%f”, sqrt(3));
Variabile – Exemple de utilizare
Citirea unei valori de la tastatură
#include <stdio .h>
int main( void )
{
int k ;
scanf(”%d” , &k );
return 0;
}
Atentie: în cazul lui scanf fiecare variabilă trebuie prefixată de simbolul &, ceea ce inseamnă
adresa acelei variabile (excepție fac șirurile de caractere pe care le vom discuta într-un alt
curs).
Se folosesc aceiași specificatori de format ca la printf (mai multe detalii într-un curs viitor).
Variabile – Exemple de utilizare
Un alt program care include funcția #include <stdio.h>
de calcul al pătratului unui număr int f(int x)
întreg, discutată în acest curs, {
poate fi: return x*x;
}
int main()
{
int z, y;
printf("Dati valoarea numarului : ");
scanf("%d", &z);
y = f(z);
printf("%d la patrat = %d\n",z,y); //afisarea rezultatului
return 0;
}
Exerciții
E2_1: Realizați un proiect cu exemplul de cod anterior și urmăriți cu ajutorul
depanatorului de programe (debugger) domeniile de vizibilitate ale tuturor variabilelor
folosite în programul respectiv.
E2_2: Realizați un program care calculează suma a două numere și urmăriți cu ajutorul
depanatorului de programe (debugger) domeniile de vizibilitate ale tuturor variabilelor
folosite în program.

Pentru mai multe informații cu privire la subiectele acoperite de acest curs, accesați:
http://staff.cs.upt.ro/~marius/curs/lp/old/notes1.pdf
Bibliografie selectivă
◦ Kernighan, B. W., & Ritchie, D. ”The C programming language - Second
edition”, 1988 Prentice Hall Software Series
◦ Minea, M., Limbaje de programare, materiale de curs
http://staff.cs.upt.ro/~marius/curs/lp/index.html
◦ Holotescu, C., Limbaje de programare, materiale de curs
http://labs.cs.upt.ro/~oose/pmwiki.php/LP/Lectures
◦ Iorga,V., Programarea Calculatoarelor, materiale de curs
http://andrei.clubcisco.ro/cursuri/anul-1/semestrul-1/programarea-
calculatoarelor.html