C++ de la zero: primul tău program

C++ este un limbaj rapid, aproape de calculator, folosit acolo unde contează fiecare milisecundă: motoare de joc, simulări, programe de sistem și multe module de servere de joc. Nu e cel mai blând limbaj pentru început, dar îți arată ce se întâmplă „sub capotă”. În acest ghid mergi pas cu pas, cu exemple mici.

Ce este C++ și unde se folosește

Un program C++ este text scris de tine. Un compilator îl transformă într-un fișier executabil, pe care îl rulezi direct. Spre deosebire de JavaScript sau Python, nu există un interpretor care să citească codul la fiecare rulare: de aceea programele C++ pornesc repede și merg repede.

• Motoare de joc și jocuri cu grafică mare.
• Programe care lucrează cu multă memorie sau cu hardware.
• Biblioteci folosite apoi din alte limbaje.
• Concursuri de algoritmi, unde viteza contează.

Instalarea unui compilator. Ai nevoie de un compilator. Pe Windows ai două drumuri comune; alege unul singur.

• g++ din MinGW-w64 (de exemplu prin MSYS2): compilatorul GNU, același care se folosește pe Linux. Detalii pe www.mingw-w64.org și gcc.gnu.org.
• MSVC, compilatorul Microsoft, din Visual Studio sau din „Build Tools”. Se instalează de pe visualstudio.microsoft.com, bifând componenta pentru dezvoltare desktop în C++.

Primul program

Creează un fișier numit main.cpp și pune în el codul de mai jos. Fiecare program C++ începe din funcția main.

#include <iostream>

int main() {
    std::cout << "Salut, DominosLand!" << std::endl;
    return 0;
}

Salut, DominosLand!

Ce face fiecare linie: #include <iostream> aduce biblioteca pentru afișare și citire. std::cout trimite text în fereastra terminalului, iar std::endl trece pe rândul următor. return 0 spune sistemului că programul s-a terminat fără erori.

Compilare și rulare

1. 1Deschide un terminal în folderul cu main.cpp.
2. 2Cu g++: scrie g++ -std=c++17 -Wall -Wextra main.cpp -o main și apasă Enter. Opțiunea -Wall cere avertismente utile.
3. 3Cu MSVC: deschide „Developer Command Prompt for VS” și scrie cl /EHsc /std:c++17 main.cpp.
4. 4Rulează programul: în PowerShell scrie .\main.exe, în Command Prompt scrie main.exe, iar pe Linux ./main. PowerShell nu rulează programe din folderul curent decât dacă le pui în față .\ .
5. 5Ai modificat codul? Compilează din nou. Fișierul executabil nu se schimbă singur.

Variabile și tipuri

O variabilă este o cutie cu nume în care ții o valoare. În C++ spui tipul cutiei: număr întreg, număr cu zecimale, text, adevărat sau fals. Tipul nu se schimbă după ce l-ai ales.

#include <iostream>
#include <string>

int main() {
    std::string nume = "Alex";
    int nivel = 5;
    double xp = 1250.5;
    bool online = true;
    char clasa = 'M';

    std::cout << nume << " este nivel " << nivel << std::endl;
    std::cout << "XP: " << xp << ", clasa: " << clasa << std::endl;
    std::cout << "Online: " << online << std::endl;
    return 0;
}

Alex este nivel 5
XP: 1250.5, clasa: M
Online: 1

Observă că un bool se afișează ca 1 (adevărat) sau 0 (fals). Textul se ține în std::string și cere #include <string>. Un singur caracter se pune între apostrofuri, textul între ghilimele.

Citirea de la tastatură. std::cin citește ce scrie utilizatorul. Pentru un cuvânt sau un număr folosești >>. Pentru o linie întreagă, cu spații, folosești std::getline.

#include <iostream>
#include <string>

int main() {
    std::string nume;
    int varsta = 0;

    std::cout << "Cum te cheamă? ";
    std::getline(std::cin, nume);
    std::cout << "Câți ani ai? ";
    std::cin >> varsta;

    std::cout << "Salut, " << nume << "! Peste un an vei avea " << varsta + 1 << " ani." << std::endl;
    return 0;
}

Condiții. Cu if și else programul alege între variante. Comparațiile sunt ==, !=, <, >, <= și >=. Le legi cu && („și”) și || („sau”).

#include <iostream>

int main() {
    int xp = 320;

    if (xp >= 1000) {
        std::cout << "Veteran" << std::endl;
    } else if (xp >= 300) {
        std::cout << "Avansat" << std::endl;
    } else {
        std::cout << "Începător" << std::endl;
    }
    return 0;
}

Avansat

Bucle. O buclă repetă cod. for se potrivește când știi de câte ori, while când repeți cât timp o condiție rămâne adevărată.

#include <iostream>

int main() {
    for (int i = 1; i <= 3; i++) {
        std::cout << "Runda " << i << std::endl;
    }

    int viata = 10;
    while (viata > 0) {
        viata -= 4;
        std::cout << "Viață rămasă: " << viata << std::endl;
    }
    return 0;
}

Runda 1
Runda 2
Runda 3
Viață rămasă: 6
Viață rămasă: 2
Viață rămasă: -2

Funcții. O funcție este o bucată de cod cu nume, pe care o poți apela de câte ori vrei. Are tip de întoarcere, nume și parametri. Funcția trebuie scrisă înainte de locul în care o folosești.

#include <iostream>
#include <string>

int patrat(int x) {
    return x * x;
}

void saluta(const std::string& nume) {
    std::cout << "Salut, " << nume << "!" << std::endl;
}

int main() {
    std::cout << patrat(7) << std::endl;
    saluta("echipa");
    return 0;
}

49
Salut, echipa!

Vectori: liste care cresc. std::vector ține mai multe valori de același tip, într-o ordine. Îl poți extinde cu push_back și îl parcurgi cu un for de tip „pentru fiecare”.

#include <iostream>
#include <string>
#include <vector>

int main() {
    std::vector<std::string> jocuri = {"Minecraft", "FiveM"};
    jocuri.push_back("CS2");

    std::cout << "Avem " << jocuri.size() << " jocuri:" << std::endl;
    for (const std::string& joc : jocuri) {
        std::cout << "- " << joc << std::endl;
    }
    return 0;
}

Avem 3 jocuri:
- Minecraft
- FiveM
- CS2

Referințe, pe scurt. În mod normal, o funcție primește o copie a valorii. Dacă pui & după tip, primește chiar variabila originală și o poate modifica. Cu const & citești fără să copiezi și fără să poți strica nimic: ideal pentru texte și vectori mari.

#include <iostream>

void adaugaBonus(int& xp, int bonus) {
    xp += bonus;
}

int main() {
    int xp = 100;
    adaugaBonus(xp, 50);
    std::cout << xp << std::endl;
    return 0;
}

150

Structuri și clase

O struct grupează mai multe valori sub un nume. O clasă face același lucru și, în plus, poate ascunde datele (private) și le poate expune doar prin metode (public).

#include <iostream>
#include <string>

class Jucator {
public:
    Jucator(const std::string& nume) : nume_(nume), xp_(0) {}

    void adaugaXp(int cantitate) { xp_ += cantitate; }
    int xp() const { return xp_; }
    const std::string& nume() const { return nume_; }

private:
    std::string nume_;
    int xp_;
};

int main() {
    Jucator j("Alex");
    j.adaugaXp(120);
    j.adaugaXp(30);
    std::cout << j.nume() << " are " << j.xp() << " XP" << std::endl;
    return 0;
}

Alex are 150 XP

Constructorul poartă numele clasei și pornește obiectul într-o stare validă. Cuvântul const după o metodă promite că ea doar citește, nu schimbă obiectul.

Pointeri, foarte pe scurt. Un pointer este o variabilă care ține adresa altei variabile. Îl creezi cu * și afli adresa cu &. Pentru început, preferă referințele și vectorii; pointerii îi vei întâlni în codul altora.

#include <iostream>

int main() {
    int viata = 10;
    int* p = &viata;
    *p = 20;
    std::cout << viata << std::endl;

    int* gol = nullptr;
    if (gol == nullptr) {
        std::cout << "pointer fără țintă" << std::endl;
    }
    return 0;
}

20
pointer fără țintă

Erori frecvente la compilare

• expected ; before ...: ai uitat punctul și virgula la finalul unei instrucțiuni. Eroarea apare adesea pe linia următoare.
• was not declared in this scope (sau undeclared identifier la MSVC): ai scris greșit un nume sau ai uitat un #include.
• no match for operator<<: încerci să afișezi un tip pe care cout nu îl cunoaște, cum ar fi o clasă proprie.
• undefined reference to main: lipsește funcția main sau ai compilat un fișier greșit (MinGW scrie undefined reference to WinMain, MSVC scrie unresolved external symbol main).
• Mesajele lungi: citește primul mesaj de eroare și ignoră restul; celelalte sunt adesea consecințe.

Mini-proiect: nivelul din XP

Punem tot la un loc. Un jucător începe la nivelul 1. Pentru nivelul 2 are nevoie de 100 XP, apoi fiecare nivel cere cu 50 XP mai mult decât cel dinainte. Programul calculează nivelul, XP-ul din nivelul curent și cât cere nivelul următor. Rezultatul e același la fiecare rulare, deci îl poți verifica.

#include <iostream>
#include <vector>

struct Rezultat {
    int nivel;
    int xpInNivel;
    int necesar;
};

Rezultat calculeaza(int xp) {
    Rezultat r{1, xp, 100};
    while (r.xpInNivel >= r.necesar) {
        r.xpInNivel -= r.necesar;
        r.nivel++;
        r.necesar += 50;
    }
    return r;
}

int main() {
    std::vector<int> valori = {0, 99, 100, 250, 1000, 1500};
    for (int xp : valori) {
        Rezultat r = calculeaza(xp);
        std::cout << "XP " << xp << " -> nivel " << r.nivel
                  << " (" << r.xpInNivel << "/" << r.necesar << ")" << std::endl;
    }
    return 0;
}

XP 0 -> nivel 1 (0/100)
XP 99 -> nivel 1 (99/100)
XP 100 -> nivel 2 (0/150)
XP 250 -> nivel 3 (0/200)
XP 1000 -> nivel 6 (0/350)
XP 1500 -> nivel 7 (150/400)

Încearcă să schimbi regula (de exemplu +80 XP pe nivel) sau să citești XP-ul de la tastatură, cu ce ai învățat mai sus. Dacă rezultatul tău diferă de cel din ghid, verifică ordinea celor trei linii din buclă.

Pașii următori

• Citește pe pagina cppreference câte o funcție din biblioteca standard când ai nevoie de ea.
• Împarte un program mare în mai multe fișiere (.h și .cpp).
• Învață std::map și algoritmii din <algorithm>, ca sort.
• Dacă te atrage partea de control al memoriei, compară cu Rust, care ia acea responsabilitate pe compilator.

• Rust de la zeroAlt limbaj rapid, cu reguli stricte despre memorie
• Plugin Minecraft cu PaperPrima ta modificare de joc, în Java
• Traseu de învățare
• Referință C++ (cppreference)Documentația completă a limbajului
• Compilatorul GCC