Sintaxa limbajului C

De la Wikipedia, enciclopedia liberă

Salt la: Navigare, căutare

Limbajul de programare C este un limbaj de programare a calculatoarelor, conceput de

Dennis Ritchie la începutul anilor 1970 pentru a scrie sistemul de operare UNIX. A rămas
unul dintre cele mai folosite limbaje pentru scrierea programelor.

Există multe extinderi ale limbajului, printre care C++, Perl, Java, Javascript şi C#.

Cuprins
[ascunde]

• 1 "Hello, World!" în C
• 2 Structura unui program
• 3 Cuvinte cheie
• 4 Identificatori
• 5 Separatori
• 6 Structura funcţiilor
• 7 Instrucţiuni
o 7.1 Expresii
o 7.2 Blocuri
o 7.3 Selecţii
 7.3.1 Instrucţiunea decizională
 7.3.2 Instrucţiunea decizională multiplă
 7.3.3 Instrucţiunea de selecţie
o 7.4 Iteraţii
 7.4.1 Instrucţiunea while
 7.4.2 Instrucţiunea do - while
 7.4.3 Instrucţiunea for
o 7.5 Salturi

 7.5.1 Instrucţiunea break

[modifică] "Hello, World!" în C

Următorul program afişează mesajul "Hello, world!".

Versiunea C

#include<stdio.h>
int main(void)
{
printf("Hello,World!\n");
return 0;
}

Versiunea C++

#include<iostream.h>
int main(void)
{
cout<<"Hello,World!\n"; //sau cout<<"Hello,World!"<<endl
return 0;
}

[modifică] Structura unui program

Un program C este alcătuit din funcţii şi variabile. Funcţiile C sunt echivalente cu subrutinele
din Fortran şi procedurile din Pascal. Funcţia main este specială prin faptul că execuţia
programului debutează întotdeauna la începutul acestei funcţii. Orice program trebuie să
includă o funcţie main.

Definiţia unei funcţii include următoarele componente: un tip de retur (int, în exemplul de
mai sus), un nume, o listă de parametri (între paranteze rotunde) şi un corp al funcţiei (cuprins
între acolade).
float CalculeazaSuprafata(float Lungime, float Latime) {
float Suprafata;
Suprafata = Lungime*Latime;
return Suprafata;
}

[modifică] Cuvinte cheie

Există 32 de cuvinte rezervate în limbajul C, care au semnificaţie predefinită şi nu pot fi
folosite în alte scopuri într-un program. Cuvintele cheie trebuie scrise cu litere mici. Iată
lista acestora, ordonată alfabetic:

• auto
• break
• case
• char
• const
• continue
• default
• do
• double
• else
• enum
• extern
• float
• for
• goto
• if
 • int
• long
• register
• return
• short
• signed
• sizeof
• static
• struct
• switch
• typedef
• union
• unsigned
• void
• volatile
• while

altă ierarhizare:

• pentru controlul fluxului: if, else, switch, do, while, for.

[modifică] Identificatori
Identificatorii sunt folosiţi pentru a indica variabile, tipuri de date, constante simbolice sau
funcţii. Primul caracter al identificatorilor trebuie să fie o literă sau underline, iar lungimea
maximă a acestora este de 31 de caractere.

[modifică] Separatori
Separatorii au rolul de a delimita unităţile lexicale dintr-un program. Iată lista separatorilor
admişi în limbajul C:

• ( ) Parantezele rotunde încadrează lista de parametrii a unei funcţii, sau precizează

ordinea de efectuare a operaţiilor pentru evaluarea unei expresii.
• { } Acoladele încadrează instrucţiunile compuse, care se mai numesc şi blocuri.
• [ ] Parantezele drepte încadrează dimensiunile tablourilor
• " " Ghilimelele încadrează şirurile de caractere
• ' ' Apostrofii încadrează un singur caracter
• ; Fiecare instrucţiune se încheie cu caracterul ;
• /* */ Comentariile sunt încadrate de caracterele /* şi */

[modifică] Structura funcţiilor

Funcţiile C sunt alcătuite dintr-un antent şi un corp. Antetul specifică tipul rezultatului,
numele funcţiei şi lista de parametri. Corpul este alcătuit dintr-un bloc ce poate să conţină
declaraţii şi instrucţiuni care specifică prelucrările realizate de funcţia respectivă.
Antetul unei funcţii este de forma următoare:
tip_r nume_f(listă_p_f)

Corpul unei funcţii este de forma următoare:

{
declaraţii
instrucţiuni
}

[modifică] Instrucţiuni
Prelucrările efectuate de un program sunt descrise cu ajutorul instrucţiunilor. Fiecare
instrucţiune trebuie încheiată cu separatorul punct şi virgulă (;). Instrucţiunile limbajului C pot
fi împărţite în următoarele categorii: Expresii, Blocuri, Selecţii, Iteraţii, Salturi.

[modifică] Expresii

O instrucţiune expresie este alcătuită dintr-o expresie urmată de punct şi virgulă. Operaţiile
realizate de aceste instrucţiuni se fac simţite datorită efectelor ce se concretizează prin apeluri
de funcţii şi modificarea valorilor unor variabile.
Exemplu de instrucţiuni expresie:

test(); /* apelul unor funcţii */

scanf("%d", &a);
a=b+c/2; /* variabila a primeşte valoarea b+c/2 */
x++; /* variabila x este incrementată */
a+f(); /* instrucţiunea este corectă, dar ciudată */
; /* instrucţiune vidă */

Un caz particular de instrucţiune expresie este instrucţiunea vidă. Aceasta este alcătuită doar
din terminatorul de instrucţiune ; şi se foloseşte de obicei în situaţiile în care sintaxa cere
prezenţa unei instrucţiuni, însă în program nu mai este necesară o operaţie.
Instrucţiunea următoare aşteaptă tastarea caracterului '€' şi ignoră orice alt caracter:

while (getch()!='€')
;

[modifică] Blocuri

Blocurile se mai numesc şi instrucţiuni compuse şi sunt alcătuite din mai multe declaraţii şi
instrucţiuni cuprinse între acolade. Structura generală a unui bloc este următoarea:

{
declaraţii
instrucţiuni
}

Declaraţiile din cadrul unui bloc se fac la început, înaintea instrucţiunilor!

[modifică] Selecţii
Limbajul C acceptă două tipuri de instrucţiuni de selecţie: if - care se mai numeşte şi
instrucţiune decizională - şi switch. În plus, operatorul ?: poate constitui, în anumite situaţii, o
alternativă la instrucţiunea decizională.

[modifică] Instrucţiunea decizională

Acestă instrucţiune are următoarele două variante:

a)

if(expresie)
instr_a

b)

if(expresie)
instr_a
else
instr_f

Execuţia instrucţiunii decizionale începe cu evaluarea expresiei. Valoarea expresiei poate fi

de orice tip scalar. Dacă valoarea expresiei este diferită de 0, atunci se execută instrucţiunea
instr_a, altfel se execută instr_b. Limbajul C nu operează cu tipul boolean, valorile de
adevăr fiind codificate numeric, după următoarea regulă: o valoare nulă este
echivalentă cu fals iar o valoare ne-nulă cu adevărat.
Exemplu:

if(a>0)
printf("pozitiv");
else
printf("negativ");

Instrucţiunea de mai sus afişează textul "pozitiv" dacă a > 0 şi "negativ" în caz contrar.
În cazul în care alternativele de prelucrare se codifică prin secvenţe de instrucţiuni, acestea
trebuie grupate în instrucţiuni compuse. De exemplu secvenţa

if(a>0)
printf("pozitiv");
np++; /* incrementează variabila np */

este diferită de

if(a>0){
printf("pozitiv");
np++;
}

deoarece în primul caz incrementarea variabilei np se realizează în afara instrucţiunii

decizionale, şi deci se efectuează în orice situaţie. În al doilea caz, instrucţiunea decizională
are asociată o instrucţiune compusă (bloc), iar incrementarea se realizează numai dacă
condiţia este adevărată (a>0).
Deoarece alternativa else a unei instrucţiuni decizionale este opţională, poate să apară o
ambiguitate legată de asocierea ei în cazul unor instrucţiuni decizionale imbricate.
Exemplu:
if( op =='/')
if(a!=0)
c=b/a;
else
printf("eroare, împărţire prin 0");

În aceste situaţii, regula este următoarea: Alternativa else se asociază ultimei decizii
incomplete. Dacă se doreşte o altă asociere se pot folosi acoladele:

if( a!=0){
if(op=='/')
c=b/a;
}else
printf("valoare nulă");

sau se poate completa alternativa else a instrucţiunii decizionale interioare cu o instrucţiune

vidă:

if( a!=0)
if(op=='/')
c=b/a;
else
;
else
printf("valoare nulă");

[modifică] Instrucţiunea decizională multiplă

O selecţie multiplă se poate realiza cu mai multe instrucţiuni decizionale în cascadă. În cazul
general în care există n alternative posibile selectate pe baza a n-1 condiţii, se recomandă
folosirea următoarei structuri:

if(expr_1)
ins_1
else if(expr_2)
ins_2
...
else if(expr_n-1)
ins_n-1
else
ins_n

Expresiile se evaluează în ordinea în care sunt scrise. Dacă se întâlneşte o expresie adevărată,
atunci se execută instrucţiunea care-i este asociată şi astfel se încheie întregul lanţ.
Instrucţiunea de după ultimul else se execută doar când nici una dintre expresii nu a fost
adevărată.

[modifică] Instrucţiunea de selecţie

Dacă o selecţie multiplă este controlată de valoarea unei singure expresii, programarea se
poate face mai eficient cu ajutorul instrucţiunii de selecţie (switch). Sintaxa generală a acestei
instrucţiuni este:

switch(expresie){
case k1 : prelucrare_1opt
 case k2 : prelucrare_2opt
...
case kn-1 : prelucrare_n-1opt
defaultopt : prelucrare_nopt
}

Expresia pe baza căreia se efectuează selecţia trebuie să fie de tip întreg (nu poate să fie de
exemplu float, double sau un tip structurat).
k1, k2, ..., kn-1 sunt expresii constante, cu valori distincte, ce pot fi convertite la tipul
expresiei de selecţie.
Prelucrările se reprezintă prin secvenţe de instrucţiuni, dar ele pot fi şi vide. În cazul în care o
prelucrare este compusă din mai multe instrucţiuni, acestea nu trebuie puse între acolade.
Execuţia instrucţiunii de selecţie începe cu evaluarea expresiei. Valoarea rezultată este
comparată succesiv cu constantele k1, k2, ..., kn-1. Dacă se găseşte o constantă ki de valoare
egală cu cea a expresiei, se trece la execuţia prelucrării asociate şi se continuă cu toate
prelucrările ce au mai rămas, până la sfârşitul instrucţiunii de selecţie. Dacă nu se găseşte o
astfel de constantă, dar este definită o alternativă default, se execută prelucrarea asociată
acesteia, altfel selecţia se încheie fără nici o prelucrare.
Exemplu de utilizare a instrucţiunii de selecţie:

/* calculează b = a la puterea n, 1 < n < 4 */

b=a;
switch(n){
case 4 : b=b*a;
case 3 : b=b*a;
case 2 : b=b*a;
}

În majoritatea situaţiilor se doreşte separarea prelucrărilor asociate unei instrucţiuni de

selecţie. Aceasta se poate realiza prin includerea instrucţiunii break la sfârşitul tuturor
prelucrărilor. Instrucţiunea break are ca efect, în cazul în care apare în interiorul unei
instrucţiuni de selecţie, terminarea imediată a acesteia. Execuţia programului va continua cu
instrucţiunea următoare (ceea ce urmează după switch).
Exemplu:

switch(op){
case '*' : inmulteste(a,b);
break;
case '+' : aduna(a,b);
break;
case '-' : scade(a,b);
break;
default : printf("eroare");
}

[modifică] Iteraţii

Execuţia repetată a unei prelucrări este folosită foarte frecvent în rezolvarea problemelor de
cele mai diverse tipuri. Instrucţiunile repetitive care descriu astfel de prelucrări sunt alcătuite
din două componente: Corpul instrucţiunii (care este alcătuit din instrucţiuni care se repetă) şi
Testul (pe baza căruia se stabileşte dacă este sau nu necesară reluarea execuţiei corpului).
În limbajul C există trei instrucţiuni repetitive, dintre care două cu test la început (while şi for)
şi una cu test la sfârşit (do while). Instrucţiunile repetitive cu test la început plasează testul
înaintea corpului, astfel corpul este parcurs numai dacă testul este trecut de la început. În
cazul celor cu test la sfârşit, corpul este executat cel puţin o dată în orice condiţii.
Instrucţiunile repetitive se mai numesc şi cicluri sau bucle.

[modifică] Instrucţiunea while

Această instrucţiune are următoarea sintaxă:

while(expresie)
instrucţiune

Expresia poate fi de orice tip scalar. Instrucţiunea specifică prelucrările ce se efectuează în

corpul buclei şi se repetă atâta timp cât expresia este adevărată, mai exact diferită de zero.

[modifică] Instrucţiunea do - while

Această instrucţiune are următoarea sintaxă

do
instrucţiune
while(expresie);

Ea are rolul de a repeta instrucţiunea până când expresia este adevărată. Diferenţa faţă
de instrucţiunea while constă în faptul că testul este plasat la sfârşitul buclei, deci
instrucţiunea se execută cu siguranţă cel puţin o dată, indiferent de valoarea expresiei.
Exemplul următor citeşte numere de la tastatură, până când numărul tastat este mai mic sau
egal cu 10.

#include <stdio.h>
void main()
{
char n;
do{
printf("\nTastaţi un număr < 10 ");
scanf("%d", &n);
}while(n>10);
}

Instrucţiunea for

Această instrucţiune are o formă generală care-i extinde mult domeniul de aplicare faţă de
instrucţiunile de acelaşi tip existente în alte limbaje de programare. Este cea utilizată
instrucţiune repetitivă, deoarece în afară de testul de rămânere în buclă, oferă două elemente
necesare în majoritatea situaţiilor: iniţializare şi actualizare.
Sintaxa instrucţiunii for:

for(expresie_intopt;expresie_condopt;expresie_actopt)

instrucţiune

- expresie_init constituie iniţializarea buclei şi se evaluează o singură dată.

- expresie_cond trebuie să fie de tip scalar şi este evaluată înaintea fiecărei iteraţii. Valoarea
acestei expresii este interpretată ca şi condiţie de rămânere în buclă.
- În interiorul buclei se realizează, la fiecare parcurgere, două operaţiuni: se execută
prelucrările specificate prin instrucţiune, după care se evaluează expresie_act.
Oricare dintre expresiile instrucţiunii for (sau chiar toate) pot să lipsească, dar delimitatorul ';'
asociat trebuie să fie prezent.
Dacă lipseşte expresie_cond, se consideră implicit că aceasta este tot timpul adevărată şi deci
bucla nu se va încheia niciodată. O astfel de buclă poate fi însă încheiată cu instrucţiunea
break.
Prelucrările efectuate cu instrucţiunea for, pot fi descrise şi cu ajutorul unei bucle while, care
se aseamănă cu for prin faptul că este tot cu test la început. Secţiunea următoare este
echivalentă cu instrucţiunea for a cărei sintaxă a fost prezentată mai sus:

expresie_init
while(expresie_cond){
instrucţiune
expresie_act
}

Exemplul următor prezintă o buclă care va rula la infinit:

#include <stdio.h>
void main()
{
for( ; ; )
printf("Buclă infinită\n");
}

[modifică] Salturi

Există trei instrucţiuni de salt în limbajul C: break, continue şi goto. Tot la această categorie
putem vorbi şi despre instrucţiunea return, care marchează încheierea prelucrărilor dintr-o
funcţie şi revenirea în programul apelant.

[modifică] Instrucţiunea break

Această instrucţiune poate să apară numai în corpul instrucţiunilor while, do-while, for şi
switch; având ca efect terminarea imediată a acestor instrucţiuni. Programul continuă cu
instrucţiunea imediat următoare celei întrerupte. În cazul unor bucle imbricate, o instrucţiunea
break aflată într-o buclă interioară nu le afectează pe cele exterioare. Aceaşi situaţie apare în
cazul instrucţiunilor switch imbricate, sau care conţin bucle.