Structura generală a unui program " C "

Curs 4 Structura unui program C; tipuri de date în C
Structura generală a unui program " C "
Un program C este un ansamblu de instrucţiuni incluse în una sau mai multe funcţii, care
specifică operaţiile ce trebuie efectuate asupra unor date pentru a fi prelucrate în sensul dorit de
către utilizator.
Un program C se compune din patru părţi şi anume:
1) Directive de preprocesare
Prin preprocesare se înţelege prelucrarea unui fişier sursă înainte de a fi supus compilării.
În urma acestei activităţi se crează un fişier temporar care conţine un cod sursă provenit în urma
traducerii directivelor de preprocesare.
Preprocesorul C este (în principiu) un program separat, invocat de către compilator în
prima parte a procesului de compilare. Preprocesorul C manipulează directivele pentru includerea
fişierelor sursă (în construcţii de forma #include), a macrodefiniţiilor (în construcţii de forma
#define) şi a includerilor condiţionate (în construcţii de forma #if ).
Directivele de preprocesare sunt de trei feluri: includeri de fişiere sursă, macrosubstituţii şi
includeri condiţionate.
a) Includeri de fişiere cu text sursă
- se fac cu directiva # include printr-o construcţie de forma :
sau :
#include
#include "nume_fisier.c"
unde nume_fisier defineşte un fişier cu text sursă păstrat pe disc.
În faza de preprocesare textul fişierului inclus se substituie construcţiei #include şi
apoi ia parte la compilare împreună cu textul fişierului în care a fost inclus.
Construcţia #include se foloseşte pentru includerea fişierelor standard
care conţin prototipuri pentru funcţiile de bibliotecă (librării). Librăriile sunt coduri gata compilate
care se adaugă programului sursă C la compilarea acestuia.
Parantezele unghiulare instruiesc compilatorul să caute fişierele care trebuie incluse în directorul cu
fişiere antet (de exemplu, C:\BorlandC\include).
Exemple:
#include
#include
Aceste construcţii instruiesc preprocesorul să trateze fişierele header ca şi cum ar face
parte din codul sursă care se compilează.
Nu toate librăriile sunt incluse automat deoarece acest lucru ar conduce la coduri mari şi timp de
compilare mărit, cu părţi de program inutile. Fişierele header care specifică librăriile ce se includ
într-un program definesc macrouri, tipuri de date şi date externe care se folosesc împreună cu
librăriile pe care le desemnează.
Dacă un anumit fişier header a fost inclus atunci numele funcţiilor, macrourilor sau tipurilor de date
definite în acel fişier nu pot fi redefinite în programul sursă. Astfel, de exemplu, poate fi definită o
funcţie cos(x) într-u program numai dacă în acel program nu a fost inclusă librăria math.h în care
este deja definită funcţia cos.
Construcţia #include "nume_fisier.c" se utilizează la includerea fişierelor nestandard
care conţin prototipuri ale eventualelor funcţii definite de către utilizator.
1

Curs 4 Structura unui program C; tipuri de date în C
Fişierul care trebuie inclus se caută în directorul curent dacă nu este specificată nici o cale.
Exemple:
# include "factorial.c"
# include "C:\\BORLANDC\\PERSLIB\\persmat.c"
Observaţii:
1) Un fişier inclus cu directiva #include poate conţine la rândul său construcţii #include
pentru alte fişiere.
2) Construcţiile #include se scriu de obicei la începutul fişierelor sursă pentru ca fişierele
incluse să fie valabile (vizibile) în întregul fişier sursă care se compilează.
Exemplu:
Presupunem că în directorul curent există fişierul persmat.c în care este definită funcţia factorial şi
că într-un program dorim să folosim această funcţie. Pentru aceasta va trebui să includem fişierul
persmat.c în program.
#include
#include "persmat.c"
double combinari (double V1, double V2)
{
return factorial(V1)/factorial(V2)/factorial(V1-V2);
}
void main()
{
double n,k,cnk;
printf("\n n= "); scanf("%lf",&n);
printf("\n k= "); scanf("%lf",&k);
cnk = combinari(n,k);
printf("\n Combinari de %lg luate cate %lg este
%lg",n,k,cnk);
getch();
}
Al doilea tip de directive de preprocesare sunt:
b) Macrosubstituiri
Macrosubstituirile înseamnă substituirea unor nume prin succesiuni de caractere şi se fac
cu directiva #define sub forma: #define succesiune_de_caractere (vezi constante
simbolice).
Macroprocesorul poate efectua şi substituţii de argumente în macrodefiniţii.
Exemplu:
#define max(a,b) (a>b?a:b)
#define min(a,b) (a

Curs 4 Structura unui program C; tipuri de date în C
Program exemplu: macrodefiniţii
#include
#define MAX2(a,b) (a>b?a:b)
#define MIN2(a,b) (ac?MAX2(a,b):c)
#define schimb(a,b) {t=a;a=b;b=t;}
#define moddif(a,b) ((a>b)?(a-b):(b-a))
#define suma(a,b) (a+b)
void main()
{
int a,b,t;
}
printf("a= ");
scanf("%d",&a);
printf("b= ");
scanf("%d",&b);
printf("\nMaximul este %d",max(a,b));
printf("\nMinimul este %d",min(a,b));
printf("\nModulul diferentei este %d",moddif(a,b));
printf("\nSuma numerelor este %d",suma(a,b));
schimb(a,b);
printf("\nDupa schimbare valorile a si b sunt %d si %d",a,b);
Rezultatul rulării acestui program este dat în figura următoare:
c) Includeri condiţionate
Aceste includeri se folosesc pentru includerea unor fişiere numai atunci când este
îndeplinită o anumită condiţie.
Exemplu:
#if SYSTEM == MSDOS // daca sistemul de operare este MS-DOS
#include // se foloseste headerul
#else
#include // altfel, se foloseste headerul
#endif
Includerile condiţionate se mai pot folosi pentru construirea grupurilor condiţionate sub forma:
#ifdef MACRO
text controlat
#endif /* MACRO */
Textul controlat va fi inclus numai dacă este definită macrocomanda MACRO şi acest text poate
include directive de preprocesare.
3

Curs 4 Structura unui program C; tipuri de date în C
Exemplu:
#ifdef TURBOC // in TurboC valorile intregi
#define INT_SIZE 16 // se stocheaza pe 16 biti iar in SO Unix
#else // acestea se stocheaza pe 32 biti
#define INT_SIZE 32
#endif
După cum se observă, orice includere condiţionată se încheie cu #endif.
Celelalte părţi ale unui program C sunt:
2. Secţiunea de declaraţii:
În această secţiune se stabilesc numele şi atributele variabilelor, a tipurilor de date
utilizator sau ale funcţiilor.
3. Funcţia principală
4. Funcţiile utilizator
În concluzie, un program C are următoarea structură:
Structura unui program C
4

Curs 4 Structura unui program C; tipuri de date în C
Tipuri de date în C
Tipurile de date descriu tipurile valorilor diverselor variabile, constante, funcţii, etc. ale unui
program. Fiecare variabilă folosită într-un program C trebuie să fie declarată compilatorului.
Declaraţia va conţine numele variabilelor şi tipul acestora.
Exemplu:
...........
int zi,luna,an:
..........
zi = 29;
luna = 2; //variabilele zi, luna şi an au valori diferite dar au acelaşi tip
an = 2000;
float medie;
..........
medie = 2; //variabilele luna şi medie au aceeaşi valoare dar tipuri diferite
1) Fiecarui tip de dată îi corespunde o denumire (un cuvânt cheie) care este utilizată pentru
crearea în memorie a obiectelor ce vor conţine valori corespunzătoare tipului respectiv.
Exemplu:
float s;
în memoria calculatorului se crează un spaţiu (o zonă) în care va fi depozitată
valoarea variabilei s.
2) Fiecărui tip de date îi corespunde o anumită mărime a zonei de memorie în care se
păstrează valoarea unei date de tipul respectiv.
Exemplu
int n;
valoarea lui n se va păstra într-o locaţie de 16 biţi (2 octeţi)
float s;
valoarea lui s se va păstra într-o zonă de 32 biţi (4 octeţi)
3) Fiecărui tip de date îi corespunde o anumită gamă de valori, determinată de mărimea locaţiei
de memorie corespunzătoare datelor de tipul respectiv.
Exemplu
int n;
n va putea avea valori în intervalul: - 32768 < n < 32767
float s;
modulul lui s va putea avea valori între valoarea minimă reprezentabilă pe 4 octeţi şi
valoarea maximă reprezentabilă pe 4 octeţi: 3.4 ·10 -38 < |s| < 3.4·10 38
Orice limbaj de programare oferă un anumit număr de tipuri de date de bază (tipuri
predefinite).
Limbajul C permite definirea unor tipuri de date derivate (tipuri utilizator) care se construiesc
cu ajutorul tipurilor de bază.
5

Curs 4 Structura unui program C; tipuri de date în C
Tipuri de date de bază
Tipurile de bază sunt tipurile predefinite şi în limbajul C acestea sunt:
char - tip de date ale căror valori sunt reprezentate pe un singur octet (byte)
int - tip de date ale căror valori sunt reprezentate pe 2 octeţi
float - tip de date reale reprezentate în virgulă mobilă, în simplă precizie
double - tip de date reale reprezentate în virgulă mobilă, în dublă precizie
În plus, există câţiva calificatori care pot fi aplicaţi acestor tipuri de bază:
unsigned, short şi long
Short şi long furnizează diferite lungimi ale locaţiilor de memorie pentru datele de tip int.
Calificatorul short înseamnă de obicei întregi reprezentaţi pe 16 biţi, iar long întregi
reprezentaţi pe minim 32 de biţi.
Calificatorii signed sau unsigned pot fi aplicaţi tipului char sau oricărui întreg. Numerele unsigned
sunt întotdeauna pozitive sau zero. Dacă datele de tip char sunt reprezentate pe 8 biţi, variabilele
unsigned char vor avea valori între 0 şi 255, iar variabilele signed char între -128 şi 127.
Pentru datele de tip real, long double specifică extinderea preciziei numerelor reprezentate în
virgulă flotantă pe 10 octeţi (80 biţi).
Fiecarui tip de date de bază îi corespunde un specificator de tip. Specificatorii de tip
definesc formatele datelor care se citesc sau se scriu şi se compun din caracterul % urmat de una
sau două litere ce depind de tipul datei (vezi tabelul de mai jos).
Tipul Specificator de tip
Lungimea
biţi octeţi
Intervalul de valori
char %c, %d 8 1 -128 127 -2 7 2 7 -1
unsigned char %c, %d 8 1 0 255 0 2 8 -1
int %d 16 2 -32768 32767 -2 15 2 15 -1
unsigned int %u 16 2 0 65535 0 2 16 -1
long int %ld 32 4 -2147483648 2147483647 -2 31 2 31 -1
unsigned long %lu 32 4 0 4294967295 0 2 32 -1
float %f,%g,%e,%E 32 4 3.410 -38 3.410 38
double %lf, %lg, %le, %lE 64 8 1.710 -308 1.710 308
long double %Lf, %Lg, %Le,%LE 80 10 3.410 -4932 1.110 4932
Deoarece aritmetica numerelor reale reprezentate în virgulă flotantă nu este atât de precisă
ca şi aritmetica numerelor întregi, recomandăm evitarea comparaţiilor între numere "floating
point". Astfel, un cod de forma:
float v;
// fă ceva cu variabila v
...
if(v==0.0)
{
// fă ceva
...}
6

Curs 4 Structura unui program C; tipuri de date în C
este foarte posibil să nu funcţioneze din cauza erorilor de rotunjire, erori care ar putea avea ca
efect un rezultat de valoare să zicem 0.0000000023 atunci când ne aşteptăm ca v să fie de fapt
0.0. Pentru a evita astfel de cazuri se recomandă folosirea unei precizii impuse, sub forma:
#define DELTA 0.000001
...
if(v0.0-DELTA)
{
// fă ceva
...
}
sau folosirea preciziei calculatorului (vezi calculul numeric al derivatelor).
De asemenea, se recomandă evitarea amestecării valorilor de tip signed şi respectiv
unsigned în operaţii de împărţire.
Structura funcţiilor
O funcţie încapsulează una sau mai multe instrucţiuni, variabile şi parametri într-un pachet
unificat care poate fi apelat din interiorul programului.
Cu ajutorul funcţiilor se împart sarcinile mari de calcul ale unui program în sarcini de complexitate
mai mică.
O funcţie se defineşte în felul următor:
tip nume (listă parametri formali)
{
declaraţii
instrucţiuni
}
unde tip reprezintă un tip de bază sau tipul void.
O funcţie cu alt tip decât tipul void trebuie să conţină în corpul ei instrucţiunea return, urmată
de o expresie sau un nume de variabilă, având tipul corespunzător tipului funcţiei sau convertibil la
tipul pe care îl returnează funcţia. In caz contrar, compilatorul va semnala o eroare de forma:
Function should return a value in function …
Funcţiile pot returna valori având ca tip: tipuri de bază, pointeri, structuri, pointeri la structuri,
pointeri la tablouri, dar nu pot returna tablouri.
O funcţie poate avea unul sau mai mulţi
parametri, dar poate de asemenea să nu aibă nici
un parametru. Parametrii funcţiilor sunt folosiţi
pentru a face transferuri de date între funcţii şi sunt
de două feluri:
a) parametri formali, care nu reprezintă
valori concrete ci ţin doar locul unor valori
pentru a se putea exprima procesul de calcul
realizat de către funcţie în momentul
apelului ei; aceşti parametri vor fi înlocuiţi
de către cei actuali în momentul apelului
funcţiei.
Transmiterea parametrilor între funcţii
b) parametri actuali, adică parametrii
7

Curs 4 Structura unui program C; tipuri de date în C
transmişi unei funcţii şi care reprezintă valori concrete cu care sunt apelate funcţiile. Aceştia pot fi
constante, variabile, expresii şi nu este obligatoriu ca numele parametrilor actuali să fie identici cu
cel al parametrilor formali.
Exemple:
int f ( ) void g ( ) char ascii (int valoare)
{ { {
...... ....... ..........
} } }
int cod (char caracter) double fact (long val)
{ {
......... ........
} }
Într-o funcţie pot exista de asemenea declaraţii ale variabilelor şi constantelor pe care le
utilizează funcţia respectivă (tip+nume).
Exemple:
char ascii (int valoare) int cod (char c)
{ {
char c; int codc;
c = (char)(valoare) codc = (int)(c);
return c; return codc;
} }
Variabilele din interiorul unei funcţii se numesc variabile locale şi aparţin clasei automatic.
Aceste variabile automatic sunt "vizibile" numai în corpul funcţiei în care au fost declarate şi există
doar atâta timp cât funcţia în care au fost declarate se află în execuţie, iar la ieşirea din funcţie
valorile lor sunt şterse din memorie (sunt volatile). Aşadar, valorile acestora nu sunt reţinute de la
un apel la altul al funcţiei.
Exemplu
int suma (int a, int b) int suma(int a, int b)
{ {
int c; return a+b;
c=a+b; }
return c;
}
Variabila c este de tip automatic şi va fi alocată în memorie de fiecare dată când se execută funcţia
suma. Compilatorul va crea un cod pentru alocarea dinamică a variabilei, pentru iniţializarea ei şi
pentru eliminarea ei din memorie la încetarea execuţiei funcţiei suma.
În cel de-al doilea exemplu, funcţia conţine doar o instrucţiune return a expresiei a+b, fără să mai
fie folosită o variabilă intermediară.
8

Curs 4 Structura unui program C; tipuri de date în C
Un alt tip de variabile este reprezentat de către variabilele statice, care sunt variabile locale care
nu se alocă pe stivă ci într-o zonă specială de memorie, rezervată acestui tip de variabile. Acestea
trebuie să fie precedate la declarare de cuvântul cheie static.
Declaraţia static este în principiu folosită pentru variabile, dar poate fi folosită şi pentru funcţii
şi de asemenea şi pentru variabile interne. Variabilele interne de tip static sunt variabile locale
ale unei anumite funcţii, dar, spre deosebire de variabilele automatic ele există tot timpul şi nu
numai atunci când este executată funcţia. În consecinţă, aceste variabile nu îşi pierd valoarea între
două apeluri ale funcţiei în care sunt declarate.
Exemplu
static int c;
Variabilele globale sunt variabile declarate în afara oricărei funcţii a programului. Acestea sunt
iniţializate automat cu zero şi pot fi utilizate de către orice funcţie a programului. Ele sunt variabile
externe, adică pot fi utilizate într-o anumită funcţie a programului chiar dacă nu au fost declarate
în funcţia respectivă. Aceste variabile au tipul static automat.
Este recomandabilă folosirea variabilelor locale deoarece acest lucru conduce la urmărirea mai
uşoară a codului unei funcţii particulare. Totuşi, dacă folosirea variabilelor locale conduce la
transmiterea multor parametri sau la reproducerea inutilă a mai multor variabile, atunci este
recomandabil să fie folosite variabile globale.
Exemple de variabile globale şi locale
int contor; // contor este o variabilă globală, vizibilă în toate funcţiile programului
// orice funcţie definită în aval va putea face referire la variabila contor
.......................
void f1()
{
int aux=contor+1; // contor este vizibilă şi în f1 chiar dacă aici nu este definită
// aux este variabilă locală pentru f1
.........
}
void f2()
{
.........
int k; // k - variabilă locală pentru f2
........
k=aux; // ?!? EROARE deoarece aux este variabilă locală pentru f1 şi deci nu este
// vizibilă în f2
} // Unknown symbol ‘aux’ in function f2()
void f3()
{
.......
int k; // definită şi în f2 şi în f3 dar este corect deoarece sunt variabile locale
int aux; // definită şi în f1 şi în f3 dar este corect deoarece sunt variabile locale
// şi au un scop limitat
..........
k=aux+contor; // aux este variabilă locală, iar contor este globală
..........
9

Curs 4 Structura unui program C; tipuri de date în C
}
void f4()
{
........
int contor; // deşi este declarată şi ca variabilă globală, în funcţia f4 contor este un
// obiect distinct de variabila globală contor
........ // !!! A SE EVITA denumiri identice de variabilă pentru a nu se crea confuzii
contor++;
}
while(a

Curs 4 Structura unui program C; tipuri de date în C
double xo, sol;
.........
sol = Newton (f, xo);
printf (\n Solutia ecuatiei este %15.8f,sol);
........
}
Un tablou poate fi parametru efectiv la apelul unei funcţii. Spre deosebire de argumentele
neindexate, dacă se doreşte ca un tablou se fie transmis ca argument unei funcţii, compilatorul va
transmite de fapt un pointer la tabloul respectiv şi dacă funcţia modifică tabloul ea va modifica
originalul acestuia.
Valorile returnate de către funcţii pot fi folosite ca şi argumente ale altor funcţii fără să fie
necesară asignarea acelor valori unor variabile cu apeluri de forma f1(f2(x)) (vezi exemplul de mai
jos).
Exemplu
# include
int f(int n)
{
return 2*n;
}
int g(int n)
{
return n*n;
}
void main()
{
}
int m;
printf("Introduceti o valoare intreaga: ");
scanf("%d",&m);
printf("f(x)=%d \t f(g(x))= %d", f(m),f(g(m)));
printf("\nf(x)=%d \t g(f(x))= %d", f(m),g(f(m)));
Exemplu
float note [50]; //declararea unui tablou unidimensional cu 50 elemente
..............
double medie (float sir[50]); //prototipul unei funcţii care are ca parametru
// un tablou unidimensional
Dimensiunea şirului poate fi omisă în prototipul funcţiei. De asemenea, valoarea primei dimensiuni
a unui tablou multidimensional este opţională deoarece compilatorul nu are nevoie de valoarea
primei dimensiuni pentru a calcula adresele elementelor tabloului ci numai de dimensiunile
următoare. Astfel, dacă avem declaraţia:
char Mat[6][8];
Adresa elementului Mat[2][3] va fi adresa lui Mat+2*8+3 deoarece Mat (numele tabloului)
este un pointer având ca valoare adresa primului element al tabloului.
11

Curs 4 Structura unui program C; tipuri de date în C
Program exemplu: calculul mediei valorilor unui şir de elemente
//exemplu functie avand ca parametru un tablou
#include
#include
float medie (int n, float sir[])
{
int i;
float m,s=0;
for(i=0;i

Curs 4 Structura unui program C; tipuri de date în C
//exemplu de funcţie factorial mai rapidă decât cele prezentate anterior
double fact (long val) ← antet fact
{
long rez=val; ← corp fact
}
while(--val>1)
rez*=val;
return rez;
13

Curs 4 Structura unui program C; tipuri de date în C
Exemple de funcţii şi includeri de fişiere sursă
// program sursă salvat în fişierul program1.c
int zi, luna, an; // variabile globale şi pot fi folosite în toate funcţiile din program1.c care
// urmează după această declaraţie
.......
int decidebisect(...)
{
int i;
.....
i=(an%4==0 && an%100!=0)an%400==0;
//un an este bisect dacă este divizibil cu 400
//sau dacă este divizibil cu 4 dar nu şi cu 100
//anii de sfârşit de secol nu sunt bisecţi chiar dacă urmează la 4 ani după un an bisect,
//cu excepţia celor care sunt divizibili cu 400
//ani bisecţi "obişnuiţi": 1872, 1912, 1960, 1996, 2008... – anii divizibili cu 4
//excepţii: 1800, 1900, 2100, 2200... – anii de sfârşit de secol divizibili cu 100
//sunt totuşi ani bisecţi: 2000, 2400... – anii de sfârşit de secol divizibili cu 400
.....
if(luna==2)
zi=28+i;
....
}
Alternativ, pentru a decide dacă un an este bisect se poate folosi secvenţa de instrucţiuni din
programul de mai jos:
int b, an;
FILE *f;
f=fopen("d:\\anibis.dat","w");
for(an=1872;an

Curs 4 Structura unui program C; tipuri de date în C
}
if(zi== 31 && luna ==12)
an++;
....
// program sursă salvat în fişierul program2.c
.......
void main()
{
extern int zi,luna,an; // variabile externe
.....
if(zi31)
printf(“\n Ziua eronata”);
else
if(luna12)
printf(“\n Luna eronata”);
.......
} // sfârşitul funcţiei main()
void timp(...)
{
int anactual;
char s[10];
....
if(ananactual)
s=”viitor”;
else s=”prezent”;
}
15