Sintaxa limbajului C

De la Wikipedia, enciclopedia liberă

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

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

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


#include<stdio.h>
int main(void)
{
printf("Hello,World!\n")
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);
}

[modifică] 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.