b'\n_START_ARTICLE_\nSintaxa limbajului C\n_START_PARAGRAPH_\nLimbajul de programare C este un limbaj de programare a calculatoarelor, conceput de Dennis Ritchie la \xc3\xaenceputul anilor 1970 pentru a scrie sistemul de operare UNIX. A r\xc4\x83mas unul dintre cele mai folosite limbaje pentru scrierea programelor._NEWLINE_Exist\xc4\x83 multe extinderi ale limbajului, printre care C++, Perl, Java, Javascript \xc8\x99i C#.\n_START_SECTION_\n"Hello, World!" \xc3\xaen C\n_START_PARAGRAPH_\nUrm\xc4\x83torul program afi\xc8\x99eaz\xc4\x83 mesajul "Hello, world!"._NEWLINE_Versiunea C_NEWLINE__NEWLINE_#include<stdio.h>_NEWLINE__NEWLINE_int main(void)_NEWLINE__NEWLINE_{_NEWLINE__NEWLINE_printf("Hello,World!\\n");_NEWLINE__NEWLINE_return 0;_NEWLINE__NEWLINE_}_NEWLINE_Versiunea C++_NEWLINE__NEWLINE_#include<iostream.h>_NEWLINE__NEWLINE_int main(void)_NEWLINE__NEWLINE_{_NEWLINE__NEWLINE_cout<<"Hello,World!\\n"; //sau cout<<"Hello,World!"<<endl;_NEWLINE__NEWLINE_return 0;_NEWLINE__NEWLINE_}\n_START_SECTION_\nStructura unui program\n_START_PARAGRAPH_\nUn program C este alc\xc4\x83tuit din func\xc8\x9bii \xc8\x99i variabile. Func\xc8\x9biile C sunt echivalente cu subrutinele din Fortran \xc8\x99i procedurile din Pascal. Func\xc8\x9bia main este special\xc4\x83 prin faptul c\xc4\x83 execu\xc8\x9bia programului debuteaz\xc4\x83 \xc3\xaentotdeauna la \xc3\xaenceputul acestei func\xc8\x9bii. Orice program trebuie s\xc4\x83 includ\xc4\x83 o func\xc8\x9bie main._NEWLINE_Defini\xc8\x9bia unei func\xc8\x9bii include urm\xc4\x83toarele componente: un tip de retur (int, \xc3\xaen exemplul de mai sus), un nume, o list\xc4\x83 de parametri (\xc3\xaentre paranteze rotunde) \xc8\x99i un corp al func\xc8\x9biei (cuprins \xc3\xaentre acolade). _NEWLINE__NEWLINE_float CalculeazaSuprafata(float Lungime, float Latime) {_NEWLINE__NEWLINE_float Suprafata;_NEWLINE__NEWLINE_Suprafata = Lungime*Latime;_NEWLINE__NEWLINE_return Suprafata;_NEWLINE__NEWLINE_}\n_START_SECTION_\nIdentificatori\n_START_PARAGRAPH_\nIdentificatorii sunt folosi\xc8\x9bi pentru a indica variabile, tipuri de date, constante simbolice sau func\xc8\x9bii. Primul caracter al identificatorilor trebuie s\xc4\x83 fie o liter\xc4\x83 sau underline, iar lungimea maxim\xc4\x83 a acestora este de 31 de caractere.\n_START_SECTION_\nStructura func\xc8\x9biilor\n_START_PARAGRAPH_\nFunc\xc8\x9biile C sunt alc\xc4\x83tuite dintr-un antent \xc8\x99i un corp. Antetul specific\xc4\x83 tipul rezultatului, numele func\xc8\x9biei \xc8\x99i lista de parametri. Corpul este alc\xc4\x83tuit dintr-un bloc ce poate s\xc4\x83 con\xc8\x9bin\xc4\x83 declara\xc8\x9bii \xc8\x99i instruc\xc8\x9biuni care specific\xc4\x83 prelucr\xc4\x83rile realizate de func\xc8\x9bia respectiv\xc4\x83._NEWLINE__NEWLINE_Antetul unei func\xc8\x9bii este de forma urm\xc4\x83toare:_NEWLINE__NEWLINE_tip_r nume_f(list\xc4\x83_p_f)_NEWLINE_Corpul unei func\xc8\x9bii este de forma urm\xc4\x83toare:_NEWLINE__NEWLINE_{_NEWLINE_     declara\xc8\x9bii_NEWLINE_     instruc\xc8\x9biuni_NEWLINE_}\n_START_SECTION_\nInstruc\xc8\x9biuni\n_START_PARAGRAPH_\nPrelucr\xc4\x83rile efectuate de un program sunt descrise cu ajutorul instruc\xc8\x9biunilor. Fiecare instruc\xc8\x9biune trebuie \xc3\xaencheiat\xc4\x83 cu separatorul punct \xc8\x99i virgul\xc4\x83 (;). Instruc\xc8\x9biunile limbajului C pot fi \xc3\xaemp\xc4\x83r\xc8\x9bite \xc3\xaen urm\xc4\x83toarele categorii: Expresii, Blocuri, Selec\xc8\x9bii, Itera\xc8\x9bii, Salturi.\n_START_SECTION_\nExpresii\n_START_PARAGRAPH_\nO instruc\xc8\x9biune expresie este alc\xc4\x83tuit\xc4\x83 dintr-o expresie urmat\xc4\x83 de punct \xc8\x99i virgul\xc4\x83. Opera\xc8\x9biile realizate de aceste instruc\xc8\x9biuni se fac sim\xc8\x9bite datorit\xc4\x83 efectelor ce se concretizeaz\xc4\x83 prin apeluri de func\xc8\x9bii \xc8\x99i modificarea valorilor unor variabile._NEWLINE_Exemplu de instruc\xc8\x9biuni expresie:_NEWLINE__NEWLINE_test();                  /* apelul unor func\xc8\x9bii */_NEWLINE_scanf("%d", &a);_NEWLINE_a=b+c/2;        /* variabila a prime\xc8\x99te valoarea b+c/2 */_NEWLINE_x++;            /* variabila x este incrementat\xc4\x83 */_NEWLINE_a+f();   /* instruc\xc8\x9biunea este corect\xc4\x83, dar ciudat\xc4\x83 */_NEWLINE_;               /* instruc\xc8\x9biune vid\xc4\x83 */_NEWLINE_Un caz particular de instruc\xc8\x9biune expresie este instruc\xc8\x9biunea vid\xc4\x83. Aceasta este alc\xc4\x83tuit\xc4\x83 doar din terminatorul de instruc\xc8\x9biune\xc2\xa0; \xc8\x99i se folose\xc8\x99te de obicei \xc3\xaen situa\xc8\x9biile \xc3\xaen care sintaxa cere prezen\xc8\x9ba unei instruc\xc8\x9biuni, \xc3\xaens\xc4\x83 \xc3\xaen program nu mai este necesar\xc4\x83 o opera\xc8\x9bie._NEWLINE_Instruc\xc8\x9biunea urm\xc4\x83toare a\xc8\x99teapt\xc4\x83 tastarea caracterului \'\xe2\x82\xac\' \xc8\x99i ignor\xc4\x83 orice alt caracter:_NEWLINE__NEWLINE_while (getch()!=\'\xe2\x82\xac\')_NEWLINE_      ;\n_START_SECTION_\nBlocuri\n_START_PARAGRAPH_\nBlocurile se mai numesc \xc8\x99i instruc\xc8\x9biuni compuse \xc8\x99i sunt alc\xc4\x83tuite din mai multe declara\xc8\x9bii \xc8\x99i instruc\xc8\x9biuni cuprinse \xc3\xaentre acolade. Structura general\xc4\x83 a unui bloc este urm\xc4\x83toarea:_NEWLINE__NEWLINE_{_NEWLINE_   declara\xc8\x9bii_NEWLINE_   instruc\xc8\x9biuni_NEWLINE_}_NEWLINE_Declara\xc8\x9biile din cadrul unui bloc se fac la \xc3\xaenceput, \xc3\xaenaintea instruc\xc8\x9biunilor!\n_START_SECTION_\nSelec\xc8\x9bii\n_START_PARAGRAPH_\nLimbajul C accept\xc4\x83 dou\xc4\x83 tipuri de instruc\xc8\x9biuni de selec\xc8\x9bie: if - care se mai nume\xc8\x99te \xc8\x99i instruc\xc8\x9biune decizional\xc4\x83 - \xc8\x99i switch. \xc3\x8en plus, operatorul ?: poate constitui, \xc3\xaen anumite situa\xc8\x9bii, o alternativ\xc4\x83 la instruc\xc8\x9biunea decizional\xc4\x83.\n_START_SECTION_\nInstruc\xc8\x9biunea decizional\xc4\x83\n_START_PARAGRAPH_\nAcest\xc4\x83 instruc\xc8\x9biune are urm\xc4\x83toarele dou\xc4\x83 variante:_NEWLINE__NEWLINE_a)_NEWLINE__NEWLINE_if(expresie)_NEWLINE_     instr_a_NEWLINE_b)_NEWLINE__NEWLINE_if(expresie)_NEWLINE_     instr_a_NEWLINE_else_NEWLINE_     instr_b_NEWLINE_Execu\xc8\x9bia instruc\xc8\x9biunii decizionale \xc3\xaencepe cu evaluarea expresiei. Valoarea expresiei poate fi de orice tip scalar. Dac\xc4\x83 valoarea expresiei este diferit\xc4\x83 de 0, atunci se execut\xc4\x83 instruc\xc8\x9biunea instr_a, altfel se execut\xc4\x83 instr_b. Limbajul C nu opereaz\xc4\x83 cu tipul boolean, valorile de adev\xc4\x83r fiind codificate numeric, dup\xc4\x83 urm\xc4\x83toarea regul\xc4\x83: o valoare nul\xc4\x83 este echivalent\xc4\x83 cu fals iar o valoare ne-nul\xc4\x83 cu adev\xc4\x83rat._NEWLINE_Exemplu:_NEWLINE__NEWLINE_if(a>0)_NEWLINE_     printf("pozitiv");_NEWLINE_else_NEWLINE_     printf("negativ");_NEWLINE_Instruc\xc8\x9biunea de mai sus afi\xc8\x99eaz\xc4\x83 textul "pozitiv" dac\xc4\x83 a > 0 \xc8\x99i "negativ" \xc3\xaen caz contrar._NEWLINE__NEWLINE_\xc3\x8en cazul \xc3\xaen care alternativele de prelucrare se codific\xc4\x83 prin secven\xc8\x9be de instruc\xc8\x9biuni, acestea trebuie grupate \xc3\xaen instruc\xc8\x9biuni compuse. De exemplu secven\xc8\x9ba_NEWLINE__NEWLINE_if(a>0)_NEWLINE_     printf("pozitiv");_NEWLINE_     np++;   /* incrementeaz\xc4\x83 variabila np */_NEWLINE_este diferit\xc4\x83 de_NEWLINE__NEWLINE_if(a>0){_NEWLINE_     printf("pozitiv");_NEWLINE_     np++;_NEWLINE_}_NEWLINE_deoarece \xc3\xaen primul caz incrementarea variabilei np se realizeaz\xc4\x83 \xc3\xaen afara instruc\xc8\x9biunii decizionale, \xc8\x99i deci se efectueaz\xc4\x83 \xc3\xaen orice situa\xc8\x9bie. \xc3\x8en al doilea caz, instruc\xc8\x9biunea decizional\xc4\x83 are asociat\xc4\x83 o instruc\xc8\x9biune compus\xc4\x83 (bloc), iar incrementarea se realizeaz\xc4\x83 numai dac\xc4\x83 condi\xc8\x9bia este adev\xc4\x83rat\xc4\x83 (a>0)._NEWLINE__NEWLINE_Deoarece alternativa else a unei instruc\xc8\x9biuni decizionale este op\xc8\x9bional\xc4\x83, poate s\xc4\x83 apar\xc4\x83 o ambiguitate legat\xc4\x83 de asocierea ei \xc3\xaen cazul unor instruc\xc8\x9biuni decizionale imbricate._NEWLINE_Exemplu:_NEWLINE__NEWLINE_if( op ==\'/\')_NEWLINE_     if(a!=0)_NEWLINE_          c=b/a;_NEWLINE_     else_NEWLINE_          printf("eroare, \xc3\xaemp\xc4\x83r\xc8\x9bire prin 0");_NEWLINE_\xc3\x8en aceste situa\xc8\x9bii, regula este urm\xc4\x83toarea: Alternativa else se asociaz\xc4\x83 ultimei decizii incomplete. Dac\xc4\x83 se dore\xc8\x99te o alt\xc4\x83 asociere se pot folosi acoladele:_NEWLINE__NEWLINE_if( a!=0){_NEWLINE_       if(op==\'/\')_NEWLINE_              c=b/a;_NEWLINE_}else_NEWLINE_      printf("valoare nul\xc4\x83");_NEWLINE_sau se poate completa alternativa else a instruc\xc8\x9biunii decizionale interioare cu o instruc\xc8\x9biune vid\xc4\x83:_NEWLINE__NEWLINE_if( a!=0)_NEWLINE_       if(op==\'/\')_NEWLINE_              c=b/a;_NEWLINE_       else_NEWLINE_              ;_NEWLINE_else_NEWLINE_       printf("valoare nul\xc4\x83");\n_START_SECTION_\nInstruc\xc8\x9biunea decizional\xc4\x83 multipl\xc4\x83\n_START_PARAGRAPH_\nO selec\xc8\x9bie multipl\xc4\x83 se poate realiza cu mai multe instruc\xc8\x9biuni decizionale \xc3\xaen cascad\xc4\x83. \xc3\x8en cazul general \xc3\xaen care exist\xc4\x83 n alternative posibile selectate pe baza a n-1 condi\xc8\x9bii, se recomand\xc4\x83 folosirea urm\xc4\x83toarei structuri:_NEWLINE__NEWLINE_if(expr_1)_NEWLINE_   ins_1_NEWLINE_else if(expr_2)_NEWLINE_   ins_2_NEWLINE_..._NEWLINE_else if(expr_n-1)_NEWLINE_   ins_n-1_NEWLINE_else_NEWLINE_   ins_n_NEWLINE_Expresiile se evalueaz\xc4\x83 \xc3\xaen ordinea \xc3\xaen care sunt scrise. Dac\xc4\x83 se \xc3\xaent\xc3\xa2lne\xc8\x99te o expresie adev\xc4\x83rat\xc4\x83, atunci se execut\xc4\x83 instruc\xc8\x9biunea care-i este asociat\xc4\x83 \xc8\x99i astfel se \xc3\xaencheie \xc3\xaentregul lan\xc8\x9b. Instruc\xc8\x9biunea de dup\xc4\x83 ultimul else se execut\xc4\x83 doar c\xc3\xa2nd nici una dintre expresii nu a fost adev\xc4\x83rat\xc4\x83.\n_START_SECTION_\nInstruc\xc8\x9biunea de selec\xc8\x9bie\n_START_PARAGRAPH_\nDac\xc4\x83 o selec\xc8\x9bie multipl\xc4\x83 este controlat\xc4\x83 de valoarea unei singure expresii, programarea se poate face mai eficient cu ajutorul instruc\xc8\x9biunii de selec\xc8\x9bie (switch). Sintaxa general\xc4\x83 a acestei instruc\xc8\x9biuni este:_NEWLINE__NEWLINE_switch(expresie){_NEWLINE_     case k1    : prelucrare_1\xe2\x82\x92\xe2\x82\x9a\xe2\x82\x9c_NEWLINE_     case k2    : prelucrare_2\xe2\x82\x92\xe2\x82\x9a\xe2\x82\x9c_NEWLINE_     ..._NEWLINE_     case kn-1  : prelucrare_n-1\xe2\x82\x92\xe2\x82\x9a\xe2\x82\x9c_NEWLINE_     default\xe2\x82\x92\xe2\x82\x9a\xe2\x82\x9c : prelucrare_n\xe2\x82\x92\xe2\x82\x9a\xe2\x82\x9c_NEWLINE_}_NEWLINE_Expresia pe baza c\xc4\x83reia se efectueaz\xc4\x83 selec\xc8\x9bia trebuie s\xc4\x83 fie de tip \xc3\xaentreg (nu poate s\xc4\x83 fie de exemplu float, double sau un tip structurat)._NEWLINE_k1, k2, ..., kn-1 sunt expresii constante, cu valori distincte, ce pot fi convertite la tipul expresiei de selec\xc8\x9bie._NEWLINE__NEWLINE_Prelucr\xc4\x83rile se reprezint\xc4\x83 prin secven\xc8\x9be de instruc\xc8\x9biuni, dar ele pot fi \xc8\x99i vide. \xc3\x8en cazul \xc3\xaen care o prelucrare este compus\xc4\x83 din mai multe instruc\xc8\x9biuni, acestea nu trebuie puse \xc3\xaentre acolade._NEWLINE__NEWLINE_Execu\xc8\x9bia instruc\xc8\x9biunii de selec\xc8\x9bie \xc3\xaencepe cu evaluarea expresiei. Valoarea rezultat\xc4\x83 este comparat\xc4\x83 succesiv cu constantele k1, k2, ..., kn-1. Dac\xc4\x83 se g\xc4\x83se\xc8\x99te o constant\xc4\x83 ki de valoare egal\xc4\x83 cu cea a expresiei, se trece la execu\xc8\x9bia prelucr\xc4\x83rii asociate \xc8\x99i se continu\xc4\x83 cu toate prelucr\xc4\x83rile ce au mai r\xc4\x83mas, p\xc3\xa2n\xc4\x83 la sf\xc3\xa2r\xc8\x99itul instruc\xc8\x9biunii de selec\xc8\x9bie. Dac\xc4\x83 nu se g\xc4\x83se\xc8\x99te o astfel de constant\xc4\x83, dar este definit\xc4\x83 o alternativ\xc4\x83 default, se execut\xc4\x83 prelucrarea asociat\xc4\x83 acesteia, altfel selec\xc8\x9bia se \xc3\xaencheie f\xc4\x83r\xc4\x83 nici o prelucrare._NEWLINE_Exemplu de utilizare a instruc\xc8\x9biunii de selec\xc8\x9bie:_NEWLINE__NEWLINE_/* calculeaz\xc4\x83 b = a la puterea n, 1 < n < 4 */_NEWLINE_b=a;_NEWLINE_switch(n){_NEWLINE_     case 4 : b=b*a;_NEWLINE_     case 3 : b=b*a;_NEWLINE_     case 2 : b=b*a;_NEWLINE_}_NEWLINE_\xc3\x8en majoritatea situa\xc8\x9biilor se dore\xc8\x99te separarea prelucr\xc4\x83rilor asociate unei instruc\xc8\x9biuni de selec\xc8\x9bie. Aceasta se poate realiza prin includerea instruc\xc8\x9biunii break la sf\xc3\xa2r\xc8\x99itul tuturor prelucr\xc4\x83rilor. Instruc\xc8\x9biunea break are ca efect, \xc3\xaen cazul \xc3\xaen care apare \xc3\xaen interiorul unei instruc\xc8\x9biuni de selec\xc8\x9bie, terminarea imediat\xc4\x83 a acesteia. Execu\xc8\x9bia programului va continua cu instruc\xc8\x9biunea urm\xc4\x83toare (ceea ce urmeaz\xc4\x83 dup\xc4\x83 switch)._NEWLINE_Exemplu:_NEWLINE__NEWLINE_switch(op){_NEWLINE_      case \'*\' : inmulteste(a,b);_NEWLINE_                 break;_NEWLINE_      case \'+\' : aduna(a,b);_NEWLINE_                 break;_NEWLINE_      case \'-\' : scade(a,b);_NEWLINE_                 break;_NEWLINE_      default  : printf("eroare");_NEWLINE_}\n_START_SECTION_\nItera\xc8\x9bii\n_START_PARAGRAPH_\nExecu\xc8\x9bia repetat\xc4\x83 a unei prelucr\xc4\x83ri este folosit\xc4\x83 foarte frecvent \xc3\xaen rezolvarea problemelor de cele mai diverse tipuri. Instruc\xc8\x9biunile repetitive care descriu astfel de prelucr\xc4\x83ri sunt alc\xc4\x83tuite din dou\xc4\x83 componente: Corpul instruc\xc8\x9biunii (care este alc\xc4\x83tuit din instruc\xc8\x9biuni care se repet\xc4\x83) \xc8\x99i Testul (pe baza c\xc4\x83ruia se stabile\xc8\x99te dac\xc4\x83 este sau nu necesar\xc4\x83 reluarea execu\xc8\x9biei corpului)._NEWLINE__NEWLINE_\xc3\x8en limbajul C exist\xc4\x83 trei instruc\xc8\x9biuni repetitive, dintre care dou\xc4\x83 cu test la \xc3\xaenceput (while \xc8\x99i for) \xc8\x99i una cu test la sf\xc3\xa2r\xc8\x99it (do while). Instruc\xc8\x9biunile repetitive cu test la \xc3\xaenceput plaseaz\xc4\x83 testul \xc3\xaenaintea corpului, astfel corpul este parcurs numai dac\xc4\x83 testul este trecut de la \xc3\xaenceput. \xc3\x8en cazul celor cu test la sf\xc3\xa2r\xc8\x99it, corpul este executat cel pu\xc8\x9bin o dat\xc4\x83 \xc3\xaen orice condi\xc8\x9bii._NEWLINE__NEWLINE_Instruc\xc8\x9biunile repetitive se mai numesc \xc8\x99i cicluri sau bucle.\n_START_SECTION_\nInstruc\xc8\x9biunea while\n_START_PARAGRAPH_\nAceast\xc4\x83 instruc\xc8\x9biune are urm\xc4\x83toarea sintax\xc4\x83:_NEWLINE__NEWLINE_while(expresie)_NEWLINE_      instruc\xc8\x9biune_NEWLINE_Expresia poate fi de orice tip scalar. Instruc\xc8\x9biunea specific\xc4\x83 prelucr\xc4\x83rile ce se efectueaz\xc4\x83 \xc3\xaen corpul buclei \xc8\x99i se repet\xc4\x83 at\xc3\xa2ta timp c\xc3\xa2t expresia este adev\xc4\x83rat\xc4\x83, mai exact diferit\xc4\x83 de zero.\n_START_SECTION_\nInstruc\xc8\x9biunea do - while\n_START_PARAGRAPH_\nAceast\xc4\x83 instruc\xc8\x9biune are urm\xc4\x83toarea sintax\xc4\x83_NEWLINE__NEWLINE_do_NEWLINE_     instruc\xc8\x9biune_NEWLINE_while(expresie);_NEWLINE_Ea are rolul de a repeta instruc\xc8\x9biunea p\xc3\xa2n\xc4\x83 c\xc3\xa2nd expresia este adev\xc4\x83rat\xc4\x83. Diferen\xc8\x9ba fa\xc8\x9b\xc4\x83 de instruc\xc8\x9biunea while const\xc4\x83 \xc3\xaen faptul c\xc4\x83 testul este plasat la sf\xc3\xa2r\xc8\x99itul buclei, deci instruc\xc8\x9biunea se execut\xc4\x83 cu siguran\xc8\x9b\xc4\x83 cel pu\xc8\x9bin o dat\xc4\x83, indiferent de valoarea expresiei._NEWLINE__NEWLINE_Exemplul urm\xc4\x83tor cite\xc8\x99te numere de la tastatur\xc4\x83, p\xc3\xa2n\xc4\x83 c\xc3\xa2nd num\xc4\x83rul tastat este mai mic sau egal cu 10._NEWLINE__NEWLINE_#include <stdio.h>_NEWLINE_int main()_NEWLINE_{_NEWLINE_   char n;_NEWLINE_        do{_NEWLINE_              printf("\\nTasta\xc8\x9bi un num\xc4\x83r < 10 ");_NEWLINE_              scanf("%d", &n);_NEWLINE_        }while(n>10);_NEWLINE_}\n_START_SECTION_\nInstruc\xc8\x9biunea for\n_START_PARAGRAPH_\nAceast\xc4\x83 instruc\xc8\x9biune are o form\xc4\x83 general\xc4\x83 care-i extinde mult domeniul de aplicare fa\xc8\x9b\xc4\x83 de instruc\xc8\x9biunile de acela\xc8\x99i tip existente \xc3\xaen alte limbaje de programare. Este cea mai utilizat\xc4\x83 instruc\xc8\x9biune repetitiv\xc4\x83, deoarece \xc3\xaen afar\xc4\x83 de testul de r\xc4\x83m\xc3\xa2nere \xc3\xaen bucl\xc4\x83, ofer\xc4\x83 dou\xc4\x83 elemente necesare \xc3\xaen majoritatea situa\xc8\x9biilor: ini\xc8\x9bializare \xc8\x99i actualizare._NEWLINE__NEWLINE_Sintaxa instruc\xc8\x9biunii for:_NEWLINE__NEWLINE_for(expresie_int\xe2\x82\x92\xe2\x82\x9a\xe2\x82\x9c;expresie_cond\xe2\x82\x92\xe2\x82\x9a\xe2\x82\x9c;expresie_act\xe2\x82\x92\xe2\x82\x9a\xe2\x82\x9c)_NEWLINE_       _NEWLINE_       instruc\xc8\x9biune_NEWLINE__NEWLINE_- expresia_initializare constituie ini\xc8\x9bializarea buclei \xc8\x99i se evalueaz\xc4\x83 o singur\xc4\x83 dat\xc4\x83._NEWLINE__NEWLINE_- expresia_actualizare trebuie s\xc4\x83 fie de tip scalar \xc8\x99i este evaluat\xc4\x83 \xc3\xaenaintea fiec\xc4\x83rei itera\xc8\x9bii. Valoarea acestei expresii este interpretat\xc4\x83 ca \xc8\x99i condi\xc8\x9bie de r\xc4\x83m\xc3\xa2nere \xc3\xaen bucl\xc4\x83._NEWLINE__NEWLINE_- \xc3\x8en interiorul buclei se realizeaz\xc4\x83, la fiecare parcurgere, dou\xc4\x83 opera\xc8\x9biuni: se execut\xc4\x83 prelucr\xc4\x83rile specificate prin instruc\xc8\x9biune, dup\xc4\x83 care se evalueaz\xc4\x83 expresie_act._NEWLINE__NEWLINE_Oricare dintre expresiile instruc\xc8\x9biunii for (sau chiar toate) pot s\xc4\x83 lipseasc\xc4\x83, dar delimitatorul \';\' asociat trebuie s\xc4\x83 fie prezent._NEWLINE__NEWLINE_Dac\xc4\x83 lipse\xc8\x99te expresie_cond, se consider\xc4\x83 implicit c\xc4\x83 aceasta este tot timpul adev\xc4\x83rat\xc4\x83 \xc8\x99i deci bucla nu se va \xc3\xaencheia niciodat\xc4\x83. O astfel de bucl\xc4\x83 poate fi \xc3\xaens\xc4\x83 \xc3\xaencheiat\xc4\x83 cu instruc\xc8\x9biunea break._NEWLINE__NEWLINE_Prelucr\xc4\x83rile efectuate cu instruc\xc8\x9biunea for, pot fi descrise \xc8\x99i cu ajutorul unei bucle while, care se aseam\xc4\x83n\xc4\x83 cu for prin faptul c\xc4\x83 este tot cu test la \xc3\xaenceput. Sec\xc8\x9biunea urm\xc4\x83toare este echivalent\xc4\x83 cu instruc\xc8\x9biunea for a c\xc4\x83rei sintax\xc4\x83 a fost prezentat\xc4\x83 mai sus:_NEWLINE__NEWLINE_expresie_init_NEWLINE_while(expresie_cond){_NEWLINE_      instruc\xc8\x9biune_NEWLINE_      expresie_act_NEWLINE_}_NEWLINE_Exemplul urm\xc4\x83tor prezint\xc4\x83 o bucl\xc4\x83 care va rula la infinit:_NEWLINE__NEWLINE_#include <stdio.h>_NEWLINE_int main()_NEWLINE_{_NEWLINE_for( ; ; )_NEWLINE_       printf("Bucl\xc4\x83 infinit\xc4\x83\\n");_NEWLINE_}\n_START_SECTION_\nSalturi\n_START_PARAGRAPH_\nExist\xc4\x83 trei instruc\xc8\x9biuni de salt \xc3\xaen limbajul C: break, continue \xc8\x99i goto. Tot la aceast\xc4\x83 categorie putem vorbi \xc8\x99i despre instruc\xc8\x9biunea return, care marcheaz\xc4\x83 \xc3\xaencheierea prelucr\xc4\x83rilor dintr-o func\xc8\x9bie \xc8\x99i revenirea \xc3\xaen programul apelant.\n_START_SECTION_\nInstruc\xc8\x9biunea break\n_START_PARAGRAPH_\nAceast\xc4\x83 instruc\xc8\x9biune poate s\xc4\x83 apar\xc4\x83 numai \xc3\xaen corpul instruc\xc8\x9biunilor while, do-while, for \xc8\x99i switch; av\xc3\xa2nd ca efect terminarea imediat\xc4\x83 a acestor instruc\xc8\x9biuni. Programul continu\xc4\x83 cu instruc\xc8\x9biunea imediat urm\xc4\x83toare celei \xc3\xaentrerupte. \xc3\x8en cazul unor bucle imbricate, o instruc\xc8\x9biune break aflat\xc4\x83 \xc3\xaentr-o bucl\xc4\x83 interioar\xc4\x83 nu le afecteaz\xc4\x83 pe cele exterioare. Acea\xc8\x99i situa\xc8\x9bie apare \xc3\xaen cazul instruc\xc8\x9biunilor switch imbricate, sau care con\xc8\x9bin bucle.'