Structura unui program

Cel mai bun mod de a învăța un limbaj de programare este scrierea de programe. De obicei, primul program scris de începători este programul numit "Hello World", care pur și simplu printeaza "Hello World" pentru ecranul computerului. Deși este foarte simplu, el conține toate componentele fundamentale ale programelor C ++:

// primul meu program in C++
#include <iostream>

int main()
{
  std::cout << "Salutare, lume!";
}
Salutare, lume!

Panoul din stânga sus prezinta codul C ++ pentru acest program. Panoul din dreapta prezinta rezultatul afisat pe ecran atunci când programul este executat de către un calculator. Numerele gri din stânga panourilor sunt numere de linie pe care le folosim pentru a face mai ușoară discutarea programelor și cercetarea erorilor. Ele nu fac parte din program.

Să examinăm acest program linie cu linie:

Linia 1: // primul meu program in C++
Doua semne slash indică faptul că restul liniei este un comentariu introdus de către programator, dar care nu are nici un efect asupra comportamentului programului. Programatorii le folosesc pentru a include explicații scurte sau observații cu privire la cod sau program. În acest caz, este vorba de o scurtă descriere introductivă a programului.

Linia 2: #include <iostream>
Liniile care încep cu un diez (#) sunt directivele de citit și interpretat de ceea ce este cunoscut sub numele de preprocesor. Acestea sunt linii speciale interpretate înainte de începerea programului în sine. În acest caz, directiva #include <iostream>, instruiește preprocesorul să includă o secțiune de cod C ++, cunoscuta ca antet-ul iostream care permite efectuarea de operațiuni de intrare și de ieșire standard, cum ar fi scrierea pe ecran a mesajului (Salutare lume).

Linia 3: O linie goală.
Liniile goale nu au niciun efect asupra unui program. Ele îmbunătățesc pur și simplu lizibilitatea codului.


Linia 4: int main ()
Această linie inițiază declararea unei funcții. În esență, o funcție este un grup de instructiuni de cod caruia ii este dat un nume: în acest caz, avem numele de "principal" pentru gruparea de instructiuni care urmează. Funcțiile vor fi discutate în detaliu într-un capitol ulterior, dar, în esență, definirea acestora este introdusa ca o succesiune de tip (int), un nume(main) și o pereche de paranteze (()), care opțional poate include si parametri.

Funcția numita main este o funcție specială în toate programele C ++; aceasta este funcția apelata atunci când programul este rulat. Executarea tuturor programelor C ++ începe cu funcția main, indiferent de locul în care funcția este de fapt localizata în cod.


Liniile 5 si 7: { si }
Acolada deschisa ({) la linia 5, indică începutul definiției funcției main, iar acolada de închidere (}) de la linia 7, indică sfârșitul ei. Tot ce este între aceste acolade formeaza corpul functiei care definește ceea ce se întâmplă atunci când se apeleaza functia principala main. Toate funcțiile folosesc acolade pentru a indica începutul și sfârșitul definițiilor lor.

Linia 6: std::cout << "Salutare, lume!";
Această linie este o instrucțiune C ++. O instrucțiune este o expresie care poate produce un efect. Este partea esențială a unui program, precizând comportamentul efectiv al acestuia. Instrucțiunile sunt executate în aceeași ordine în care apar în corpul unei funcții.

Această instrucțiune are trei părți: în primul rând, std::cout, care identifică dispozitivul standard de afișare (iesire = output) a caracterelor (de obicei, acest lucru este ecranul calculatorului). În al doilea rând, operatorul de inserare (<<), care indică faptul că ceea ce urmează este introdus în std::cout. În cele din urmă, o propoziție între ghilimele ("Salutare, lume!"), este ceea ce se trimite la ieșirea standard.

Observați că declarația se termină cu punct și virgulă (;). Acest caracter marchează sfârșitul instrucțiunii, la fel cum punctul încheie o propoziție în limba engleză. Toate instrucțiunile C ++ trebuie să se termine cu un caracter punct și virgulă. Una dintre cele mai comune erori de sintaxă în C ++ este cand se uita terminarea unei instrucțiuni cu punct și virgulă.

Poate că ați observat că nu toate liniile acestui program efectuează acțiuni atunci când se execută codul. Există o linie care conține un comentariu (începând cu //). Există o linie cu o directivă pentru preprocesor (începând cu #). Există o linie care definește o funcție (în acest caz, funcția principală main). Și, în cele din urmă, o linie cu instructiuni se termină cu punct și virgulă (folosirea lui cout), care a fost în cadrul blocului delimitat de acolade ( { } ) din funcția main.

Programul a fost structurat pe diferite linii și indentate în mod corespunzător, în scopul de a-l face mai ușor de înțeles pentru oamenii care il citesc. Dar C ++ nu are reguli stricte cu privire la indentare sau cu privire la modul de împărțire a instrucțiunilor în linii diferite. De exemplu, în loc de

1
2
3
4
5
6
#include<iostream>

int main ()
{
  std::cout << " Salutare, lume!";
}

am fi putut scrie:
1
2
3
#include<iostream>

int main () { std::cout << "Salutare, lume!"; }

toate într-o singură linie, iar acest lucru ar fi avut exact același înțeles (pentru compilator) ca și codul precedent.

În C ++, separarea dintre instrucțiuni se marcheaza cu ajutorul simbolului punct și virgulă (;) care se pune la sfarsit de instructiune, iar separarea pe diferite linii nu are nici o importanta în acest sens. Mai multe instrucțiuni pot fi scrise pe o singură linie, sau fiecare instrucțiune poate fi scrisa pe propria linie. Impartirea codului pe linii diferite servește doar pentru a-l face mai lizibil și pentru a-l schematiza pentru oamenii care il pot citi, dar nu are nici un efect asupra comportamentului real al programului.


Acum, haideți să adăugăm o instrucțiune suplimentară pentru primul nostru program:

// al doilea program al meu in C++
#include <iostream>

int main ()
{
  std::cout << "Salutare, lume! ";
  std::cout << "Eu sunt un program C++.";
}
Salutare, lume! Eu sunt un program C++.

În acest caz, programul efectuează două inserții în std::cout în două instrucțiuni diferite. Încă o dată, separarea pe diferite linii de cod, pur și simplu dă o mai mare vizibilitate la program, deoarece main ar fi putut fi perfect valabil definită si în acest fel:

1
2
#include<iostream>
int main () { std::cout << " Salutare, lume! "; std::cout << " Eu sunt un program C++. "; }

Codul sursă ar fi putut fi, de asemenea, împărțit în mai multe linii de cod:


1
2
3
4
5
6
7
8
#include<iostream>
int main ()
{
  std::cout <<
    "Salutare, lume!";
  std::cout
    << "Eu sunt un program C++.";
}

iar rezultatul ar fi fost din nou exact la fel ca în exemplele precedente.

Directivele preproces (cele care încep cu #) fac exceptie de la această regulă generală, deoarece acestea nu sunt instructiuni. Acestea sunt linii citite și prelucrate de către preprocesor inainte de a incepe compilarea corespunzătoare. Directivele preprocesorului trebuie să fie specificate în linia lor și, pentru că ele nu sunt instructiuni, nu trebuie să se termine cu punct și virgulă (;).

Comentarii

După cum s-a menționat anterior, comentariile nu afectează funcționarea programului; cu toate acestea, ele oferă un instrument important de documentare direct în codul sursă al programului privind modul în care acesta funcționează.

C ++ acceptă două moduri de comentarii in cod:

1
2
// comentariu linie
/* comentariu bloc */

Primul dintre ele, cunoscut sub numele de comentariu linie: reprezinta comentariu tot ceea ce este de la perechea de semne bară oblică (//) până la sfârșitul aceluiași rând. Cel de al doilea, cunoscut sub numele de comentariu bloc: tot ceea ce este cuprins între perechea de caractere /* și prima apariție a perechii de caractere */, cu posibilitatea de a include mai multe linii.

Să adăugăm comentarii la al doilea program al nostru:

/* al doilea program al meu in C++
   cu mai multe comentarii */

#include <iostream>

int main ()
{
  std::cout << "Salutare, lume! ";     // afiseaza Salutare, lume!
  std::cout << "Eu sunt un program C++."; // afiseaza Eu sunt un program C++
}
Salutare, lume! Eu sunt un program C++.

În cazul în care comentariile sunt incluse în codul sursă al unui program fără a utiliza combinațiile de caractere comentariu //, /* sau */, compilatorul le ia ca și când ar fi expresii C ++, cel mai probabil, provocând compilarea să eșueze si sa afiseze unul sau mai multe mesaje de eroare.

Using namespace std

Dacă ați mai văzut cod C ++ inainte, este posibil să fi văzut cout folosit în loc de std::cout. Ambele numesc același obiect: prima folosește nume necalificat (cout), în timp ce al doilea il califică direct în spațiul de nume std (astfel, std::cout).

cout este parte din biblioteca standard, iar toate elementele din biblioteca standard C ++ sunt declarate în ceea ce se numește un namespace (spatiu de nume): namespace std.

În scopul de a se referi la elementele din spațiul de nume std un program fie califică fiecare utilizare a elementelor bibliotecii (așa cum am făcut prin prefixarea cout cu std::), fie dă vizibilitate componentelor sale. Modul cel mai tipic de a da vizibilitate acestor componente se face prin utilizarea instrucțiunii using declaratii:

1
using namespace std;

Instrucțiunea de mai sus permite tuturor elementelor din spațiul de nume std să fie accesate în manieră necalificată (fără prefixul std::).

Cu aceasta în minte, ultimul exemplu poate fi rescris pentru utiliza cout necalificat astfel:

// al doilea program al meu in C++
#include <iostream>
using namespace std;

int main ()
{
  cout << "Salutare, lume! ";
  cout << "Eu sunt un program C++.";
}
Salutare, lume! Eu sunt un program C++.

Ambele modalități de accesare a elementelor spațiului de nume std namespace (calificarea explicită și folosirea instrucțiunii using) sunt valabile în C ++ și produc exact același comportament. Pentru simplitate, și pentru a îmbunătăți lizibilitatea, exemplele din acest tutorial vor folosi mai des această din urmă abordare (cu instructiunea using, deși calificarea explicită este singura modalitate care garantează că nu se produc coliziuni de nume.

Spațiile de nume sunt explicate în detaliu într-un capitol ulterior.
Index
Index