Nou Generator de prompt AI — scrie prompturi mai bune pentru ChatGPT, Claude și Gemini →
C++

Învață C++: comenzi explicate cu exemple

423 de comenzi 44 de categorii Comunitate & Q&A

C++ este limbajul de programare compilat de uz general, tipizat static și de nivel înalt cu capabilități de nivel scăzut, creat în 1979 de informaticianul danez Bjarne Stroustrup la Bell Labs ca o extensie orientată pe obiecte a limbajului C („C with Classes”). Astăzi, C++ este fundamentul pe care sunt construite motoarele grafice de jocuri AAA (Unreal Engine), sistemele de operare (nucleul Windows, macOS, Android), sistemele financiare de tranzacționare de înaltă frecvență (HFT), motoarele de căutare web, bazele de date distribuite și bibliotecile de calcul pentru Inteligență Artificială (PyTorch, TensorFlow, CUDA).

Puterea inegalabilă a limbajului C++ derivă din Principiul Costului Zero (Zero-Overhead Principle) enunțat de creatorul său: „Ce nu folosești, nu plătești; iar ce folosești, nu ai fi putut scrie manual mai rapid sau mai eficient în limbaj de asamblare”. C++ oferă control total și determinist asupra fiecărui octet de memorie, acces direct la instrucțiuni hardware (SIMD, registre de sistem), compilare nativă direct în cod mașină binar fără runtime sau Garbage Collector (GC), combinat simultan cu cele mai avansate abstracțiuni declarative la timpul compilării (Compile-Time Metaprogramming).

Pilonul Stabilității C++: Idiomul RAII (Resource Acquisition Is Initialization)
// În C++, resursele (memorie pe heap, lock-uri de mutex, descriptori de fișiere, socket-uri de rețea)
// sunt legate indisolubil de durata de viață (scope) a unui obiect alocat pe stivă (Stack).
// Constructorul achiziționează resursa, iar Destructorul o eliberează AUTOMAT când obiectul iese din scope,
// chiar dacă funcția se termină devreme cu 'return' sau aruncă o excepție!

#include <iostream>
#include <fstream>
#include <memory>
#include <mutex>

void proceseazaDateSecurizat(std::mutex& mtx, const std::string& caleFisier) {
    // 1. Mutex-ul este blocat în constructor:
    std::scoped_lock lock(mtx);

    // 2. Fișierul este deschis în constructor:
    std::ofstream fisier(caleFisier);
    if (!fisier.is_open()) {
        throw std::runtime_error("Eroare la deschiderea fisierului!");
    }

    fisier << "Date critice scrise pe disc.
";

    // 3. LA IEȘIREA DIN BLOC (sau la aruncarea excepției):
    //    - destructorul 'fisier' închide automat stream-ul de pe disc;
    //    - destructorul 'lock' deblochează automat mutex-ul 'mtx'.
    // ZERO memory leaks, ZERO deadlocks!
}

Evoluția Limbajului: De la C++11 la Revoluția C++20 și C++23

Standardizarea C++ cunoaște o evoluție rapidă pe un ciclu fix de 3 ani, transformând C++-ul modern într-un limbaj complet diferit de C-ul tradițional:

  • C++11 / C++14 (Renașterea Modernă): A introdus Move Semantics (eliminarea copierilor inutile de memorie prin referințe rvalue &&), deducerea automată de tipuri cu auto, expresii Lambda funcționale, pointeri inteligenți fără overhead (std::unique_ptr, std::shared_ptr), calcul la compilare cu constexpr și biblioteca standard nativă de fire de execuție (std::thread, std::atomic).
  • C++17: A simplificat lucrul cu date opționale și eterogene prin std::optional, std::variant, std::any, manipularea fără alocare a șirurilor prin std::string_view, sistemul de fișiere portabil std::filesystem și atribuirea structurată (Structured Bindings: auto [cheie, valoare] = map_element;).
  • C++20 (Cea mai mare revoluție):
    • Concepte (Concepts): Constrângeri formale asupra parametrilor de șablon la compilare (înlocuiesc tehnicile greoaie și erorile kilometrice de tip SFINAE cu mesaje de eroare clare și precise).
    • Coroutine (Coroutines): Funcții asincrone cooperatiste care pot fi suspendate și reluate la cerere prin co_await, co_yield și co_return fără alocare de thread-uri noi de sistem de operare.
    • Module (C++ Modules): Eliminarea fișierelor lente de header #include în favoarea importurilor compilate modular (import std;), reducând timpii de compilare cu până la 500%.
    • Ranges & Views: Procesare funcțională, curată și leneșă (lazy evaluation) a colecțiilor de date folosind operatorul de conductă (pipe |).
  • C++23: A adăugat gestionarea monadică a erorilor fără excepții prin std::expected, formatarea modernă și rapidă de tip-sigur prin biblioteca <print> (std::print), matrici multidimensionale contigue prin std::mdspan și generatorul de coroutine std::generator.

Semantica de Mutare (Move Semantics): Transfer de Proprietate în $O(1)$

Înainte de C++11, returnarea sau transmiterea unui container mare (cum ar fi un std::vector<int> cu 10 milioane de elemente) presupunea copierea profundă (Deep Copy) a fiecărui element de pe heap. Semantica de mutare rezolvă această ineficiență prin transferarea directă a pointerilor interni:

Deep Copy ($O(N)$ lent) vs Move Semantics ($O(1)$ instantaneu)
std::vector<int> dateMari(10'000'000, 42); // Alocă 40 MB de memorie pe Heap

// 1. COPIERE PROFUNDĂ (Deep Copy - O(N)):
// Alocă alți 40 MB de memorie pe heap și copiază fiecare număr în parte:
std::vector<int> dateCopiate = dateMari; 

// 2. MUTARE PRIN TRANSFER (Move Semantics - O(1)):
// Copiază doar 3 pointeri interni (început, sfârșit, capacitate = 24 octeți pe stivă!).
// Obiectul sursă 'dateMari' devine gol, iar noul vector deține instant memoria deja alocată:
std::vector<int> dateMutate = std::move(dateMari);

Tabel Comparativ: Organizarea Memoriei în C++

Zonă de Memorie Alocare / Dezalocare Viteză de Acces Gestionare și Riscuri
Stivă (Stack) Automate (la intrarea și ieșirea din blocul curent de cod). Maximă (datele sunt aproape întotdeauna prezente în cache-ul L1/L2 al procesorului). Spațiu limitat (tipic 1-8 MB). Risc de Stack Overflow la recursivitate adâncă sau alocări locale gigantice.
Grămadă (Heap / Free Store) Dinamică (prin new/delete sau containere STL precum std::vector). Mai lentă (dereferențiere de pointeri, posibilă fragmentare de memorie). Spațiu vast (limitat doar de memoria RAM a sistemului). Se gestionează exclusiv prin Smart Pointers (std::unique_ptr) pentru a preveni memory leaks.
Statică / Globală La pornirea programului, eliberată la închiderea procesului. Viteză nativă stabilă. Risc de Static Initialization Order Fiasco dacă variabilele globale depind unele de altele între unități de compilare diferite.

Formatare 11 comenzi

Valori opționale și alternative (optional, variant, expected) 9 comenzi

Ranges și views 16 comenzi

Perechi, tupluri și span 9 comenzi

Containere asociative (map, set) 16 comenzi

Excepții și erori 10 comenzi

Fire de execuție și sincronizare 20 de comenzi

Funcții și lambda 4 comenzi

Pointeri inteligenți și memorie 11 comenzi

Șabloane (template) și concepte 6 comenzi

Utilitare (utility) 8 comenzi

Bazele programului 7 comenzi

Tipuri de date 17 comenzi

Constante și specificatori 10 comenzi

Structuri de control 10 comenzi

Clase și obiecte 8 comenzi

Memorie, pointeri și referințe 4 comenzi

Excepții 3 comenzi

Operatori alternativi și preprocesor 5 comenzi

Afișare și citire 7 comenzi

Fișiere și fluxuri 13 comenzi

Șiruri de caractere (std::string) 22 de comenzi

Conversii între text și numere 5 comenzi

Caractere și șiruri C 9 comenzi

Intrare/ieșire în stil C 5 comenzi

Expresii regulate 5 comenzi

std::vector 18 comenzi

Alte containere secvențiale 9 comenzi

Containere neordonate (hash) 4 comenzi

Adaptoare: stack, queue, priority_queue 3 comenzi

Iteratori 9 comenzi

Sortare și căutare 14 comenzi

Algoritmi de modificare 17 comenzi

Minim, maxim și comparații 11 comenzi

Mulțimi și heap 6 comenzi

Numerice (accumulate, reduce...) 9 comenzi

Matematică (cmath) 16 comenzi

Numere aleatorii 8 comenzi

Utilitare C (cstdlib) 6 comenzi

Limite, biți și constante 9 comenzi

Funcții ca valori 8 comenzi

Timp (chrono) 6 comenzi

Fișiere și directoare (filesystem) 9 comenzi

Tipuri: traits, concepte, întregi cu mărime fixă 11 comenzi

Index complet de funcții, clase și algoritmi C++ (Standard C++20 / C++23)

Consultați referința completă a limbajului C++ modern: de la tipuri de bază, clase și pointeri inteligenți (std::unique_ptr, std::shared_ptr), până la containere STL, algoritmi de căutare/sortare, Ranges & Views, multithreading și noutățile din standardul C++23:

Adaptoare: stack, queue, priority_queue (3)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::priority_queue Coadă cu priorități: top() returnează mereu elementul cel mai mare (sau cel mai mic, cu std::greater).
std::queue Coadă (FIFO): adaugi la coadă cu push și servești de la început cu front și pop.
std::stack Stivă (LIFO): adaugi deasupra cu push, citești vârful cu top și îl scoți cu pop.

Afișare și citire (7)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::cerr Scrie mesaje de eroare și de jurnal pe canalul de eroare, separat de ieșirea normală.
std::cin Citește valori de la tastatură în variabile, cu operatorul >>.
std::cout Afișează text și valori în consolă, cu operatorul
std::endl Trece pe rândul următor și golește bufferul; std::flush doar golește bufferul.
std::getline Citește un rând întreg, cu spații cu tot, într-un std::string.
std::print Afișează text formatat cu acolade {}, fără rând nou la final (C++23).
std::println Afișează text formatat cu acolade {} și trece pe rândul următor (C++23).

Algoritmi de modificare (17)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::copy Copiază elementele unui interval (copy) sau primele n elemente (copy_n) la o destinație.
std::copy_if Copiază doar elementele care îndeplinesc o condiție, păstrând ordinea lor.
std::fill Atribuie aceeași valoare tuturor elementelor unui interval (fill) sau primelor n elemente (fill_n).
std::for_each Aplică o funcție fiecărui element dintr-un interval, de exemplu pentru afișare sau modificare.
std::generate Completează un interval cu valorile returnate de apeluri succesive ale unei funcții.
std::move Mută elementele unui interval la o destinație, fără să le copieze (versiunea din ).
std::partition Împarte elementele în două grupuri: întâi cele care îndeplinesc condiția, apoi celelalte.
std::remove Mută la final elementele egale cu o valoare și returnează noul sfârșit; ștergerea reală se face cu erase.
std::remove_if Elimină logic elementele care îndeplinesc o condiție; folosit cu erase sau înlocuit de std::erase_if (C++20).
std::replace Înlocuiește pe loc toate elementele egale cu o valoare (replace) sau care îndeplinesc o condiție (replace_if).
std::reverse Inversează pe loc ordinea elementelor dintr-un interval.
std::rotate Rotește elementele astfel încât middle devine primul element, iar cele dinaintea lui trec la final.
std::sample Alege aleatoriu n elemente distincte dintr-un interval și le copiază la destinație.
std::shuffle Amestecă aleatoriu elementele unui interval folosind un generator de numere aleatorii.
std::swap_ranges Schimbă între ele elementele a două intervale de aceeași lungime, poziție cu poziție.
std::transform Aplică o funcție fiecărui element și scrie rezultatele în alt interval (sau în același).
std::unique Elimină duplicatele aflate unul lângă altul; după sortare, elimină toate duplicatele.

Alte containere secvențiale (9)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::array Tablou cu dimensiune fixă, cunoscută la compilare, cu interfața unui container (size, at, begin, end).
std::bitset Șir de N biți cu dimensiune fixă: setezi, ștergi și numeri biți, cu conversie în text sau în număr.
std::deque Coadă cu două capete: adăugare și ștergere rapidă atât la început, cât și la sfârșit, plus acces după poziție.
std::forward_list Listă simplu înlănțuită: fiecare nod știe doar de următorul. Ocupă mai puțină memorie decât std::list.
std::list Listă dublu înlănțuită: inserare și ștergere rapidă oriunde, fără invalidarea celorlalte elemente, dar fără acces după poziție.
std::list::remove remove() șterge din listă toate elementele egale cu o valoare; unique() șterge duplicatele consecutive.
std::list::sort sort() sortează lista schimbând doar legăturile dintre noduri; reverse() inversează ordinea elementelor.
std::list::splice splice() mută noduri dintr-o listă în alta fără copiere; merge() interclasează două liste sortate.
std::to_array Creează un std::array dintr-un tablou C sau dintr-o listă, cu dimensiunea dedusă automat.

Bazele programului (7)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
asm Inserează instrucțiuni în limbaj de asamblare direct în codul C++; sintaxa și instrucțiunile depind de compilator și de procesor.
extern Declară o variabilă sau funcție definită în altă parte (de obicei în alt fișier) sau cere legare în stilul limbajului C.
main Funcția cu care începe orice program C++: sistemul o apelează la pornire, iar valoarea returnată spune dacă programul a reușit.
module, import, export Modulele (C++20) înlocuiesc fișierele antet: un modul exportă ce vrea să fie vizibil, iar alt fișier îl folosește cu import.
namespace Grupează funcții, clase și variabile sub un nume comun, ca să nu se încurce cu alte nume identice din program sau din biblioteci.
typedef Creează un nume nou (alias) pentru un tip existent; forma veche, moștenită din C, a lui using.
using Aduce nume dintr-un spațiu de nume în locul curent sau creează un nume nou (alias) pentru un tip existent.

Caractere și șiruri C (9)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::isalpha Verifică tipul unui caracter: literă, cifră, spațiu, majusculă, minusculă sau punctuație.
std::memcmp Compară n octeți din două zone de memorie: 0 dacă sunt identici.
std::memcpy Copiază n octeți dintr-o zonă de memorie în alta; memmove permite zone suprapuse.
std::memset Umple n octeți de memorie cu aceeași valoare, de obicei pentru a pune totul pe zero.
std::strchr Caută un caracter (strchr) sau un text (strstr) într-un șir C și returnează pointer la el.
std::strcmp Compară două șiruri C: 0 dacă sunt egale, negativ sau pozitiv după ordinea lor.
std::strcpy Copiază (strcpy, strncpy) sau lipește (strcat) șiruri C în tablouri de char.
std::strlen Returnează lungimea unui șir C, numărând octeții până la terminatorul \0.
std::toupper Transformă o literă în majusculă (toupper) sau minusculă (tolower); restul rămân neschimbate.

Clase și obiecte (8)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
class Definește un tip nou care grupează date (membri) și funcțiile care lucrează cu ele (metode); baza programării orientate pe obiecte.
explicit Interzice folosirea unui constructor sau a unui operator de conversie pentru conversii automate, ascunse.
friend Dă unei funcții sau altei clase acces la membrii privați și protejați ai clasei.
override, final override cere compilatorului să verifice că metoda chiar suprascrie una virtuală; final oprește suprascrierea sau moștenirea mai departe.
public, private, protected Specificatorii de acces: stabilesc cine poate folosi membrii unei clase și cum se moștenește o clasă de bază.
struct Grupează mai multe valori într-un singur tip; ca o clasă, dar cu membri publici implicit.
this Pointer către obiectul curent, disponibil în orice metodă nestatică a unei clase.
virtual Marchează o metodă care poate fi suprascrisă în clasele derivate; apelul printr-un pointer sau o referință la bază alege varianta tipului real.

Constante și specificatori (10)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
const Marchează o valoare care nu mai poate fi modificată după inițializare; compilatorul oprește orice încercare de schimbare.
consteval Definește o funcție imediată: fiecare apel trebuie calculat la compilare, altfel programul nu se compilează.
constexpr Cere ca o valoare să fie calculată la compilare; o funcție constexpr poate rula atât la compilare, cât și la rulare.
constinit Garantează că o variabilă globală sau statică este inițializată la compilare, dar fără să o facă constantă.
inline Permite ca o funcție sau variabilă să fie definită în mai multe fișiere (de obicei într-un antet) fără eroare de definiție dublă.
mutable Permite modificarea unui membru chiar și în metode const sau modificarea variabilelor capturate prin copie într-o lambda.
register Fost specificator care sugera păstrarea variabilei într-un registru al procesorului; a fost eliminat în C++17, dar cuvântul rămâne rezervat.
static Are trei sensuri: variabilă locală care își păstrează valoarea între apeluri, membru comun al clasei sau nume vizibil doar în fișierul curent.
thread_local Fiecare fir de execuție (thread) primește propria copie a variabilei, creată când pornește firul și distrusă la final.
volatile Spune compilatorului că valoarea se poate schimba din afara programului, deci fiecare citire și scriere trebuie făcută efectiv.

Containere asociative (map, set) (16)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
Containere Asociative Secvențiale Cache-Friendly cu std::flat_map în C++23 Ghid de performanță pentru std::flat_map și std::flat_set în C++23: stocarea cheilor și valorilor în vectori paraleli contigui în loc de arbori roșu-negru nodali, maximizând localitatea cache-ului CPU (L1/L2) și căutarea binară ultra-rapidă.
std::flat_map Dicționar ordonat ca std::map, dar ținut în doi vectori sortați: căutare și parcurgere rapide, inserare mai lentă.
std::map Dicționar ordonat: asociază fiecărei chei unice o valoare și păstrează cheile sortate.
std::map::at Returnează valoarea unei chei existente; aruncă std::out_of_range dacă cheia nu există, fără să o adauge.
std::map::erase Șterge din map o cheie (cu valoarea ei), elementul indicat de un iterator sau un interval.
std::map::extract extract() scoate un nod din map fără să-l distrugă (îi poți schimba cheia); merge() mută nodurile din alt map.
std::map::find find() caută o cheie și returnează un iterator la ea sau end(); count() și contains() spun doar dacă există.
std::map::insert Adaugă o pereche cheie-valoare doar dacă cheia nu există; spune prin rezultat dacă a adăugat-o.
std::map::lower_bound lower_bound() găsește prima cheie mai mare sau egală cu valoarea dată, upper_bound() prima cheie strict mai mare.
std::map::try_emplace try_emplace adaugă doar dacă cheia lipsește; insert_or_assign adaugă sau înlocuiește și spune ce a făcut.
std::multimap Ca std::map, dar aceeași cheie poate apărea de mai multe ori, cu valori diferite.
std::multiset Mulțime ordonată care permite valori repetate; util pentru valori sortate cu frecvență.
std::set Mulțime ordonată de valori unice: elimină automat duplicatele și păstrează elementele sortate.
std::set::erase Șterge din set o valoare, elementul indicat de un iterator sau un interval de elemente.
std::set::find Caută o valoare în set: find() returnează un iterator (sau end()), contains() și count() spun dacă există.
std::set::insert Adaugă o valoare în set dacă nu există deja și spune prin rezultat dacă a fost adăugată.

Containere neordonate (hash) (4)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::unordered_map Dicționar bazat pe tabelă hash: căutare în timp mediu constant, dar fără o ordine anume a elementelor.
std::unordered_map::reserve reserve() pregătește tabela hash pentru n elemente; bucket_count() și load_factor() arată cât de încărcată este.
std::unordered_multimap Tabelă hash care permite aceeași cheie de mai multe ori; elementele nu au o ordine anume.
std::unordered_set Mulțime de valori unice bazată pe hash: verificare „există?” în timp mediu constant, fără ordine.

Conversii între text și numere (5)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::from_chars Citește un număr dintr-un text, foarte rapid, fără excepții, cu raport exact despre erori.
std::stod Transformă un text într-un număr real: stod în double, stof în float.
std::stoi Transformă un text în număr întreg (int, long, long long, unsigned long), cu excepții la erori.
std::to_chars Scrie un număr ca text într-un tablou de char, foarte rapid, fără alocări și fără excepții.
std::to_string Transformă un număr în std::string, de exemplu 42 în „42”.

Excepții (3)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
noexcept Marchează o funcție care promite că nu aruncă excepții; ca operator, verifică la compilare dacă o expresie poate arunca.
throw Aruncă o excepție: oprește execuția normală și trimite eroarea la cel mai apropiat catch potrivit.
try, catch try marchează codul care poate arunca o excepție, iar blocurile catch prind și tratează excepțiile de un anumit tip.

Excepții și erori (10)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
assert Verifică o condiție care trebuie să fie mereu adevărată; dacă e falsă, oprește programul cu un mesaj.
Capturarea Programatică a Urmei Apelurilor cu std::stacktrace în C++23 Ghid de depanare modernă în C++23 cu biblioteca : capturarea automată a stivei de apeluri (call stack) la apariția unei erori sau a unei excepții, afișarea numelui fișierului, funcției și numărului liniei fără utilitare externe.
std::current_exception Salvează excepția prinsă într-un exception_ptr, ca să fie aruncată din nou mai târziu, chiar pe alt fir.
std::exception Clasa de bază a tuturor excepțiilor din biblioteca standard; what() returnează mesajul erorii.
std::invalid_argument Excepție pentru un argument cu valoare nepermisă, de exemplu text care nu este număr la std::stoi.
std::logic_error Excepție pentru greșeli de logică ce puteau fi evitate prin cod corect; domain_error: valoare în afara domeniului.
std::out_of_range Excepție aruncată când un index sau o cheie este în afara limitelor (vector::at, string::substr, map::at).
std::overflow_error Excepție pentru un rezultat prea mare ca să încapă în tipul folosit (depășire aritmetică).
std::runtime_error Excepție pentru erorile care apar doar la rulare, din cauze externe: fișier lipsă, rețea, date greșite.
std::terminate Oprește imediat programul; este apelată automat când o excepție nu este prinsă nicăieri.

Expresii regulate (5)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::regex O expresie regulată compilată, folosită pentru verificarea, căutarea și înlocuirea textului.
std::regex_match Verifică dacă tot textul se potrivește cu modelul; std::smatch păstrează grupurile capturate.
std::regex_replace Înlocuiește toate potrivirile unei expresii regulate cu alt text, care poate folosi grupurile $1, $2.
std::regex_search Caută prima porțiune din text care se potrivește cu modelul, oriunde în text.
std::sregex_iterator Parcurge una câte una toate potrivirile unei expresii regulate dintr-un std::string.

Fire de execuție și sincronizare (20)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::async Rulează o funcție (de obicei pe alt fir) și îți dă un std::future din care iei rezultatul mai târziu.
std::atomic Variabilă care poate fi citită și modificată sigur de mai multe fire, fără mutex.
std::call_once Rulează o funcție o singură dată, chiar dacă mai multe fire încearcă simultan.
std::condition_variable Permite unui fir să aștepte, fără să consume procesor, până când alt fir îl anunță că o condiție s-a îndeplinit.
Programare Concurentă și Paralelism în C++: Modelul de Memorie, Atomics și jthread Ghid aprofundat de multithreading și programare concurentă în C++: gestionarea sigură a ciclului de viață cu std::jthread și std::stop_token, înțelegerea modelului de memorie (Sequential Consistency vs Acquire-Release vs Relaxed) și algoritmi Lock-Free.
Operațiuni Atomice Fără Blocare pe Variabile Non-Atomice cu std::atomic_ref în C++20 Ghid de concurență de înaltă performanță cu std::atomic_ref în C++20: aplicarea operațiunilor atomice sigure pe elemente existente dintr-un vector sau structură fără a impune ca întreaga variabilă să fie de tip std::atomic.
Controlul Accesului la Resurse Limitate cu std::counting_semaphore în C++20 Ghid practic pentru semafoarele moderne în C++20: limitarea accesului concurent la un număr fix de resurse partajate (thread pool-uri, pool-uri de conexiuni la baze de date) prin std::counting_semaphore și std::binary_semaphore.
Sincronizarea Multithreading a Firelor de Execuție cu std::latch și std::barrier în C++20 Ghid complet pentru primitivele de sincronizare std::latch (numărător unidirecțional) și std::barrier (barieră fazică reutilizabilă) în C++20: coordonarea precisă a grupurilor de fire de execuție concurente fără mecanisme lente de mutex.
std::future Un rezultat care va fi disponibil în viitor (de la std::async sau std::promise); get() îl așteaptă și îl returnează.
std::jthread Fir de execuție care face join automat la distrugere și poate fi rugat să se oprească (stop_token).
std::lock_guard Ocupă un mutex la creare și îl eliberează automat la ieșirea din bloc (RAII).
std::mutex Încuietoare pentru date comune: un singur fir de execuție o poate ține la un moment dat.
std::promise Capătul de scriere al unui std::future: un fir promite o valoare și o trimite cu set_value.
std::scoped_lock Ocupă unul sau mai multe mutexuri deodată, fără risc de blocaj reciproc, și le eliberează automat.
std::this_thread::get_id Returnează identificatorul firului de execuție curent (std::thread::id).
std::this_thread::sleep_for Oprește firul de execuție curent pentru (cel puțin) durata dată.
std::thread Pornește o funcție pe un fir de execuție separat, care rulează în paralel cu restul programului.
std::thread::detach Desparte firul de obiectul std::thread: rulează mai departe singur și nu mai poate fi așteptat cu join.
std::thread::hardware_concurrency Returnează câte fire pot rula cu adevărat în paralel pe acest calculator (de obicei numărul de nuclee logice).
std::unique_lock Blocare de mutex flexibilă: poate fi eliberată și reluată, amânată, mutată; necesară pentru condition_variable.

Fișiere și directoare (filesystem) (9)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::filesystem::copy Copiază fișiere și directoare; cu copy_options::recursive copiază un director cu tot conținutul.
std::filesystem::create_directory Creează un director; create_directories creează și toate directoarele părinte care lipsesc.
std::filesystem::current_path Returnează sau schimbă directorul de lucru curent al programului.
std::filesystem::directory_iterator Parcurge fișierele și directoarele dintr-un director; varianta recursive intră și în subdirectoare.
std::filesystem::exists Verifică dacă un fișier sau director există pe disc.
std::filesystem::file_size Returnează dimensiunea unui fișier, în octeți.
std::filesystem::path Reprezintă calea unui fișier sau director și permite construirea și desfacerea ei pe componente.
std::filesystem::remove Șterge un fișier sau un director gol; remove_all șterge un director cu tot conținutul lui.
std::filesystem::rename Redenumește sau mută un fișier sau un director.

Fișiere și fluxuri (13)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::fstream Flux de fișier care poate și citi, și scrie în același fișier.
std::ifstream Deschide un fișier pentru citire și îl citește la fel ca pe std::cin.
std::ifstream::open Deschide, verifică și închide fișierul unui flux: open, is_open, close.
std::istream::eof Verifică starea unui flux: eof (sfârșitul datelor) și fail (citire eșuată).
std::istream::get Citește un singur caracter, inclusiv spații și rânduri noi; put scrie un caracter.
std::istream::ignore Sare peste caractere din intrare, de obicei până la sfârșitul rândului curent.
std::istream::peek Arată următorul caracter din intrare fără să-l consume.
std::istream::read Citește sau scrie un număr exact de octeți: read și write, pentru fișiere binare.
std::istream::seekg Mută poziția de citire în flux (seekg) și arată poziția curentă (tellg).
std::istringstream Flux de citire dintr-un șir: desparte un text în cuvinte, numere sau câmpuri.
std::ofstream Creează sau deschide un fișier pentru scriere și scrie în el la fel ca în std::cout.
std::ostringstream Flux de scriere într-un șir: construiește text cu
std::stringstream Flux care scrie și citește într-un șir din memorie; str() îi dă sau îi schimbă textul.

Formatare (11)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::boolalpha Afișează și citește valorile bool ca true/false în loc de 1/0.
Afișarea Formatată Modernă de Tip Sigur cu std::print și std::println în C++23 Ghid complet pentru biblioteca introdusă în C++23: înlocuirea modernă a std::cout și printf prin std::print și std::println, formatare sigură la compilare (compile-time type safety) și viteză extremă fără overhead de stream-uri.
std::format Construiește un std::string dintr-un șablon cu acolade {} și valori (C++20).
std::format_to Scrie textul formatat direct într-un iterator de ieșire, de exemplu la finalul unui șir.
std::hex Afișează și citește numerele întregi în baza 16 (hex), 8 (oct) sau 10 (dec).
std::put_time Afișează o dată și o oră (std::tm) după un șablon, de exemplu %d.%m.%Y %H:%M.
std::quoted Scrie un text între ghilimele sau citește un text între ghilimele, cu spații cu tot.
std::setprecision Controlează câte cifre sau zecimale au numerele reale afișate, cu fixed și scientific.
std::setw Stabilește lățimea minimă a următoarei valori, cu aliniere și caracter de umplere.
std::showpos Afișează semnul + în fața numerelor pozitive (și a lui zero).
std::vformat Formatează după un șablon cunoscut abia la rulare, de exemplu ales după limbă.

Funcții ca valori (8)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::bind Creează o funcție nouă dintr-una existentă, fixând unele argumente sau schimbându-le ordinea.
std::bind_front Fixează primele argumente ale unei funcții și returnează o funcție care le primește doar pe restul.
std::function Variabilă care poate ține orice funcție, lambda sau obiect apelabil cu o anumită semnătură.
std::hash Obiect-funcție care transformă o valoare într-un număr (hash), folosit de unordered_map și unordered_set.
std::invoke Apelează orice lucru apelabil cu argumentele date, inclusiv pointeri la metode și la membri.
std::less Obiecte-funcție pentru operatori: less (), plus (+), folosite la sortări și containere.
std::mem_fn Transformă un pointer la metodă sau la câmp într-o funcție obișnuită care primește obiectul ca argument.
std::ref Împachetează o referință ca să poată fi transmisă prin funcții care copiază argumentele (thread, bind).

Funcții și lambda (4)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
co_await, co_yield, co_return Cuvintele cheie ale corutinelor (C++20): funcții care se pot opri la jumătate și pot fi reluate mai târziu de unde au rămas.
Programarea Asincronă cu Coroutine, co_await și co_yield în C++20 Ghid fundamental pentru arhitectura coroutinelor în C++20: înțelegerea funcțiilor suspendabile fără stack (stackless coroutines), rolul tipurilor promisiune (promise_type), coroutine_handle și cuvintele cheie co_await, co_yield și co_return.
lambda ([](){}) O funcție fără nume, scrisă direct acolo unde e folosită; poate „captura” variabile din jur.
operator Definește ce face un operator (+, ==,

Intrare/ieșire în stil C (5)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::fopen Deschide un fișier în stil C (fopen) și îl închide (fclose); lucrezi cu el prin FILE*.
std::printf Afișează text formatat în stil C, cu marcaje precum %d, %s, %.2f.
std::puts Afișează un șir C și trece pe rândul următor.
std::scanf Citește valori formatate de la tastatură în stil C, primind adresele variabilelor.
std::snprintf Scrie text formatat ca printf într-un tablou de char, fără să-i depășească mărimea.

Iteratori (9)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::advance Mută un iterator cu n poziții înainte (sau înapoi, pentru n negativ), pentru orice tip de container.
std::back_inserter Iteratori de inserare: fiecare scriere prin back_inserter face push_back, iar prin inserter face insert la o poziție.
std::begin Funcții libere care dau iteratorul de început și de sfârșit pentru orice container, inclusiv pentru tablourile C.
std::distance Numără câte poziții sunt între doi iteratori, adică câte elemente are intervalul [prim, ultim).
std::istream_iterator Iterator care citește valori dintr-un flux de intrare (cin, fișier, stringstream) cu >>, până la final sau la o eroare.
std::next std::next returnează un iterator mutat cu n poziții înainte, std::prev unul mutat înapoi; originalul rămâne neschimbat.
std::ostream_iterator Iterator care scrie fiecare valoare primită într-un flux de ieșire (cout, fișier), urmată de un separator.
std::reverse_iterator Adaptor care inversează direcția unui iterator: ++ merge spre începutul containerului. Este tipul returnat de rbegin().
std::size std::size dă numărul de elemente al unui container sau tablou C; std::empty spune dacă nu are elemente.

Limite, biți și constante (9)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::bit_cast Reinterpretează biții unui obiect ca alt tip de aceeași mărime, în mod sigur (de exemplu biții unui float ca uint32_t).
std::bit_width Returnează câți biți sunt necesari pentru a reprezenta un număr fără semn (0 pentru 0).
std::complex Numere complexe (a + bi), cu operațiile aritmetice obișnuite, modul, argument și funcții matematice.
std::has_single_bit Verifică dacă un număr fără semn este o putere a lui 2 (are exact un bit de 1).
std::numbers::pi Constanta π cu precizia maximă a tipului double, plus alte constante matematice: e, √2, ln 2, φ.
std::numeric_limits Dă proprietățile unui tip numeric: valoarea maximă și minimă, precizia, dacă are semn, infinitul.
std::popcount Numără câți biți de 1 are un număr întreg fără semn.
std::ratio O fracție calculată la compilare (numărător/numitor), folosită pentru unități precum milisecunde sau kilometri.
std::rotl Rotește biții unui număr fără semn spre stânga (rotl) sau spre dreapta (rotr); biții care ies pe o parte intră pe cealaltă.

Matematică (cmath) (16)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::abs Returnează valoarea absolută a unui număr (distanța lui față de zero, fără semn).
std::asin Funcțiile trigonometrice inverse: din valoarea sinusului, cosinusului sau tangentei obții unghiul, în radiani.
std::atan2 Calculează unghiul punctului (x, y) față de axa orizontală, între -π și π, ținând cont de cadran.
std::exp Calculează e la puterea x, unde e ≈ 2,71828 este baza logaritmului natural.
std::floor Rotunjește în jos la cel mai apropiat întreg (floor) sau în sus (ceil).
std::fmin Returnează minimul (fmin) sau maximul (fmax) a două numere cu virgulă, ignorând o valoare NaN.
std::fmod Calculează restul împărțirii a două numere cu virgulă (echivalentul lui % pentru double).
std::hypot Calculează ipotenuza, adică √(x² + y²), fără depășiri la valori mari; din C++17 și în 3 dimensiuni.
std::isnan Verifică dacă un număr cu virgulă este NaN (rezultat nedefinit) sau infinit (inf).
std::lerp Interpolare liniară: valoarea aflată la fracțiunea t pe drumul dintre a și b (a + t·(b − a)).
std::log Calculează logaritmul natural (log), în baza 10 (log10) sau în baza 2 (log2) al unui număr pozitiv.
std::pow Ridică un număr la o putere: baza la exponent. Exponentul poate fi și negativ sau cu zecimale.
std::round Rotunjește la cel mai apropiat întreg; la jumătate (x,5) rotunjește în direcția opusă lui zero.
std::sin Funcțiile trigonometrice sinus, cosinus și tangentă; unghiul se dă în radiani, nu în grade.
std::sqrt Calculează rădăcina pătrată (sqrt) sau rădăcina cubică (cbrt) a unui număr.
std::trunc Taie partea zecimală a unui număr, rotunjind spre zero.

Memorie, pointeri și referințe (4)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
delete Distruge un obiect creat cu new și eliberează memoria; scris ca = delete, interzice folosirea unei funcții.
new Creează un obiect în memoria dinamică (heap) și returnează un pointer la el; obiectul trăiește până este distrus explicit cu delete.
pointeri (*, &) Un pointer este o variabilă care ține adresa altei variabile; prin el poți citi și modifica valoarea de la acea adresă.
referințe (&, &&) O referință este un alt nume pentru o variabilă existentă; tot ce faci cu referința se face de fapt cu variabila originală.

Minim, maxim și comparații (11)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::clamp Limitează o valoare la un interval: o aduce la minim dacă e prea mică și la maxim dacă e prea mare.
std::equal Verifică dacă două intervale conțin aceleași elemente, în aceeași ordine.
std::is_permutation Verifică dacă două intervale conțin aceleași elemente, de același număr de ori, în orice ordine.
std::lexicographical_compare Compară două intervale ca în dicționar și spune dacă primul vine înaintea celui de-al doilea.
std::max Returnează cea mai mare dintre două valori sau dintr-o listă de valori scrisă între acolade.
std::min Returnează cea mai mică dintre două valori sau dintr-o listă de valori scrisă între acolade.
std::min_element Găsește cel mai mic (min_element) sau cel mai mare (max_element) element dintr-un interval și returnează un iterator.
std::minmax Returnează dintr-un singur apel o pereche formată din cea mai mică și cea mai mare valoare.
std::minmax_element Găsește într-o singură parcurgere atât cel mai mic, cât și cel mai mare element dintr-un interval.
std::mismatch Găsește prima poziție unde două intervale diferă și returnează iteratorii din ambele.
std::next_permutation Transformă intervalul în următoarea (sau precedenta) permutare în ordine lexicografică.

Mulțimi și heap (6)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::includes Verifică dacă toate elementele unui interval sortat se află și în alt interval sortat (submulțime).
std::make_heap Transformă un vector într-un heap (cel mai mare element mereu primul) și îl întreține cu push_heap, pop_heap, sort_heap.
std::merge Combină două intervale sortate într-un singur interval sortat, păstrând toate elementele.
std::set_difference Calculează diferența a două intervale sortate: elementele din primul care nu apar în al doilea.
std::set_intersection Calculează intersecția a două intervale sortate: elementele care apar în ambele.
std::set_union Calculează reuniunea a două intervale sortate: elementele care apar în oricare dintre ele, fără dubluri între ele.

Numere aleatorii (8)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::bernoulli_distribution Produce true cu probabilitatea p și false în rest: un „da sau nu” aleatoriu, ca o monedă (eventual măsluită).
std::discrete_distribution Alege aleatoriu un index 0, 1, 2… cu probabilități proporționale cu ponderile date.
std::mt19937 Generatorul Mersenne Twister: numere pseudo-aleatorii rapide și de calitate, reproductibile cu un seed fix.
std::normal_distribution Produce numere aleatorii după distribuția normală (gaussiană, „clopotul”), cu media și abaterea standard date.
std::rand Generatorul vechi de numere pseudo-aleatorii din C (rand), inițializat cu srand; în cod nou preferă .
std::random_device Sursă de numere aleatorii nedeterministe, oferită de sistem; folosită de obicei ca seed pentru std::mt19937.
std::uniform_int_distribution Transformă numerele unui generator în întregi aleatorii dintr-un interval [a, b], toate cu aceeași probabilitate.
std::uniform_real_distribution Produce numere cu virgulă aleatorii, distribuite uniform în intervalul [a, b).

Numerice (accumulate, reduce…) (9)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::accumulate Adună toate elementele unui interval pornind de la o valoare inițială (sau le combină cu o operație dată).
std::adjacent_difference Calculează diferențele dintre fiecare element și cel dinaintea lui; primul element este copiat neschimbat.
std::gcd Calculează cel mai mare divizor comun (gcd) și cel mai mic multiplu comun (lcm) a două numere întregi.
std::inner_product Calculează produsul scalar: suma produselor elementelor aflate pe aceleași poziții în două intervale.
std::iota Completează un interval cu valori consecutive: valoare, valoare + 1, valoare + 2…
std::midpoint Calculează mijlocul dintre două numere (sau pointeri) fără risc de depășire a limitei tipului.
std::partial_sum Calculează sumele parțiale (cumulate): fiecare element al rezultatului este suma tuturor elementelor până la el.
std::reduce Ca accumulate, dar fără ordine fixă a operațiilor, ceea ce permite calcul în paralel.
std::transform_reduce Transformă fiecare element și combină rezultatele într-o singură valoare, într-o singură trecere.

Operatori alternativi și preprocesor (5)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
and, or, not și ceilalți operatori alternativi Cuvinte care pot înlocui simbolurile unor operatori: and pentru &&, or pentru ||, not pentru !, bitand pentru & și altele.
#define Definește un macro: preprocesorul înlocuiește textual numele cu valoarea lui, peste tot în cod, înainte de compilare.
#ifdef, #ifndef, #if, #endif Compilare condiționată: păstrează sau elimină bucăți de cod înainte de compilare, după ce macro-uri sunt definite.
#include Directivă a preprocesorului care copiază conținutul unui fișier antet în locul ei, ca să poți folosi funcțiile și clasele declarate acolo.
#pragma once Pusă la începutul unui fișier antet, face ca fișierul să fie inclus o singură dată, chiar dacă apare în mai multe #include-uri.

Perechi, tupluri și span (9)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::apply Apelează o funcție dând ca argumente, pe rând, elementele unui tuplu (sau ale unei perechi, ale unui std::array).
Vederi Multidimensionale Contigue peste Memorie cu std::mdspan în C++23 Ghid complet pentru std::mdspan în C++23: reprezentarea eficientă a tensorilor și matricilor multidimensionale 2D/3D peste un simplu buffer de memorie contiguu, cu suport pentru layout-uri personalizate (layout_right, layout_left).
std::get Citește elementul unui tuplu, al unei perechi sau al unui std::array după poziție (sau după tip), la compilare.
std::initializer_list Tipul listei scrise între acolade, {1, 2, 3}: permite funcțiilor și claselor să primească oricâte valori de același tip.
std::pair Grupează două valori, eventual de tipuri diferite, într-un singur obiect cu membrii first și second.
std::span O „fereastră” spre elemente consecutive din memorie (vector, array, tablou C), fără copiere și fără să le dețină.
std::tie Creează un tuplu de referințe la variabile existente: despachetează un tuplu în ele sau compară mai multe câmpuri deodată.
std::tuple Grupează oricâte valori de tipuri diferite într-un singur obiect; generalizarea lui std::pair.
std::tuple_size Dă, la compilare, numărul de elemente dintr-un tip tuple, pair sau std::array.

Pointeri inteligenți și memorie (11)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::addressof Returnează adresa reală a unui obiect, chiar dacă clasa lui a redefinit operatorul &.
std::allocator Alocatorul implicit al containerelor: rezervă și eliberează memorie brută pentru obiecte de tip T.
Ghid de Gestiune a Memoriei în C++ Modern: RAII, Move Semantics și Pointeri Inteligenți (unique_ptr, shared_ptr) Ghid complet de gestiune sigură a memoriei în C++: eliminarea scurgerilor de memorie cu std::make_unique și std::make_shared, evitarea referințelor circulare cu std::weak_ptr, regula celor 5 (Rule of 5) și semantica de mutare.
std::enable_shared_from_this Clasă de bază care permite unui obiect deținut de shared_ptr să obțină un shared_ptr către el însuși.
std::make_shared Creează un obiect și un std::shared_ptr care îl deține, cu o singură alocare de memorie.
std::make_unique Creează un obiect pe heap și returnează un std::unique_ptr care îl deține.
std::shared_ptr Pointer inteligent cu proprietate comună: obiectul este șters când ultimul shared_ptr dispare.
std::unique_ptr Pointer inteligent care deține singur un obiect și îl șterge automat când iese din domeniu.
std::unique_ptr::get Returnează pointerul brut către obiectul deținut, fără să renunțe la proprietate.
std::unique_ptr::reset reset șterge obiectul deținut (și poate prelua altul); release renunță la proprietate fără să șteargă.
std::weak_ptr Referință slabă la un obiect deținut de shared_ptr: nu îl ține în viață; lock() îl folosește în siguranță.

Ranges și views (16)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
Generatoare Asincrone și Coroutine cu std::generator în C++23 Ghid de utilizare a tipului std::generator în C++23: crearea facilă de coroutine generatoare cu evaluare leneșă (lazy evaluation) prin co_yield, compatibilitate nativă cu algoritmii std::ranges și buclele for bazate pe intervale.
std::ranges::find Caută o valoare direct într-un container, opțional după un câmp al elementelor (proiecție).
std::ranges::sort Sortează un container întreg dintr-un apel, cu opțiunea de a sorta după un câmp (proiecție).
std::ranges::to Transformă un range sau un view (filtrat, transformat) într-un container nou: vector, set, string, map.
std::views::drop Creează o vedere care sare peste primele n elemente ale unui range.
std::views::filter Creează o vedere asupra unui container care conține doar elementele ce îndeplinesc o condiție, fără copiere.
std::views::iota Generează numerele consecutive dintr-un interval (sau la infinit) fără să le stocheze.
std::views::join Aplatizează un range de range-uri: parcurge pe rând elementele tuturor sub-range-urilor, ca o singură secvență.
std::views::keys Din perechi (de exemplu dintr-un std::map), păstrează doar cheile (keys) sau doar valorile (values).
std::views::repeat Generează aceeași valoare repetată de n ori (sau la infinit), fără să o copieze într-un container.
std::views::reverse Creează o vedere care parcurge un range de la ultimul element la primul, fără să-l modifice.
std::views::split Împarte un range (de obicei un text) în bucăți, după un separator: un caracter sau o secvență.
std::views::take Creează o vedere cu primele n elemente ale unui range (sau toate, dacă sunt mai puține).
std::views::take_while Creează o vedere cu elementele de la început, cât timp îndeplinesc o condiție; se oprește la primul care nu o îndeplinește.
std::views::transform Creează o vedere în care fiecare element este rezultatul unei funcții aplicate elementului original.
std::views::zip Parcurge mai multe range-uri în paralel, oferind la fiecare pas un tuplu cu elementele de pe aceeași poziție.

Sortare și căutare (14)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::adjacent_find Găsește prima pereche de elemente vecine egale (sau care îndeplinesc o condiție între ele).
std::all_of Verifică dacă toate (all_of), măcar unul (any_of) sau niciunul (none_of) dintre elemente îndeplinesc o condiție.
std::binary_search Verifică foarte rapid dacă o valoare există într-un interval deja sortat.
std::count Numără de câte ori apare o valoare (count) sau câte elemente îndeplinesc o condiție (count_if).
std::equal_range Într-un interval sortat, returnează perechea de iteratori care delimitează toate elementele egale cu valoarea.
std::find Caută prima apariție a unei valori într-un interval și returnează un iterator către ea.
std::find_if Găsește primul element care îndeplinește o condiție (find_if) sau primul care nu o îndeplinește (find_if_not).
std::is_sorted Verifică dacă elementele unui interval sunt deja în ordine crescătoare (sau după regula dată).
std::lower_bound Într-un interval sortat, găsește primul element ≥ valoare (lower_bound) sau primul element > valoare (upper_bound).
std::nth_element Pune pe poziția n elementul care ar fi acolo după sortare; util pentru mediană sau al k-lea cel mai mic.
std::partial_sort Pune în ordine doar primele k elemente (cele mai mici sau cele mai mari), restul rămân neordonate.
std::search Caută prima apariție a unei secvențe de elemente în interiorul altui interval.
std::sort Sortează elementele dintr-un interval, crescător sau după o regulă dată de tine.
std::stable_sort Sortează un interval păstrând ordinea inițială a elementelor considerate egale.

Structuri de control (10)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
break, continue break oprește imediat bucla sau switch-ul curent; continue sare peste restul pasului curent și trece la următorul.
do … while Buclă care execută blocul cel puțin o dată și abia apoi verifică condiția.
for Bucla cu contor: repetă un bloc de cod cât timp condiția este adevărată, cu inițializare și pas scrise pe același rând.
goto Sare direct la o etichetă din aceeași funcție; folosit foarte rar, de obicei doar pentru ieșirea din mai multe bucle imbricate.
if, else Execută un bloc de cod doar dacă o condiție este adevărată; else oferă varianta pentru cazul contrar.
if constexpr Un if evaluat la compilare: ramura falsă este eliminată complet, deci poate conține cod care nu s-ar compila pentru tipul curent.
range-for (for (x : colecție)) Parcurge pe rând toate elementele unei colecții (vector, tablou, string, map) fără index și fără iteratori scriși de mână.
return Încheie funcția curentă și trimite, opțional, o valoare înapoi celui care a apelat-o.
switch, case, default Alege una dintre mai multe ramuri după valoarea unei expresii întregi, a unui caracter sau a unui enum.
while Repetă un bloc de cod cât timp condiția este adevărată; condiția este verificată înainte de fiecare trecere.

Timp (chrono) (6)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::chrono::duration O durată de timp cu unitate de măsură: secunde, milisecunde, minute, ore. Conversiile sunt automate și sigure.
std::chrono::duration_cast Transformă o durată în altă unitate, trunchiind partea care nu încape (de exemplu secunde în minute).
std::chrono::steady_clock Ceas monoton, care nu sare niciodată înapoi: ceasul corect pentru măsurarea duratelor.
std::chrono::system_clock Ceasul sistemului: data și ora reale (UTC), care pot fi transformate în dată calendaristică.
std::chrono::time_point Un moment în timp măsurat după un anumit ceas. Diferența a două momente este o durată.
std::chrono::year_month_day O dată calendaristică (an, lună, zi) cu validare, ziua săptămânii și calcule cu luni și ani.

Tipuri de date (17)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
alignas, alignof alignof spune la ce multiplu de octeți trebuie să înceapă un tip în memorie; alignas cere o aliniere mai mare.
auto Lasă compilatorul să deducă tipul variabilei din valoarea cu care este inițializată.
bool, true, false Tipul logic: o variabilă bool are doar două valori, true (adevărat) sau false (fals).
char Tipul pentru un singur caracter (un octet); în spate este un număr mic, codul caracterului.
decltype Dă tipul exact al unei expresii, fără să o evalueze; util pentru a declara variabile „de același tip ca”.
double, float Tipuri pentru numere reale (cu zecimale): double are aproximativ 15-16 cifre exacte, float doar 6-7.
enum Definește un tip cu o listă fixă de valori cu nume, de exemplu zilele săptămânii sau stările unei comenzi.
int Tipul de bază pentru numere întregi (fără zecimale), de obicei pe 4 octeți, cu valori între aproximativ -2,1 și 2,1 miliarde.
nullptr Valoarea unui pointer care nu arată spre nimic; înlocuiește vechile NULL și 0.
sizeof Dă numărul de octeți ocupați în memorie de un tip sau de o variabilă; se calculează la compilare.
static_cast, dynamic_cast, const_cast, reinterpret_cast Cele patru conversii explicite: static_cast (obișnuite), dynamic_cast (clase), const_cast (const) și reinterpret_cast (biți).
structured bindings (auto [a, b]) Desface o pereche, un tuplu, o structură sau un tablou în variabile separate, cu nume, într-o singură declarație.
typeid Dă informații despre tipul unei expresii la rulare; pentru clase cu funcții virtuale arată tipul real al obiectului.
union Un tip în care toți membrii împart aceeași zonă de memorie; la un moment dat doar unul dintre ei are o valoare validă.
signed, unsigned, short, long Modificatori care schimbă mărimea (short, long) sau semnul (signed, unsigned) tipurilor întregi.
void Înseamnă „niciun tip”: o funcție void nu returnează nimic, iar void* este un pointer către date de orice tip.
wchar_t, char8_t, char16_t, char32_t Tipuri de caractere pentru Unicode: char8_t (UTF-8), char16_t (UTF-16), char32_t (UTF-32) și wchar_t, caracterul „lat” dependent de sistem.

Tipuri: traits, concepte, întregi cu mărime fixă (11)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::conditional Alege un tip din două, la compilare, după o condiție: un fel de operator ?: pentru tipuri.
std::enable_if Activează o funcție-șablon doar pentru tipurile care îndeplinesc o condiție (tehnica SFINAE).
std::int32_t Tipuri întregi cu mărime exactă: int32_t are mereu 32 de biți, uint8_t 8 biți fără semn etc.
std::integral Concepte C++20 care restrâng un șablon la tipuri întregi (integral) sau reale (floating_point).
std::is_base_of Verifică la compilare dacă o clasă este clasa de bază a alteia (sau aceeași clasă).
std::is_integral is_integral verifică dacă un tip este întreg (inclusiv bool și char); is_floating_point, dacă este real.
std::is_same Verifică la compilare dacă două tipuri sunt exact același tip.
std::remove_reference remove_reference scoate referința dintr-un tip; decay îl transformă ca la transmiterea prin valoare.
std::same_as Concepte C++20: same_as cere exact același tip, convertible_to cere un tip care se poate converti în altul.
std::size_t Tip întreg fără semn pentru mărimi și indici: îl returnează sizeof și metodele size() ale containerelor.
std::source_location Informații despre locul din cod (fișier, funcție, linie) unde este apelată o funcție; înlocuiește __LINE__.

Utilitare (utility) (8)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::as_const Returnează o referință const la un obiect, ca să fie folosite variantele const ale metodelor.
Optimizarea Performanței la Nivel Extrem în C++: Localitatea Cache-ului, Struct-of-Arrays (SoA) și Abstracțiuni Zero-Cost Ghid de optimizare la nivel hardware în C++: proiectarea structurilor orientate pe date (Data-Oriented Design), compararea Array-of-Structures (AoS) cu Struct-of-Arrays (SoA), vectorizare automată SIMD și utilizarea std::span.
std::exchange Pune o valoare nouă într-o variabilă și returnează valoarea veche.
std::forward Transmite un argument mai departe păstrând felul lui: valoare temporară (mutabilă) sau variabilă cu nume.
std::in_range Verifică dacă un număr întreg încape în alt tip întreg, fără capcanele conversiilor cu semn.
std::swap Schimbă între ele valorile a două variabile de același tip.
std::to_underlying Transformă o valoare de enumerare (inclusiv enum class) în numărul întreg din spatele ei.
std::unreachable Îi spune compilatorului că un punct din cod nu poate fi atins niciodată, ca să optimizeze.

Utilitare C (cstdlib) (6)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::atoi Transformă un text C în număr întreg (atoi) sau cu virgulă (atof), fără nicio semnalare a erorilor.
std::div Calculează într-un singur apel câtul și restul împărțirii a două numere întregi.
std::exit Oprește imediat programul cu un cod de ieșire; rulează funcțiile atexit și distruge obiectele statice, dar nu și pe cele locale.
std::getenv Citește valoarea unei variabile de mediu (de exemplu HOME sau PATH); returnează nullptr dacă nu există.
std::qsort Funcția de sortare din C: sortează un tablou primind dimensiunea elementelor și o funcție de comparare cu void*.
std::system Rulează o comandă în shell-ul sistemului de operare și așteaptă să se termine.

Valori opționale și alternative (optional, variant, expected) (9)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::any Container pentru o singură valoare de orice tip; std::any_cast o scoate înapoi cu tipul corect.
Gestiunea Monadică a Erorilor fără Excepții cu std::expected în C++23 Ghid avansat pentru std::expected în C++23: tratarea funcțională a erorilor de sistem fără a plăti costul de performanță al excepțiilor C++, metode monadice (and_then, or_else, transform) și interfețe sigure.
std::expected Rezultatul unei operații care poate eșua: conține fie valoarea (T), fie motivul erorii (E).
std::holds_alternative holds_alternative verifică ce tip are acum un variant; get_if returnează pointer la valoare sau nullptr.
std::optional O valoare care poate lipsi: conține fie un obiect de tip T, fie nimic (std::nullopt).
std::optional::and_then Înlănțuiește operații pe un optional: and_then și transform rulează funcția doar dacă există valoare.
std::optional::value value() citește valoarea și aruncă excepție dacă optional e gol; value_or() dă o valoare implicită.
std::variant O valoare care are, la un moment dat, exact unul dintre mai multe tipuri posibile (union sigur).
std::visit Apelează o funcție cu valoarea curentă dintr-un std::variant, oricare ar fi tipul ei.

std::vector (18)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::erase_if Șterge dintr-un container toate elementele egale cu o valoare (std::erase) sau care îndeplinesc o condiție (std::erase_if).
std::vector Tabloul dinamic din C++: ține elementele unul după altul în memorie și își mărește singur dimensiunea.
std::vector::assign Înlocuiește tot conținutul vectorului cu n copii ale unei valori, cu un interval sau cu o listă.
std::vector::at Returnează elementul de la o poziție, cu verificare: aruncă std::out_of_range dacă poziția nu există.
std::vector::begin begin() dă un iterator la primul element, end() unul după ultimul, iar rbegin() pornește parcurgerea de la coadă.
std::vector::clear Șterge toate elementele vectorului; dimensiunea devine 0, dar memoria rezervată rămâne.
std::vector::data Returnează un pointer la primul element al vectorului, pentru funcții care lucrează cu tablouri C.
std::vector::emplace_back Construiește un element nou direct la sfârșitul vectorului, din argumentele constructorului.
std::vector::erase Șterge un element sau un interval de elemente din vector și returnează iteratorul elementului de după.
std::vector::front front() returnează primul element al vectorului, iar back() ultimul.
std::vector::insert Inserează unul sau mai multe elemente înaintea unei poziții din vector; emplace construiește elementul pe loc.
std::vector::operator[] Accesează elementul de pe o poziție cu v[i], fără verificare a limitelor.
std::vector::pop_back Șterge ultimul element al vectorului; dimensiunea scade cu 1.
std::vector::push_back Adaugă un element la sfârșitul vectorului; vectorul crește cu o poziție.
std::vector::reserve reserve() rezervă memorie pentru n elemente, capacity() spune cât loc este rezervat, iar shrink_to_fit() cere eliberarea locului nefolosit.
std::vector::resize Schimbă numărul de elemente: adaugă elemente noi la final sau le șterge pe cele în plus.
std::vector::size size() spune câte elemente are vectorul; empty() spune dacă nu are niciunul.
std::vector::swap Schimbă instant conținutul a doi vectori de același tip, fără să copieze elementele.

Șabloane (template) și concepte (6)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
concept Dă un nume unui set de cerințe pentru tipuri, folosit ca să restrângi ce tipuri acceptă un șablon.
Metaprogramare la Compilare în C++20/C++23: Concepte (Concepts), constexpr, consteval și SFINAE Modern Ghid complet de calcul și metaprogramare la timpul compilării în C++20/C++23: definirea conceptelor cu clauza requires, înlocuirea SFINAE cu mesaje de eroare clare, funcții garantate la compilare (consteval) și if constexpr.
requires Scrie cerințe pentru parametrii unui șablon: ca clauză care restrânge șablonul sau ca expresie care verifică dacă un cod este valid.
static_assert Verifică o condiție la compilare; dacă este falsă, compilarea se oprește cu mesajul dat.
template Scrie o funcție sau o clasă o singură dată, pentru orice tip; compilatorul generează varianta potrivită pentru fiecare tip folosit.
typename Introduce un parametru de tip într-un șablon sau anunță compilatorul că un nume care depinde de șablon este un tip.

Șiruri de caractere (std::string) (22)

Funcție / Clasă / Algoritm Descriere și Aplicabilitate Tehnică
std::string Șir de caractere care își gestionează singur memoria; atenție, lucrează cu octeți, nu cu litere.
std::string::append Adaugă text la sfârșitul șirului, la fel ca +=, cu variante pentru bucăți și caractere repetate.
std::string::assign Înlocuiește tot conținutul șirului cu alt text, cu o bucată din alt text sau cu n caractere.
std::string::at at(i) dă caracterul de la poziția i cu verificare; front() și back() dau primul și ultimul.
std::string::c_str Dă un pointer la textul șirului, terminat cu \0, pentru funcțiile care cer char* (stil C).
std::string::compare Compară două șiruri și returnează un număr negativ, zero sau pozitiv, ca la sortare.
std::string::contains Verifică dacă șirul conține un anumit text sau caracter, oriunde în el (C++23).
std::string::copy Copiază cel mult n caractere din șir într-un tablou de char, fără să adauge \0.
std::string::empty empty() verifică dacă șirul este gol; clear() îl golește.
std::string::erase Șterge o porțiune din șir, dată prin poziția de început și numărul de caractere.
std::string::find Caută un text și returnează poziția primei (find) sau ultimei (rfind) apariții, ori npos.
std::string::find_first_of Caută primul sau ultimul caracter dintr-un set, sau primul caracter care nu e în set.
std::string::insert Inserează text la o anumită poziție în șir, mutând restul spre dreapta.
std::string::push_back push_back adaugă un caracter la final; pop_back șterge ultimul caracter.
std::string::replace Înlocuiește porțiunea de n caractere de la poziția poz cu alt text.
std::string::reserve reserve rezervă memorie dinainte; capacity arată cât încape; shrink_to_fit eliberează surplusul.
std::string::resize Schimbă lungimea șirului: îl taie la n caractere sau îl completează cu un caracter.
std::string::size Returnează lungimea șirului în octeți; length() este exact același lucru.
std::string::starts_with Verifică dacă șirul începe (starts_with) sau se termină (ends_with) cu un text dat (C++20).
std::string::substr Returnează o bucată nouă din șir: n caractere începând de la poziția poz.
std::string::swap Schimbă conținutul a două șiruri între ele, rapid, fără copierea textului.
std::string_view Vedere doar pentru citire asupra unui text existent, fără copiere; se poate micșora la capete.
Comunitate & Schimb de cunoștințe

Discuții, Întrebări & Coduri C++

Ai o întrebare legată de C++, cauți o soluție sau vrei să împărtășești un fragment util de cod? Trimite mai jos contribuția ta.

💬

Fii primul care pune o întrebare sau distribuie un fragment de cod / prompt!

Nu au fost adăugate încă întrebări sau exemple de cod pentru această pagină. Dacă ai întâlnit o problemă sau ai un snippet util, adaugă-l mai jos pentru a-i ajuta pe ceilalți.

Comunitate Adaugă o întrebare sau distribuie un cod

Moderare & Siguranță:

Pentru a menține calitatea și securitatea informațiilor, fiecare întrebare sau fragment de cod/prompt este analizat (manual sau prin moderare asistată de AI) înainte de publicare.