Ap Curs-01

Algoritmi i programare
2011 2012
Cristian Gau Mdlina Rschip www.infoiasi.ro/~ap
Organizare
Lector dr. Cristian Gau
e-mail: cgatu@info.uaic.ro cabinet: C212 (corp C, parter); tel: 0232-201546 url: www.infoiasi.ro/~cgatu consultaii: vineri, 10:00-12:00
Asist. dr. Mdlina Rschip

e-mail: mionita@info.uaic.ro cabinet: C416 ; tel: 0232-202469 url: www.info.uaic.ro/~mionita consultaii: luni, 10:00-12:00
2
Pagina cursului
www.info.uaic.ro/~ap
Obiective
Algoritmi
nsuirea unei gndiri algoritmice dezvoltarea abilitilor de proiectare de soluii algoritmice nsuirea tehnicilor de utilizare a principalelor structuri de date evaluarea timpului de execuie n cazul cel mai nefavorabil
Programare
iniiere n utilizarea unui limbaj de programare implementarea principalelor structuri de date nsuirea tehnicilor de baz n proiectarea programelor
Coninutul disciplinei
Algoritmi
limbaj algoritmic, tablouri, structuri statice/nlnuite liste liniare arbori binari, heap-uri, union-find grafuri (ca structuri de date) sortare, cutare paradigme
Programare
prezentarea graduat a limbajului C (ISO Standard) cu accent pe implementarea structurilor de date i a soluiilor prezentate n partea de algoritmic
Evaluare
condiii:
activitatea la laborator (AL) testele scrise (TS)
criterii de promovare:
numr de teme de laborator: 5 AL >= 6, TS >= 4
forme:
AL
fiecare tem de laborator va fi punctat (note 1-10) ntrebri, participare la discuii, soluii originale (bonus!)
TS:
2 teste scrise (spt. 8, 16), fiecare test coninnd 8 ntrebri de tip gril i o problem
Evaluare
normele ECTS (European Credit Transfer System) Punctaj Final (PF) = 50% AL +50% TS Nota final:
<= 4 dac sunt ndeplinite condiiile i NU sunt ndeplinite criteriile de promovare, = 10 dac PF este n primii 5% din cei promovai (A) = 9 urmtorii 10% din cei promovai (B) = 8 urmtorii 20% din cei promovai (C) = 7 urmtorii 30% din cei promovai (D) = 6 urmtorii 25% din cei promovai (E) = 5 ultimii 10% din cei promovai
Bibliografie
D. Lucanu, M. Craus: Proiectarea algoritmilor, Polirom, 2008. T.H. Cormen, C.E. Leiserson, R.L. Rivest: Introducere in algoritmi, Libris Agora, 2000. L. Livovschi, H. Georgescu: Sinteza si analiza algoritmilor, Ed. Stiintifica si enciclopedica, 1986. H. Schildt: C Manual complet, Teora, 1998. B.W. Kernighan, D.M. Ritchie: The C Programming Language, 2nd edition, Prentice Hall, 1988 A. Kelley, I. Pohl: A book on C: Programming in C, 4th edition, Addison Wesley, 1998
Algoritmi i programare 8
Curs 1
limbaj algoritmic modelarea memoriei tipuri de date elementare (cu prezentarea elementelor de limbaj C corespunztoare)
Algoritmi, limbaj algoritmic

Problem, Soluie Algoritm: o secven finit de pai aranjat ntr-o ordine logic specific, cu proprietatea c, atunci cnd este executat, produce o soluie pentru o problem dat. Exemplu: reeta culinar Algoritm calculator (computer algorithm) = un algoritm pentru care secvena de pai este executat de un calculator Limbaj Algoritmic = un limbaj folosit pentru descrierea algoritmilor
Algoritmi - Etimologie
Muhammad ibn Musa al-Khwarizmi

Algoritmi - proprieti
intrare (input) zero sau mai multe entiti de date furnizate din exterior ieire (output) algoritmul produce informaie terminare pentru orice intrare, algoritmul execut un numr finit de pai corectitudine algoritmul se termin i produce ieirea corect pentru orice intrare. Spunem c algoritmul rezolv problema dat.
Primul program C
void main(){}
You dont have to know every detail of C++ to write good programs. (B. Stroustrup)
Primul program C
/* * first program in C */ #include <stdio.h> int main(void) { printf(Salut!\n); printf(Primul program C!); return (0); }
14
Primul program C
/* * first program in C */ #include <stdio.h> int main(void) { printf(Salut!\n); printf(Primul program C!); return (0); }
15
Primul program C
OUTPUT:
Salut! Primul program C!Press any key to continue
16
Caracterele limbajului C
Litere: A B C D X Y Z a b c d x y z Cifre: 0 1 2 3 4 5 6 7 8 9 Alte caractere: + - * / = ( ) { } [ ] < > ! # % & _ |^ ~ \ . , ; : ? Caractere spaiu: blank, newline, tab, etc.
Cuvintele cheie (rezervate)

auto const double extern float inline register restrict sizeof typedef volatile break continue else for int return static union while case default do enum goto long short struct unsigned char
if signed switch void
18
Limbaj algoritmic
modelarea memoriei tipuri de date elementare instruciuni tipuri de date structurate de nivel jos calcul timp de execuie
19
Variabil
Nume Adres Atribute (tip de date asociat valorilor memorate)
x int adr
Instan a variabilei
Memoria
Structur liniar de celule
Variabile adr x Pointeri int
adr
adr p int*
*p
int
21
Tip de date
Domeniul tipului (colecia de obiecte) Operaiile tipului Categorii de tipuri de date:
Tipuri de date elementare Tipuri de date structurate de nivel jos
Operaiile la nivel de component
Tipuri de date de nivel nalt

Operaiile implementate de algoritmi utilizator
22
Tipuri standard
Tipul char Tipurile standard ntregi:
5 tipuri ntregi cu semn: signed char, short int, int, long int i long long int. 5 tipuri ntregi fr semn: desemnate de cuvntul unsigned (tipuri ce ocup aceeai cantitate de memorie)
Tipuri reale flotante:

float, double i long double.
23
Echivalene
signed short int unsigned short int signed int unsigned int signed long int unsigned long int
short unsigned short int unsigned long unsigned long

24
Declaraii
Forma unei declaraii:
tip variabila; tip var1, var2, , varn; tip variabila = expresie_constanta;
Variabile globale: declararea lor se face n afara oricrei funcii. Variabile locale: declararea se face n corpul funciei.
char c; signed char sc;
int i; int suma = 0; long j;
float x1, x2, x3; float pi = 3.14; double y;

25
Tipul ntreg
int
sizeof(int) = 2 sau 4 octei
short int sau short

sizeof(short)=2, {-32768, , 32767}
long int sau long

sizeof(long)=4 {-2 147 483 648, , 2 147 483 647}
signed int, signed short int, signed long int

ntregi fr semn
unsigned int unsigned short int
{0, , 65535}
unsigned long int Nu exist overflow (depire) calculul se efectueaz modulo 2n, unde n este numrul de bii
27
ntregi foarte scuri: char

Tipul char este o submulime a tipului int char reprezint, n funcie de main, domeniul de valori:
{-128, , 127} sau {0, , 255}
unsigned char {0, , 255} signed char {-128, , 127} sizeof(char) = 1
28
Constante ntregi n <limits.h>

16 bii INT_MAX INT_MIN LONG_MAX LONG_MIN
215 1
32 bii
231 1
215 231 1 231
231 263 1 263
Atenie la reprezentarea circular!

INT_MAX + 1 == INT_MIN INT_MIN 1 == INT_MAX LONG_MAX + 1 == LONG_MIN LONG_MIN 1 == LONG_MAX
Constante ntregi
Octale: au prefixul 0 (zero) 032 = 26 077 = 63 Hexazecimale: au prefixul 0x sau 0X 0x32 = 50 0x3F = 63 ntregi long: au sufixul l sau L 2147483647L 0xaf9Fl = 44959 ntregi unsigned au sufixul u sau U 345u 0xffffu = 65535 Caractere ntre apostrof: A, +, n Caractere n zecimal: 65, 42 Caractere n octal: \101, \52 Caractere n hexazecimal: \x41, \x2A Notaii pentru caractere speciale: \n, \t, \r, \\, \a,\, \0, \
Citiri, afiri
citirea unui int afiarea unui int citirea unui char afiarea unui char
printf(a: ); scanf(%d, &a); int a = 10; printf(a = %d, a); printf(a: ); scanf(%c, &a); char a = a; printf(a = %c, a);
31
Constante - exemplu
/* Exemple de constante caracter */ #include <stdio.h> int main(){ char a, b, c, d; a = 'A'; b = 65; c = '\101'; d = '\x41'; printf("%c %c %c %c\n", a, b, c, d); printf("%c %d %o %x\n", a, a, a, a); return 0; } A A A A A 65 101 41
Codurile ASCII
#include <stdio.h> int main (void){ short c; for(c = 0; c <= 127; c++){ printf("cod ASCII: %d",c); printf(" caracter: %c\n",c); } return 0; } /* for(c=a; c<=z; c++) */
33
Macrourile getchar() i putchar()

Sunt definite n <stdio.h> Citire caracter de la tastatur Scriere caracter pe ecran #include <stdio.h> int main (void){ char c; while ((c=getchar()) != EOF) {putchar(c); putchar(c);} return 0; } Sirul de intrare: 123456abcd va produce sirul: 112233445566aabbccdd
Operaii; Funcii n biblioteci

Operaii pentru tipurile ntregi: + - * / >= ++ - Funcii: % == != < <= >
cele de la tipul flotant cele din biblioteca <ctype.h>: tolower, toupper, isalpha, isalnum, iscntrl, isdigit, isxdigit, islower, isupper, isgraph, isprint, ispunct, isspace
35
Operatorii ++ i - Se aplic doar unei expresii ce desemneaz un obiect din memorie (L-value): Expresie Valoare ++i i++ --i i-i+1 i i-1 i
i dup evaluare i+1 i+1 i-1 i-1 ++5 --(k+1) ++i++ nu au sens
36
Exemplu ++ (tem)
#include <stdio.h> int* f(int* a){ int b = 2; (*a) += b; return a; } int main (void){ int a = 5; (*f(&a))++; printf("%d \n", a); return 0; }
Tipul flotant (real)

float
Numere reale n simpl precizie sizeof(float) = 4 10 37 abs( f ) 1038 6 cifre semnificative
double
Numere reale n dubl precizie sizeof(double) = 8 10 307 abs( f ) 10308 15 cifre semnificative
Tipul flotant (real)

long double
Numere reale n extra dubl precizie sizeof(long double) = 12 10 4931 abs( f ) 10 4932 18 cifre semnificative
Limitele se gsesc n <float.h> Operaii: + * / == != < <= > >=
39
Constante reale
Constantele reale sunt implicit double 125.435 1.12E2 123E-2 .45e+6 13. .56
Pentru a fi float trebuie sa aib sufixul f sau F .56f 23e4f 45.54E-1F
Pentru long double trebuie sa aib sufixul l sau L 123.456e78L
40
Citire, afiare
citirea unui float afiarea unui float citirea unui double afiarea unui double
printf(x: ); scanf(%f, &x); float pi = 3.14; printf(pi = %f, pi); printf(x: ); scanf(%lf, &x); double pi = 3.14L; printf(pi = %lf, pi);
41
Funcii (n biblioteca <math.h>)

sin acos tanh pow fabs fmod cos atan exp sqrt ldexp tan sinh log ceil frexp asin cosh log10 floor modf
42
Funcia printf
int printf(const char *format, ...);
Apelul returneaz numrul de conversii realizate cu succes n irul format apar specificatorii de conversie introdui prin caracterul % La apel, corespondena argument --- specificator de conversie Caracterele ce nu fac parte din specificatorii de conversie sunt scrise n stream-ul de ieire printf(a = %d, b = %f, c = %s.\n, a, b, c); Funciile sprintf, fprintf
Funcia printf
specificator_de_conversie ::= %{modificator}opt {marime_camp}opt {.precizie}opt caracter_de_conversie caracter_de_conversie ::= c|d|i|u|o|x|X|e|E|f|g|G|s|p|n|% modificator ::= h|l|L|-|+|#|0 marime_camp ::= numar_intreg_fara_semn precizie ::= numar_intreg_fara_semn
44
Funcia printf
Tip char int unsigned int long int unsigned long float double long double Specificator %c, %d %d %u %ld %lu %f, %g, %e, %E %lf, %lg, %le, %lE %Lf, %Lg, %Le, %LE
float pa = 2.568; printf(a = %10f\n, a); /* printf(a = %6g\n, a); /* printf(a = %10.2f\n, a);/*
a a a
= = =
2.568000 */ 2.568 */ 2.57 */

45
Funcia printf
Cmpul mrime sau/i precizie poate fi nlocuit prin * : valoarea va fi luat dintr-un argument: printf(x= %*.*f\n, m, n, x);
46
Funcia scanf
int scanf(const char *format, ...);
Apelul returneaz numrul de conversii realizate cu succes, respectiv EOF dac stream-ul de intrare este vid n irul format apar specificatorii de conversie introdui prin caracterul % La apel, corespondena argument --- specificator de conversie. Argumentele trebuie sa fie pointeri sau adrese Caracterele ce nu fac parte din specificatorii de conversie trebuie s apar n stream-ul de intrare Funciile sscanf, fscanf
Funcia scanf
int i; char c; char sir[15]; scanf(%d , %*s %% %c %7s &i, %s, &c, sir, &sir[7]);
Dac stream-ul de intrare este: 45 , sir_ce_se_ignora % A string_citit**

45 se memoreaz n i , se potriveste cu , din format Este ignorat sirul sir_ce_se_ignora % se potriveste cu % din format A se memoreaza n c string_ se memoreaz n sir[0]..sir[6], iar n sir[6] se pune \0 citit** se memoreaz n sir[7]..sir[13], iar n sir[14] se pune \0
48
Tipul void
Conversia n tip void a unei expresii semnific faptul c valoarea sa este ignorat Utilizat pentru tipul pointer; nu se face controlul tipului la un pointer de tip void Utilizat pentru funcii fr valoare returnat sau pentru funcii fr parametri Este un tip incomplet ce nu poate fi completat
Utilizare typedef
Mecanism prin care se asociaz un tip unui identificator:
typedef char litera_mare; typedef short varsta; typedef unsigned long size_t;
Identificatorul respectiv se poate utiliza pentru a declara variabile sau funcii:

litera_mare u, v=a; varsta v1, v2; size_t dim;
Date booleene (logice)

Nu exist un tip special pentru date logice Domeniul de valori: {false, true} false = 0 true = 1 dar i orice ntreg nenul Operaii: ! && || == != Declaraii posibile:
typedef enum {false = 0, true = 1} bool; bool x, y;
51
Expresii logice
expresie_relationala ::= expr < expr | expr > expr | expr <= expr | expr >= expr | expr == expr | expr != expr expresie_logica ::= ! expr | expr || expr | expr && expr
52
Valoarea expresiilor relaionale

a-b a<b a>b 1 0 0 a<=b 0 1 1 a>=b 1 1 0 a==b a!=b 0 1 0 1 0 1
positiv 0 zero 0
negativ 1
53
Valoarea expresiilor logice ||

exp1 <> 0 = 0 exp2 nu se evalueaz se evalueaz exp1 || exp2
1
1 dac exp2 <> 0 0 dac exp2 = 0
54
Valoarea expresiilor logice &&

exp1 = 0 <> 0 exp2 nu se evalueaz se evalueaz exp1 && exp2 0 1 dac exp2 <> 0 0 dac exp2 = 0
55
Exemple
O condiie de forma a x b se scrie n limbajul C:
(x >= a) && (x <= b) (a <= x) && (x <= b)
O condiie de forma a > x sau x > b se scrie n limbajul C:

(x < a) || (x > b)
!(x >= a && x <= b)

56
Operatorul condiional ?:
exp1 ? exp2 : exp3
Se evalueaz exp1 Dac exp1 are valoare true (nenul) atunci valoarea expresiei este valoarea lui exp2; exp3 nu se evalueaz Dac exp1 are valoare false (nul) atunci valoarea expresiei este valoarea lui exp3; exp2 nu se evalueaz Operatorul ?: este drept asociativ
Operatorul condiional ?: Exemple

x x x >= 0 ? x : y > y ? x : y > y ? x > z ? x : z : y > z ? y : z
#include <stdio.h> int main(void){ int a=1, b=2, c=3; int x, y, z; x = a?b:c?a:b; y = (a?b:c)?a:b; /* z = a?b:(c?a:b); /* printf("x = %d, y = } /* x = 2, y = 1, z = 2
asociere stanga */ asociere dreapta */ %d, z = %d\n", x, y, z); */

58
Operatorul = (Expresia de atribuire)

exp1 = exp2
exp1 este o L-value (obiect din memorie: variabil, variabil tablou cu indici, etc.) Tipul expresiei este tipul lui exp1 Se evalueaz exp2, apoi exp1 capat valoarea lui exp2, eventual convertit Aadar, operatorul = modific valoarea operandului stang Valoarea expresiei este valoarea lui exp1 dup evaluare Operatorul = este drept asociativ
59
Operatorul = (Exemple)
x = sqrt(9); a = ( b = 2 ) + ( c = 3 ); a = b = c = 0; /* echivalenta cu */ a = (b = (c = 0)); while((c = getchar()) != EOF) putchar(c);
Nu confundai e1 = e2 cu e1 == e2 !
a = 0; if ( a == 0 ) printf(nul); else printf(nenul); /* nul */ if ( a = 0) printf(nul); else printf(nenul); /* nenul */
Operatori de atribuire compus

O expresie de atribuire compus are forma: unde op= este unul din:
exp1 op= exp2 %= &= |=
+=
-=
*=
/=
^=
>>=
<<=
Expresia este echivalent cu
cu precizarea c exp1 se evalueaz o singur dat. j *= k + 3; j = j * (k + 3); /* echivalent cu: */
exp1 = exp1 op (exp2)
j *= k = m + 5; /* echivalent cu: */ j = (j * (k = (m + 5)));

Operatorul virgul ,
expresia_virgula ::= expresie, expresie
Se evalueaz prima expresie apoi cea de-a doua. Valoarea i tipul ntregii expresii este valoarea i tipul operandului drept. Operatorul virgul are cea mai mic preceden.
a = 1, b = 2; i = 1, j = 2, ++k + 1; k != 1, ++x * 2.0 + 1; for(suma = 0, i = 1; i <= n; suma += i, ++i);
Operatorul sizeof()
Operator unar ce permite gsirea numrului de octei pe care se reprezint un obiect (tip,expresie)
sizeof(int), sizeof(b*b-4*a*c), sizeof(double); sizeof(i);
sizeof(char)<=sizeof(short)<=sizeof(int)<=sizeof(long) sizeof(signed) = sizeof(unsigned) = sizeof(int) sizeof(float)<=sizeof(double)<=sizeof(long double)
63
Operatorul sizeof()
#include <stdio.h> int main(void){ int x = 1; double y = 9; long z = 0; printf("Operatorul sizeof()\n\n\n"); printf("sizeof(char) = %2u\n",sizeof(char)); printf("sizeof(int) = %2u\n",sizeof(int)); printf("sizeof(short) = %2u\n",sizeof(short)); printf("sizeof(long) = %2u\n",sizeof(long)); printf("sizeof(float) = %2u\n",sizeof(float)); printf("sizeof(double) = %2u\n",sizeof(double)); printf("sizeof(long double) = %2u\n",sizeof(long double)); printf("sizeof(x +y + z) = %2u\n",sizeof(x+y+z)); return 0; }
64
Operatorul sizeof()
Rezultatul executiei Visual C++: sizeof(char) = sizeof(int) = sizeof(short) = sizeof(long) = sizeof(float) = sizeof(double) = sizeof(long double) sizeof(x + y + z) 1 4 2 4 4 8 = 8 = 8
65
Precedena operatorilor
Operatori
() ++ -- (postfix) ++ -- (prefix) ! & (adresa) * (deref) + - (unari) sizeof() * + < == && || ?: = += -= *= /= %= stnga 66 , (operatorul virgula) Algoritmi i programare / <= != > >= % stnga stnga stnga stnga stnga stnga dreapta dreapta
Asociere
stnga dreapta
Compatibilitatea tipurilor predefinite

Toate tipurile aritmetice (caractere, ntregi, reale) sunt compatibile ntre ele; compilatorul admite orice combinaie de obiecte de diverse tipuri ntr-o expresie La evaluarea unei expresii n care apar tipuri diferite compilatorul face conversii implicite
67
Reguli pentru conversia implicit

n absena unui unsigned obiectele se convertesc la tipul cel mai nalt n ordinea (descrescatoare): long double, double, float, long int, int Regulile pentru operanzii unsigned depind de implementare. Conversia la unsigned se face doar n caz de necesitate (de ex. valoarea din unsigned nu ncape n cellat operand).
68
Reguli pentru conversia implicit

Regula integer promotion : operaiile se fac cel puin n int, deci char i short sunt promovai la int. La o asignare (v = exp) tipul membrului drept se convertete la tipul membrului stng (care este i tipul rezultatului).
ATENIE: se pot produce Pierderea preciziei (double float long int) Pierderea unor bii semnificativi (long char) Nedeterminri
69
Conversii la asignare
Tipul rezultatului signed char char char short int int (32 biti) int float double Tipul expresiei char short int int (32 bii) / long int int (32 bii) long int float double long double Posibile pierderi daca valoarea > 127, rezultat negativ 8 bii semnificativi 24 bii semnificativi 16 bii semnificativi nimic partea fracionar (i posibil mai mult) precizia (rotunjire) precizia (rotunjire)
double int: double float, float int conversia int float, float double nu aduce precizie sau acuratee (doar se schimb forma n care valoarea este reprezentat). Algoritmi i programare 70
Exemplu
#include <stdio.h> int main(void){ char c1 = -126, c2; /* c1 = 10000010 unsigned char c3, c4 = 255; /* c4 = 111111111 short s1, s2 = -32767; /* s2=10000000 00000001 short s3 = -1, s4; /* s3 = 11111111 11111111 s1 = c1; printf("c1 = %d, s1 = %d\n", c1, s1); c2 = s2; printf("c2 c3 = s3; printf("c3 = %d, s2 = %d\n", c2, s2); = %d, s3 = %d\n", c3, s3); */ */ */ */
Algoritmi i programare }
s4 = c4; printf("c4 = %d, s4 = %d\n", c4, s4); return 0;
71
Exemplu (rezultatul execuiei)

c1 = 10000010 c1 = -126, s1 = -126 s2=10000000 00000001 c2 = 1, s2 = -32767 s3 = 11111111 11111111 c3 = 255, s3 = -1 c4 = 111111111 c4 = 255, s4 = 255
s1 = c1;
c2 = s2; c3 = s3;
s4 = c4;
72
Exemplu
int i; long l; float f; double d = char c = 'c'; i = 2.9; f = d; f = 'A'; i i l l = = = = /* f=65.0 (codul ASCII) */ calcul expr - in int, i=30099 */ /* 'depasire', i=-25536 */ /* -25536 convertit la long */ /* rezultat corect, l=40000 */
.45e+6;
/* pierderea preciziei */ /* 2.9 convertit implicit la int, i=2 */
30000 + c ; /* 30000 + 10000; i; 30000u + 10000;
i = l; /* pierdere biti semnificativi, i=-25536 */

Forarea tipului - cast

Conversia explicit la tipul numetip: (numetip) expresie Exemple:
(long)(A + 1.0) (int)(b*b-4*a*c) (double)(x+y)/z (float)x*y/z x / (float)2
74
Exemplu cast
#include <stdio.h> int main(void){ int i, j; double x, y, z, t; i = 5/2; x = 5/2; y = (double)(5/2); j = (double)5/2; z = (double)5/2; t = 5./2; printf(%d, %g, %g, %d, %g, %g\n, i, x, y, j, z, t); return 0; } /* 2, 2, 2, 2, 2.5, 2.5 */
Fiiere n bibliotec relative la tipuri

<limits.h> - pentru tipurile ntregi
ntregul min/max: INT_MIN, INT_MAX Numrul de bii pe caracter CHAR_BIT Etc.
<float.h> - pentru tipurile flotante:

Exponentul maxim Precizia zecimal, etc.
<stdlib.h> - conine funcii de conversie:

ir de caractere n int: atoi(const char*) ir de caractere n float:atof(const char*)

Ap Curs-01

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Ap Curs-01

Uploaded by

Copyright:

Available Formats

Algoritmi i programare

Cristian Gau Mdlina Rschip www.infoiasi.ro/~ap

Asist. dr. Mdlina Rschip

Algoritmi, limbaj algoritmic

Muhammad ibn Musa al-Khwarizmi

Cuvintele cheie (rezervate)

if signed switch void

Tipuri de date de nivel nalt

Tipuri reale flotante:

short unsigned short int unsigned long unsigned long

int i; int suma = 0; long j;

float x1, x2, x3; float pi = 3.14; double y;

short int sau short

long int sau long

signed int, signed short int, signed long int

ntregi foarte scuri: char

unsigned char {0, , 255} signed char {-128, , 127} sizeof(char) = 1

Constante ntregi n <limits.h>

215 231 1 231

231 263 1 263

Atenie la reprezentarea circular!

Macrourile getchar() i putchar()

Operaii; Funcii n biblioteci

Tipul flotant (real)

Tipul flotant (real)

Pentru a fi float trebuie sa aib sufixul f sau F .56f 23e4f 45.54E-1F

Pentru long double trebuie sa aib sufixul l sau L 123.456e78L

Funcii (n biblioteca <math.h>)

2.568000 */ 2.568 */ 2.57 */

Dac stream-ul de intrare este: 45 , sir_ce_se_ignora % A string_citit**

Identificatorul respectiv se poate utiliza pentru a declara variabile sau funcii:

Date booleene (logice)

Valoarea expresiilor relaionale

Valoarea expresiilor logice ||

Valoarea expresiilor logice &&

O condiie de forma a > x sau x > b se scrie n limbajul C:

!(x >= a && x <= b)

Operatorul condiional ?: Exemple

asociere stanga */ asociere dreapta */ %d, z = %d\n", x, y, z); */

Operatorul = (Expresia de atribuire)

Operatori de atribuire compus

exp1 op= exp2 %= &= |=

Expresia este echivalent cu

cu precizarea c exp1 se evalueaz o singur dat. j *= k + 3; j = j * (k + 3); /* echivalent cu: */

exp1 = exp1 op (exp2)

j *= k = m + 5; /* echivalent cu: */ j = (j * (k = (m + 5)));

sizeof(char)<=sizeof(short)<=sizeof(int)<=sizeof(long) sizeof(signed) = sizeof(unsigned) = sizeof(int) sizeof(float)<=sizeof(double)<=sizeof(long double)

Compatibilitatea tipurilor predefinite

Reguli pentru conversia implicit

Reguli pentru conversia implicit

s4 = c4; printf("c4 = %d, s4 = %d\n", c4, s4); return 0;

Exemplu (rezultatul execuiei)

/* pierderea preciziei */ /* 2.9 convertit implicit la int, i=2 */

30000 + c ; /* 30000 + 10000; i; 30000u + 10000;

i = l; /* pierdere biti semnificativi, i=-25536 */

Forarea tipului - cast

Fiiere n bibliotec relative la tipuri

<float.h> - pentru tipurile flotante:

<stdlib.h> - conine funcii de conversie:

You might also like

2.568000 / 2.568 / 2.57 */

asociere stanga / asociere dreapta / %d, z = %d\n", x, y, z); */

cu precizarea c exp1 se evalueaz o singur dat. j = k + 3; j = j (k + 3); /* echivalent cu: */

j = k = m + 5; / echivalent cu: / j = (j (k = (m + 5)));

/* pierderea preciziei / / 2.9 convertit implicit la int, i=2 */