dexblog.ro
C++

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

409 comenzi 44 de categorii

C++ este limbajul din spatele jocurilor, browserelor, bazelor de date și al multor programe care trebuie să fie foarte rapide. Este un limbaj compilat: codul este transformat într-un program executabil înainte de a rula.

Mai jos găsești cuvintele cheie ale limbajului și cele mai folosite părți ale bibliotecii standard (std::): intrare și ieșire, șiruri de caractere, containere precum std::vector și std::map, algoritmi, pointeri inteligenți, timp și fire de execuție.

Toate exemplele au fost compilate cu standardul C++23 (cu avertismentele tratate ca erori) și rulate; rezultatul afișat este cel real. Un program C++ începe din funcția main(), iar fiecare instrucțiune se termină cu punct și virgulă.

Bazele programului 7 comenzi

Tipuri de date 17 comenzi

Constante și specificatori 10 comenzi

Structuri de control 10 comenzi

Funcții și lambda 3 comenzi

Clase și obiecte 8 comenzi

Șabloane (template) și concepte 5 comenzi

Memorie, pointeri și referințe 4 comenzi

Excepții 3 comenzi

Operatori alternativi și preprocesor 5 comenzi

Afișare și citire 7 comenzi

Formatare 10 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 asociative (map, set) 15 comenzi

Containere neordonate (hash) 4 comenzi

Adaptoare: stack, queue, priority_queue 3 comenzi

Perechi, tupluri și span 8 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

Ranges și views 15 comenzi

Matematică (cmath) 16 comenzi

Numere aleatorii 8 comenzi

Utilitare C (cstdlib) 6 comenzi

Limite, biți și constante 9 comenzi

Pointeri inteligenți și memorie 10 comenzi

Utilitare (utility) 7 comenzi

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

Funcții ca valori 8 comenzi

Timp (chrono) 6 comenzi

Fire de execuție și sincronizare 16 comenzi

Excepții și erori 9 comenzi

Fișiere și directoare (filesystem) 9 comenzi

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

Toate funcțiile

Lista completă a cuvintelor cheie și a funcțiilor din biblioteca standard C++ incluse în această secțiune, cu antetul (#include) din care fac parte. Cele cu link au o pagină dedicată, cu explicații și exemple compilate.

Cuvinte cheie și construcții de limbaj (107)

Funcție Ce face
alignas Cere ca o variabilă sau un tip să fie aliniat în memorie la un multiplu mai mare de octeți.
alignof Dă alinierea cerută de un tip: multiplul de octeți la care trebuie să înceapă în memorie.
and Operator alternativ pentru && (și logic).
and_eq Operator alternativ pentru &= (și pe biți, cu atribuire).
asm Inserează instrucțiuni în limbaj de asamblare; sintaxa depinde de compilator și de procesor.
auto Lasă compilatorul să deducă tipul variabilei din valoarea de inițializare.
bitand Operator alternativ pentru & (și pe biți).
bitor Operator alternativ pentru | (sau pe biți).
bool Tipul logic, cu valorile true și false.
break Iese imediat din bucla curentă sau din switch.
case Marchează o ramură a unui switch pentru o anumită valoare.
catch Prinde și tratează o excepție de un anumit tip, aruncată în blocul try.
char Tipul pentru un caracter (un octet); în spate este codul numeric al caracterului.
char8_t Tipul unei unități de text UTF-8 (C++20), folosit de literalii u8″…”.
char16_t Tipul unei unități de text UTF-16, folosit de literalii u”…”.
char32_t Tipul unui caracter Unicode complet (UTF-32), folosit de literalii U”…”.
class Definește un tip cu date și metode, cu membrii privați implicit.
compl Operator alternativ pentru ~ (inversarea tuturor biților).
concept Dă un nume unui set de cerințe pentru tipuri, folosit la restrângerea șabloanelor (C++20).
const Marchează o valoare care nu mai poate fi modificată după inițializare.
consteval Definește o funcție care trebuie calculată obligatoriu la compilare (C++20).
constexpr Cere ca o valoare sau un apel de funcție să poată fi calculat la compilare.
constinit Garantează inițializarea la compilare a unei variabile statice, fără să o facă constantă (C++20).
const_cast Adaugă sau scoate const de pe un pointer sau o referință.
continue Sare peste restul pasului curent al buclei și trece la următorul.
co_await Suspendă o corutină până când operația așteptată este gata (C++20).
co_return Încheie o corutină, opțional cu o valoare (C++20).
co_yield Produce o valoare dintr-o corutină și o suspendă până la cererea următoare (C++20).
decltype Dă tipul exact al unei expresii, fără să o evalueze.
default Ramura implicită a unui switch; ca = default, cere varianta generată de compilator.
delete Distruge un obiect creat cu new; ca = delete, interzice o funcție.
do Buclă do … while: execută blocul cel puțin o dată, apoi verifică condiția.
double Tip pentru numere reale cu dublă precizie (aproximativ 15-16 cifre exacte).
dynamic_cast Conversie verificată la rulare între clase polimorfice; dă nullptr sau aruncă la eșec.
else Ramura executată când condiția lui if este falsă.
enum Definește un tip cu o listă fixă de valori cu nume; enum class este varianta sigură.
explicit Interzice folosirea unui constructor sau operator de conversie pentru conversii automate.
export Face vizibilă în afara unui modul o declarație (C++20).
extern Declară o variabilă sau funcție definită în altă parte; extern „C” cere legare în stil C.
false Valoarea logică „fals” a tipului bool.
float Tip pentru numere reale cu simplă precizie (aproximativ 6-7 cifre exacte).
for Buclă cu inițializare, condiție și pas.
friend Dă unei funcții sau clase acces la membrii privați ai clasei.
goto Sare la o etichetă din aceeași funcție.
if Execută un bloc de cod doar dacă o condiție este adevărată.
inline Permite definirea aceleiași funcții sau variabile în mai multe fișiere (de obicei în antete).
int Tipul de bază pentru numere întregi, de obicei pe 4 octeți.
long Modificator pentru întregi mai mari: long (cel puțin 32 de biți), long long (cel puțin 64).
mutable Permite modificarea unui membru în metode const sau a capturilor unei lambda.
namespace Grupează nume sub un prefix comun, ca să evite conflictele.
new Creează un obiect în memoria dinamică și returnează un pointer la el.
noexcept Promite că o funcție nu aruncă excepții; ca operator, verifică dacă o expresie poate arunca.
not Operator alternativ pentru ! (negație logică).
not_eq Operator alternativ pentru != (diferit).
nullptr Valoarea unui pointer care nu arată spre nimic.
operator Definește comportamentul unui operator (+, ==, <<, [] etc.) pentru un tip propriu.
or Operator alternativ pentru || (sau logic).
or_eq Operator alternativ pentru |= (sau pe biți, cu atribuire).
private Membrii de după el sunt accesibili doar în clasă și prietenilor ei.
protected Membrii de după el sunt accesibili în clasă și în clasele derivate.
public Membrii de după el sunt accesibili de oriunde; la moștenire păstrează accesul.
register Fost specificator pentru păstrarea în registre; eliminat în C++17, cuvânt rămas rezervat.
reinterpret_cast Reinterpretează biții unei valori ca alt tip (pointeri, octeți); periculos.
requires Scrie cerințe pentru parametrii unui șablon sau verifică dacă un cod este valid (C++20).
return Încheie funcția și trimite, opțional, o valoare celui care a apelat-o.
short Modificator pentru întregi mici, de cel puțin 16 biți.
signed Tip întreg cu semn (implicit pentru int); se scrie de obicei la signed char.
sizeof Dă numărul de octeți ocupați de un tip sau o variabilă, calculat la compilare.
static Variabilă care își păstrează valoarea, membru comun al clasei sau nume vizibil doar în fișier.
static_assert Verifică o condiție la compilare și oprește compilarea dacă este falsă.
static_cast Conversie explicită obișnuită, verificată la compilare (numere, enumerări, clase).
struct Definește un tip care grupează date, cu membrii publici implicit.
switch Alege una dintre mai multe ramuri după valoarea unei expresii întregi sau enum.
template Definește o funcție sau o clasă generică, pentru orice tip.
this Pointer către obiectul curent, în metodele unei clase.
thread_local Fiecare fir de execuție primește propria copie a variabilei.
throw Aruncă o excepție sau, singur într-un catch, o aruncă din nou.
true Valoarea logică „adevărat” a tipului bool.
try Marchează blocul de cod din care se pot prinde excepții cu catch.
typedef Creează un nume nou pentru un tip existent (forma veche a lui using).
typeid Dă informații despre tipul unei expresii la rulare (std::type_info).
typename Introduce un parametru de tip în șablon sau marchează un nume dependent ca tip.
union Tip în care toți membrii împart aceeași zonă de memorie.
unsigned Tip întreg fără semn: doar valori pozitive, cu limită maximă dublă.
using Aduce nume dintr-un spațiu de nume sau creează un alias pentru un tip.
virtual Marchează o metodă care poate fi suprascrisă și apelată polimorfic.
void „Niciun tip”: funcție care nu returnează nimic sau pointer generic (void*).
volatile Cere ca fiecare citire și scriere a variabilei să fie făcută efectiv în memorie.
wchar_t Tip de caracter „lat”, cu mărime dependentă de sistem (2 octeți pe Windows, 4 pe Linux/macOS).
while Repetă un bloc cât timp condiția este adevărată, verificând-o înainte de fiecare pas.
xor Operator alternativ pentru ^ (sau exclusiv pe biți).
xor_eq Operator alternativ pentru ^= (sau exclusiv pe biți, cu atribuire).
final Interzice suprascrierea unei metode virtuale sau moștenirea dintr-o clasă.
override Cere verificarea că metoda suprascrie o metodă virtuală din clasa de bază.
import Folosește un modul C++20 (sau, din C++23, toată biblioteca standard cu import std).
module Începe sau declară un modul C++20, alternativa modernă la fișierele antet.
#include Copiază conținutul unui fișier antet în locul directivei, înainte de compilare.
#define Definește un macro, înlocuit textual de preprocesor înainte de compilare.
#ifdef Compilare condiționată: păstrează codul doar dacă un macro este definit.
#pragma once Face ca un fișier antet să fie inclus o singură dată în același fișier compilat.
main Funcția cu care începe programul; valoarea returnată este codul de ieșire.
lambda Funcție fără nume scrisă pe loc, care poate captura variabile din jur.
range-for Bucla for (x : colecție), care parcurge toate elementele unei colecții.
referinte Referințe (&, &&): alte nume pentru variabile existente; folosite la parametri și mutare.
pointeri Variabile care țin adresa altor variabile; se folosesc cu &, * și ->.
structured-bindings auto [a, b] = …: desface o pereche, un tuplu sau o structură în variabile separate (C++17).
if-constexpr if evaluat la compilare: ramura falsă este eliminată complet (C++17).

Intrare/ieșire, șiruri de caractere și text (126)

Funcție Ce face
std::cout Fluxul de ieșire standard: afișează text și valori în consolă cu operatorul <<.
#include <iostream>
std::cin Fluxul de intrare standard: citește valori de la tastatură cu operatorul >>.
#include <iostream>
std::cerr Fluxul pentru mesaje de eroare, fără buffer: textul apare imediat, separat de ieșirea normală.
#include <iostream>
std::clog Flux pentru jurnal (log), pe canalul de eroare, dar cu buffer.
#include <iostream>
std::endl Scrie un rând nou și golește bufferul fluxului.
#include <iostream>
std::flush Golește bufferul fluxului, fără să adauge un rând nou.
#include <iostream>
std::ws Sare peste spațiile albe (spații, Enter, tab) de la începutul intrării.
#include <iostream>
std::print Afișează text formatat cu acoladele {} (C++23), fără rând nou la final.
#include <print>
std::println Afișează text formatat cu acoladele {} (C++23) și trece pe rândul următor.
#include <print>
std::format Construiește un std::string dintr-un șablon cu acolade {} și valori (C++20).
#include <format>
std::format_to Scrie textul formatat direct într-un iterator de ieșire, de exemplu la finalul unui șir.
#include <format>
std::vformat Varianta lui format cu șablonul cunoscut abia la rulare și argumentele împachetate.
#include <format>
std::setw Stabilește lățimea minimă a următoarei valori afișate, pentru tabele aliniate.
#include <iomanip>
std::setprecision Stabilește câte cifre (sau zecimale, cu fixed) au numerele reale afișate.
#include <iomanip>
std::setfill Alege caracterul folosit pentru completare când valoarea e mai scurtă decât setw.
#include <iomanip>
std::fixed Afișează numerele reale cu un număr fix de zecimale, fără notație științifică.
#include <iomanip>
std::scientific Afișează numerele reale în notație științifică, de forma 1.5e+06.
#include <iomanip>
std::left Aliniază valorile la stânga în spațiul dat de setw.
#include <iomanip>
std::right Aliniază valorile la dreapta în spațiul dat de setw (implicit).
#include <iomanip>
std::boolalpha Afișează și citește valorile bool ca true/false în loc de 1/0.
#include <iomanip>
std::hex Afișează și citește numerele întregi în baza 16.
#include <iomanip>
std::dec Revine la afișarea și citirea numerelor întregi în baza 10.
#include <iomanip>
std::oct Afișează și citește numerele întregi în baza 8.
#include <iomanip>
std::showpos Afișează semnul + în fața numerelor pozitive.
#include <iomanip>
std::quoted Scrie sau citește un text între ghilimele, păstrând spațiile din interior.
#include <iomanip>
std::put_time Afișează o dată și o oră (std::tm) după un șablon precum %d.%m.%Y.
#include <iomanip>
std::ifstream Flux pentru citirea dintr-un fișier, folosit la fel ca std::cin.
#include <fstream>
std::ofstream Flux pentru scrierea într-un fișier, folosit la fel ca std::cout.
#include <fstream>
std::fstream Flux de fișier deschis atât pentru citire, cât și pentru scriere.
#include <fstream>
std::ifstream::open Deschide un fișier pentru un flux creat fără nume sau închis anterior.
#include <fstream>
std::ifstream::is_open Spune dacă fluxul are un fișier deschis cu succes.
#include <fstream>
std::ifstream::close Închide fișierul asociat fluxului și golește bufferul.
#include <fstream>
std::istream::eof Spune dacă o citire a ajuns la sfârșitul datelor.
#include <fstream>
std::istream::fail Spune dacă ultima operație pe flux a eșuat (date greșite sau fișier lipsă).
#include <fstream>
std::istream::read Citește un număr exact de octeți într-o zonă de memorie (fișiere binare).
#include <fstream>
std::ostream::write Scrie un număr exact de octeți dintr-o zonă de memorie (fișiere binare).
#include <fstream>
std::istream::seekg Mută poziția de citire într-un flux, de exemplu la începutul fișierului.
#include <fstream>
std::istream::tellg Returnează poziția curentă de citire din flux, în octeți.
#include <fstream>
std::istream::ignore Sare peste caractere din intrare, de obicei până la sfârșitul rândului.
#include <fstream>
std::istream::peek Arată următorul caracter din intrare fără să-l consume.
#include <fstream>
std::istream::get Citește un singur caracter, inclusiv spațiile și rândul nou.
#include <fstream>
std::ostream::put Scrie un singur caracter în flux.
#include <fstream>
std::stringstream Flux care citește și scrie într-un șir din memorie, nu în consolă sau fișier.
#include <sstream>
std::istringstream Flux de citire dintr-un șir: desparte textul în cuvinte sau numere.
#include <sstream>
std::ostringstream Flux de scriere într-un șir: construiește text cu operatorul <<.
#include <sstream>
std::stringstream::str Returnează sau înlocuiește textul din interiorul unui flux de șir.
#include <sstream>
std::string Șir de caractere care își gestionează singur memoria și poate crește oricât.
#include <string>
std::getline Citește un rând întreg, cu spații, dintr-un flux într-un std::string.
#include <string>
std::to_string Transformă un număr în std::string.
#include <string>
std::stoi Transformă textul de la începutul unui șir în int; aruncă excepție dacă nu e număr.
#include <string>
std::stol Transformă textul în long; aruncă excepție dacă nu e număr sau e prea mare.
#include <string>
std::stoll Transformă textul în long long, pentru numere întregi foarte mari.
#include <string>
std::stoul Transformă textul în unsigned long (număr întreg fără semn).
#include <string>
std::stof Transformă textul în float (număr real cu precizie simplă).
#include <string>
std::stod Transformă textul în double (număr real), de exemplu „19.99” în 19.99.
#include <string>
std::string::size Returnează numărul de octeți din șir (diacriticele au 2 octeți în UTF-8).
#include <string>
std::string::length Identic cu size(): numărul de octeți din șir.
#include <string>
std::string::empty Spune dacă șirul nu are niciun caracter.
#include <string>
std::string::clear Șterge tot conținutul șirului, care devine gol.
#include <string>
std::string::append Adaugă text la sfârșitul șirului, la fel ca +=.
#include <string>
std::string::push_back Adaugă un singur caracter la sfârșitul șirului.
#include <string>
std::string::pop_back Șterge ultimul caracter (octet) din șir.
#include <string>
std::string::insert Inserează text la o anumită poziție în șir.
#include <string>
std::string::erase Șterge o porțiune din șir, dată prin poziție și lungime.
#include <string>
std::string::replace Înlocuiește o porțiune din șir, dată prin poziție și lungime, cu alt text.
#include <string>
std::string::substr Returnează o bucată din șir, de la o poziție, cu o anumită lungime.
#include <string>
std::string::find Caută un text sau caracter și returnează poziția primei apariții sau npos.
#include <string>
std::string::rfind Caută un text de la sfârșit spre început: poziția ultimei apariții sau npos.
#include <string>
std::string::find_first_of Găsește primul caracter care face parte dintr-un set de caractere.
#include <string>
std::string::find_last_of Găsește ultimul caracter care face parte dintr-un set de caractere.
#include <string>
std::string::find_first_not_of Găsește primul caracter care NU face parte dintr-un set de caractere.
#include <string>
std::string::compare Compară două șiruri și returnează un număr negativ, zero sau pozitiv.
#include <string>
std::string::starts_with Verifică dacă șirul începe cu un anumit text (C++20).
#include <string>
std::string::ends_with Verifică dacă șirul se termină cu un anumit text (C++20).
#include <string>
std::string::contains Verifică dacă șirul conține un anumit text sau caracter (C++23).
#include <string>
std::string::c_str Returnează un pointer const char* la text, terminat cu \0, pentru funcțiile C.
#include <string>
std::string::data Returnează un pointer la caracterele șirului; din C++17 poate fi și modificabil.
#include <string>
std::string::at Returnează caracterul de la o poziție, cu verificare: aruncă out_of_range.
#include <string>
std::string::front Returnează primul caracter din șir.
#include <string>
std::string::back Returnează ultimul caracter din șir.
#include <string>
std::string::resize Schimbă lungimea șirului: îl taie sau îl completează cu un caracter.
#include <string>
std::string::reserve Rezervă memorie dinainte, ca adăugările să nu realoce de fiecare dată.
#include <string>
std::string::capacity Returnează câți octeți încap în memoria deja alocată, fără realocare.
#include <string>
std::string::shrink_to_fit Cere eliberarea memoriei rezervate în plus față de lungimea șirului.
#include <string>
std::string::swap Schimbă rapid conținutul a două șiruri între ele.
#include <string>
std::string::copy Copiază o porțiune din șir într-un tablou de char, fără să adauge \0.
#include <string>
std::string::npos Valoarea specială returnată de funcțiile de căutare când nu găsesc nimic.
#include <string>
std::string::assign Înlocuiește tot conținutul șirului cu alt text sau cu n caractere repetate.
#include <string>
std::string_view Vedere doar pentru citire asupra unui text existent, fără copiere (C++17).
#include <string_view>
std::string_view::remove_prefix Micșorează vederea, eliminând n caractere de la început.
#include <string_view>
std::string_view::remove_suffix Micșorează vederea, eliminând n caractere de la sfârșit.
#include <string_view>
std::isalpha Verifică dacă un caracter este literă (a-z, A-Z).
#include <cctype>
std::isdigit Verifică dacă un caracter este cifră (0-9).
#include <cctype>
std::isalnum Verifică dacă un caracter este literă sau cifră.
#include <cctype>
std::isspace Verifică dacă un caracter este spațiu alb: spațiu, tab, rând nou.
#include <cctype>
std::isupper Verifică dacă un caracter este literă mare.
#include <cctype>
std::islower Verifică dacă un caracter este literă mică.
#include <cctype>
std::ispunct Verifică dacă un caracter este semn de punctuație (.,!? etc.).
#include <cctype>
std::toupper Transformă o literă mică în literă mare; celelalte caractere rămân la fel.
#include <cctype>
std::tolower Transformă o literă mare în literă mică; celelalte caractere rămân la fel.
#include <cctype>
std::strlen Returnează lungimea unui șir C (char*), numărând octeții până la \0.
#include <cstring>
std::strcpy Copiază un șir C în alt tablou de char, inclusiv terminatorul \0.
#include <cstring>
std::strncpy Copiază cel mult n caractere dintr-un șir C; poate lăsa rezultatul fără \0.
#include <cstring>
std::strcat Lipește un șir C la sfârșitul altuia.
#include <cstring>
std::strcmp Compară două șiruri C: zero dacă sunt egale, negativ sau pozitiv altfel.
#include <cstring>
std::strncmp Compară primele n caractere din două șiruri C.
#include <cstring>
std::strchr Caută un caracter într-un șir C și returnează pointer la el sau nullptr.
#include <cstring>
std::strstr Caută un text într-un șir C și returnează pointer la prima apariție sau nullptr.
#include <cstring>
std::memcpy Copiază n octeți dintr-o zonă de memorie în alta (zonele nu au voie să se suprapună).
#include <cstring>
std::memset Umple n octeți de memorie cu aceeași valoare, de obicei 0.
#include <cstring>
std::memcmp Compară n octeți din două zone de memorie.
#include <cstring>
std::memmove Copiază n octeți între zone de memorie care se pot suprapune.
#include <cstring>
std::printf Afișează text formatat în stil C, cu marcaje precum %d, %s, %.2f.
#include <cstdio>
std::scanf Citește valori formatate de la tastatură în stil C, cu marcaje precum %d.
#include <cstdio>
std::snprintf Scrie text formatat în stil C într-un tablou de char, fără să-i depășească mărimea.
#include <cstdio>
std::puts Afișează un șir C urmat de un rând nou.
#include <cstdio>
std::fopen Deschide un fișier în stil C și returnează un FILE* (sau nullptr la eroare).
#include <cstdio>
std::fclose Închide un fișier deschis cu fopen.
#include <cstdio>
std::to_chars Scrie un număr ca text într-un tablou de char, rapid și fără alocare (C++17).
#include <charconv>
std::from_chars Citește un număr dintr-un text, rapid, fără excepții și fără alocare (C++17).
#include <charconv>
std::regex O expresie regulată compilată, folosită pentru căutare, verificare și înlocuire în text.
#include <regex>
std::regex_match Verifică dacă TOT textul se potrivește cu o expresie regulată.
#include <regex>
std::regex_search Caută prima porțiune din text care se potrivește cu o expresie regulată.
#include <regex>
std::regex_replace Înlocuiește toate potrivirile unei expresii regulate cu alt text.
#include <regex>
std::smatch Păstrează rezultatul unei potriviri regex pe un std::string, cu grupurile capturate.
#include <regex>
std::sregex_iterator Parcurge, una câte una, toate potrivirile unei expresii regulate dintr-un șir.
#include <regex>

Containere și iteratori (102)

Funcție Ce face
std::vector Tablou dinamic: elemente consecutive în memorie, crește singur la adăugare.
#include <vector>
std::vector::push_back Adaugă un element la sfârșitul vectorului (poate realoca memoria).
#include <vector>
std::vector::emplace_back Construiește un element nou direct la sfârșitul vectorului, din argumente.
#include <vector>
std::vector::pop_back Șterge ultimul element; nu îl returnează.
#include <vector>
std::vector::size Numărul de elemente din vector (fără semn, std::size_t).
#include <vector>
std::vector::empty Verifică dacă vectorul nu are niciun element.
#include <vector>
std::vector::clear Șterge toate elementele; capacitatea rezervată rămâne.
#include <vector>
std::vector::at Elementul de la o poziție, cu verificare: aruncă std::out_of_range.
#include <vector>
std::vector::operator[] Elementul de la o poziție, v[i], fără verificarea limitelor.
#include <vector>
std::vector::front Referință la primul element.
#include <vector>
std::vector::back Referință la ultimul element.
#include <vector>
std::vector::begin Iterator la primul element.
#include <vector>
std::vector::end Iterator la poziția de după ultimul element (nu se citește).
#include <vector>
std::vector::rbegin Iterator invers la ultimul element, pentru parcurgere de la coadă.
#include <vector>
std::vector::insert Inserează elemente înaintea unei poziții; mută elementele de după.
#include <vector>
std::vector::emplace Construiește un element pe loc, înaintea unei poziții.
#include <vector>
std::vector::erase Șterge un element sau un interval și returnează iteratorul următor.
#include <vector>
std::vector::resize Schimbă numărul de elemente: adaugă valori noi sau taie de la final.
#include <vector>
std::vector::reserve Rezervă memorie pentru cel puțin n elemente, fără să le creeze.
#include <vector>
std::vector::capacity Câte elemente încap în memoria alocată fără realocare.
#include <vector>
std::vector::shrink_to_fit Cere reducerea capacității la numărul de elemente.
#include <vector>
std::vector::data Pointer la primul element, pentru funcții care lucrează cu tablouri C.
#include <vector>
std::vector::assign Înlocuiește tot conținutul cu n copii, un interval sau o listă.
#include <vector>
std::vector::swap Schimbă conținutul cu alt vector, instantaneu, fără copiere.
#include <vector>
std::erase Șterge dintr-un container toate elementele egale cu o valoare (C++20).
#include <vector>
std::erase_if Șterge dintr-un container toate elementele care îndeplinesc o condiție (C++20).
#include <vector>
std::array Tablou cu dimensiune fixă la compilare, cu interfață de container.
#include <array>
std::array::fill Pune aceeași valoare în toate elementele tabloului.
#include <array>
std::to_array Creează un std::array dintr-un tablou C sau o listă, cu dimensiunea dedusă.
#include <array>
std::deque Coadă cu două capete: adăugare și ștergere rapidă la început și la sfârșit.
#include <deque>
std::deque::push_front Adaugă un element la începutul deque-ului.
#include <deque>
std::deque::pop_front Șterge primul element al deque-ului.
#include <deque>
std::list Listă dublu înlănțuită: inserare și ștergere rapidă oriunde, fără acces după poziție.
#include <list>
std::list::sort Sortează lista (stabil), schimbând doar legăturile dintre noduri.
#include <list>
std::list::splice Mută noduri dintr-o listă în alta, fără copiere.
#include <list>
std::list::remove Șterge din listă toate elementele egale cu o valoare.
#include <list>
std::list::unique Șterge elementele egale aflate unul după altul.
#include <list>
std::list::merge Interclasează în listă o altă listă sortată, care rămâne goală.
#include <list>
std::list::reverse Inversează ordinea elementelor din listă.
#include <list>
std::forward_list Listă simplu înlănțuită, doar înainte; inserare după o poziție.
#include <forward_list>
std::map Dicționar ordonat: chei unice sortate, fiecare cu o valoare.
#include <map>
std::multimap Dicționar ordonat în care aceeași cheie poate apărea de mai multe ori.
#include <map>
std::map::insert Adaugă o pereche doar dacă cheia lipsește; spune dacă a adăugat-o.
#include <map>
std::map::emplace Construiește o pereche pe loc, dacă cheia nu există.
#include <map>
std::map::try_emplace Construiește valoarea doar dacă cheia lipsește; altfel nu atinge argumentele.
#include <map>
std::map::insert_or_assign Adaugă cheia sau îi înlocuiește valoarea; spune ce a făcut.
#include <map>
std::map::find Caută o cheie; returnează iteratorul ei sau end().
#include <map>
std::map::count Câte elemente au cheia dată (0 sau 1 la map).
#include <map>
std::map::contains Verifică dacă o cheie există, fără să o adauge (C++20).
#include <map>
std::map::erase Șterge o cheie, elementul unui iterator sau un interval.
#include <map>
std::map::lower_bound Primul element cu cheia mai mare sau egală cu valoarea dată.
#include <map>
std::map::upper_bound Primul element cu cheia strict mai mare decât valoarea dată.
#include <map>
std::map::at Valoarea unei chei existente; aruncă std::out_of_range dacă lipsește.
#include <map>
std::map::extract Scoate un nod din map fără să-l distrugă; cheia lui poate fi schimbată.
#include <map>
std::map::merge Mută în map nodurile din alt map ale căror chei lipsesc.
#include <map>
std::set Mulțime ordonată de valori unice.
#include <set>
std::multiset Mulțime ordonată care permite valori repetate.
#include <set>
std::set::insert Adaugă o valoare dacă nu există; spune dacă a fost nouă.
#include <set>
std::set::find Caută o valoare; returnează iteratorul ei sau end().
#include <set>
std::set::erase Șterge o valoare, elementul unui iterator sau un interval.
#include <set>
std::set::contains Verifică dacă o valoare există în set (C++20).
#include <set>
std::set::count De câte ori apare o valoare (0 sau 1 la set).
#include <set>
std::unordered_map Dicționar cu tabelă hash: căutare rapidă în medie, fără ordine.
#include <unordered_map>
std::unordered_multimap Tabelă hash cu chei repetate permise.
#include <unordered_map>
std::unordered_map::reserve Pregătește tabela hash pentru n elemente, fără rehash-uri ulterioare.
#include <unordered_map>
std::unordered_map::bucket_count Numărul de găleți (buckets) ale tabelei hash.
#include <unordered_map>
std::unordered_map::load_factor Media de elemente pe găleată: size() / bucket_count().
#include <unordered_map>
std::unordered_set Mulțime de valori unice cu tabelă hash, fără ordine.
#include <unordered_set>
std::unordered_multiset Mulțime cu tabelă hash care permite valori repetate.
#include <unordered_set>
std::stack Stivă (LIFO): ultimul element adăugat este primul scos.
#include <stack>
std::stack::push Pune un element în vârful stivei.
#include <stack>
std::stack::pop Scoate elementul din vârful stivei; nu îl returnează.
#include <stack>
std::stack::top Referință la elementul din vârful stivei.
#include <stack>
std::queue Coadă (FIFO): primul element adăugat este primul scos.
#include <queue>
std::priority_queue Coadă cu priorități: în vârf este mereu cel mai mare element.
#include <queue>
std::queue::front Referință la primul element din coadă (următorul servit).
#include <queue>
std::priority_queue::top Elementul cu prioritatea cea mai mare.
#include <queue>
std::span Vedere fără copiere asupra unor elemente consecutive (vector, array, tablou C).
#include <span>
std::pair Grupează două valori, first și second.
#include <utility>
std::make_pair Creează un std::pair cu tipurile deduse din argumente.
#include <utility>
std::tuple Grupează oricâte valori de tipuri diferite.
#include <tuple>
std::make_tuple Creează un std::tuple cu tipurile deduse din argumente.
#include <tuple>
std::get Elementul unui tuple, pair, array sau variant, după poziție sau tip.
#include <tuple>
std::tie Tuplu de referințe la variabile: despachetare și comparare pe mai multe câmpuri.
#include <tuple>
std::apply Apelează o funcție cu elementele unui tuplu ca argumente (C++17).
#include <tuple>
std::tuple_size Numărul de elemente al unui tip tuple, pair sau array, la compilare.
#include <tuple>
std::begin Iterator la începutul oricărui container sau tablou C.
#include <iterator>
std::end Iterator la sfârșitul oricărui container sau tablou C.
#include <iterator>
std::size Numărul de elemente al unui container sau tablou C (C++17).
#include <iterator>
std::empty Verifică dacă un container nu are elemente (C++17).
#include <iterator>
std::advance Mută un iterator cu n poziții (îl modifică).
#include <iterator>
std::next Returnează iteratorul aflat cu n poziții mai departe.
#include <iterator>
std::prev Returnează iteratorul aflat cu n poziții mai înapoi.
#include <iterator>
std::distance Numărul de poziții dintre doi iteratori.
#include <iterator>
std::back_inserter Iterator care face push_back la fiecare scriere.
#include <iterator>
std::inserter Iterator care face insert la o poziție la fiecare scriere.
#include <iterator>
std::istream_iterator Iterator care citește valori dintr-un flux de intrare cu >>.
#include <iterator>
std::ostream_iterator Iterator care scrie valori într-un flux de ieșire, cu separator.
#include <iterator>
std::reverse_iterator Adaptor care inversează sensul unui iterator; tipul lui rbegin().
#include <iterator>
std::initializer_list Tipul listei între acolade {a, b, c}, primit de funcții și constructori.
#include <initializer_list>
std::bitset Șir fix de N biți, cu operații pe biți și conversie în text sau număr.
#include <bitset>
std::flat_map Dicționar ordonat ținut în vectori sortați: căutare rapidă, inserare lentă (C++23).
#include <flat_map>

Algoritmi, numere și matematică (141)

Funcție Ce face
std::sort Sortează un interval crescător sau după o funcție de comparare, în O(n log n).
#include <algorithm>
std::stable_sort Sortează păstrând ordinea inițială a elementelor egale.
#include <algorithm>
std::partial_sort Pune în ordine doar primele k elemente cele mai mici (sau mai mari).
#include <algorithm>
std::nth_element Aduce pe poziția n elementul care ar fi acolo după sortare; util pentru mediană.
#include <algorithm>
std::is_sorted Verifică dacă un interval este deja sortat.
#include <algorithm>
std::find Caută prima apariție a unei valori și returnează un iterator către ea.
#include <algorithm>
std::find_if Găsește primul element care îndeplinește o condiție.
#include <algorithm>
std::find_if_not Găsește primul element care nu îndeplinește o condiție.
#include <algorithm>
std::count Numără de câte ori apare o valoare într-un interval.
#include <algorithm>
std::count_if Numără elementele care îndeplinesc o condiție.
#include <algorithm>
std::all_of Verifică dacă toate elementele îndeplinesc o condiție.
#include <algorithm>
std::any_of Verifică dacă măcar un element îndeplinește o condiție.
#include <algorithm>
std::none_of Verifică dacă niciun element nu îndeplinește o condiție.
#include <algorithm>
std::for_each Aplică o funcție fiecărui element dintr-un interval.
#include <algorithm>
std::transform Aplică o funcție fiecărui element și scrie rezultatele la o destinație.
#include <algorithm>
std::copy Copiază elementele unui interval la o destinație.
#include <algorithm>
std::copy_if Copiază doar elementele care îndeplinesc o condiție.
#include <algorithm>
std::copy_n Copiază primele n elemente pornind de la un iterator.
#include <algorithm>
std::move Varianta din <algorithm>: mută elementele unui interval la o destinație, fără copiere.
#include <algorithm>
std::fill Atribuie aceeași valoare tuturor elementelor unui interval.
#include <algorithm>
std::fill_n Atribuie aceeași valoare primelor n elemente.
#include <algorithm>
std::generate Completează un interval cu valorile returnate de o funcție apelată repetat.
#include <algorithm>
std::remove Mută la final elementele egale cu o valoare; ștergerea reală se face cu erase.
#include <algorithm>
std::remove_if Elimină logic elementele care îndeplinesc o condiție (tiparul erase-remove, std::erase_if).
#include <algorithm>
std::replace Înlocuiește pe loc toate aparițiile unei valori cu alta.
#include <algorithm>
std::replace_if Înlocuiește elementele care îndeplinesc o condiție cu o valoare nouă.
#include <algorithm>
std::unique Elimină duplicatele consecutive; după sortare, elimină toate dublurile.
#include <algorithm>
std::reverse Inversează pe loc ordinea elementelor.
#include <algorithm>
std::rotate Rotește elementele astfel încât un element ales devine primul.
#include <algorithm>
std::shuffle Amestecă aleatoriu elementele folosind un generator de numere aleatorii.
#include <algorithm>
std::sample Alege aleatoriu n elemente distincte dintr-un interval.
#include <algorithm>
std::min Returnează cea mai mică dintre două valori sau dintr-o listă între acolade.
#include <algorithm>
std::max Returnează cea mai mare dintre două valori sau dintr-o listă între acolade.
#include <algorithm>
std::minmax Returnează o pereche cu cea mai mică și cea mai mare valoare.
#include <algorithm>
std::min_element Returnează un iterator către cel mai mic element dintr-un interval.
#include <algorithm>
std::max_element Returnează un iterator către cel mai mare element dintr-un interval.
#include <algorithm>
std::minmax_element Găsește într-o singură parcurgere atât minimul, cât și maximul unui interval.
#include <algorithm>
std::clamp Limitează o valoare la un interval [minim, maxim].
#include <algorithm>
std::binary_search Verifică rapid, prin căutare binară, dacă o valoare există într-un interval sortat.
#include <algorithm>
std::lower_bound Într-un interval sortat, găsește primul element mai mare sau egal cu o valoare.
#include <algorithm>
std::upper_bound Într-un interval sortat, găsește primul element strict mai mare decât o valoare.
#include <algorithm>
std::equal_range Returnează perechea de iteratori care delimitează elementele egale cu o valoare.
#include <algorithm>
std::merge Combină două intervale sortate într-unul singur, tot sortat.
#include <algorithm>
std::includes Verifică dacă un interval sortat este inclus în altul (submulțime).
#include <algorithm>
std::set_union Calculează reuniunea a două intervale sortate.
#include <algorithm>
std::set_intersection Calculează intersecția a două intervale sortate.
#include <algorithm>
std::set_difference Calculează elementele din primul interval sortat care lipsesc din al doilea.
#include <algorithm>
std::equal Verifică dacă două intervale au aceleași elemente, în aceeași ordine.
#include <algorithm>
std::mismatch Găsește prima poziție unde două intervale diferă.
#include <algorithm>
std::search Caută prima apariție a unei secvențe de elemente în alt interval.
#include <algorithm>
std::adjacent_find Găsește prima pereche de elemente vecine egale sau care respectă o condiție.
#include <algorithm>
std::partition Pune înainte elementele care îndeplinesc o condiție, apoi pe celelalte.
#include <algorithm>
std::stable_partition Împarte elementele în două grupuri păstrând ordinea din fiecare grup.
#include <algorithm>
std::is_permutation Verifică dacă două intervale conțin aceleași elemente în orice ordine.
#include <algorithm>
std::next_permutation Trece la următoarea permutare în ordine lexicografică.
#include <algorithm>
std::prev_permutation Trece la permutarea precedentă în ordine lexicografică.
#include <algorithm>
std::make_heap Rearanjează un interval într-un heap, cu elementul maxim pe prima poziție.
#include <algorithm>
std::push_heap Duce la locul lui ultimul element adăugat într-un heap.
#include <algorithm>
std::pop_heap Mută maximul unui heap la final, păstrând restul ca heap.
#include <algorithm>
std::sort_heap Transformă un heap într-un interval sortat crescător.
#include <algorithm>
std::lexicographical_compare Compară două intervale ca în dicționar.
#include <algorithm>
std::swap_ranges Schimbă între ele elementele a două intervale, poziție cu poziție.
#include <algorithm>
std::accumulate Adună elementele pornind de la o valoare inițială sau le combină cu o operație.
#include <numeric>
std::reduce Combină elementele ca accumulate, dar în orice ordine, ceea ce permite calcul paralel.
#include <numeric>
std::iota Completează un interval cu valori consecutive: v, v+1, v+2…
#include <numeric>
std::partial_sum Calculează sumele parțiale (cumulate) ale unui interval.
#include <numeric>
std::inclusive_scan Sume cumulate ca partial_sum, fără ordine fixă a operațiilor (paralelizabil).
#include <numeric>
std::adjacent_difference Calculează diferențele dintre fiecare element și cel dinaintea lui.
#include <numeric>
std::inner_product Calculează produsul scalar: suma produselor elementelor de pe aceleași poziții.
#include <numeric>
std::transform_reduce Transformă fiecare element și combină rezultatele într-o singură valoare.
#include <numeric>
std::gcd Calculează cel mai mare divizor comun a două numere întregi.
#include <numeric>
std::lcm Calculează cel mai mic multiplu comun a două numere întregi.
#include <numeric>
std::midpoint Calculează mijlocul dintre două numere fără risc de depășire.
#include <numeric>
std::ranges::sort Sortează direct un container, cu comparator și proiecție opționale.
#include <ranges>
std::ranges::find Caută o valoare direct într-un container, opțional după un câmp (proiecție).
#include <ranges>
std::ranges::to Construiește un container (vector, set, string…) dintr-un range sau view.
#include <ranges>
std::views::filter Vedere care păstrează doar elementele ce îndeplinesc o condiție, fără copiere.
#include <ranges>
std::views::transform Vedere în care fiecare element este rezultatul unei funcții.
#include <ranges>
std::views::take Vedere cu primele n elemente ale unui range.
#include <ranges>
std::views::drop Vedere care sare peste primele n elemente.
#include <ranges>
std::views::reverse Vedere care parcurge un range de la final la început.
#include <ranges>
std::views::iota Generează numere consecutive într-un interval sau la infinit, fără stocare.
#include <ranges>
std::views::split Împarte un range (de exemplu un text) în bucăți, după un separator.
#include <ranges>
std::views::join Aplatizează un range de range-uri într-o singură secvență.
#include <ranges>
std::views::zip Parcurge mai multe range-uri în paralel, cu tupluri de elemente.
#include <ranges>
std::views::keys Vedere cu primul element al fiecărei perechi (cheile unui map).
#include <ranges>
std::views::values Vedere cu al doilea element al fiecărei perechi (valorile unui map).
#include <ranges>
std::views::take_while Vedere cu elementele de la început, cât timp îndeplinesc o condiție.
#include <ranges>
std::views::repeat Generează aceeași valoare de n ori sau la infinit.
#include <ranges>
std::abs Returnează valoarea absolută a unui număr.
#include <cmath>
std::sqrt Calculează rădăcina pătrată.
#include <cmath>
std::cbrt Calculează rădăcina cubică, inclusiv pentru numere negative.
#include <cmath>
std::pow Ridică un număr la o putere.
#include <cmath>
std::exp Calculează e la puterea x.
#include <cmath>
std::log Calculează logaritmul natural (baza e).
#include <cmath>
std::log10 Calculează logaritmul în baza 10.
#include <cmath>
std::log2 Calculează logaritmul în baza 2.
#include <cmath>
std::sin Calculează sinusul unui unghi dat în radiani.
#include <cmath>
std::cos Calculează cosinusul unui unghi dat în radiani.
#include <cmath>
std::tan Calculează tangenta unui unghi dat în radiani.
#include <cmath>
std::asin Calculează arcsinusul: unghiul (în radiani) care are sinusul dat.
#include <cmath>
std::acos Calculează arccosinusul: unghiul (în radiani) care are cosinusul dat.
#include <cmath>
std::atan Calculează arctangenta: unghiul (în radiani) care are tangenta dată.
#include <cmath>
std::atan2 Calculează unghiul punctului (x, y), ținând cont de cadran.
#include <cmath>
std::ceil Rotunjește în sus la cel mai apropiat întreg.
#include <cmath>
std::floor Rotunjește în jos la cel mai apropiat întreg.
#include <cmath>
std::round Rotunjește la cel mai apropiat întreg; la jumătate, departe de zero.
#include <cmath>
std::trunc Taie partea zecimală, rotunjind spre zero.
#include <cmath>
std::fmod Calculează restul împărțirii pentru numere cu virgulă.
#include <cmath>
std::hypot Calculează √(x² + y²) (ipotenuza) fără depășire.
#include <cmath>
std::fabs Returnează valoarea absolută a unui număr cu virgulă.
#include <cmath>
std::fmin Returnează minimul a două numere cu virgulă, ignorând NaN.
#include <cmath>
std::fmax Returnează maximul a două numere cu virgulă, ignorând NaN.
#include <cmath>
std::isnan Verifică dacă un număr cu virgulă este NaN.
#include <cmath>
std::isinf Verifică dacă un număr cu virgulă este infinit.
#include <cmath>
std::lerp Interpolare liniară între două valori: a + t·(b − a).
#include <cmath>
std::rand Generatorul vechi din C: un întreg pseudo-aleatoriu între 0 și RAND_MAX.
#include <cstdlib>
std::srand Stabilește seed-ul pentru rand().
#include <cstdlib>
std::exit Oprește programul cu un cod de ieșire, după funcțiile atexit și distrugerea obiectelor statice.
#include <cstdlib>
std::atoi Transformă un text C în int, fără semnalarea erorilor.
#include <cstdlib>
std::atof Transformă un text C în double, fără semnalarea erorilor.
#include <cstdlib>
std::system Rulează o comandă în shell-ul sistemului de operare.
#include <cstdlib>
std::getenv Citește valoarea unei variabile de mediu sau returnează nullptr.
#include <cstdlib>
std::qsort Sortarea din C, cu funcție de comparare pe pointeri void*.
#include <cstdlib>
std::div Calculează câtul și restul împărțirii întregi într-un singur apel.
#include <cstdlib>
std::random_device Sursă de numere aleatorii nedeterministe de la sistem, folosită ca seed.
#include <random>
std::mt19937 Generatorul Mersenne Twister: numere pseudo-aleatorii rapide, reproductibile cu seed fix.
#include <random>
std::uniform_int_distribution Întregi aleatorii dintr-un interval [a, b], cu șanse egale.
#include <random>
std::uniform_real_distribution Numere reale aleatorii distribuite uniform în [a, b).
#include <random>
std::normal_distribution Numere aleatorii după distribuția normală (gaussiană), cu medie și abatere dată.
#include <random>
std::bernoulli_distribution Produce true cu probabilitatea p, altfel false.
#include <random>
std::discrete_distribution Alege un index aleatoriu cu probabilități proporționale cu ponderile date.
#include <random>
std::numeric_limits Limitele și proprietățile unui tip numeric: max, min, lowest, epsilon, infinity.
#include <limits>
std::numbers::pi Constanta π (C++20); antetul definește și e, sqrt2, phi și altele.
#include <numbers>
std::popcount Numără biții de 1 dintr-un întreg fără semn.
#include <bit>
std::bit_cast Reinterpretează sigur biții unui obiect ca alt tip de aceeași mărime.
#include <bit>
std::has_single_bit Verifică dacă un întreg fără semn este o putere a lui 2.
#include <bit>
std::bit_width Returnează câți biți sunt necesari pentru a reprezenta un întreg fără semn.
#include <bit>
std::rotl Rotește biții unui întreg fără semn spre stânga.
#include <bit>
std::complex Numere complexe (a + bi) cu operații aritmetice și funcții matematice.
#include <complex>
std::ratio Fracție calculată la compilare, folosită pentru unități ca milli sau kilo.
#include <ratio>

Memorie, utilitare, timp, fire de execuție și erori (112)

Funcție Ce face
std::unique_ptr Pointer inteligent cu un singur proprietar; șterge automat obiectul când iese din domeniu.
#include <memory>
std::make_unique Creează un obiect pe heap și returnează un unique_ptr care îl deține.
#include <memory>
std::shared_ptr Pointer inteligent cu proprietate comună; obiectul dispare când ultimul proprietar dispare.
#include <memory>
std::make_shared Creează un obiect și un shared_ptr către el, cu o singură alocare.
#include <memory>
std::weak_ptr Referință slabă la un obiect deținut de shared_ptr, care nu îl ține în viață.
#include <memory>
std::unique_ptr::reset Șterge obiectul deținut și, opțional, preia un pointer nou.
#include <memory>
std::unique_ptr::release Renunță la proprietate fără să șteargă obiectul și returnează pointerul brut.
#include <memory>
std::unique_ptr::get Returnează pointerul brut, fără să renunțe la proprietate.
#include <memory>
std::shared_ptr::use_count Returnează câți shared_ptr dețin în prezent același obiect.
#include <memory>
std::weak_ptr::lock Returnează un shared_ptr valid dacă obiectul mai există, altfel unul gol.
#include <memory>
std::enable_shared_from_this Bază care permite unui obiect să obțină un shared_ptr către el însuși.
#include <memory>
std::addressof Returnează adresa reală a unui obiect, chiar dacă operatorul & a fost redefinit.
#include <memory>
std::allocator Alocatorul implicit al containerelor: rezervă și eliberează memorie brută pentru obiecte.
#include <memory>
std::swap Schimbă între ele valorile a două variabile.
#include <utility>
std::exchange Pune o valoare nouă într-o variabilă și returnează valoarea veche.
#include <utility>
std::forward Transmite un argument mai departe păstrând felul lui (lvalue sau rvalue).
#include <utility>
std::as_const Returnează o referință const la un obiect.
#include <utility>
std::to_underlying Transformă o valoare de enumerare în numărul întreg din spatele ei.
#include <utility>
std::unreachable Marchează un punct din cod care nu poate fi atins; atingerea lui este comportament nedefinit.
#include <utility>
std::in_range Verifică dacă un număr întreg încape în alt tip întreg.
#include <utility>
std::optional Valoare care poate lipsi: conține fie un obiect, fie nimic.
#include <optional>
std::optional::value Returnează valoarea; aruncă bad_optional_access dacă optional este gol.
#include <optional>
std::optional::value_or Returnează valoarea sau o valoare implicită dacă optional este gol.
#include <optional>
std::optional::has_value Spune dacă optional conține o valoare.
#include <optional>
std::nullopt Constanta care înseamnă un optional gol.
#include <optional>
std::make_optional Creează un optional cu tipul dedus din argument.
#include <optional>
std::optional::and_then Aplică o funcție care returnează optional, doar dacă există valoare.
#include <optional>
std::optional::transform Aplică o funcție pe valoare și pune rezultatul într-un optional nou.
#include <optional>
std::variant Valoare care are, la un moment dat, unul dintre mai multe tipuri posibile.
#include <variant>
std::visit Apelează o funcție cu valoarea curentă dintr-un variant, oricare ar fi tipul ei.
#include <variant>
std::holds_alternative Verifică dacă un variant conține acum un anumit tip.
#include <variant>
std::get_if Returnează un pointer la valoarea din variant dacă tipul se potrivește, altfel nullptr.
#include <variant>
std::any Container pentru o singură valoare de orice tip copiabil.
#include <any>
std::any_cast Scoate valoarea dintr-un any cu tipul exact; aruncă bad_any_cast dacă tipul diferă.
#include <any>
std::expected Rezultatul unei operații care poate eșua: fie valoarea, fie motivul erorii.
#include <expected>
std::unexpected Construiește partea de eroare a unui expected.
#include <expected>
std::function Variabilă care poate ține orice funcție, lambda sau obiect apelabil cu o semnătură dată.
#include <functional>
std::bind Creează o funcție nouă fixând unele argumente sau schimbându-le ordinea.
#include <functional>
std::invoke Apelează orice lucru apelabil, inclusiv pointeri la metode și la membri.
#include <functional>
std::ref Împachetează o referință ca să treacă prin funcții care copiază argumentele.
#include <functional>
std::cref Împachetează o referință const ca să treacă prin funcții care copiază argumentele.
#include <functional>
std::hash Obiect-funcție care calculează hash-ul unei valori (folosit de containerele unordered).
#include <functional>
std::less Obiect-funcție pentru comparația a < b; comparatorul implicit al sortărilor și al map.
#include <functional>
std::greater Obiect-funcție pentru comparația a > b; util pentru ordine descrescătoare.
#include <functional>
std::plus Obiect-funcție care returnează a + b.
#include <functional>
std::bind_front Fixează primele argumente ale unei funcții și returnează o funcție pentru restul.
#include <functional>
std::mem_fn Transformă un pointer la metodă sau câmp într-o funcție care primește obiectul.
#include <functional>
std::chrono::system_clock Ceasul sistemului: data și ora reale (UTC).
#include <chrono>
std::chrono::steady_clock Ceas monoton, care nu sare înapoi; potrivit pentru măsurarea duratelor.
#include <chrono>
std::chrono::high_resolution_clock Ceasul cu cea mai mare precizie; alias pentru steady_clock sau system_clock.
#include <chrono>
std::chrono::duration O durată de timp cu unitate de măsură.
#include <chrono>
std::chrono::duration_cast Transformă o durată în altă unitate, trunchiind ce nu încape.
#include <chrono>
std::chrono::milliseconds Durată măsurată în milisecunde.
#include <chrono>
std::chrono::seconds Durată măsurată în secunde.
#include <chrono>
std::chrono::year_month_day Dată calendaristică (an, lună, zi) cu validare și calcule.
#include <chrono>
std::chrono::time_point Moment în timp măsurat după un anumit ceas.
#include <chrono>
std::thread Pornește o funcție pe un fir de execuție separat.
#include <thread>
std::thread::join Așteaptă ca firul de execuție să termine.
#include <thread>
std::thread::detach Lasă firul să ruleze independent; nu mai poate fi așteptat cu join.
#include <thread>
std::jthread Fir de execuție cu join automat la distrugere și oprire cooperativă (stop_token).
#include <thread>
std::this_thread::sleep_for Oprește firul curent pentru cel puțin durata dată.
#include <thread>
std::this_thread::get_id Returnează identificatorul firului de execuție curent.
#include <thread>
std::thread::hardware_concurrency Returnează câte fire pot rula cu adevărat în paralel (0 dacă nu se știe).
#include <thread>
std::mutex Încuietoare pe care un singur fir o poate ține la un moment dat.
#include <mutex>
std::lock_guard Ocupă un mutex și îl eliberează automat la ieșirea din bloc.
#include <mutex>
std::unique_lock Blocare flexibilă de mutex: se poate elibera, relua, amâna și muta.
#include <mutex>
std::scoped_lock Ocupă mai multe mutexuri deodată, fără blocaj reciproc, și le eliberează automat.
#include <mutex>
std::call_once Rulează o funcție o singură dată, chiar dacă o cer mai multe fire simultan.
#include <mutex>
std::condition_variable Permite unui fir să aștepte până când alt fir îl anunță că o condiție s-a îndeplinit.
#include <condition_variable>
std::async Rulează o funcție (de obicei pe alt fir) și returnează un future cu rezultatul.
#include <future>
std::future Rezultat disponibil în viitor; get() îl așteaptă și îl returnează.
#include <future>
std::promise Capătul de scriere al unui future: trimite o valoare sau o excepție.
#include <future>
std::atomic Variabilă citită și modificată sigur de mai multe fire, fără mutex.
#include <atomic>
std::exception Clasa de bază a tuturor excepțiilor din biblioteca standard.
#include <exception>
std::exception::what Returnează mesajul care descrie excepția.
#include <exception>
std::terminate Oprește imediat programul; apelată automat pentru excepțiile neprinse.
#include <exception>
std::current_exception Returnează un exception_ptr către excepția tratată acum.
#include <exception>
std::rethrow_exception Aruncă din nou o excepție salvată într-un exception_ptr.
#include <exception>
std::runtime_error Excepție pentru erori care apar la rulare din cauze externe.
#include <stdexcept>
std::logic_error Excepție pentru greșeli de logică ce puteau fi evitate prin cod corect.
#include <stdexcept>
std::out_of_range Excepție pentru index sau cheie în afara limitelor (at, substr, map::at).
#include <stdexcept>
std::invalid_argument Excepție pentru un argument cu valoare nepermisă (de exemplu stoi pe text).
#include <stdexcept>
std::overflow_error Excepție pentru un rezultat prea mare pentru tipul folosit.
#include <stdexcept>
std::domain_error Excepție pentru o valoare în afara domeniului unei funcții matematice.
#include <stdexcept>
assert Macro care oprește programul cu un mesaj dacă o condiție internă este falsă.
#include <cassert>
std::filesystem::path Calea unui fișier sau director, cu operații pe componente (nume, extensie, părinte).
#include <filesystem>
std::filesystem::exists Verifică dacă un fișier sau director există.
#include <filesystem>
std::filesystem::create_directory Creează un director (create_directories creează și părinții).
#include <filesystem>
std::filesystem::remove Șterge un fișier sau un director gol (remove_all șterge recursiv).
#include <filesystem>
std::filesystem::file_size Returnează mărimea unui fișier, în octeți.
#include <filesystem>
std::filesystem::directory_iterator Parcurge intrările dintr-un director.
#include <filesystem>
std::filesystem::copy Copiază fișiere sau directoare, opțional recursiv.
#include <filesystem>
std::filesystem::rename Redenumește sau mută un fișier ori un director.
#include <filesystem>
std::filesystem::current_path Returnează sau schimbă directorul de lucru curent.
#include <filesystem>
std::filesystem::recursive_directory_iterator Parcurge intrările unui director și ale tuturor subdirectoarelor.
#include <filesystem>
std::is_same Verifică la compilare dacă două tipuri sunt identice.
#include <type_traits>
std::is_integral Verifică la compilare dacă un tip este întreg (inclusiv bool și char).
#include <type_traits>
std::is_floating_point Verifică la compilare dacă un tip este real (float, double, long double).
#include <type_traits>
std::enable_if Activează un șablon doar când o condiție pe tipuri este adevărată (SFINAE).
#include <type_traits>
std::conditional Alege la compilare unul din două tipuri, după o condiție.
#include <type_traits>
std::remove_reference Scoate referința dintr-un tip (T& și T&& devin T).
#include <type_traits>
std::decay Transformă un tip ca la transmiterea prin valoare (fără referință, const, tablou).
#include <type_traits>
std::is_base_of Verifică la compilare dacă o clasă este baza alteia.
#include <type_traits>
std::integral Concept satisfăcut de tipurile întregi.
#include <concepts>
std::floating_point Concept satisfăcut de tipurile reale.
#include <concepts>
std::same_as Concept satisfăcut când două tipuri sunt identice.
#include <concepts>
std::convertible_to Concept satisfăcut când un tip se poate converti implicit în altul.
#include <concepts>
std::source_location Fișierul, funcția, linia și coloana locului din cod unde este apelată o funcție.
#include <source_location>
std::int32_t Întreg cu semn de exact 32 de biți.
#include <cstdint>
std::int64_t Întreg cu semn de exact 64 de biți.
#include <cstdint>
std::uint8_t Întreg fără semn de exact 8 biți (0–255).
#include <cstdint>
std::size_t Tip întreg fără semn pentru mărimi și indici; returnat de sizeof și size().
#include <cstdint>