> For the complete documentation index, see [llms.txt](https://ase.lucianvilcea.ro/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://ase.lucianvilcea.ro/home/programare-orientata-obiect/recapitulare-c++/editor.md).

# Sintaxa C++

Dacă te-ai întrebat vreodată cum arată un program C++ și ce înseamnă toate acele simboluri și cuvinte ciudate, ai ajuns la locul potrivit! În acest articol vom înțelege structura de bază a unui program C++.

Să începem cu cel mai simplu program posibil:

```cpp
#include <iostream>

int main() {
    // Afișează text pe ecran
    std::cout << "Salut!" << std::endl;
    return 0;
}
```

Pare complicat? Nu te îngrijora! Să analizăm fiecare linie în parte.

### Ce înseamnă #include?

```cpp
#include <iostream>
```

Această linie se numește **directivă de preprocesor**. Gândește-te la ea ca la o instrucțiune pentru calculator, care-l face capabil să înțeleagă instrucțiuni pe care nu le-ai definit tu: "Înainte să compilezi programul meu, adaugă toate funcționalitățile din biblioteca `iostream`".

`iostream` vine de la "input/output stream" și conține funcțiile necesare pentru a citi de la tastatură și a afișa pe ecran. Fără această linie, nu ai putea, de exemplu, să folosești `std::cout` pentru a afișa text pe ecran.

**Regulă importantă**: Toate directivele `#include` se scriu la începutul programului, înainte de orice altceva.

### Funcția main()

Funcția `main()` este punctul de pornire al oricărui program C++. Când rulezi programul, calculatorul caută automat funcția `main()` și începe să execute instrucțiunile din ea.

```cpp
int main() {    
    return 0;
}
```

Să analizăm sintaxa:

* `int` - reprezintă tipul returnat de funcție. În cazul nostru, funcția va returna un număr întreg
* `main` - numele funcției (obligatoriu să fie exact așa)
* `()` - parantezele rotunde indică faptul că următorul bloc este o funcție
* `{}` - definește un bloc de instrucțiuni
* `return 0;` - spune sistemului că programul s-a terminat cu succes

### Acoladele

```cpp
{
    // Tot ce e între aceste acolade face parte din funcția main
    std::cout << "Salut!" << std::endl;
    return 0;
}
```

Acoladele `{` și `}` delimitează **blocul de cod** care aparține funcției `main()`. Tot ce scrii între aceste acolade se va executa când programul rulează. De cele mai multe ori, acestea definesc totodată și un **scop**. Vom discuta în detaliu importanța scopurilor în secțiunea dedicată variabilelor.

**Atenție**: Fiecare acoladă deschisă `{` trebuie să aibă perechea ei închisă `}`!

### Afișarea pe ecran

```cpp
std::cout << "Salut!" << std::endl;
```

Această linie afișează textul "Salut!" pe ecran. Să o descompunem:

* `std::cout` - obiectul folosit pentru afișare pe ecran
* `<<` - operatorul de inserție (gândește-te că "inserezi" textul în fluxul de afișare)
* `"Salut!"` - textul pe care vrei să-l afișezi (între ghilimele!)
* `std::endl` - trece la rândul următor (ca și Enter)
* `;` - punct și virgulă care marchează sfârșitul instrucțiunii

### Punctul și virgula

În C++, aproape fiecare instrucțiune se termină cu `;`. Este ca punctul de la sfârșitul unei propoziții - spune compilatorului că instrucțiunea s-a terminat.

```cpp
std::cout << "Prima linie" << std::endl;
std::cout << "A doua linie" << std::endl;
std::cout << "A treia linie" << std::endl;
```

### Comentariile

```cpp
// Acesta este un comentariu pe o singură linie

/*
Acesta este un comentariu
pe mai multe linii
*/

int main() {
    std::cout << "Salut!" << std::endl; // Comentariu la sfârșitul liniei
    return 0;
}
```

Comentariile sunt ignorare complet de către compilator. Le folosești pentru a-ți lăsa notițe sau pentru a explica ce face codul. Utilizarea acestora nu este recomandată în practică, deoarece "poluează" vizual și fac codul mai greu de parcurs. În general, este de preferat ca însuși codul să fie suficient de ușor de înteles astfel încât să se explice singur.

## Utilizarea numelor de domeniu

În C++, pentru a evita specificarea explicită a spațiului de nume `std` de fiecare dată când sunt utilizate funcții și clase din biblioteca standard, poți folosi direct directiva `using namespace std`. Aceasta permite utilizarea elementelor din `std` fără a mai folosi prefixul `std::`. Iată cum se aplică:

```cpp
#include <iostream>

using namespace std;

int main() {
    // Acum putem folosi `cout` și `endl` fără `std::`
    cout << "Bine ai venit!" << endl;
    return 0;
}
```

Nu-ți face griji dacă nu înțelegi însă cum funcționează numele de domeniu. Vom discuta în detaliu ce sunt ele și cum putem defini propriile nume de domeniu într-un capitol viitor.

**Notă**: În proiectele mari, folosirea necontrolată a acestei directive poate duce la conflicte de nume, așa că este recomandat să îl folosești cu precauție.

## Un exemplu mai complex

```cpp
#include <iostream>

using namespace std;

int main() {
    // Afișează un mesaj de întâmpinare
    cout << "Bun venit la cursul de POO!" << endl;
    
    // Afișează o linie goală
    cout << endl;
    
    // Afișează mai multe linii
    cout << "Acesta este primul meu program!" << endl;
    cout << "Este foarte simplu, nu-i așa?" << endl;
    
    // Sfârșitul programului
    return 0;
}
```

## Regulile de bază ale sintaxei C++

1. **Case-sensitive**: `main` și `Main` sunt lucruri diferite
2. **Spații albe**: poți adăuga spații, tab-uri și linii goale pentru claritate
3. **Punct și virgulă**: obligatoriu la sfârșitul instrucțiunilor
4. **Acolade**: trebuie să fie echilibrate
5. **Ghilimele**: textul se pune între `"ghilimele"`

## Exercițiu pentru tine

Încearcă să scrii un program care afișează:

```
Nume: [numele tău]
Vârsta: [vârsta ta]
Hobby: Programarea în C++
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://ase.lucianvilcea.ro/home/programare-orientata-obiect/recapitulare-c++/editor.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.