...
Pregătire interviuri

100 de întrebări de interviu C++, cu răspunsuri

Întrebările despre C++ care apar des la interviurile tehnice, fiecare cu un răspuns scurt, explicația pe larg și ce urmărește intervievatorul. Citește-le sau exersează cu răspunsurile ascunse. Înveți de la zero cu Curs C++: primele 15 lecții sunt gratuite.

Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

  • 100întrebări
  • 50junior
  • 35mid
  • 15senior
  • 120 minde citit
Întrebări de interviu C++ cu răspunsuri

La un interviu pentru un rol în care se lucrează cu C++, întrebările despre limbaj vin de obicei în trei forme: teorie (ce face compilatorul, ce garantează standardul), fragmente de cod la care trebuie să spui ce se afișează sau unde e bug-ul și o problemă scrisă live sau ca temă, în care contează la fel de mult cât de idiomatic e codul. C++ are multe reguli subtile, așa că intervievatorii urmăresc în special dacă știi de ce se întâmplă un lucru, nu doar ce se întâmplă.

De la un junior se așteaptă fundamente solide: referințe și const, clase, constructori și destructori, containerele și algoritmii STL de bază, smart pointers și excepții. La nivel mid apar mutarea și copy elision, șabloanele și concepts, invalidarea iteratorilor, comportamentul nedefinit și sincronizarea între thread-uri. Întrebările de nivel senior verifică designul, costurile reale ale abstracțiilor și modul în care conduci schimbări într-o bază de cod mare.

Întrebările sunt grupate pe teme, de la junior la senior, și se referă la C++ modern (C++11–C++20), cu mențiuni explicite când un detaliu ține de C++23. Citește întâi răspunsul scurt și încearcă să-l explici cu voce tare, apoi compară cu răspunsul detaliat. Pentru fragmentele de cod, ghicește rezultatul înainte să citești explicația și compilează-le singur. Bazele comune cu limbajul C și întrebările generale de meserie sunt pe paginile dedicate.

Referințe, tipuri și funcții

1 Junior

Ce afișează codul următor? Poate fi „mutată” o referință pe altă variabilă?

C++
int a = 1, b = 2;
int& r = a;
r = b;
r = 5;
std::cout << a << ' ' << b << '\n';

Răspuns scurt: Afișează 5 2. O referință este legată o singură dată, la inițializare, de a; r = b copiază valoarea lui b în a, nu leagă referința de b.

O referință este un alt nume pentru un obiect existent. Legătura se face obligatoriu la declarare (int& r; nu compilează) și nu se mai poate schimba pe toată durata de viață a referinței. Orice operație pe r este, de fapt, o operație pe a.

Pas cu pas:

  • int& r = a; leagă r de a.
  • r = b; nu „mută” referința. Este o atribuire obișnuită: a primește valoarea 2.
  • r = 5; scrie 5 tot în a.
  • b nu a fost atins, deci rămâne 2.

Rezultatul este 5 2. Mulți candidați spun 1 5, gândindu-se la referință ca la un pointer care poate fi reorientat.

Dacă ai nevoie de ceva care să poată arăta pe rând spre obiecte diferite, folosești un pointer sau std::reference_wrapper<int> (din <functional>), care se poate reasigna și se poate pune într-un container:

C++
std::reference_wrapper<int> w = a;
w = b;          // acum w se referă la b
w.get() = 7;    // b devine 7

Tot din cauza acestei reguli, o clasă cu un membru de tip referință nu are operator de atribuire generat implicit: compilatorul nu are cum să „reasigneze” referința.

Ce urmărește intervievatorul: Se verifică dacă înțelegi modelul mental al referinței ca alias permanent. Greșeala tipică este să o tratezi ca pe un pointer care poate fi redirecționat.

Eroarea, în practică:reference variable requires an initializer

2 Junior

Ce afișează programul și când alegi transmiterea prin valoare, prin referință sau prin const&?

C++
void dublu1(int x)  { x *= 2; }
void dublu2(int& x) { x *= 2; }

int main() {
    int n = 5;
    dublu1(n);
    dublu2(n);
    dublu2(n);
    std::cout << n << '\n';
}

Răspuns scurt: Afișează 20: dublu1 lucrează pe o copie, iar cele două apeluri dublu2 modifică direct n (5, 10, 20). Prin valoare pentru tipuri mici, prin & când funcția modifică argumentul, prin const& pentru obiecte mari doar citite.

La transmiterea prin valoare, parametrul este o copie. dublu1 dublează copia, care dispare la ieșirea din funcție, deci n rămâne 5. La transmiterea prin referință, parametrul este chiar variabila apelantului, așa că fiecare dublu2 o modifică: 10, apoi 20.

Regulile practice folosite în cod real:

  • Prin valoare pentru tipuri mici și ieftin de copiat: int, double, char, pointeri, iteratori, std::string_view.
  • Prin T& când funcția trebuie să modifice argumentul (parametru de ieșire). Numele funcției ar trebui să facă evident acest lucru.
  • Prin const T& pentru obiecte mari pe care doar le citești: std::string, std::vector, clase proprii. Eviți copia și garantezi că nu modifici nimic.
C++
double medie(const std::vector<double>& v);
void normalizeaza(std::vector<double>& v);

O diferență importantă: dublu2(5) nu compilează, pentru că o referință neconstantă nu se poate lega de o valoare temporară. În schimb const int& acceptă și 5, și n + 1.

Pentru tipuri mici, const int& nu aduce nimic, ba poate fi mai lent, pentru că funcția lucrează printr-o adresă în loc de un registru.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi efectul fiecărui mod de transmitere și că ai reguli clare pentru alegere. Greșeala tipică este să pui const& peste tot, inclusiv la int.

Eroarea, în practică:loop variable creates a copy

3 Junior

Este valid codul de mai jos? Ce se întâmplă cu obiectul temporar întors de make()?

C++
std::string make() { return "salut"; }

int main() {
    const std::string& r1 = make();
    std::string& r2 = make();
    std::cout << r1 << '\n';
}

Răspuns scurt: Linia cu r1 este validă: legarea unui temporar de o referință const& îi prelungește viața până la sfârșitul domeniului lui r1. Linia cu r2 nu compilează, pentru că o referință neconstantă nu se leagă de un temporar.

make() întoarce un obiect temporar (un prvalue). În mod normal, un temporar este distrus la sfârșitul expresiei complete în care apare. Există însă o regulă specială: când un temporar este legat direct de o referință const T& (sau T&&), durata lui de viață se prelungește până când referința iese din domeniu. De aceea r1 este perfect sigur.

Pentru r2, regula limbajului interzice legarea unei referințe lvalue neconstante de un rvalue, ca să nu modifici din greșeală un obiect care oricum dispare. Compilatorul dă eroare. Dacă vrei să modifici rezultatul, îl păstrezi prin valoare (std::string s = make();, fără nicio copie datorită copy elision) sau folosești std::string&& r = make();.

Regula are limite care produc bug-uri reale:

  • Nu se propagă prin funcții care întorc referințe. const std::string& m = std::max(make(), std::string("a")); lasă m agățat de un temporar deja distrus.
  • Nu se aplică unui membru referință inițializat în constructor dintr-un temporar.
  • Nu se aplică dacă legi o referință de un membru al unui obiect întors de o funcție care întoarce referință.

În cod nou, cel mai simplu este să păstrezi rezultatele funcțiilor prin valoare și să lași compilatorul să elimine copiile.

Ce urmărește intervievatorul: Se verifică înțelegerea duratei de viață a temporarelor. Candidații care știu regula, dar nu și limitele ei, scriu cod cu referințe agățate (dangling).

Eroarea, în practică:non-const lvalue reference cannot bind to temporaryobject backing the pointer will be destroyed

4 Junior

Care e diferența dintre inițializarea cu paranteze și cu acolade? Ce conține fiecare variabilă?

C++
int x(3.7);
int y{3.7};
std::vector<int> a(3, 1);
std::vector<int> b{3, 1};

Răspuns scurt: x devine 3 (conversie cu trunchiere), iar y{3.7} nu compilează, pentru că acoladele interzic conversiile care pierd informație (narrowing). a are trei elemente {1, 1, 1}, iar b are două: {3, 1}.

Inițializarea cu acolade (numită și inițializare uniformă, din C++11) are două proprietăți care o deosebesc de cea cu paranteze.

Prima: interzice narrowing, adică conversiile implicite care pot pierde informație, cum ar fi double în int sau long long în int cu o valoare care nu încape. int y{3.7}; este eroare de compilare, pe când int x(3.7); trunchiază tăcut la 3.

A doua: dacă tipul are un constructor care primește std::initializer_list, acoladele îl preferă aproape mereu. std::vector<int> b{3, 1} construiește lista cu elementele 3 și 1. Varianta cu paranteze apelează constructorul „număr de elemente, valoare”, deci a are trei de 1. La interviu, aceasta este cea mai frecventă capcană.

Acoladele rezolvă și „most vexing parse”:

C++
Widget w();   // declară o funcție care întoarce Widget!
Widget w2{};  // obiect construit implicit

Cu auto regulile diferă: din C++17, auto v{5}; este int, iar auto v = {5}; este std::initializer_list<int>.

Recomandarea uzuală este să folosești acolade implicit, pentru siguranța la narrowing, și paranteze explicit când vrei constructorul „mărime, valoare” al unui container.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi capcana cu initializer_list și protecția la narrowing. Mulți candidați cred că cele două forme sunt echivalente.

Eroarea, în practică:type 'double' cannot be narrowed to 'int'base of member reference is a function

5 Junior

Ce se afișează pentru fiecare apel și care dintre ele nu compilează?

C++
void f(int)    { std::cout << "int\n"; }
void f(double) { std::cout << "double\n"; }

int main() {
    f('a');
    f(3.0f);
    f(5L);
}

Răspuns scurt: f('a') afișează int și f(3.0f) afișează double, fiindcă ambele sunt promoții. f(5L) nu compilează: conversia long în int și cea long în double au același rang, deci apelul este ambiguu.

La supraîncărcare (overloading), compilatorul alege funcția pe baza unui clasament al conversiilor necesare pentru fiecare argument. Ordinea, de la cea mai bună:

  • potrivire exactă (inclusiv adăugarea de const sau array la pointer);
  • promoție: char, short, bool în int; float în double;
  • conversie standard: orice altă conversie între tipuri numerice, de exemplu long în int, int în double, double în int;
  • conversie definită de utilizator (constructor sau operator de conversie).

Pentru f('a'): char în int este promoție, iar char în double este conversie, deci câștigă f(int). Pentru f(3.0f): float în double este promoție, deci câștigă f(double). Pentru f(5L): nu există f(long), iar ambele variante cer o conversie de același rang. Compilatorul nu are criteriu de departajare și raportează call of overloaded 'f(long int)' is ambiguous.

Soluțiile sunt să adaugi supraîncărcarea lipsă sau să faci conversia explicit: f(static_cast<int>(5L)).

O capcană înrudită: f(0) cu supraîncărcările f(int) și f(char*) alege f(int). Este unul dintre motivele pentru care în C++ modern scrii nullptr, nu 0, când te referi la un pointer.

Ce urmărește intervievatorul: Se verifică dacă știi că există reguli precise de rezolvare a supraîncărcării, nu „compilatorul ghicește”. Greșeala tipică este să crezi că 5L merge automat la double, fiindcă „e mai mare”.

Eroarea, în practică:call to 'afiseaza' is ambiguous

6 Junior

Care e diferența dintre enum și enum class? De ce se preferă enum class în C++ modern?

Răspuns scurt: enum class (C++11) are valorile în domeniul propriu de nume (Culoare::Rosu) și nu se convertește implicit la int. enum clasic își varsă numele în domeniul înconjurător și se convertește tăcut la întreg, ceea ce produce conflicte și bug-uri.

Cu un enum clasic, numele valorilor intră direct în domeniul în care e declarat enum-ul. Două enum-uri cu aceeași valoare intră în conflict:

C++
enum Semafor { Rosu, Galben, Verde };
enum Fruct   { Mar, Rosu };            // eroare: Rosu redefinit

Mai grav, valorile se convertesc implicit la int, așa că if (culoare == 2) sau compararea a două enum-uri fără legătură compilează fără avertisment.

enum class (numit și scoped enum) rezolvă ambele probleme:

C++
enum class Semafor : std::uint8_t { Rosu, Galben, Verde };
Semafor s = Semafor::Verde;
int cod = static_cast<int>(s);   // conversia trebuie cerută explicit
// if (s == 2) {}                // eroare de compilare

Alte avantaje:

  • Poți alege tipul subiacent (: std::uint8_t), util pentru structuri compacte sau protocoale. Și enum clasic acceptă asta din C++11, dar la enum class implicitul este int și e garantat.
  • Se poate declara în avans (enum class Stare : int;), ceea ce reduce dependențele dintre headere.
  • Din C++20, using enum Semafor; aduce local numele în domeniu, de exemplu într-un switch, ca să nu repeți prefixul.

enum clasic mai are sens rar, de exemplu pentru flag-uri combinate cu |, unde conversia la întreg este dorită. Și acolo, multe echipe preferă enum class cu operatori supraîncărcați.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi de ce a apărut enum class și că îl folosești implicit. Greșeala tipică este să spui doar „e mai modern”, fără să explici domeniul de nume și conversiile.

7 Junior

La ce folosesc spațiile de nume (namespaces)? De ce nu se pune using namespace std; într-un header?

Răspuns scurt: Un namespace grupează nume sub un prefix comun, ca să eviți coliziunile între biblioteci. using namespace std; într-un header importă toate numele din std în fiecare fișier care include header-ul, ceea ce poate produce ambiguități greu de urmărit.

Un namespace este un domeniu de nume. Biblioteca standard își pune totul în std, iar un proiect își pune codul în propriul namespace, de exemplu banca::Cont. Astfel, funcția ta count nu intră în conflict cu std::count.

using namespace std; aduce în domeniul curent toate numele din std, inclusiv cele pe care nu le cunoști. Într-un fișier .cpp mic sau într-un exercițiu efectul e limitat la acel fișier. Într-un header, însă, efectul se propagă în fiecare fișier care îl include, direct sau indirect, iar cel care include nu are cum să-l anuleze. Rezultatul tipic:

C++
#include "util.h"     // conține using namespace std;
int count = 0;
int main() { count++; }  // eroare: referință ambiguă la 'count'

Alternative bune:

  • prefix explicit std:: (stilul cel mai răspândit în cod profesional);
  • using std::string; pentru un singur nume, în fișiere .cpp sau în interiorul unei funcții;
  • alias pentru namespace-uri lungi: namespace fs = std::filesystem;.

Un caz special este namespace-ul anonim: namespace { int contor = 0; } într-un .cpp face numele vizibile doar în acel fișier (internal linkage). Este alternativa C++ la static pentru funcții și variabile globale locale fișierului.

Ce urmărește intervievatorul: Se verifică dacă ai lucrat în proiecte cu mai multe fișiere, nu doar în exerciții. Greșeala tipică este să nu vezi diferența dintre using într-un .cpp și într-un header.

Eroarea, în practică:use of undeclared identifier 'cout'unknown type name 'string'

8 Junior

Care dintre liniile de mai jos compilează și ce conține fiecare variabilă?

C++
std::string s1 = "abc" + "def";
std::string s2 = std::string("abc") + "def";
std::string s3 = "abc" + 1;
std::string s4 = "abc" + std::string("def");

Răspuns scurt: s1 nu compilează, pentru că "abc" și "def" sunt tablouri de char, iar doi pointeri nu se pot aduna. s2 și s4 conțin abcdef. s3 compilează, dar conține bc: este aritmetică de pointeri, nu concatenare.

Un literal de tip text, "abc", nu este std::string. Tipul lui este const char[4], care într-o expresie devine un pointer const char* spre primul caracter.

  • "abc" + "def": adunarea a doi pointeri nu are sens, deci compilatorul dă eroare.
  • std::string("abc") + "def": operandul stâng este std::string, deci se folosește operator+ definit pentru string și const char*, care concatenează.
  • "abc" + 1: pointer plus întreg este aritmetică de pointeri validă. Rezultatul arată spre 'b', iar s3 devine "bc". Fără avertisment, este un bug clasic.
  • "abc" + std::string("def"): există și operator+(const char*, const std::string&), deci funcționează.

Soluția elegantă din C++14 este sufixul s:

C++
using namespace std::string_literals;
auto t = "abc"s + "def";   // std::string("abcdef")

Alte detalii despre std::string care apar la interviu:

  • s[i] nu verifică limitele, iar s.at(i) aruncă std::out_of_range.
  • s.size() și s.length() sunt identice și întorc std::size_t, un tip fără semn.
  • s.c_str() dă un const char* pentru API-uri C, valid doar până la următoarea modificare a lui s.

Ce urmărește intervievatorul: Intervievatorul verifică dacă faci diferența dintre literal C și std::string. Linia cu + 1 arată dacă înțelegi că un literal se comportă ca un pointer.

Eroarea, în practică:invalid operands ('const char[8]' and ...)adding 'int' to a string does not append

9 Junior

Ce afișează codul de mai jos și de ce?

C++
std::vector<int> v{1, 2, 3};
int i = -1;
if (i < v.size())
    std::cout << "mai mic\n";
else
    std::cout << "mai mare\n";

Răspuns scurt: Afișează mai mare. v.size() este std::size_t, fără semn, așa că i este convertit la fără semn, iar -1 devine cea mai mare valoare reprezentabilă, mult peste 3.

Când compari un int cu un tip întreg fără semn de rang cel puțin egal (std::size_t), regulile de conversie aritmetică transformă operandul cu semn în fără semn. -1 devine SIZE_MAX (de exemplu 18446744073709551615 pe 64 de biți), deci condiția i < v.size() este falsă. Comportamentul este bine definit, nu UB, dar aproape niciodată nu e ce voia autorul.

Aceeași familie de bug-uri:

C++
// buclă infinită: i >= 0 este mereu adevărat pentru size_t
for (std::size_t i = v.size() - 1; i >= 0; --i) { }

// pe un vector gol, v.size() - 1 este uriaș
for (std::size_t i = 0; i < v.size() - 1; ++i) { }

Cum te aperi:

  • compilezi cu -Wall -Wextra, care include -Wsign-compare și semnalează comparația;
  • în C++20 folosești std::ssize(v), care întoarce un tip cu semn, sau std::cmp_less(i, v.size()) din <utility>, care compară corect matematic tipuri diferite;
  • preferi range-for sau algoritmi în locul indicilor manuali;
  • pentru parcurgere inversă: for (auto it = v.rbegin(); it != v.rend(); ++it).

Merită să spui la interviu că tipul fără semn al lui size() este considerat chiar de membri ai comitetului C++ o decizie istorică nefericită, de aceea a apărut std::ssize.

Ce urmărește intervievatorul: Se verifică atenția la conversiile implicite dintre tipuri cu și fără semn. Greșeala tipică este să răspunzi „mai mic”, judecând matematic, nu după regulile limbajului.

Eroarea, în practică:comparison of integers of different signsunsigned expression >= 0 is always true

10 Junior

Care sunt regulile pentru parametrii cu valori implicite? Unde e problema în codul următor?

C++
void log(const std::string& msg, int nivel = 1);
void log(const std::string& msg);

int main() { log("start"); }

Răspuns scurt: Valorile implicite se pun de la dreapta la stânga, o singură dată (de obicei în declarația din header) și se evaluează la fiecare apel. Aici apelul log("start") este ambiguu: se potrivesc la fel de bine ambele supraîncărcări.

Regulile principale:

  • După primul parametru cu valoare implicită, toți cei din dreapta lui trebuie să aibă și ei. void f(int a = 1, int b); nu compilează.
  • Valoarea se specifică o singură dată, de obicei în declarația din header. Dacă o repeți și în definiția din .cpp, primești eroare de redefinire.
  • Expresia implicită se evaluează la fiecare apel, în contextul apelantului. void f(int t = timpCurent()); apelează timpCurent() de fiecare dată.
  • Valoarea implicită ține de declarația văzută la apel, nu de funcție. De aici vine și comportamentul surprinzător la funcțiile virtuale, unde contează tipul static al obiectului.

În codul dat, ambele declarații sunt legale separat, dar log("start") se potrivește cu log(msg, nivel = 1) și cu log(msg) la fel de bine. Compilatorul nu are criteriu de alegere și dă eroare de ambiguitate. Apelul log("x", 2) ar compila, pentru că doar prima variantă acceptă doi parametri.

Corect este să alegi un singur mecanism. Fie păstrezi doar varianta cu valoare implicită, fie supraîncarci explicit:

C++
void log(const std::string& msg, int nivel);
inline void log(const std::string& msg) { log(msg, 1); }

Supraîncărcarea explicită are un avantaj în biblioteci: valoarea implicită nu este „copiată” în codul compilat al apelanților, deci o poți schimba fără să recompilezi tot proiectul.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi regulile și interacțiunea cu supraîncărcarea. Greșeala tipică este să nu observi ambiguitatea dintre cele două declarații.

Eroarea, în practică:redefinition of default argumentmissing default argument on parameter

11 Mid

Ce tip are fiecare variabilă de mai jos? Care e diferența dintre auto și decltype?

C++
int x = 0;
const int& cr = x;
auto a = cr;
decltype(cr) b = x;
decltype(x) c = 1;
decltype((x)) d = x;

Răspuns scurt: a este int, b este const int&, c este int, iar d este int&. auto deduce ca la un parametru de template transmis prin valoare (pierde referința și const-ul de pe nivelul de sus), iar decltype întoarce exact tipul declarat al expresiei.

auto urmează regulile de deducere a template-urilor pentru un parametru transmis prin valoare: elimină referința și calificatorii const/volatile de pe nivelul de sus. De aceea auto a = cr; face o copie de tip int. Dacă vrei referința, scrii const auto& a = cr; sau auto& a = cr; (tot const int&, fiindcă const-ul obiectului referit se păstrează).

decltype funcționează diferit, în două moduri:

  • decltype(nume), cu un nume simplu de variabilă sau membru, dă tipul declarat al acelui nume. decltype(cr) este const int&, iar decltype(x) este int.
  • decltype(expresie), pentru orice altă expresie, ține cont de categoria valorii: pentru un lvalue dă T&, pentru un xvalue dă T&&, pentru un prvalue dă T. (x) între paranteze nu mai este un nume simplu, ci o expresie lvalue, deci decltype((x)) este int&.

Diferența contează în special la decltype(auto) (C++14), folosit pentru tipuri de retur care trebuie să păstreze exact referința:

C++
decltype(auto) primul(std::vector<int>& v) { return v[0]; }  // int&

decltype(auto) gresit() {
    int local = 0;
    return (local);   // int& spre o variabilă locală: referință agățată
}

Parantezele în plus din al doilea exemplu schimbă tipul de retur în referință, o greșeală subtilă care compilează fără probleme.

Ce urmărește intervievatorul: Se verifică înțelegerea precisă a deducerii tipurilor, necesară pentru cod generic. Greșeala tipică este să crezi că auto păstrează referințele.

Eroarea, în practică:deduced type 'auto' requires an initializer

Clase și OOP

12 Junior

Ce înseamnă const la finalul unei metode? La ce folosește cuvântul mutable?

Răspuns scurt: O metodă const promite că nu modifică starea observabilă a obiectului și este singura care se poate apela pe un obiect sau o referință const. mutable marchează membrii care pot fi modificați și în metode const, cum ar fi un cache sau un mutex.

Într-o metodă const, pointerul this are tipul const T*, deci orice atribuire unui membru este eroare de compilare. Mai important, un obiect const (sau primit prin const T&) poate apela doar metode const:

C++
class Cont {
    double sold_ = 0;
public:
    double sold() const { return sold_; }
    void depune(double s) { sold_ += s; }
};

void afiseaza(const Cont& c) {
    std::cout << c.sold();   // ok
    // c.depune(10);         // eroare: metodă non-const pe obiect const
}

Dacă uiți const la un getter, nimeni nu-l mai poate apela prin const Cont&, iar cine folosește clasa ta ajunge să renunțe la const peste tot. De aceea regula este: orice metodă care nu modifică obiectul se declară const.

mutable există pentru membrii care nu fac parte din starea logică a obiectului:

C++
class Raport {
    std::vector<int> date_;
    mutable std::optional<double> medieCache_;
    mutable std::mutex m_;
public:
    double medie() const {
        std::lock_guard<std::mutex> lk(m_);
        if (!medieCache_)
            medieCache_ = std::accumulate(date_.begin(), date_.end(), 0.0) / date_.size();
        return *medieCache_;
    }
};

Exemplul presupune un vector nevid. Din punctul de vedere al apelantului, medie() nu schimbă nimic, deși intern salvează rezultatul. Folosit pentru altceva decât cache, sincronizare sau statistici interne, mutable ascunde un design greșit.

Ce urmărește intervievatorul: Intervievatorul verifică dacă practici const-correctness. Greșeala tipică este să folosești mutable sau const_cast ca să „repari” o metodă care chiar modifică obiectul.

Eroarea, în practică:'this' argument has type const, not marked constnon-member function cannot have 'const' qualifier

13 Junior

De ce compilează apelul f(3.5) mai jos și ce schimbă cuvântul explicit?

C++
struct Metri {
    Metri(double v) : valoare(v) {}
    double valoare;
};

void f(Metri m);

int main() { f(3.5); }

Răspuns scurt: Un constructor cu un singur parametru este și o conversie implicită: compilatorul transformă tăcut 3.5 într-un Metri. Cu explicit Metri(double v), apelul f(3.5) nu mai compilează și trebuie scris f(Metri{3.5}).

Orice constructor care poate fi apelat cu un singur argument (inclusiv unul cu restul parametrilor impliciți) definește o conversie de la tipul argumentului la clasa ta. Uneori e util, de exemplu std::string s = "abc"; folosește conversia din const char*. De cele mai multe ori, însă, ascunde greșeli:

  • f(3.5) acceptă orice double, inclusiv secunde sau kilograme, deși funcția voia explicit metri;
  • std::vector<int> v = 10; ar fi un vector cu 10 elemente dacă acel constructor n-ar fi explicit (și este, tocmai de aceea);
  • comparații ciudate: if (m == 2.0) compilează dacă există operator==(Metri, Metri).
C++
struct Metri {
    explicit Metri(double v) : valoare(v) {}
    double valoare;
};

f(Metri{3.5});  // ok, intenția e clară
// f(3.5);      // eroare

Regula recomandată de C++ Core Guidelines: marchează explicit orice constructor cu un singur argument, cu excepția cazurilor în care conversia implicită este cu adevărat dorită.

explicit se aplică și operatorilor de conversie. explicit operator bool() const permite if (obj), dar interzice int n = obj; sau obj1 + obj2, care ar compila cu un operator bool obișnuit. Smart pointer-ii și stream-urile din biblioteca standard folosesc exact acest mecanism. Din C++20 există și explicit(conditie), folosit în cod generic.

Ce urmărește intervievatorul: Se verifică dacă știi că un constructor cu un argument este o conversie implicită. Mulți candidați n-au auzit de explicit sau nu-l pot motiva.

Eroarea, în practică:no viable conversion from 'Cos *' to unique_ptr

14 Junior

Ce sunt membrii statici ai unei clase și cum se definește corect un membru static de date?

Răspuns scurt: Un membru static aparține clasei, nu fiecărui obiect: există o singură copie, partajată de toate instanțele. Înainte de C++17 trebuia definit într-un singur fișier .cpp; din C++17 se poate scrie direct în clasă cu inline static.

Un membru de date static este, practic, o variabilă globală cu numele în domeniul clasei și supusă controlului de acces (private, public). O metodă static nu are this, deci poate accesa doar membri statici și se apelează prin numele clasei.

C++
class Comanda {
public:
    Comanda() : id_(++urmatorulId_) {}
    static int total() { return urmatorulId_; }
    int id() const { return id_; }
private:
    int id_;
    inline static int urmatorulId_ = 0;   // C++17
};

int main() {
    Comanda a, b;
    std::cout << Comanda::total() << ' ' << b.id();   // 2 2
}

Înainte de C++17, în clasă puteai doar să-l declari, iar definiția trebuia pusă exact o dată într-un .cpp:

C++
// comanda.h
class Comanda { static int urmatorulId_; };
// comanda.cpp
int Comanda::urmatorulId_ = 0;

Dacă uitai definiția, primeai la linkare undefined reference to Comanda::urmatorulId_. Excepția erau constantele întregi static const int N = 10;, care se puteau inițializa în clasă.

De reținut:

  • inline static și static constexpr (care este implicit inline din C++17) elimină nevoia definiției separate;
  • un membru static nu este inițializat de constructor, ci o singură dată, înaintea lui main în cazul variabilelor inițializate dinamic;
  • membrii statici modificabili sunt stare globală, deci au aceleași probleme de testare și de concurență ca orice variabilă globală.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi diferența dintre declarare și definire pentru membri statici și eroarea de linkare tipică. Menționarea lui inline static arată că știi C++17.

Eroarea, în practică:undefined reference to (linker)static data member must be initialized out of line

15 Junior

Unde este bug-ul din constructorul următor?

C++
class Buffer {
    int* data_;
    std::size_t size_;
public:
    explicit Buffer(std::size_t n)
        : size_(n), data_(new int[size_]) {}
    ~Buffer() { delete[] data_; }
};

Răspuns scurt: Membrii se inițializează în ordinea declarării în clasă, nu în ordinea din lista de inițializare. data_ e declarat primul, deci new int[size_] citește size_ înainte să fie inițializat: comportament nedefinit.

Lista de inițializare arată ca o secvență de pași, dar ordinea scrisă acolo nu contează. Standardul garantează că membrii se construiesc în ordinea în care sunt declarați în clasă, iar la distrugere se distrug în ordine inversă. Ordinea este fixă ca să fie aceeași pentru toți constructorii, altfel destructorul n-ar ști în ce ordine să distrugă.

Aici data_ este declarat înaintea lui size_, deci:

1. se evaluează new int[size_], cu size_ încă neinițializat, adică o valoare arbitrară (UB); 2. abia apoi size_ primește n.

Programul poate aloca o dimensiune aleatoare, poate arunca std::bad_alloc sau poate părea că merge.

Corecturi posibile:

C++
class Buffer {
    std::size_t size_;   // declarat primul
    int* data_;
public:
    explicit Buffer(std::size_t n)
        : size_(n), data_(new int[n]) {}   // și folosim n, nu size_
    ~Buffer() { delete[] data_; }
};

Cel mai robust este să nu depinzi deloc de alți membri în inițializare, ci de parametrii constructorului.

GCC și Clang avertizează cu -Wreorder (inclus în -Wall) când ordinea din listă diferă de cea a declarațiilor. Este un motiv în plus să compilezi cu avertismentele activate și să le tratezi ca erori.

Clasa mai are o problemă: gestionează memorie manual, dar nu definește copierea. O copie ar duce la dublă eliberare. În cod real ai folosi std::vector<int> sau std::unique_ptr<int[]>.

Ce urmărește intervievatorul: Se verifică dacă știi regula ordinii de inițializare a membrilor. Greșeala tipică este să citești lista de inițializare ca pe niște instrucțiuni executate de sus în jos.

Eroarea, în practică:field will be initialized after field

16 Junior

Ce fac = default și = delete și în ce situații le folosești?

Răspuns scurt: = default cere compilatorului să genereze implementarea standard a unei funcții speciale (constructor, destructor, copiere, mutare). = delete interzice o funcție: orice apel devine eroare de compilare, de exemplu ca să faci o clasă necopiabilă sau să blochezi o conversie.

Ambele au apărut în C++11 și fac intenția explicită în cod, în locul trucurilor vechi.

= default este util când vrei comportamentul generat de compilator, dar regulile limbajului nu ți l-ar mai da automat sau vrei să-l documentezi:

C++
class Punct {
public:
    Punct() = default;          // altfel dispare, fiindcă există alt constructor
    Punct(int x, int y) : x_(x), y_(y) {}
    virtual ~Punct() = default; // destructor virtual, dar implementare standard
private:
    int x_ = 0, y_ = 0;
};

Un constructor implicit = default poate păstra clasa trivială (relevant pentru performanță și compatibilitate cu C), pe când Punct() {} scris de mână nu.

= delete funcționează pe orice funcție, nu doar pe cele speciale:

C++
class Conexiune {
public:
    Conexiune(const Conexiune&) = delete;            // necopiabilă
    Conexiune& operator=(const Conexiune&) = delete;
    Conexiune(Conexiune&&) noexcept = default;       // dar mutabilă
};

void setVarsta(int ani);
void setVarsta(double) = delete;   // setVarsta(30.5) nu compilează

Înainte de C++11, pentru a face o clasă necopiabilă declarai constructorul de copiere private fără să-l definești. Eroarea apărea uneori abia la linkare și era confuză. Cu = delete, mesajul este clar și apare la compilare.

O funcție ștearsă participă totuși la rezolvarea supraîncărcării. Dacă este aleasă ca cea mai bună variantă, apelul dă eroare, exact ca în exemplul cu setVarsta(double).

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să controlezi funcțiile speciale generate de compilator. Exemplul cu ștergerea unei supraîncărcări arată că înțelegi mecanismul, nu doar idiomul clasei necopiabile.

Eroarea, în practică:call to implicitly-deleted copy constructorcopy assignment operator is implicitly deleted

17 Junior

Implementează +, += și << pentru o clasă Fractie. Care operatori ar trebui să fie membri și care funcții libere?

Răspuns scurt: += este membru, fiindcă modifică obiectul stâng. + și << sunt funcții libere (de obicei friend): + ca să funcționeze simetric și cu conversii pe ambele părți (2 + f), iar << pentru că operandul stâng este std::ostream, nu clasa ta.

Regula de bază: dacă operatorul modifică operandul stâng (+=, -=, ++), îl faci membru. Dacă tratează operanzii simetric (+, ==, <), îl faci funcție liberă, implementată pe baza variantei compuse.

C++
#include <iostream>

class Fractie {
    int num_, den_;
public:
    Fractie(int n, int d = 1) : num_(n), den_(d) {}

    Fractie& operator+=(const Fractie& o) {
        num_ = num_ * o.den_ + o.num_ * den_;
        den_ *= o.den_;
        return *this;
    }

    friend Fractie operator+(Fractie a, const Fractie& b) {
        a += b;
        return a;
    }

    friend std::ostream& operator<<(std::ostream& os, const Fractie& f) {
        return os << f.num_ << '/' << f.den_;
    }
};

int main() {
    Fractie f(1, 2);
    std::cout << f + 1 << ' ' << 2 + f << '\n';   // 3/2 5/2
}

De ce funcționează 2 + f: constructorul nu este explicit, deci 2 se convertește la Fractie. Dacă operator+ ar fi membru, 2 + f n-ar compila, pentru că pe operandul stâng al unui membru nu se aplică conversii implicite.

operator<< întoarce std::ostream& ca să permită înlănțuirea std::cout << a << b. Este friend doar pentru că accesează membrii privați. Dacă ai getteri publici, poate fi o funcție liberă obișnuită.

Unii operatori sunt obligatoriu membri: =, [], (), -> și operatorii de conversie. Pentru claritate, exemplul nu simplifică fracția și nu verifică numitorul zero.

Ce urmărește intervievatorul: Se verifică dacă știi criteriile alegerii între membru și funcție liberă, nu doar sintaxa. Greșeala tipică este operator<< ca membru, care ar obliga la scrierea f << std::cout.

Eroarea, în practică:invalid operands ('ostream' and 'Bani')overloaded 'operator<<' must be a binary operator

18 Junior

Cum supraîncarci operatorii ++ prefix și postfix? De ce se spune că ++it e preferabil lui it++?

Răspuns scurt: Prefixul este T& operator++() și întoarce obiectul modificat. Postfixul este T operator++(int), cu un parametru int fictiv, și întoarce o copie a valorii vechi. Copia face postfixul potențial mai scump, mai ales la iteratori complecși.

Limbajul distinge cele două forme printr-un parametru int nefolosit, adăugat doar la postfix:

C++
class Contor {
    int v_ = 0;
public:
    Contor& operator++() {      // ++c
        ++v_;
        return *this;
    }
    Contor operator++(int) {    // c++
        Contor vechi = *this;
        ++*this;                // refolosim prefixul
        return vechi;
    }
    int valoare() const { return v_; }
};

Semantica trebuie să o imite pe cea a tipurilor predefinite:

  • prefixul incrementează și întoarce o referință la obiect, deci ++++c funcționează ca la int;
  • postfixul întoarce prin valoare starea dinainte. Nu poate întoarce o referință, pentru că starea veche nu mai există în obiect.

Implementarea postfixului prin prefix garantează că logica de incrementare există într-un singur loc.

Despre performanță: pentru int sau pentru iteratorii de std::vector, compilatorul optimizează identic i++ și ++i când rezultatul nu e folosit. Pentru iteratori mai complecși (de exemplu de std::map, sau iteratori proprii cu stare), copia din postfix poate rămâne, mai ales dacă funcția nu e vizibilă pentru inlining. De aceea convenția în C++ este să scrii ++it în bucle: nu costă nimic și nu depinde de optimizator.

Aceeași logică se aplică pentru --. Iar operator+= și operator+ se implementează de obicei la fel, cel simplu pe baza celui compus.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi semnăturile și semantica corectă, inclusiv tipul de retur. Mulți candidați nu știu rostul parametrului int sau întorc o referință din postfix.

19 Junior

Care e diferența dintre moștenirea public, protected și private? Când ai folosi moștenire privată?

Răspuns scurt: Tipul moștenirii stabilește accesul maxim la membrii moșteniți: public îi păstrează, protected îi face cel mult protected, private îi face privați. Doar moștenirea publică exprimă relația „este un”; cea privată înseamnă „implementat cu ajutorul lui” și e o alternativă rară la compoziție.

Membrii private ai bazei nu sunt accesibili în clasa derivată, indiferent de tipul moștenirii. Pentru restul, tipul moștenirii funcționează ca un „plafon”:

  • class D : public B: membrii public din B rămân public, cei protected rămân protected. Un D* se convertește implicit la B* oriunde. Este relația „este un” (is-a), singura care permite polimorfismul obișnuit.
  • class D : protected B: public și protected din B devin protected în D. Conversia D* în B* e permisă doar în D și în derivatele lui. Se folosește foarte rar.
  • class D : private B: totul devine private în D. Codul din exterior nu știe că D moștenește B, iar conversia în B* nu e permisă din afară.

Atenție la implicit: pentru class moștenirea implicită este private, iar pentru struct este public. class Caine : Animal {} fără public este o greșeală frecventă, care apare când încerci să pui un Caine* într-un Animal*.

Moștenirea privată exprimă „implementat cu ajutorul lui” (implemented-in-terms-of). De obicei compoziția (un membru de tip B) este preferabilă. Moștenirea privată are sens când:

  • trebuie să suprascrii o funcție virtuală a lui B fără să expui B public;
  • vrei optimizarea bazei goale (empty base optimization), deși din C++20 atributul [[no_unique_address]] o oferă și pentru membri;
  • vrei să re-expui selectiv câteva funcții cu using B::functie; în secțiunea publică.

Ce urmărește intervievatorul: Se verifică dacă înțelegi că moștenirea publică are o semnificație de design, nu doar de acces. Greșeala tipică este uitarea lui public la class.

Eroarea, în practică:cannot cast to its private base classis a protected member of

20 Junior

Ce îți dă compilatorul C++20 dacă scrii auto operator<=>(const T&) const = default;? Folosește-l pentru o clasă Versiune.

Răspuns scurt: Operatorul „navă spațială” <=> (C++20) implicit compară membrii lexicografic, în ordinea declarării. Din el compilatorul derivă <, <=, > și >=, iar varianta implicită declară automat și ==, deci primești toți cei șase operatori de comparare dintr-o linie.

Înainte de C++20, pentru o clasă comparabilă scriai ==, !=, <, >, <=, >=, de obicei pe baza lui std::tie. Cu operatorul de comparare în trei căi, totul se reduce la o declarație:

C++
#include <compare>
#include <iostream>

struct Versiune {
    int major, minor, patch;
    auto operator<=>(const Versiune&) const = default;
};

int main() {
    Versiune a{1, 4, 2}, b{1, 10, 0};
    std::cout << (a < b) << (a == b) << '\n';   // 10
}

Ce se întâmplă:

  • <=> implicit compară major, apoi minor, apoi patch, în ordinea declarării, și se oprește la prima diferență;
  • rezultatul este de tip std::strong_ordering pentru int. Pentru membri double ar fi std::partial_ordering, fiindcă NaN nu se poate ordona;
  • expresia a < b este rescrisă de compilator ca (a <=> b) < 0;
  • un operator<=> implicit declară implicit și operator== implicit, iar != se obține prin rescrierea lui ==.

Dacă scrii manual corpul lui <=>, == nu mai este generat automat și trebuie definit separat. Motivul este performanța: pentru string-uri sau containere, egalitatea poate fi verificată mult mai repede (de exemplu comparând întâi lungimile) decât o ordonare completă.

Pentru ordinea membrilor contează designul: dacă vrei sortare după alt criteriu decât ordinea declarării, scrii <=> explicit sau folosești un comparator separat.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă dacă știi C++20 și relația dintre <=> și ==. Greșeala tipică este să crezi că un <=> scris de mână generează și egalitatea.

Eroarea, în practică:invalid operands ('const Produs' and 'const Produs')

21 Mid

Ce afișează codul următor? Cum faci ca d.f(5) să apeleze varianta din bază?

C++
struct Baza {
    void f(int)       { std::cout << "Baza::f(int)\n"; }
};
struct Derivata : Baza {
    void f(double)    { std::cout << "Derivata::f(double)\n"; }
};

int main() {
    Derivata d;
    d.f(5);
}

Răspuns scurt: Afișează Derivata::f(double). Un nume declarat în clasa derivată ascunde toate funcțiile cu același nume din bază, indiferent de parametri, deci Baza::f(int) nici nu este luată în calcul. Cu using Baza::f; în Derivata le aduci înapoi în rezolvarea supraîncărcării.

Căutarea numelor în C++ se face din domeniul cel mai interior spre exterior și se oprește la primul domeniu în care găsește numele. Pentru d.f, compilatorul caută în Derivata, găsește f(double) și nu mai urcă în Baza. Abia apoi aplică rezolvarea supraîncărcării, doar pe ce a găsit. 5 se convertește la double și se apelează Derivata::f(double). Fenomenul se numește name hiding.

Soluția este o declarație using:

C++
struct Derivata : Baza {
    using Baza::f;                 // aduce toate f-urile din bază
    void f(double) { std::cout << "Derivata::f(double)\n"; }
};
// d.f(5)   -> Baza::f(int)
// d.f(5.0) -> Derivata::f(double)

Alternativ, poți apela explicit d.Baza::f(5);, dar asta mută responsabilitatea la fiecare apelant.

Problema apare des cu funcțiile virtuale supraîncărcate:

C++
struct Forma {
    virtual void deseneaza(int) {}
    virtual void deseneaza(std::string) {}
    virtual ~Forma() = default;
};
struct Cerc : Forma {
    void deseneaza(int) override {}   // ascunde deseneaza(std::string)
};
// Cerc c; c.deseneaza("x");  // eroare de compilare

Prin Forma& ambele variante sunt vizibile, prin Cerc doar una. Compilatoarele pot avertiza: Clang are -Woverloaded-virtual (inclus în -Wall), iar GCC îl are separat. Când suprascrii doar o parte dintr-un set de supraîncărcări, adaugi using Baza::deseneaza;.

Ce urmărește intervievatorul: Se verifică înțelegerea ordinii dintre căutarea numelui și rezolvarea supraîncărcării. Mulți candidați răspund Baza::f(int), convinși că se alege cea mai bună potrivire din toată ierarhia.

22 Mid

Ce afișează programul?

C++
struct M { M() { std::cout << "M "; }  ~M() { std::cout << "~M "; } };
struct B { B() { std::cout << "B "; }  ~B() { std::cout << "~B "; } };
struct D : B {
    M m;
    D()  { std::cout << "D "; }
    ~D() { std::cout << "~D "; }
};

int main() { D d; }

Răspuns scurt: Afișează B M D ~D ~M ~B. Se construiesc întâi clasele de bază, apoi membrii în ordinea declarării, apoi rulează corpul constructorului. Distrugerea se face exact în ordine inversă.

Ordinea de construcție a unui obiect este fixată de standard:

1. clasele de bază virtuale (dacă există), de la cea mai derivată ierarhie; 2. clasele de bază directe, în ordinea în care apar în lista de moștenire; 3. membrii nestatici, în ordinea declarării în clasă; 4. corpul constructorului.

Pentru D: se construiește B (afișează B), apoi membrul m (afișează M), apoi corpul lui D() (afișează D).

Distrugerea este oglinda construcției: întâi corpul destructorului ~D(), apoi membrii în ordine inversă a declarării (~M), apoi bazele în ordine inversă (~B).

De ce contează ordinea aceasta:

  • În corpul constructorului lui D poți folosi liniștit și baza, și membrii: sunt deja construiți.
  • În corpul destructorului lui D membrii încă există, deci poți să-i folosești, de exemplu să închizi un fișier sau să trimiți un ultim mesaj.
  • Un membru nu trebuie să depindă de altul declarat după el.
  • Dacă un constructor aruncă o excepție, se distrug doar părțile deja construite complet, în ordine inversă.

O consecință mai puțin evidentă: în constructorul lui B, partea D nu există încă. De aceea un apel virtual din constructorul bazei nu ajunge la versiunea din derivată.

Același mecanism stă la baza RAII: dacă resursele unei clase sunt membri care se gestionează singuri, destructorul generat le eliberează automat și în ordinea corectă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi ordinea precisă, inclusiv locul membrilor între bază și corpul constructorului. Greșeala tipică este B D M sau o distrugere în aceeași ordine ca la construcție.

23 Mid

Ce afișează codul următor și de ce?

C++
struct Baza {
    virtual void salut(std::string s = "baza") {
        std::cout << "Baza " << s << '\n';
    }
    virtual ~Baza() = default;
};
struct Derivata : Baza {
    void salut(std::string s = "derivata") override {
        std::cout << "Derivata " << s << '\n';
    }
};

int main() {
    std::unique_ptr<Baza> p = std::make_unique<Derivata>();
    p->salut();
}

Răspuns scurt: Afișează Derivata baza. Funcția se alege dinamic, după tipul real al obiectului, dar valoarea implicită a parametrului se alege la compilare, după tipul static al expresiei (Baza).

Sunt două mecanisme separate, care lucrează la momente diferite:

  • Dispatch-ul virtual se face la rulare, prin vtable. Obiectul este un Derivata, deci se execută Derivata::salut.
  • Argumentele implicite sunt o facilitate de compilare. Compilatorul vede apelul p->salut() prin tipul static Baza* și completează argumentul lipsă cu valoarea din declarația pe care o vede, adică "baza". Apoi se generează un apel virtual obișnuit cu un argument.

Rezultatul combină corpul derivatei cu valoarea implicită a bazei, ceea ce aproape niciodată nu e intenția.

Dacă ai apela prin Derivata d; d.salut();, ai obține Derivata derivata. Același obiect produce rezultate diferite în funcție de tipul static al expresiei, un bug greu de găsit.

Reguli de urmat:

  • Nu redefini valorile implicite în clasele derivate (C++ Core Guidelines și Effective C++ recomandă explicit asta).
  • Mai bine, evită argumentele implicite pe funcții virtuale. Folosește idiomul NVI (non-virtual interface): o funcție publică nevirtuală cu argument implicit, care apelează o funcție virtuală privată fără valori implicite.
C++
struct Baza {
    void salut(std::string s = "baza") { faSalut(s); }
    virtual ~Baza() = default;
private:
    virtual void faSalut(const std::string& s) = 0;
};

Astfel, valoarea implicită există într-un singur loc, iar derivatele suprascriu doar comportamentul.

Ce urmărește intervievatorul: Se verifică dacă înțelegi ce se decide la compilare și ce la rulare. Majoritatea candidaților răspund Derivata derivata.

24 Mid

Poate o funcție pur virtuală să aibă implementare? De ce un destructor pur virtual trebuie neapărat să aibă corp?

Răspuns scurt: Da. = 0 înseamnă doar că derivatele trebuie să o suprascrie și că clasa e abstractă; poți totuși defini funcția separat și o apelezi explicit cu Baza::f(). Un destructor pur virtual trebuie definit, pentru că destructorul fiecărei derivate apelează automat destructorul bazei.

Mulți cred că „pur virtual” înseamnă „fără implementare”. De fapt, = 0 are două efecte: clasa devine abstractă (nu poți crea obiecte de tipul ei), iar orice clasă derivată concretă trebuie să suprascrie funcția. Nimic nu te împiedică să-i dai și un corp, definit în afara clasei:

C++
struct Logger {
    virtual void scrie(const std::string& msg) = 0;
    virtual ~Logger() = 0;
};

void Logger::scrie(const std::string& msg) {
    std::cout << "[log] " << msg << '\n';   // comportament comun
}
Logger::~Logger() {}                        // obligatoriu

struct ConsoleLogger : Logger {
    void scrie(const std::string& msg) override {
        Logger::scrie(msg);                 // apel explicit, nevirtual
    }
};

Utilizări reale:

  • Comportament implicit opțional: derivata trebuie să decidă conștient să-l folosească, apelând Baza::f(). Spre deosebire de o funcție virtuală obișnuită, nu îl poate moșteni din neatenție.
  • Clasă abstractă fără alte funcții pure: dacă vrei o bază abstractă, dar toate metodele au implementări rezonabile, faci destructorul pur virtual.

Destructorul este un caz special. Când un ConsoleLogger se distruge, după corpul lui se apelează automat Logger::~Logger(). Dacă nu l-ai definit, primești eroare la linkare, undefined reference to Logger::~Logger(). Pentru alte funcții pure, corpul e necesar doar dacă cineva îl apelează explicit.

O funcție pur virtuală nu poate fi definită direct în clasă (virtual void f() = 0 {} nu e permis), ci doar în afara ei.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi ce înseamnă exact = 0. Greșeala tipică este să crezi că o funcție pur virtuală nu poate avea niciodată corp.

Eroarea, în practică:variable type is an abstract classPure virtual function called!

25 Senior

Implementează operatorul de atribuire pentru o clasă care gestionează un buffer folosind idiomul copy-and-swap. Ce garanții oferă și ce dezavantaj are?

Răspuns scurt: Operatorul primește parametrul prin valoare (copia se face la apel), apoi interschimbă conținutul cu *this; vechiul conținut se eliberează când parametrul iese din domeniu. Oferă garanția puternică la excepții și tratează corect auto-atribuirea, dar alocă mereu, chiar și când bufferul existent ar fi ajuns.

C++
#include <algorithm>
#include <cstddef>
#include <utility>

class Buffer {
    std::size_t n_ = 0;
    int* d_ = nullptr;
public:
    explicit Buffer(std::size_t n) : n_(n), d_(new int[n]{}) {}
    Buffer(const Buffer& o) : n_(o.n_), d_(new int[o.n_]) {
        std::copy(o.d_, o.d_ + n_, d_);
    }
    Buffer(Buffer&& o) noexcept
        : n_(std::exchange(o.n_, 0)), d_(std::exchange(o.d_, nullptr)) {}
    ~Buffer() { delete[] d_; }

    friend void swap(Buffer& a, Buffer& b) noexcept {
        using std::swap;
        swap(a.n_, b.n_);
        swap(a.d_, b.d_);
    }

    Buffer& operator=(Buffer o) noexcept {   // copiere SAU mutare la apel
        swap(*this, o);
        return *this;
    }                                         // o distruge vechiul buffer
};

Cum funcționează: parametrul o se construiește la apel. Dintr-un lvalue prin constructorul de copiere, dintr-un rvalue prin cel de mutare, deci un singur operator acoperă ambele cazuri. Dacă alocarea din copiere aruncă, excepția apare înainte să intrăm în corp, iar *this rămâne neatins. Aceasta este garanția puternică (strong exception guarantee): operația reușește complet sau nu schimbă nimic. Corpul conține doar swap-uri care nu aruncă, de aceea operatorul poate fi noexcept.

Auto-atribuirea b = b funcționează corect fără niciun test if (this != &o): se face o copie și se schimbă cu ea.

Dezavantajul este performanța. Un operator scris de mână ar putea refolosi memoria existentă când n_ e suficient de mare, evitând o alocare. Containerele standard (std::vector) fac exact asta și oferă doar garanția de bază la atribuire. Copy-and-swap este alegerea bună când corectitudinea primează. În majoritatea claselor, însă, varianta cea mai bună rămâne regula lui zero: membri ca std::vector<int>, fără niciun operator scris de tine.

Ce urmărește intervievatorul: Se verifică înțelegerea garanțiilor la excepții și a costurilor, nu doar memorarea idiomului. Un candidat senior menționează compromisul de performanță și preferința pentru regula lui zero.

26 Senior

Ce este idiomul PIMPL, ce probleme rezolvă și de ce destructorul clasei trebuie definit în .cpp când folosești std::unique_ptr<Impl>?

Răspuns scurt: PIMPL („pointer to implementation”) ascunde membrii privați într-o structură declarată doar în avans în header și definită în .cpp. Reduce recompilările și stabilizează ABI-ul. Destructorul trebuie definit acolo unde Impl este complet, pentru că std::unique_ptr are nevoie de tipul complet ca să-l șteargă.

Într-o clasă obișnuită, membrii privați sunt în header. Orice modificare a lor, chiar și adăugarea unui câmp privat, obligă la recompilarea tuturor fișierelor care includ header-ul și schimbă dimensiunea obiectului, deci ABI-ul (interfața binară). PIMPL mută tot ce e privat într-un tip ascuns:

C++
// widget.h
#include <memory>
class Widget {
public:
    Widget();
    ~Widget();
    Widget(Widget&&) noexcept;
    Widget& operator=(Widget&&) noexcept;
    void deseneaza();
private:
    struct Impl;                 // doar declarat
    std::unique_ptr<Impl> p_;
};

// widget.cpp
#include "widget.h"
#include <string>
struct Widget::Impl { std::string titlu; int latime = 0; };
Widget::Widget() : p_(std::make_unique<Impl>()) {}
Widget::~Widget() = default;     // aici Impl e complet
Widget::Widget(Widget&&) noexcept = default;
Widget& Widget::operator=(Widget&&) noexcept = default;
void Widget::deseneaza() { /* folosește p_->titlu */ }

Dacă lași destructorul generat implicit în header, compilatorul îl instanțiază în fiecare fișier care distruge un Widget. Acolo Impl este incomplet, iar deleter-ul lui std::unique_ptr refuză să compileze (invalid application of 'sizeof' to an incomplete type). Același lucru e valabil pentru operațiile de mutare, de aceea sunt declarate în header și definite = default în .cpp. Copierea, dacă o vrei, se scrie manual.

Beneficii: header-ele includ mai puțin, build-ul e mai rapid, iar o bibliotecă partajată poate schimba implementarea fără să-și strice clienții. Costuri: o alocare pe heap per obiect, o indirectare la fiecare acces și cod de legătură în plus. Nu se folosește pentru clase mici, aflate pe calea critică a performanței.

Ce urmărește intervievatorul: Intervievatorul verifică experiența cu proiecte mari, timpi de build și biblioteci cu ABI stabil. Detaliul cu tipul incomplet separă candidații care au implementat PIMPL de cei care doar l-au citit.

RAII și smart pointers

Exersează capitolul cu exerciții reale: Curs C++ online →
27 Junior

Ce se întâmplă la fiecare linie? Ce afișează programul?

C++
auto a = std::make_unique<int>(42);
// auto b = a;
auto b = std::move(a);
std::cout << (a == nullptr) << ' ' << *b << '\n';

Răspuns scurt: Linia comentată nu ar compila: std::unique_ptr nu se poate copia. std::move(a) transferă proprietatea în b, iar a rămâne nullptr, deci se afișează 1 42.

std::unique_ptr modelează proprietatea exclusivă: un singur obiect unique_ptr deține resursa și o eliberează în destructor. Dacă s-ar putea copia, două obiecte ar crede că dețin același pointer și l-ar șterge de două ori. De aceea constructorul și operatorul de copiere sunt = delete, iar auto b = a; dă eroare de compilare.

Mutarea este permisă. std::move(a) doar transformă a într-un rvalue, iar constructorul de mutare al lui b preia pointerul și îl setează pe nullptr în a. Spre deosebire de majoritatea tipurilor, unde starea după mutare este „validă, dar nespecificată”, la unique_ptr standardul garantează că sursa devine nulă. Deci a == nullptr este adevărat și se afișează 1 42.

Ce ar fi greșit după mutare:

C++
std::cout << *a;   // dereferențiere de nullptr: comportament nedefinit

Situații în care transferul apare natural:

  • returnarea dintr-o funcție: return std::make_unique<Comanda>(); nu cere std::move;
  • punerea într-un container: v.push_back(std::move(p));;
  • transmiterea prin valoare unei funcții care preia proprietatea: adauga(std::move(p));.

Alte operații utile: p.get() dă pointerul brut fără să cedeze proprietatea, p.release() cedează proprietatea și întoarce pointerul (de acum îl ștergi tu), iar p.reset() eliberează resursa imediat.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi proprietatea exclusivă și starea după mutare. Greșeala tipică este folosirea pointerului sursă după std::move.

Eroarea, în practică:call to implicitly-deleted copy constructor

28 Junior

Care e diferența dintre delete și delete[]? Ce se întâmplă dacă le amesteci?

Răspuns scurt: new T se eliberează cu delete, iar new T[n] cu delete[], care apelează destructorul fiecărui element. Amestecarea lor este comportament nedefinit: poate strica heap-ul, poate sări destructori sau poate părea că merge. În C++ modern folosești std::vector sau std::unique_ptr<T[]>.

Cele două forme sunt perechi diferite de operatori. new T[n] alocă spațiu pentru n obiecte și, pentru tipurile cu destructor netrivial, de obicei memorează undeva și numărul n, ca delete[] să știe câți destructori să apeleze. delete simplu presupune un singur obiect.

C++
std::string* p = new std::string[3];
delete p;      // UB: un singur destructor, apoi eliberare cu adresă greșită
delete[] p;    // corect

int* q = new int(5);
delete[] q;    // UB și în sens invers

Standardul declară ambele amestecuri comportament nedefinit. În practică, pentru int poate părea că merge, ceea ce face bug-ul și mai periculos: codul trece testele și se strică în producție sau la schimbarea tipului.

Cum detectezi: AddressSanitizer (-fsanitize=address) raportează explicit alloc-dealloc-mismatch, iar Valgrind dă Mismatched free() / delete / delete [].

Cum eviți complet problema în C++ modern:

  • std::vector<T> pentru tablouri dinamice: ține dimensiunea, se redimensionează, se copiază corect;
  • std::unique_ptr<T[]> (sau std::make_unique<T[]>(n)) dacă ai nevoie de un buffer cu dimensiune fixă, fără overhead-ul de capacitate; el apelează automat delete[];
  • std::array<T, N> când dimensiunea e cunoscută la compilare.

Atenție: std::unique_ptr<int> p(new int[10]); (fără [] în tip) repetă exact aceeași greșeală, pentru că deleter-ul implicit va apela delete.

Ce urmărește intervievatorul: Se verifică disciplina în gestionarea memoriei. Un răspuns bun nu se oprește la regulă, ci arată și cum elimini problema cu tipuri RAII.

Eroarea, în practică:'delete' applied to a pointer allocated with 'new[]'

29 Junior

Unde este bug-ul în codul următor?

C++
int* raw = new int(10);
std::shared_ptr<int> a(raw);
std::shared_ptr<int> b(raw);
std::cout << a.use_count() << ' ' << b.use_count() << '\n';

Răspuns scurt: a și b creează două blocuri de control separate pentru același pointer, fiecare cu contorul 1, deci se afișează 1 1. La final ambele șterg raw: dublă eliberare, adică comportament nedefinit. Soluția este auto a = std::make_shared<int>(10); auto b = a;.

Un std::shared_ptr nu numără „câte shared_ptr arată spre adresa X”. Numără câte obiecte shared_ptr partajează același bloc de control, o structură alocată separat care conține contorul de referințe, contorul de weak_ptr și deleter-ul.

Blocul de control se creează când construiești un shared_ptr dintr-un pointer brut sau cu make_shared. Copierea unui shared_ptr existent incrementează contorul din blocul deja existent. Aici ai două construcții din pointer brut, deci două blocuri independente, fiecare cu use_count() == 1. Când b iese din domeniu, șterge raw. Când iese și a, îl șterge din nou. Programul poate crăpa, poate strica heap-ul sau poate să nu arate nimic.

Corect:

C++
auto a = std::make_shared<int>(10);
auto b = a;                    // același bloc de control
std::cout << a.use_count();    // 2

Variante ale aceluiași bug întâlnite în cod real:

  • std::shared_ptr<T>(this) într-o metodă, când obiectul este deja gestionat de un shared_ptr (soluția este enable_shared_from_this);
  • std::shared_ptr<T> p(q.get());, unde q e alt smart pointer;
  • un pointer brut pus și într-un unique_ptr, și într-un shared_ptr.

Regula simplă: un pointer brut ajunge într-un smart pointer o singură dată, ideal chiar în momentul alocării, prin make_shared sau make_unique.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi rolul blocului de control. Greșeala tipică este să crezi că shared_ptr „recunoaște” pointerul și partajează automat contorul.

Eroarea, în practică:double free detected in tcache 2

30 Junior

Dacă în C++ modern folosim smart pointers, mai are rost pointerul brut T*? Când e corect să-l folosești?

Răspuns scurt: Da, pentru acces fără proprietate: o funcție care doar folosește un obiect deținut de altcineva primește T* (dacă poate lipsi) sau T& (dacă e obligatoriu). Pointerul brut nu trebuie să dețină memorie, adică nu se face delete pe el.

Ghidurile moderne (C++ Core Guidelines) separă două roluri pe care în C++ vechi le juca același T*:

  • proprietate: cine eliberează obiectul. Rolul acesta îl preiau std::unique_ptr, std::shared_ptr și containerele;
  • observare: cine doar folosește obiectul, fără să-i controleze durata de viață. Aici pointerul brut și referința sunt alegerea corectă.
C++
class Motor { /* ... */ };

class Masina {
    std::unique_ptr<Motor> motor_;      // deține
public:
    Motor* motor() { return motor_.get(); }
};

void diagnosticheaza(const Motor& m);   // obligatoriu, nu-l deține
void logheaza(const Motor* m);          // poate fi nullptr

Un T* într-o semnătură, în cod modern, comunică „pot primi nimic și nu preiau proprietatea”. Dacă funcția ar avea nevoie să păstreze obiectul după ce se întoarce, semnătura trebuie să ceară un smart pointer.

Riscul pointerului observator rămâne același ca înainte: dacă proprietarul distruge obiectul, pointerul devine agățat. De aceea el trebuie folosit doar pe durata în care e clar că proprietarul trăiește, de exemplu în timpul unui apel de funcție. Dacă durata de viață nu e garantată, folosești std::weak_ptr.

Pointerii bruți mai apar legitim la interfața cu API-uri C, în structuri de date implementate intern (de exemplu legătura spre părinte dintr-un arbore ale cărui noduri sunt deținute de unique_ptr) și în cod de performanță foarte specializat.

Ce urmărește intervievatorul: Se verifică dacă înțelegi distincția proprietate/observare, nu doar sloganul „nu folosi pointeri bruți”. Greșeala tipică este să transmiți shared_ptr peste tot, inclusiv acolo unde ajunge o referință.

31 Mid

Cum transmiți un smart pointer unei funcții? Ce comunică fiecare semnătură de mai jos?

C++
void a(Widget& w);
void b(std::unique_ptr<Widget> w);
void c(std::unique_ptr<Widget>& w);
void d(std::shared_ptr<Widget> w);
void e(const std::shared_ptr<Widget>& w);

Răspuns scurt: a: doar folosește obiectul. b: preia proprietatea (apelantul face std::move). c: poate înlocui sau reseta pointerul apelantului. d: devine co-proprietar și păstrează obiectul. e: poate copia pointerul dacă vrea, fără cost de contor la apel.

Semnătura unei funcții este documentație despre proprietate. Regulile din C++ Core Guidelines (secțiunea R.30–R.37) se rezumă așa:

  • Widget& sau Widget*: funcția folosește obiectul și nu se interesează cum e deținut. Aceasta este alegerea implicită. Apelantul scrie a(*p) indiferent dacă p e unique_ptr, shared_ptr sau obiect pe stivă.
  • std::unique_ptr<Widget> prin valoare: funcția preia proprietatea. Apelul b(std::move(p)) face transferul vizibil în codul apelantului.
  • std::unique_ptr<Widget>&: funcția poate reseta sau înlocui pointerul apelantului (w.reset(new ...)). Este rar și merită un nume clar.
  • std::shared_ptr<Widget> prin valoare: funcția devine co-proprietar, de obicei pentru că salvează pointerul într-un membru sau îl dă unui alt thread. Apelantul poate face std::move dacă nu mai are nevoie de el.
  • const std::shared_ptr<Widget>&: funcția poate să păstreze o copie, dar nu întotdeauna. Eviți incrementarea atomică a contorului la fiecare apel.
C++
class Galerie {
    std::vector<std::shared_ptr<Imagine>> imagini_;
public:
    void adauga(std::shared_ptr<Imagine> img) {
        imagini_.push_back(std::move(img));
    }
};

Greșeala frecventă este void deseneaza(std::shared_ptr<Widget> w) pentru o funcție care doar citește. Fiecare apel copiază pointerul, deci face o incrementare și o decrementare atomică, și leagă degeaba funcția de un anumit tip de proprietate. void deseneaza(const Widget& w) e mai rapidă și mai ușor de testat.

Ce urmărește intervievatorul: Intervievatorul verifică dacă proiectezi interfețe care spun clar cine deține ce. Un candidat mid nu transmite shared_ptr prin valoare acolo unde ajunge o referință.

32 Mid

Cum folosești std::unique_ptr ca să gestionezi automat un FILE* deschis cu fopen?

Răspuns scurt: Dai lui unique_ptr un deleter personalizat care apelează fclose: std::unique_ptr<std::FILE, FileCloser>. Fișierul se închide automat la ieșirea din domeniu, inclusiv la excepții sau la return-uri timpurii.

std::unique_ptr<T, D> acceptă ca al doilea parametru de template tipul unui obiect apelabil care eliberează resursa. Implicit este std::default_delete<T>, care face delete. Pentru resurse din API-uri C, înlocuiești deleter-ul:

C++
#include <cstdio>
#include <memory>
#include <stdexcept>

struct FileCloser {
    void operator()(std::FILE* f) const noexcept {
        if (f) std::fclose(f);
    }
};
using FilePtr = std::unique_ptr<std::FILE, FileCloser>;

FilePtr deschide(const char* cale) {
    FilePtr f(std::fopen(cale, "r"));
    if (!f) throw std::runtime_error("nu pot deschide fisierul");
    return f;
}

void citeste() {
    FilePtr f = deschide("date.txt");
    char linie[256];
    while (std::fgets(linie, sizeof linie, f.get())) { /* ... */ }
}   // fclose apelat automat

De ce structură și nu o lambda sau un pointer la funcție? Un functor fără stare nu adaugă nimic la dimensiunea lui unique_ptr, care rămâne cât un pointer. Cu std::unique_ptr<std::FILE, decltype(&std::fclose)> pointerul la funcție ocupă loc în plus și trebuie dat la fiecare construcție. Pe deasupra, standardul nu garantează că poți lua adresa funcțiilor din biblioteca standard. Din C++20 merge și o lambda fără captură: std::unique_ptr<std::FILE, decltype([](std::FILE* f){ std::fclose(f); })>.

La std::shared_ptr deleter-ul nu face parte din tip, se dă doar la construcție: std::shared_ptr<std::FILE> f(std::fopen(...), FileCloser{}).

Același tipar se aplică pentru handle-uri de socket, conexiuni la baze de date, SDL_Window* și altele. Pentru resurse care nu sunt pointeri (de exemplu descriptori int), scrii o clasă RAII mică, cu constructor de mutare și destructor.

Ce urmărește intervievatorul: Se verifică dacă știi să aplici RAII dincolo de new/delete. Detaliul despre dimensiunea deleter-ului arată înțelegerea costurilor.

33 Mid

Ai o ierarhie Forma cu derivate Cerc și Patrat. Cum ții formele într-un container polimorfic, cum le sortezi după arie și ce operații nu mai funcționează ca la un vector obișnuit?

Răspuns scurt: Folosești std::vector<std::unique_ptr<Forma>>, cu Forma având destructor virtual. Sortezi cu un comparator care dereferențiază pointerii. Vectorul devine doar mutabil, nu copiabil, iar în bucle iei elementele prin referință.

Un std::vector<Forma> ar tăia obiectele (slicing) la partea de bază. Un vector de pointeri bruți ar cere delete manual. Varianta idiomatică este un vector de unique_ptr:

C++
#include <algorithm>
#include <memory>
#include <vector>

struct Forma {
    virtual double arie() const = 0;
    virtual ~Forma() = default;
};
struct Cerc : Forma {
    double r;
    explicit Cerc(double r) : r(r) {}
    double arie() const override { return 3.14159 * r * r; }
};
struct Patrat : Forma {
    double l;
    explicit Patrat(double l) : l(l) {}
    double arie() const override { return l * l; }
};

int main() {
    std::vector<std::unique_ptr<Forma>> forme;
    forme.push_back(std::make_unique<Cerc>(1.0));
    forme.emplace_back(std::make_unique<Patrat>(3.0));

    std::sort(forme.begin(), forme.end(),
              [](const auto& a, const auto& b) { return a->arie() < b->arie(); });

    for (const auto& f : forme) { /* f->arie() */ }
}

Ce se schimbă față de un vector de valori:

  • auto copie = forme; nu compilează, pentru că elementele nu se pot copia. Dacă ai nevoie de copii, adaugi în bază o metodă virtuală clone().
  • for (auto f : forme) nu compilează din același motiv; folosești const auto&.
  • std::sort, std::remove_if și erase funcționează, pentru că lucrează prin mutări.
  • Pentru std::find cauți după predicat (std::find_if), nu după valoare.
  • Destructorul virtual din Forma este obligatoriu, altfel unique_ptr<Forma> ar distruge doar partea de bază.

Dacă formele trebuie partajate cu alte structuri, treci la shared_ptr. Dacă setul de tipuri este închis și cunoscut, std::vector<std::variant<Cerc, Patrat>> evită complet alocările pe heap.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi combina polimorfismul cu proprietatea automată și ce restricții apar. Menționarea alternativei cu std::variant arată experiență de design.

34 Senior

De ce nu poți scrie return std::shared_ptr<Sesiune>(this); într-o metodă? Ce rezolvă std::enable_shared_from_this și ce capcane are?

Răspuns scurt: shared_ptr(this) creează un al doilea bloc de control pentru un obiect deja gestionat de alt shared_ptr, deci obiectul ar fi șters de două ori. enable_shared_from_this oferă shared_from_this(), care întoarce un shared_ptr legat de blocul de control existent.

Cazul tipic este codul asincron: un obiect își programează un callback și trebuie să rămână în viață până când callback-ul rulează, chiar dacă restul programului a renunțat la el.

C++
#include <functional>
#include <memory>

class Sesiune : public std::enable_shared_from_this<Sesiune> {
public:
    static std::shared_ptr<Sesiune> creeaza() {
        return std::shared_ptr<Sesiune>(new Sesiune());
    }
    void start(std::function<void(std::function<void()>)> programeaza) {
        auto self = shared_from_this();          // contor +1
        programeaza([self] { self->peTimeout(); });
    }
private:
    Sesiune() = default;                          // doar prin creeaza()
    void peTimeout() {}
};

Clasa de bază enable_shared_from_this<T> conține un weak_ptr<T> intern. Când obiectul este pus prima dată într-un shared_ptr (prin constructor sau make_shared), biblioteca completează acel weak_ptr. shared_from_this() doar îl transformă în shared_ptr, deci folosește blocul de control existent.

Capcane:

  • Dacă obiectul nu este deținut de niciun shared_ptr (de exemplu e pe stivă), shared_from_this() aruncă std::bad_weak_ptr din C++17. Înainte, comportamentul era nedefinit. De aceea constructorul se face privat și se expune o funcție fabrică.
  • Nu poți apela shared_from_this() în constructor: weak_ptr-ul intern nu e încă setat.
  • Moștenirea trebuie să fie publică, altfel mecanismul nu se activează.
  • Funcția fabrică nu poate folosi std::make_shared cu un constructor privat, decât cu un truc (o structură „cheie” sau o derivată locală). De aceea exemplul folosește new direct.
  • Din C++17 există și weak_from_this(), util când vrei ca callback-ul să nu țină obiectul în viață.

Ce urmărește intervievatorul: Se verifică experiența cu cod asincron (de exemplu Asio) și înțelegerea blocului de control. Un senior menționează excepția bad_weak_ptr și restricția din constructor.

Eroarea, în practică:uncaught exception of type std::bad_weak_ptr

Copiere, mutare și categorii de valori

35 Junior

Ce conține a după codul de mai jos? E sigur să-l mai folosești?

C++
std::string a = "un text suficient de lung ca sa fie pe heap";
std::string b = std::move(a);
std::cout << b << '\n';
std::cout << a.size() << '\n';
a = "nou";

Răspuns scurt: a este într-o stare validă, dar nespecificată: în practică de obicei gol, dar standardul nu garantează asta. Poți să-l distrugi, să-i atribui o valoare nouă sau să apelezi metode fără precondiții, cum e size(); nu te baza însă pe conținutul lui.

Mutarea transferă resursele (aici bufferul alocat pe heap) din a în b, fără să copieze caracterele. Standardul cere ca obiectele din biblioteca standard mutate să rămână în „stare validă, dar nespecificată”. Asta înseamnă:

  • invarianții clasei sunt respectați: obiectul poate fi distrus fără probleme și se poate atribui;
  • operațiile fără precondiții funcționează: size(), empty(), clear(), atribuirea;
  • nu știi ce valoare are. Implementările uzuale lasă un std::string mutat gol, dar unui string scurt, ținut în bufferul intern (SSO), implementarea i-ar putea lăsa conținutul.

În codul dat, b conține textul, a.size() este legal (probabil 0), iar a = "nou"; readuce a într-o stare cunoscută. Ce ar fi greșit:

C++
std::string b = std::move(a);
if (a == "...") {}      // logică bazată pe o valoare nespecificată
char c = a[0];          // UB dacă a e gol

Câteva tipuri au garanții mai puternice: un std::unique_ptr mutat devine nullptr, iar un std::shared_ptr mutat devine gol. Pentru std::vector, standardul garantează în practică vector gol doar la constructorul de mutare.

Pentru clasele proprii, regula bună este să lași sursa într-o stare simplă și ușor de descris (de exemplu goală) și să documentezi asta.

Instrumentele ajută: clang-tidy are verificarea bugprone-use-after-move, care semnalează folosirea unei variabile după std::move.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi contractul obiectelor mutate. Greșeala tipică este fie „a e garantat gol”, fie „a nu mai poate fi folosit deloc”.

36 Junior

Se mută sau se copiază textul în codul de mai jos?

C++
const std::string s = "un text lung, alocat pe heap, de copiat";
std::string t = std::move(s);

Răspuns scurt: Se copiază. std::move(s) produce un const std::string&&, iar constructorul de mutare cere std::string&& neconstant. Singurul candidat potrivit este constructorul de copiere, care primește const std::string&, așa că codul compilează tăcut și face o copie.

std::move nu mută nimic. Este doar un cast la referință rvalue, care păstrează calificatorii: pentru o variabilă const std::string, rezultatul este const std::string&&.

Când compilatorul alege constructorul lui t, are doi candidați:

  • string(string&& other): nu se poate lega de un obiect const, pentru că mutarea modifică sursa;
  • string(const string& other): o referință const& se leagă de orice, inclusiv de un const&&.

Se alege copierea, fără eroare și fără avertisment de la compilator. Bug-ul este de performanță, nu de corectitudine, de aceea scapă ușor la review.

Situații în care apare în practică:

C++
void adauga(const std::string& nume) {
    lista.push_back(std::move(nume));   // copiere, nume e const&
}

for (const auto& x : surse)
    dest.push_back(std::move(x));       // copiere la fiecare element

Soluții:

  • dacă vrei să muți, sursa nu trebuie să fie const: parametru prin valoare (std::string nume) sau std::string&&;
  • în buclă, for (auto& x : surse) dest.push_back(std::move(x)); dacă poți lăsa sursele golite.

clang-tidy are verificarea performance-move-const-arg, care semnalează exact std::move pe obiecte const sau pe tipuri trivial copiabile, unde nu are efect.

Regula de reținut: const și mutarea nu merg împreună. O variabilă locală pe care plănuiești s-o muți mai târziu nu o declari const.

Ce urmărește intervievatorul: Se verifică dacă înțelegi că std::move este doar un cast. Majoritatea candidaților răspund „se mută”, pentru că așa sugerează numele.

37 Mid

Ce afișează programul?

C++
void g(const std::string&) { std::cout << "lvalue\n"; }
void g(std::string&&)      { std::cout << "rvalue\n"; }

void f(std::string&& s) {
    g(s);
    g(std::move(s));
}

int main() { f("text"); }

Răspuns scurt: Afișează lvalue și apoi rvalue. Deși s are tipul „referință rvalue”, în corpul funcției este o variabilă cu nume, deci o expresie lvalue. Ca să fie tratat din nou ca rvalue, trebuie std::move(s).

În C++ trebuie separate două noțiuni care sună la fel:

  • tipul unei variabile: s are tipul std::string&&;
  • categoria de valoare a unei expresii: expresia s, fiind numele unei variabile, este un lvalue.

Supraîncărcarea se rezolvă după categoria expresiei, nu după tipul declarat al variabilei. Deci g(s) alege g(const std::string&). Regula este intenționată: o variabilă cu nume poate fi folosită de mai multe ori în funcție, iar dacă prima utilizare ar muta-o automat, a doua ar găsi-o goală.

C++
void f(std::string&& s) {
    log(s);              // folosire, nu trebuie să mute
    v.push_back(s);      // copiere
    v.push_back(std::move(s));  // mutare explicită, ultima folosire
}

Concluzia practică: într-o funcție care primește T&& sau într-un constructor de mutare, trebuie să scrii explicit std::move când vrei să muți mai departe. Greșeala tipică este un constructor de mutare care copiază membrii:

C++
Persoana(Persoana&& o) : nume_(o.nume_) {}             // copiază!
Persoana(Persoana&& o) noexcept : nume_(std::move(o.nume_)) {}  // corect

o este lvalue, deci și o.nume_ este lvalue. Fără std::move, se apelează constructorul de copiere al lui std::string.

La template-uri cu referințe de forwarding (T&& dedus) regula e aceeași, dar instrumentul este std::forward<T>(x), care mută doar dacă argumentul original a fost rvalue.

Ce urmărește intervievatorul: Intervievatorul verifică dacă distingi tipul de categoria de valoare. Este fundamentul pentru scrierea corectă a constructorilor de mutare.

38 Mid

Un coleg scrie return std::move(rezultat); la finalul fiecărei funcții, „ca să fie mai rapid”. Are dreptate?

C++
std::vector<int> construieste() {
    std::vector<int> rezultat;
    rezultat.push_back(1);
    return std::move(rezultat);
}

Răspuns scurt: Nu. Pentru o variabilă locală întoarsă după nume, compilatorul poate aplica NRVO (fără nicio copiere sau mutare) și, dacă nu poate, o tratează oricum automat ca rvalue. std::move împiedică NRVO, deci transformă o operație gratuită într-o mutare.

La return rezultat; compilatorul are două mecanisme:

  • NRVO (named return value optimization): construiește rezultat direct în locul în care apelantul așteaptă valoarea. Nu există copiere și nici mutare. NRVO nu e obligatoriu, dar compilatoarele mari îl aplică în cazurile simple.
  • Mutarea implicită: dacă NRVO nu se aplică, standardul (din C++11, extins în C++20 și C++23) cere ca o variabilă locală întoarsă după nume să fie tratată întâi ca rvalue. Se mută automat, fără să scrii nimic.

NRVO funcționează doar când expresia din return este numele unei variabile locale de același tip cu cel întors. std::move(rezultat) nu mai este un nume, ci un apel de funcție care întoarce std::vector<int>&&. Compilatorul nu mai poate aplica elision și face o mutare. Pentru un vector diferența e mică, dar pentru tipuri cu mutare scumpă sau fără constructor de mutare, pierderea e reală. GCC avertizează cu -Wpessimizing-move, iar Clang are același avertisment.

Când std::move în return are sens:

C++
std::string extrage(Persoana&& p) {
    return std::move(p.nume);   // membru al unui parametru: nu se mută automat
}

std::unique_ptr<Baza> fa() {
    auto d = std::make_unique<Derivata>();
    return d;                    // C++14+: se convertește prin mutare implicită
}

Pentru membri ai obiectelor și pentru parametri de tip referință, mutarea automată nu se aplică, deci acolo std::move este necesar. Pentru variabile locale întoarse după nume, este dăunător.

Ce urmărește intervievatorul: Se verifică înțelegerea elision-ului și a mutării implicite la return. Greșeala tipică este credința că std::move ajută mereu performanța.

Eroarea, în practică:moving a local object prevents copy elision

39 Mid

Ce garantează C++17 despre copy elision? Compilează codul următor în C++17, deși clasa nu are constructor de copiere sau de mutare?

C++
struct Lacat {
    Lacat() = default;
    Lacat(const Lacat&) = delete;
    Lacat(Lacat&&) = delete;
};

Lacat fabrica() { return Lacat{}; }

int main() { Lacat l = fabrica(); }

Răspuns scurt: Da. Din C++17, inițializarea dintr-un prvalue de același tip (de exemplu return Lacat{};) nu mai creează un temporar care apoi se copiază: obiectul se construiește direct la destinație. Copy elision este garantat aici, deci constructorii de copiere și mutare nici nu trebuie să existe.

Înainte de C++17, return Lacat{}; crea conceptual un temporar care se copia sau se muta în valoarea de retur, apoi încă o dată în l. Compilatoarele eliminau aproape mereu aceste operații (RVO), dar constructorul de copiere sau de mutare trebuia totuși să fie accesibil. Codul de mai sus nu compila.

C++17 a schimbat definiția prvalue-urilor: un prvalue nu mai este un obiect temporar, ci „rețeta” de inițializare a unui obiect. Obiectul se materializează doar acolo unde e nevoie, aici direct în l. De aceea vorbim de copy elision garantat: nu există nicio copiere de eliminat.

Ce intră în garanție și ce nu:

  • garantat: return T{...};, return fabrica();, T x = T{...};, adică orice inițializare dintr-un prvalue de același tip;
  • negarantat: NRVO, adică returnarea unei variabile locale cu nume (T r; ...; return r;). Compilatorul îl poate aplica, dar constructorul de copiere sau de mutare trebuie să existe.
C++
Lacat f2() {
    Lacat l;
    return l;   // eroare: constructor de mutare șters
}

Consecințe practice: poți întoarce prin valoare din funcții fabrică tipuri care nu se pot muta, cum ar fi std::mutex, std::atomic<int> sau clase cu membri de acest fel. Poți scrie și auto m = std::atomic<int>{0};, care înainte nu compila.

Pentru performanță, regula rămâne simplă: întoarce prin valoare, nu prin pointeri sau parametri de ieșire.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi diferența dintre RVO garantat și NRVO opțional. Mulți candidați cred că elision este mereu doar o optimizare facultativă.

Eroarea, în practică:moving a local object prevents copy elision

40 Mid

Cum scrii constructorul unei clase care păstrează un std::string primit ca parametru, astfel încât să fie eficient și pentru lvalues, și pentru rvalues?

Răspuns scurt: Varianta simplă și eficientă: parametrul se ia prin valoare și se mută în membru: Persoana(std::string nume) : nume_(std::move(nume)) {}. Pentru un lvalue costă o copie și o mutare, pentru un rvalue două mutări, fără să scrii două supraîncărcări.

Un parametru care va fi păstrat de funcție (un „sink parameter”) are trei implementări uzuale:

C++
class Persoana {
    std::string nume_;
public:
    // 1. const& : o copie mereu, chiar și pentru temporare
    explicit Persoana(const std::string& n) : nume_(n) {}

    // 2. două supraîncărcări: optim, dar se dublează codul
    // Persoana(const std::string& n) : nume_(n) {}
    // Persoana(std::string&& n) : nume_(std::move(n)) {}

    // 3. prin valoare + move: aproape optim, un singur constructor
    // explicit Persoana(std::string n) : nume_(std::move(n)) {}
};

Costurile pentru varianta 3:

  • Persoana p(numeExistent);: copia se face la construcția parametrului, apoi o mutare în membru;
  • Persoana p(citesteNume()); sau Persoana p("Ana");: parametrul se construiește direct (elision sau conversie), apoi o mutare.

O mutare de std::string costă câteva atribuiri de pointeri, deci în practică varianta 3 este la fel de bună ca 2. Cu mai mulți parametri, varianta 2 ar cere 2^n supraîncărcări, de aceea varianta 3 este alegerea uzuală.

Când nu se potrivește:

  • dacă funcția doar citește parametrul și nu-l păstrează, folosești const std::string& sau std::string_view;
  • la un setter apelat des, void setNume(const std::string& n) { nume_ = n; } poate refolosi memoria deja alocată de nume_, pe când varianta prin valoare alocă mereu un buffer nou pentru copie. Diferența contează pe căile critice;
  • pentru tipuri scumpe de mutat (de exemplu std::array mare), mutarea nu e mai ieftină decât copierea.

Alternativa generică este o referință de forwarding cu std::forward, dar complică interfața și mesajele de eroare.

Ce urmărește intervievatorul: Se verifică dacă știi să cântărești copierile și mutările în designul unei interfețe. Un răspuns bun menționează și excepția setter-ului.

41 Senior

Clasa de mai jos are doar un destructor declarat. Are constructor de mutare? Ce se întâmplă la v.push_back(std::move(c))?

C++
class Cache {
    std::vector<std::string> intrari_;
public:
    ~Cache() = default;
};

Răspuns scurt: Nu are. Orice destructor, constructor de copiere sau operator de atribuire declarat de utilizator (chiar și = default) împiedică generarea implicită a operațiilor de mutare. std::move(c) va apela tăcut constructorul de copiere, care copiază tot vectorul.

Regulile de generare implicită, pe scurt:

  • Constructorul și atribuirea prin mutare sunt declarate implicit doar dacă clasa nu declară niciunul dintre: constructor de copiere, atribuire prin copiere, destructor, cealaltă operație de mutare.
  • Copierea este încă generată chiar dacă declari destructorul (comportament păstrat pentru compatibilitate și marcat deprecated). Dacă însă declari o operație de mutare, copierea devine ștearsă.

Pentru Cache, destructorul declarat suprimă mutarea, dar copierea rămâne. Un rvalue Cache&& se leagă de const Cache&, deci orice „mutare” devine copiere. Codul compilează, testele trec, iar performanța scade fără nicio eroare. Problema e frecventă când cineva adaugă un destructor doar ca să pună un breakpoint sau un mesaj de log.

Soluții:

C++
class Cache {
    std::vector<std::string> intrari_;
public:
    // Varianta 1 (regula lui zero): nu declara nimic.

    // Varianta 2: dacă ai nevoie de destructor, declari explicit toate cinci.
    ~Cache() = default;
    Cache() = default;
    Cache(const Cache&) = default;
    Cache& operator=(const Cache&) = default;
    Cache(Cache&&) noexcept = default;
    Cache& operator=(Cache&&) noexcept = default;
};

Poți verifica la compilare că intenția este respectată:

C++
static_assert(std::is_nothrow_move_constructible_v<Cache>);

Testul de mai sus nu e suficient singur: verifică doar că expresia de construire dintr-un rvalue compilează fără să arunce. Un tip doar copiabil, cu un constructor de copiere care nu aruncă, ar trece și el. Pentru clase critice, verificarea sigură rămâne citirea regulilor sau un test care măsoară alocările. Un virtual ~Baza() = default; într-o ierarhie are același efect, de aceea bazele polimorfe declară explicit și operațiile de mutare, sau le șterg pe toate pentru a evita slicing-ul.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi regulile exacte de generare, care stau la baza regulii celor cinci. Un senior știe că efectul este tăcut și explică cum îl previi.

42 Senior

Explică categoriile de valoare din C++11 încoace: lvalue, prvalue, xvalue, glvalue și rvalue. În ce categorie intră fiecare expresie de mai jos?

C++
std::string s = "a";
s;                      // (1)
std::string("b");       // (2)
std::move(s);           // (3)
s + "c";                // (4)
std::vector<int>{}[0];  // (5)

Răspuns scurt: Expresiile au două proprietăți: au identitate (o adresă) și pot fi mutate. lvalue: identitate, nu se mută implicit. prvalue: valoare pură, fără identitate. xvalue: identitate și se poate muta. (1) lvalue, (2) prvalue, (3) xvalue, (4) prvalue, (5) lvalue.

Standardul împarte expresiile după două întrebări: are expresia identitate (se referă la un obiect anume, căruia îi poți lua adresa)? Se poate muta resursa din ea?

  • lvalue: are identitate, nu se mută implicit. Exemple: nume de variabile, *p, v[i], apeluri de funcții care întorc T&.
  • xvalue („expiring value”): are identitate, dar poate fi mutată. Exemple: std::move(x), apeluri care întorc T&&, membrul unui rvalue (std::move(p).nume).
  • prvalue („pure rvalue”): nu are identitate, e doar o valoare care inițializează ceva. Exemple: literali (în afară de șiruri), T{...}, apeluri care întorc prin valoare, a + b.

Grupările derivate:

  • glvalue = lvalue + xvalue (are identitate);
  • rvalue = prvalue + xvalue (poate fi mutat; se leagă de T&&).

Pentru exemple:

1. s: nume de variabilă, lvalue. 2. std::string("b"): obiect temporar creat prin conversie explicită, prvalue. 3. std::move(s): funcție care întoarce std::string&&, xvalue. 4. s + "c": operator+ întoarce std::string prin valoare, prvalue. 5. operator[] întoarce int&, deci lvalue, chiar dacă vectorul este un temporar. Referința devine agățată după expresie, dar categoria rămâne lvalue.

Utilitatea practică: din C++17, prvalue-urile nu mai creează temporare până nu e nevoie (materializare temporară), de unde vine copy elision garantat. decltype reflectă categoriile: decltype((s)) dă std::string&, decltype(std::move(s)) dă std::string&&, iar decltype(s + "c") dă std::string.

Ce urmărește intervievatorul: Se verifică o înțelegere profundă a limbajului, necesară pentru cod generic și pentru motivarea mutărilor și a elision-ului. Greșeala tipică este să crezi că „rvalue” înseamnă doar „temporar”.

Eroarea, în practică:non-const lvalue reference cannot bind to temporary

43 Senior

Ce sunt calificatorii de referință (ref-qualifiers) pe metode, & și &&? Dă un exemplu în care sunt utili.

Răspuns scurt: Un & sau && după lista de parametri a unei metode restricționează metoda la obiecte lvalue, respectiv rvalue. Așa poți oferi o versiune care mută datele afară atunci când obiectul e temporar și o versiune care întoarce o referință când obiectul trăiește.

Așa cum const după parametri se aplică lui *this, calificatorii & și && spun pe ce fel de obiect se poate apela metoda. Exemplul clasic este un builder sau un wrapper care ține date mari:

C++
#include <string>
#include <utility>

class Builder {
    std::string s_;
public:
    Builder& adauga(const std::string& x) & {
        s_ += x;
        return *this;
    }
    Builder&& adauga(const std::string& x) && {
        s_ += x;
        return std::move(*this);
    }
    const std::string& str() const& { return s_; }   // pe obiect care trăiește
    std::string str() && { return std::move(s_); }    // pe temporar: mută
};

std::string t = Builder{}.adauga("a").adauga("b").str();  // fără copiere
Builder b;
b.adauga("x");
const std::string& r = b.str();                           // referință, fără copiere

Pe temporar, str() && mută bufferul în rezultat, deci nu se copiază nimic. Pe un obiect cu nume, str() const& întoarce o referință și obiectul rămâne intact.

Ref-qualifiers rezolvă și o capcană de siguranță. Versiunea && întoarce prin valoare, deci const std::string& r = Builder{}.str(); primește un temporar cu viață prelungită, nu o referință agățată. Biblioteca standard folosește tiparul: std::optional::value() și operator* au variante &, const&, &&, const&&.

Un alt uz este interzicerea atribuirii la temporare:

C++
struct Punct {
    int x, y;
    Punct& operator=(const Punct&) & = default;   // Punct{} = p; nu compilează
};

Regulă: dacă supraîncarci o metodă după ref-qualifier, toate supraîncărcările cu același nume și aceiași parametri trebuie să aibă unul. C++23 adaugă „deducing this”, care permite scrierea tuturor variantelor într-o singură funcție template.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi instrumente de optimizare mai puțin cunoscute și cum se leagă de categoriile de valoare. Este o întrebare de nivel senior, folosită pentru a vedea cât de adânc merge candidatul.

Șabloane și concepts

44 Junior

De ce nu compilează apelul de mai jos și cum îl repari?

C++
template <typename T>
T maxim(T a, T b) { return a > b ? a : b; }

int main() {
    auto m = maxim(1, 2.5);
}

Răspuns scurt: Compilatorul deduce T din fiecare argument separat: int din 1 și double din 2.5. Deducerile sunt în conflict, iar la deducerea template-urilor nu se fac conversii implicite. Repari cu maxim<double>(1, 2.5), cu maxim(1.0, 2.5) sau cu doi parametri de template.

La un apel fără argumente explicite de template, compilatorul încearcă să deducă T comparând tipul fiecărui argument cu tipul parametrului. Din primul argument rezultă T = int, din al doilea T = double. Pentru că aceeași T ar trebui să aibă două valori, deducerea eșuează: deduced conflicting types for parameter 'T' ('int' and 'double').

Spre deosebire de funcțiile obișnuite, la deducere nu se iau în calcul conversiile implicite (int în double). Conversiile se aplică abia după ce tipul e fixat.

Soluții, în ordinea simplității:

C++
auto m1 = maxim<double>(1, 2.5);   // T fixat explicit, 1 se convertește
auto m2 = maxim(1.0, 2.5);         // argumente de același tip

template <typename A, typename B>
auto maxim2(A a, B b) -> std::common_type_t<A, B> {
    return a > b ? a : b;
}
auto m3 = maxim2(1, 2.5);          // double

std::common_type_t<int, double> este double, tipul în care s-ar converti ambii operanzi într-o expresie aritmetică. Biblioteca standard alege voit varianta cu un singur tip: std::max(1, 2.5) nu compilează, tocmai ca să nu facă conversii surprinzătoare.

Încă un detaliu util: parametrii luați prin valoare elimină const și referința. maxim(x, y) cu const int x și int y deduce T = int pentru ambii, deci compilează.

Ce urmărește intervievatorul: Se verifică înțelegerea mecanismului de deducere a template-urilor. Greșeala tipică este să crezi că se aplică promovarea int în double la deducere.

Eroarea, în practică:no matching function for call to

45 Junior

Ce sunt parametrii de template care nu sunt tipuri (non-type template parameters)? Scrie o funcție care află dimensiunea unui tablou C primit ca argument.

Răspuns scurt: Un template poate primi și valori constante la compilare, nu doar tipuri, de exemplu template <std::size_t N>. Așa funcționează std::array<int, 5> și std::bitset<8>. Cu o referință la tablou, compilatorul deduce chiar dimensiunea: template <typename T, std::size_t N> constexpr std::size_t marime(T (&)[N]) { return N; }.

Parametrii non-tip sunt valori cunoscute la compilare: întregi, enumerări, pointeri, std::nullptr_t și, din C++20, numere în virgulă mobilă și tipuri clasă simple („structural types”). Fiecare valoare diferită produce o instanțiere diferită, deci std::array<int, 3> și std::array<int, 4> sunt tipuri distincte.

Funcția pentru dimensiunea unui tablou:

C++
#include <cstddef>
#include <iostream>

template <typename T, std::size_t N>
constexpr std::size_t marime(const T (&)[N]) noexcept {
    return N;
}

int main() {
    int note[] = {9, 7, 10, 8};
    static_assert(marime(note) == 4);
    std::cout << marime(note) << '\n';
}

Parametrul este o referință la tablou, deci tabloul nu se degradează în pointer și N poate fi dedus. Dacă ai trimite un int*, codul nu ar compila, iar asta e un avantaj față de trucul C sizeof(a) / sizeof(a[0]), care pe un pointer dă tăcut un rezultat greșit. Din C++17 există chiar std::size(note), implementat exact așa.

Alte utilizări uzuale:

  • buffere de dimensiune fixă: template <std::size_t Cap> class RingBuffer { std::array<int, Cap> d_; };
  • configurare la compilare: template <bool Debug> void proceseaza();
  • unități de măsură și calcule constante.

Dezavantajul: fiecare valoare nouă generează cod nou, deci folosirea cu multe valori diferite poate mări binarul.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi că template-urile nu sunt doar pentru tipuri și cum se evită degradarea tabloului în pointer. Exemplul cu std::size arată legătura cu biblioteca standard.

Eroarea, în practică:cannot build range expression with array parameternon-type template argument is not a constant ...

46 Junior

Scrie o clasă template Stiva<T> cu operațiile push, pop, top, empty și size. De ce pop() din std::stack nu întoarce elementul scos?

Răspuns scurt: Folosești intern un std::vector<T> și delegi operațiile lui. pop() întoarce void pentru siguranță la excepții: dacă ar întoarce prin valoare elementul scos și copierea lui ar arunca, elementul ar fi deja eliminat și pierdut.

C++
#include <stdexcept>
#include <utility>
#include <vector>

template <typename T>
class Stiva {
    std::vector<T> date_;
public:
    void push(const T& x) { date_.push_back(x); }
    void push(T&& x)      { date_.push_back(std::move(x)); }

    void pop() {
        if (date_.empty()) throw std::out_of_range("pop pe stiva goala");
        date_.pop_back();
    }
    const T& top() const {
        if (date_.empty()) throw std::out_of_range("top pe stiva goala");
        return date_.back();
    }
    bool empty() const noexcept { return date_.empty(); }
    std::size_t size() const noexcept { return date_.size(); }
};

int main() {
    Stiva<std::string> s;
    s.push("a");
    s.push("b");
    std::string varf = s.top();   // "b"
    s.pop();
}

Puncte pe care le urmărește intervievatorul:

  • definițiile metodelor stau în clasă, în header, pentru că un template trebuie văzut complet de fiecare fișier care îl instanțiază;
  • există două variante de push, pentru lvalue (copiere) și rvalue (mutare);
  • metodele care nu modifică stiva sunt const;
  • pentru stiva goală se aruncă excepție (alternativa standard este precondiția: std::stack nu verifică, iar top() pe stivă goală e UB).

Motivul separării top() de pop(): o funcție T pop() ar scoate elementul și apoi l-ar copia în valoarea de retur. Dacă acea copiere aruncă (de exemplu std::bad_alloc la un string), elementul nu mai e în stivă, dar nici nu a ajuns la apelant. Separând operațiile, top() copiază fără să modifice nimic, iar pop() nu poate eșua după ce a modificat. Aceasta este garanția puternică la excepții. Cu mutare noexcept, problema se diminuează, dar interfața standard a rămas aceeași.

Ce urmărește intervievatorul: Se verifică dacă știi să scrii un template de clasă complet și corect. Explicația despre pop() arată dacă înțelegi garanțiile la excepții.

47 Mid

De ce nu compilează funcția de mai jos în C++17 și ce rol are cuvântul typename în corectura ei?

C++
template <typename C>
void afiseazaPrimul(const C& c) {
    C::const_iterator it = c.begin();
    std::cout << *it << '\n';
}

Răspuns scurt: C::const_iterator este un nume dependent de parametrul de template, iar la parsarea template-ului compilatorul presupune că un astfel de nume e o valoare, nu un tip. Trebuie scris typename C::const_iterator it = c.begin(); sau, mai simplu, auto it = c.begin();.

Un template se verifică în două faze. În prima, la definire, compilatorul parsează codul fără să știe ce este C. Pentru C::const_iterator, nu are de unde să știe dacă e un tip, un membru static sau o funcție, pentru că o specializare a lui C ar putea defini oricare dintre ele. Regula standardului: un nume calificat care depinde de un parametru de template se consideră valoare, cu excepția cazului în care e precedat de typename. Linia este interpretată ca o expresie fără sens, de unde eroarea.

C++
template <typename C>
void afiseazaPrimul(const C& c) {
    typename C::const_iterator it = c.begin();
    std::cout << *it << '\n';
}

Există o regulă înrudită pentru template-uri membre dependente, cu cuvântul template:

C++
template <typename T>
void f(T& obj) {
    auto x = obj.template get<0>();   // altfel '<' e citit ca „mai mic”
}

C++20 a relaxat regula pentru typename în contexte unde numai un tip are sens: tipul de retur, parametrii de funcții la nivel de namespace, aliasurile using, ținta lui static_cast. Exemplul de mai sus, o declarație de variabilă locală, cere încă typename.

În cod modern, nevoia apare rar, pentru că:

  • auto it = c.begin(); evită complet numele dependent;
  • există aliasuri gata făcute: std::ranges::iterator_t<C>, typename C::value_type devine std::ranges::range_value_t<C>.

typename și class sunt interschimbabile doar în lista de parametri a template-ului (template <class T>), nu în contextul de mai sus.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai scris cod generic real. Candidații care doar au citit despre template-uri nu știu de ce apare eroarea.

Eroarea, în practică:missing 'typename' prior to dependent type name

48 Mid

Scrie o funcție suma(...) care primește oricâte argumente numerice și o funcție afiseaza(...) care le tipărește separate prin spațiu, folosind variadic templates și fold expressions.

Răspuns scurt: Cu un parameter pack typename... Ts și o fold expression din C++17: return (xs + ... + 0); pentru sumă și ((std::cout << xs << ' '), ...); pentru afișare. Compilatorul expandează expresia peste toate argumentele, fără recursivitate.

Un variadic template primește un număr oarecare de argumente de template, grupate într-un „parameter pack”. Înainte de C++17 le procesai recursiv, cu un caz de bază și un caz general. C++17 a adăugat fold expressions, care aplică un operator peste tot pack-ul:

C++
#include <iostream>
#include <string>

template <typename... Ts>
auto suma(Ts... xs) {
    return (xs + ... + 0);     // fold binar la dreapta, cu valoare inițială
}

template <typename... Ts>
void afiseaza(const Ts&... xs) {
    ((std::cout << xs << ' '), ...);   // fold peste operatorul virgulă
    std::cout << '\n';
}

int main() {
    std::cout << suma(1, 2, 3.5) << '\n';         // 6.5
    std::cout << suma() << '\n';                  // 0
    afiseaza("total:", 3, 'x', std::string("ok"));
}

Detalii:

  • (xs + ... + 0) se expandează în x1 + (x2 + (x3 + 0)). Valoarea inițială 0 face ca suma() fără argumente să compileze. Fără ea, (xs + ...) cu pack gol nu compilează pentru + (doar &&, || și , au valori implicite).
  • Fold-ul cu virgulă execută expresia pentru fiecare argument, în ordine de la stânga la dreapta.
  • sizeof...(Ts) dă numărul de elemente din pack la compilare.
  • const Ts&... evită copierea argumentelor mari, iar Ts&&... cu std::forward<Ts>(xs)... le transmite mai departe păstrându-le categoria.

Același mecanism stă la baza lui std::make_unique, emplace_back, std::tuple și std::format. Dacă vrei să accepți doar numere, poți constrânge: template <typename... Ts> requires (std::is_arithmetic_v<Ts> && ...).

Ce urmărește intervievatorul: Se verifică cunoașterea template-urilor moderne, folosite intens în biblioteci. Detaliul despre pack-ul gol separă candidații care au scris efectiv fold expressions.

49 Mid

Ce face if constexpr și de ce funcția de mai jos ar da eroare de compilare cu un if obișnuit?

C++
template <typename T>
std::string descrie(const T& x) {
    if constexpr (std::is_integral_v<T>)
        return "intreg " + std::to_string(x);
    else if constexpr (std::is_floating_point_v<T>)
        return "real " + std::to_string(x);
    else
        return "text " + std::string(x);
}

Răspuns scurt: if constexpr (C++17) evaluează condiția la compilare și nu instanțiază ramura falsă dintr-un template. Cu if obișnuit, toate ramurile s-ar compila pentru fiecare T: pentru descrie(std::string{"a"}) ar trebui compilat și std::to_string(std::string), care nu există.

Într-un template, un if obișnuit cere ca ambele ramuri să fie valide pentru tipul curent, chiar dacă condiția e cunoscută la compilare. Pentru T = std::string, prima ramură conține std::to_string(x), iar std::to_string nu are supraîncărcare pentru string, deci compilarea eșuează. Pentru T = int, ultima ramură ar conține std::string(x), adică std::string(int), care nu compilează nici ea.

Cu if constexpr, condiția trebuie să fie o expresie constantă. Ramura respinsă este „discarded statement”: dacă depinde de parametrul de template, nu se instanțiază deloc. Fiecare instanțiere conține practic doar ramura potrivită.

C++
descrie(42);                 // "intreg 42"
descrie(2.5);                // "real 2.500000"
descrie(std::string("ok"));  // "text ok"
descrie("ok");               // T = char[3], ramura text

Limite importante:

  • Ramura respinsă trebuie să fie totuși corectă sintactic. Și, în afara unui template, nu se aruncă nimic: ambele ramuri se verifică.
  • Pentru un mesaj de eroare în ramura „imposibilă”, static_assert(false, "...") funcționează doar din C++23. Înainte, condiția trebuia să depindă de T, de exemplu static_assert(sizeof(T) == 0, "tip nesuportat").
  • Tipul de retur dedus cu auto poate diferi între instanțieri, dar nu între ramurile active ale aceleiași instanțieri.

if constexpr înlocuiește multe cazuri în care înainte foloseai SFINAE sau tag dispatching cu mai multe supraîncărcări, iar codul rezultat e mult mai ușor de citit.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi diferența dintre ramificarea la compilare și cea la rulare. Greșeala tipică este să crezi că if constexpr e doar o optimizare.

50 Mid

Scrie un concept C++20 AreArie pentru tipuri care au o metodă arie() convertibilă la double și folosește-l într-o funcție. Ce se întâmplă când două supraîncărcări constrânse se potrivesc amândouă?

Răspuns scurt: Definești conceptul cu o expresie requires, apoi îl folosești ca restricție: template <AreArie T> double dublu(const T& f). Dacă se potrivesc două supraîncărcări, câștigă cea mai constrânsă, dacă una o include logic pe cealaltă (subsumption); altfel apelul e ambiguu.

Un concept este un predicat cu nume, evaluat la compilare, peste parametri de template. O expresie requires descrie ce operații trebuie să fie valide:

C++
#include <concepts>
#include <iostream>

template <typename T>
concept AreArie = requires(const T& f) {
    { f.arie() } -> std::convertible_to<double>;
};

struct Cerc { double r; double arie() const { return 3.14159 * r * r; } };

template <AreArie T>
double dubluArie(const T& f) { return 2 * f.arie(); }

// forme echivalente:
// template <typename T> requires AreArie<T> double dubluArie(const T& f);
// double dubluArie(const AreArie auto& f);

int main() {
    std::cout << dubluArie(Cerc{1.0}) << '\n';
    // dubluArie(42);  // eroare clară: 'int' nu satisface 'AreArie'
}

Avantajul principal față de un template neconstrâns: eroarea apare la locul apelului, cu motivul exact („nu satisface AreArie”, „expresia f.arie() nu e validă”), nu adânc în corpul funcției.

Subsumption (includerea constrângerilor): când două supraîncărcări sunt valide, compilatorul o alege pe cea ale cărei constrângeri le implică pe ale celeilalte.

C++
template <std::integral T> void f(T) { std::cout << "integral\n"; }
template <std::signed_integral T> void f(T) { std::cout << "cu semn\n"; }
f(5);    // "cu semn": signed_integral este definit ca integral && ...
f(5u);   // "integral"

Regula funcționează doar dacă relația e vizibilă prin compunerea conceptelor cu && și ||. Două expresii requires scrise separat, chiar identice textual, nu se subsumează, iar apelul devine ambiguu. De aceea conceptele complexe se construiesc din concepte mai mici, cu nume.

Ce urmărește intervievatorul: Se verifică dacă poți scrie concepte, nu doar recunoaște sintaxa. Subsumption arată o înțelegere mai profundă a supraîncărcării constrânse.

51 Mid

Ce este deducerea argumentelor de template pentru clase (CTAD) din C++17? Ce tip are fiecare variabilă de mai jos?

C++
std::vector v1{1, 2, 3};
std::pair p{1, 2.5};
std::vector v2(v1.begin(), v1.end());
std::vector v3{v1.begin(), v1.end()};

Răspuns scurt: CTAD permite omiterea argumentelor de template ale unei clase, deduse din constructor. v1 este std::vector<int>, p este std::pair<int, double>, v2 este std::vector<int> (prin ghidul de deducere pentru iteratori), iar v3 este un vector de iteratori, din cauza acoladelor.

Înainte de C++17, argumentele de template ale unei clase trebuiau scrise explicit, de aceea existau funcții ajutătoare ca std::make_pair. Cu CTAD (class template argument deduction), compilatorul tratează constructorii clasei ca pe niște funcții template și deduce argumentele din apel.

Pentru exemple:

  • std::vector v1{1, 2, 3}; folosește constructorul cu initializer_list<int>, deci std::vector<int>.
  • std::pair p{1, 2.5}; dă std::pair<int, double>.
  • std::vector v2(v1.begin(), v1.end()); folosește un ghid de deducere din biblioteca standard, care spune „din doi iteratori deduce tipul elementului”, deci std::vector<int>.
  • std::vector v3{v1.begin(), v1.end()}; preferă constructorul cu initializer_list, așa că rezultă std::vector<std::vector<int>::iterator> cu două elemente. Este aceeași capcană a acoladelor, doar mai bine ascunsă.

Unde CTAD e foarte comod:

C++
std::mutex m;
std::lock_guard lk(m);              // std::lock_guard<std::mutex>
std::array a{1, 2, 3};              // std::array<int, 3>
std::optional o{3.14};              // std::optional<double>

Pentru clasele proprii, poți scrie ghiduri de deducere:

C++
template <typename T>
struct Eticheta { T text; };

Eticheta(const char*) -> Eticheta<std::string>;

Eticheta e{"salut"};   // Eticheta<std::string>, nu Eticheta<const char*>

Din C++20, CTAD funcționează și pentru agregate (structuri fără constructori) și pentru aliasuri de template. Când tipul dedus nu e evident pentru cititor, e mai clar să scrii argumentele explicit.

Ce urmărește intervievatorul: Intervievatorul verifică dacă folosești C++17 în mod conștient. Capcana cu v3 arată dacă știi interacțiunea dintre CTAD și acolade.

Eroarea, în practică:use of class template requires template arguments

52 Mid

Cum restricționezi o funcție template să accepte doar tipuri numerice și cum dai un mesaj de eroare clar? Ce sunt type traits?

Răspuns scurt: Type traits sunt template-uri din <type_traits> care răspund la compilare la întrebări despre tipuri (std::is_arithmetic_v<T>) sau le transformă (std::remove_cvref_t<T>). Combinate cu static_assert, produc un mesaj de eroare clar; în C++20 poți folosi direct un concept.

Un type trait este o structură template care expune o valoare sau un tip calculat la compilare. Există două familii:

  • predicate: std::is_integral_v<T>, std::is_arithmetic_v<T>, std::is_same_v<A, B>, std::is_trivially_copyable_v<T>, std::is_nothrow_move_constructible_v<T>;
  • transformări: std::remove_reference_t<T>, std::decay_t<T>, std::remove_cvref_t<T> (C++20), std::conditional_t<cond, A, B>, std::common_type_t<A, B>.

Sufixele _v (C++17) și _t (C++14) sunt prescurtări pentru ::value și ::type.

C++
#include <type_traits>
#include <vector>

template <typename T>
double medie(const std::vector<T>& v) {
    static_assert(std::is_arithmetic_v<T>,
                  "medie() cere un vector de numere");
    if (v.empty()) return 0.0;
    double s = 0;
    for (const T& x : v) s += x;
    return s / v.size();
}

// medie(std::vector<std::string>{"a"});
// eroare: static assertion failed: medie() cere un vector de numere

Fără static_assert, eroarea ar apărea la s += x, într-un mesaj lung despre operator+= și std::string.

Diferența față de concepte: static_assert respinge apelul după ce funcția a fost aleasă, deci nu ajută la alegerea între supraîncărcări. Un concept (template <typename T> requires std::is_arithmetic_v<T>) scoate funcția din rezolvarea supraîncărcării, ca să poată câștiga altă variantă.

Type traits sunt folosite des și pentru optimizări: un container poate copia cu memcpy când std::is_trivially_copyable_v<T> e adevărat, iar std::vector mută elementele la realocare doar dacă std::is_nothrow_move_constructible_v<T>.

Ce urmărește intervievatorul: Se verifică dacă știi instrumentele de introspecție la compilare. Un răspuns bun explică și diferența dintre static_assert și o constrângere care participă la supraîncărcare.

53 Senior

Ce este type erasure? Implementează un tip Desenabil care poate ține orice obiect cu o metodă deseneaza(), fără ca acele tipuri să moștenească o bază comună.

Răspuns scurt: Type erasure ascunde tipul concret în spatele unei interfețe uniforme: o bază virtuală internă („concept”) și un template derivat („model”) care învelește orice tip. Așa funcționează std::function, std::any și deleter-ul din std::shared_ptr.

Moștenirea clasică cere ca fiecare tip să derive din aceeași bază. Type erasure inversează relația: tipurile rămân independente, iar adaptarea se face automat, într-un template.

C++
#include <iostream>
#include <memory>
#include <string>
#include <vector>

class Desenabil {
    struct Concept {
        virtual ~Concept() = default;
        virtual void deseneaza() const = 0;
    };
    template <typename T>
    struct Model final : Concept {
        T obj;
        explicit Model(T o) : obj(std::move(o)) {}
        void deseneaza() const override { obj.deseneaza(); }
    };
    std::unique_ptr<Concept> p_;
public:
    template <typename T>
    Desenabil(T obj) : p_(std::make_unique<Model<T>>(std::move(obj))) {}
    void deseneaza() const { p_->deseneaza(); }
};

struct Cerc  { void deseneaza() const { std::cout << "cerc\n"; } };
struct Text  { std::string s; void deseneaza() const { std::cout << s << '\n'; } };

int main() {
    std::vector<Desenabil> scena;
    scena.emplace_back(Cerc{});
    scena.emplace_back(Text{"salut"});
    for (const auto& d : scena) d.deseneaza();
}

Cerc și Text nu știu nimic de Desenabil. Constructorul template creează un Model<T> potrivit, iar apelul trece printr-o funcție virtuală internă. Pentru apelant, tipul concret a fost „șters”.

Compromisuri:

  • o alocare pe heap per obiect. Implementările reale (inclusiv std::function) folosesc small buffer optimization: obiectele mici se țin direct în interior;
  • un apel indirect prin vtable, la fel ca la moștenire;
  • copierea cere o metodă virtuală clone() în Concept. Versiunea de aici este doar mutabilă;
  • constructorul template ar trebui constrâns cu un concept, altfel erorile pentru tipuri fără deseneaza() apar adânc în Model.

Avantajul de design: poți adapta tipuri din biblioteci externe fără să le modifici și ții semantica de valoare (containere de obiecte, nu de pointeri).

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi cum sunt construite componente standard ca std::function. Un senior discută costurile și small buffer optimization.

STL: containere, iteratori, algoritmi

Exersează capitolul cu exerciții reale: Curs C++ online →
54 Junior

Ce este un iterator în STL și ce categorii de iteratori există? De ce nu compilează std::sort pe un std::list?

Răspuns scurt: Un iterator indică un element dintr-un container și știe să avanseze; end() indică poziția de după ultimul element. Categoriile sunt input, forward, bidirectional, random access și contiguous. std::sort cere random access, iar std::list are doar bidirecționali, deci folosești list::sort().

Iteratorii sunt „lipiciul” dintre containere și algoritmi. Un algoritm ca std::find nu știe nimic despre vector sau set, ci primește doi iteratori, [first, last), și folosește doar operațiile pe care categoria lor le garantează:

  • input: citire într-o singură trecere (de exemplu std::istream_iterator);
  • forward: mai multe treceri, doar înainte (std::forward_list, std::unordered_map);
  • bidirectional: și înapoi, cu --it (std::list, std::map, std::set);
  • random access: salturi în timp constant, it + n, it2 - it1, it[n] (std::deque);
  • contiguous (C++20): elementele sunt consecutive în memorie (std::vector, std::array, std::string).

std::sort folosește introsort, care are nevoie de acces direct la poziții arbitrare. Pe std::list, std::sort(l.begin(), l.end()) dă o eroare lungă de compilare despre lipsa lui operator-. Soluția este l.sort(), un merge sort pe noduri care nu mută elementele, ci doar reface legăturile.

C++
std::list<int> l{3, 1, 2};
l.sort();                                       // 1 2 3
std::vector<int> v{3, 1, 2};
std::sort(v.begin(), v.end());                  // 1 2 3
auto it = std::find(v.begin(), v.end(), 5);
if (it != v.end()) std::cout << *it;            // verificare obligatorie

end() nu indică un element. Dereferențierea lui este comportament nedefinit, de aceea rezultatul lui find se compară întotdeauna cu end() înainte de folosire. Același criteriu explică de ce std::binary_search pe un std::list compilează, dar are complexitate liniară la avansarea iteratorilor.

Ce urmărește intervievatorul: Se verifică dacă înțelegi modelul container–iterator–algoritm al STL. Greșeala tipică este să nu știi de ce unii algoritmi refuză anumite containere.

Eroarea, în practică:no viable conversion from iterator to 'int'

55 Junior

Ce afișează codul următor și de ce e o problemă?

C++
std::map<std::string, int> stoc{{"mere", 5}};
if (stoc["pere"] > 0)
    std::cout << "avem pere\n";
std::cout << stoc.size() << '\n';

Răspuns scurt: Afișează 2. operator[] inserează cheia lipsă cu valoarea implicită (0 pentru int), deci o simplă verificare a modificat map-ul. Pentru căutare folosești find, count, contains (C++20) sau at.

std::map::operator[] are contractul „dă-mi o referință la valoarea pentru cheia aceasta; dacă nu există, creează-o”. Este comod pentru scriere și pentru numărare (frecventa[cuvant]++), dar periculos pentru citire:

  • map-ul crește cu chei pe care nimeni nu le-a vrut;
  • iteratorii nu se invalidează, dar alte părți ale programului văd brusc produse cu stoc 0;
  • operator[] nu se poate apela pe un const std::map, pentru că ar putea modifica. Dacă primești map-ul prin const&, codul nu compilează;
  • valoarea trebuie să aibă constructor implicit, altfel operator[] nu compilează deloc.

Variante corecte, după intenție:

C++
// doar existența
if (stoc.contains("pere")) {}        // C++20
if (stoc.count("pere")) {}           // înainte de C++20

// existență + valoare, o singură căutare
if (auto it = stoc.find("pere"); it != stoc.end() && it->second > 0)
    std::cout << "avem pere\n";

// valoarea trebuie să existe; altfel e eroare
int n = stoc.at("mere");             // aruncă std::out_of_range dacă lipsește

Forma if (init; conditie) este din C++17 și ține iteratorul local blocului if.

Același comportament îl are std::unordered_map::operator[]. La interviu merită spus când vrei exact acest efect: pentru numărarea frecvențelor, frecventa[c]++ este idiomul corect, pentru că valoarea inițială 0 este exact cea dorită.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi efectul secundar al lui operator[]. Este o sursă frecventă de bug-uri în cod de producție și de erori de compilare cu map-uri const.

Eroarea, în practică:no viable overloaded operator[] for const map

56 Junior

Ce întorc lower_bound și upper_bound pe vectorul de mai jos? Cum numeri câte apariții are valoarea 3?

C++
std::vector<int> v{1, 3, 3, 3, 7, 9};
auto lo = std::lower_bound(v.begin(), v.end(), 3);
auto hi = std::upper_bound(v.begin(), v.end(), 3);
auto x  = std::lower_bound(v.begin(), v.end(), 5);

Răspuns scurt: lo indică primul element mai mare sau egal cu 3 (indexul 1), iar hi primul element strict mai mare decât 3 (indexul 4). Numărul de apariții este hi - lo, adică 3. x indică 7 (indexul 4), poziția la care s-ar insera 5 păstrând ordinea.

Ambele funcții fac căutare binară în O(log n) pe un interval sortat și întorc iteratori:

  • lower_bound(val): primul element care nu este mai mic decât val, adică >= val;
  • upper_bound(val): primul element strict mai mare decât val.

Intervalul [lo, hi) conține exact elementele egale cu val. Dacă valoarea lipsește, cele două coincid și indică poziția de inserare.

C++
std::cout << (lo - v.begin()) << ' '      // 1
          << (hi - v.begin()) << ' '      // 4
          << (hi - lo) << ' '             // 3
          << (x - v.begin()) << '\n';     // 4

// existența unei valori
bool are5 = (x != v.end() && *x == 5);    // false

// inserare cu păstrarea ordinii
v.insert(std::upper_bound(v.begin(), v.end(), 5), 5);

// ambele dintr-o dată
auto [a, b] = std::equal_range(v.begin(), v.end(), 3);

std::binary_search întoarce doar bool, deci când vrei și poziția folosești lower_bound.

Capcane:

  • pe un vector nesortat rezultatul este fără sens (formal, precondiția încălcată înseamnă comportament nedefinit);
  • dacă vectorul a fost sortat cu un comparator personalizat, același comparator trebuie dat și căutării;
  • pe std::set și std::map folosești metodele membre s.lower_bound(x), care sunt O(log n). Funcția liberă std::lower_bound pe iteratori bidirecționali face O(n) pași de avansare.

Ce urmărește intervievatorul: Se verifică dacă stăpânești căutarea binară din STL, des cerută în probleme de cod live. Greșeala tipică este confuzia dintre „>=” și „>” la cele două funcții.

Eroarea, în practică:no viable conversion from iterator to 'int'

57 Junior

Sortează un vector de studenți descrescător după notă, iar la note egale după nume. Ce diferență e între std::sort și std::stable_sort?

Răspuns scurt: Dai lui std::sort un comparator care întoarce true când primul element trebuie să fie înaintea celui de-al doilea; pentru două criterii, std::tie compară lexicografic. std::stable_sort păstrează ordinea inițială a elementelor egale, iar std::sort nu o garantează.

C++
#include <algorithm>
#include <string>
#include <tuple>
#include <vector>

struct Student {
    std::string nume;
    int nota;
};

int main() {
    std::vector<Student> v{{"Ion", 9}, {"Ana", 10}, {"Dan", 9}};

    std::sort(v.begin(), v.end(), [](const Student& a, const Student& b) {
        return std::tie(b.nota, a.nume) < std::tie(a.nota, b.nume);
    });
    // Ana 10, Dan 9, Ion 9
}

Trucul cu std::tie creează tupluri de referințe care se compară lexicografic. Inversând a și b pe primul criteriu obții ordinea descrescătoare după notă, iar pe al doilea criteriu rămâne ordinea crescătoare după nume. Varianta explicită ar fi:

C++
if (a.nota != b.nota) return a.nota > b.nota;
return a.nume < b.nume;

Comparatorul trebuie să fie o ordine strictă: pentru elemente egale întoarce false. Un >= sau <= produce comportament nedefinit.

Diferența dintre algoritmi:

  • std::sort: O(n log n), nestabil. Două elemente echivalente pot ieși în orice ordine;
  • std::stable_sort: O(n log n) dacă poate aloca memorie suplimentară (altfel O(n log² n)), stabil.

Stabilitatea contează când sortezi pe etape. Dacă lista e deja ordonată după nume și vrei acum ordinea după notă, cu numele ordonate la note egale, un stable_sort doar după notă păstrează efectul primei sortări. Cu std::sort, ordinea după nume s-ar pierde.

Pentru cele mai bune k elemente, std::partial_sort sau std::nth_element sunt mai rapide decât o sortare completă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să scrii comparatori corecți și când contează stabilitatea. Greșeala tipică este un comparator cu >=.

Eroarea, în practică:invalid operands ('const Produs' and 'const Produs')

58 Junior

Care sunt adaptorii de containere din STL? Cum obții o coadă cu prioritate care scoate întâi elementul cel mai mic?

Răspuns scurt: Adaptorii sunt std::stack (LIFO), std::queue (FIFO) și std::priority_queue (heap); ei restrâng interfața unui container de bază. priority_queue este implicit un max-heap; pentru min-heap scrii std::priority_queue<int, std::vector<int>, std::greater<int>>.

Un adaptor nu e un container nou, ci o interfață restrânsă peste unul existent:

  • std::stack<T>: push, pop, top; implicit peste std::deque<T>;
  • std::queue<T>: push la coadă, pop din față, front, back; implicit peste std::deque<T>;
  • std::priority_queue<T>: push, pop, top în O(log n), respectiv O(1); implicit un max-heap peste std::vector<T>, folosind std::less<T>.

Comparatorul la priority_queue e contraintuitiv: cu std::less, vârful este cel mai mare element. Pentru min-heap folosești std::greater:

C++
#include <functional>
#include <iostream>
#include <queue>
#include <vector>

int main() {
    std::priority_queue<int, std::vector<int>, std::greater<int>> pq;
    for (int x : {5, 1, 8, 3}) pq.push(x);
    while (!pq.empty()) {
        std::cout << pq.top() << ' ';   // 1 3 5 8
        pq.pop();
    }
}

Pentru tipuri proprii, de exemplu în algoritmul lui Dijkstra, perechea (distanta, nod) funcționează direct cu std::greater<std::pair<int, int>>, pentru că pair are comparare lexicografică. Altfel scrii un comparator: auto cmp = [](const Task& a, const Task& b) { return a.prioritate < b.prioritate; }; std::priority_queue<Task, std::vector<Task>, decltype(cmp)> q(cmp);

Ca la std::stack, pop() întoarce void: citești cu top() și apoi scoți. Adaptorii nu au iteratori, deci nu poți parcurge conținutul fără să-l golești. Dacă ai nevoie și de parcurgere sau de modificarea priorităților, folosești un std::set ori funcțiile std::make_heap, std::push_heap și std::pop_heap direct pe un vector.

Ce urmărește intervievatorul: Se verifică dacă știi structurile de date de bază din STL folosite la algoritmi. Greșeala tipică este să crezi că priority_queue scoate implicit minimul.

59 Junior

Ce afișează codul și unde e bug-ul?

C++
std::vector<double> v{1.5, 2.5, 3.0};
auto s = std::accumulate(v.begin(), v.end(), 0);
std::cout << s << '\n';

Răspuns scurt: Afișează 6 în loc de 7. Tipul rezultatului lui std::accumulate este tipul valorii inițiale, aici int din 0, deci fiecare sumă parțială se trunchiază la întreg. Corect este std::accumulate(v.begin(), v.end(), 0.0).

std::accumulate (din <numeric>) este declarat aproximativ așa:

C++
template <class InputIt, class T>
T accumulate(InputIt first, InputIt last, T init);

Tipul acumulatorului este T, dedus din init, nu din elemente. Cu 0, T este int, iar la fiecare pas rezultatul acc + element, calculat în double, se convertește înapoi la int:

  • 0 + 1.5 = 1.5, se trunchiază la 1;
  • 1 + 2.5 = 3.5, se trunchiază la 3;
  • 3 + 3.0 = 6.0, rămâne 6.

Rezultatul afișat este 6, iar auto s are tipul int. Compilatorul poate avertiza cu -Wconversion, dar în configurații obișnuite tace.

Aceeași capcană apare cu depășirea:

C++
std::vector<long long> mari{3'000'000'000LL, 3'000'000'000LL};
auto t = std::accumulate(mari.begin(), mari.end(), 0);    // int: depășire
auto u = std::accumulate(mari.begin(), mari.end(), 0LL);  // corect

Variante sigure:

  • valoarea inițială de tipul corect: 0.0, 0LL, std::string{};
  • explicit: std::accumulate(v.begin(), v.end(), double{0});
  • din C++17, std::reduce, care poate rula și în paralel. Atenție, el poate reordona operațiile, deci pentru double rezultatul poate diferi ușor de suma secvențială;
  • în C++23, std::ranges::fold_left(v, 0.0, std::plus{}).

std::accumulate primește și o operație: std::accumulate(v.begin(), v.end(), 1LL, std::multiplies<>{}) calculează produsul.

Ce urmărește intervievatorul: Intervievatorul verifică atenția la deducerea tipurilor în algoritmi. Greșeala apare des în cod real și trece de compilare fără erori.

60 Junior

Cum găsești toate valorile asociate unei chei într-un std::multimap? Ce face s.erase(5) pe un std::multiset care conține de trei ori valoarea 5?

Răspuns scurt: Folosești equal_range(cheie), care întoarce perechea de iteratori [primul, dupa_ultimul) pentru acea cheie. s.erase(5) șterge toate cele trei apariții; ca să ștergi doar una, scrii s.erase(s.find(5)), după ce verifici că find nu a întors end().

std::multimap și std::multiset sunt variantele ordonate care permit chei duplicate. Elementele egale sunt consecutive, de aceea se folosesc intervale de iteratori:

C++
#include <iostream>
#include <map>
#include <set>
#include <string>

int main() {
    std::multimap<std::string, std::string> telefoane{
        {"Ana", "0711"}, {"Dan", "0733"}, {"Ana", "0722"}};

    auto [b, e] = telefoane.equal_range("Ana");
    for (auto it = b; it != e; ++it)
        std::cout << it->second << '\n';           // 0711, 0722
    std::cout << telefoane.count("Ana") << '\n';   // 2

    std::multiset<int> s{5, 1, 5, 5, 7};
    if (auto it = s.find(5); it != s.end())
        s.erase(it);                // șterge o singură apariție
    std::cout << s.count(5) << '\n';                // 2
    s.erase(5);                     // șterge toate aparițiile rămase
    std::cout << s.size() << '\n';                  // 2
}

Diferențe față de std::map:

  • multimap nu are operator[] și nici at(), pentru că o cheie poate avea mai multe valori;
  • insert reușește mereu și întoarce un iterator, nu o pereche (iterator, bool);
  • elementele cu aceeași cheie păstrează ordinea inserării (garantat din C++11).

erase(valoare) pe orice container asociativ șterge toate elementele cu acea cheie și întoarce câte a șters. Pe multiset este o capcană frecventă, de exemplu într-o fereastră glisantă în care vrei să scoți o singură apariție a valorii care iese din fereastră.

Pentru acces rapid fără ordonare, există std::unordered_multimap, cu aceeași funcție equal_range.

Ce urmărește intervievatorul: Se verifică dacă știi containerele cu chei duplicate și capcana lui erase(valoare). Întrebarea apare des în probleme de algoritmică cu ferestre glisante.

61 Junior

Vrei să ștergi dintr-un std::map toate produsele cu stoc 0. Unde e bug-ul și cum se scrie corect?

C++
for (auto it = stoc.begin(); it != stoc.end(); ++it)
    if (it->second == 0)
        stoc.erase(it);

Răspuns scurt: erase(it) invalidează it, iar ++it se execută apoi pe un iterator invalid: comportament nedefinit. Corect folosești valoarea întoarsă de erase, care indică elementul următor (it = stoc.erase(it);), sau, din C++20, std::erase_if(stoc, predicat).

La containerele bazate pe noduri (std::map, std::set, std::list, std::unordered_map), erase invalidează doar iteratorii spre elementul șters, iar ceilalți rămân valizi. Problema din cod este că exact iteratorul șters este incrementat după ștergere. Programul poate merge, poate sări elemente sau poate crăpa, în funcție de implementare și de date.

Varianta corectă, valabilă din C++11:

C++
for (auto it = stoc.begin(); it != stoc.end(); ) {
    if (it->second == 0)
        it = stoc.erase(it);   // erase întoarce iteratorul următor
    else
        ++it;
}

Atenție la cele două ramuri: incrementarea se face doar când nu ștergi. Bucla for nu mai are expresia de incrementare.

Varianta modernă, cea mai clară:

C++
std::erase_if(stoc, [](const auto& p) { return p.second == 0; });   // C++20

std::erase_if există pentru toate containerele standard cu dimensiune variabilă. La std::vector și std::string înlocuiește idiomul erase-remove, iar la containerele asociative face exact bucla de mai sus.

Înainte de C++11, map::erase întorcea void, iar idiomul era stoc.erase(it++);: postfixul copiază iteratorul, îl avansează, apoi șterge copia veche. Încă îl vei întâlni în cod vechi.

Regulile diferă pe containere. La std::vector, erase invalidează toți iteratorii de la poziția ștearsă până la final, iar la std::unordered_map o rehash-uire în timpul inserării invalidează toți iteratorii, deci inserarea în timpul parcurgerii e interzisă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi regulile de invalidare pentru containerele bazate pe noduri. Greșeala clasică este exact bucla din enunț.

62 Junior

Construiește un vector cu pătratele elementelor din alt vector, folosind std::transform. Unde e bug-ul în varianta de mai jos?

C++
std::vector<int> v{1, 2, 3};
std::vector<int> patrate;
std::transform(v.begin(), v.end(), patrate.begin(),
               [](int x) { return x * x; });

Răspuns scurt: patrate e gol, iar transform scrie la patrate.begin() ca într-un tablou deja alocat: comportament nedefinit. Algoritmii nu adaugă elemente singuri. Folosești std::back_inserter(patrate) sau redimensionezi destinația înainte.

Algoritmii STL lucrează cu iteratori și nu știu nimic de container. std::transform scrie rezultatul prin iteratorul de ieșire, făcând *out = valoare; ++out;. Dacă destinația nu are elemente, scrie în memorie care nu aparține vectorului.

Trei variante corecte:

C++
#include <algorithm>
#include <iterator>
#include <vector>

std::vector<int> v{1, 2, 3};

// 1. iterator de inserare: fiecare atribuire devine push_back
std::vector<int> a;
a.reserve(v.size());
std::transform(v.begin(), v.end(), std::back_inserter(a),
               [](int x) { return x * x; });

// 2. destinație dimensionată în prealabil
std::vector<int> b(v.size());
std::transform(v.begin(), v.end(), b.begin(),
               [](int x) { return x * x; });

// 3. pe loc
std::transform(v.begin(), v.end(), v.begin(),
               [](int x) { return x * x; });

std::back_inserter creează un output iterator special, la care atribuirea *it = x apelează push_back(x). Există și std::front_inserter (pentru deque și list) și std::inserter(c, poz) (pentru set sau inserare la o poziție). reserve evită realocările repetate, dar nu creează elemente, deci nu ajunge singur pentru varianta 2.

Aceeași capcană apare la std::copy, std::copy_if, std::merge și std::set_intersection. La copy_if nu știi dinainte câte elemente trec, deci back_inserter e varianta naturală.

Din C++20, cu ranges, poți scrie și std::ranges::transform(v, std::back_inserter(a), f);, iar cu C++23 auto c = v | std::views::transform(f) | std::ranges::to<std::vector>();.

Ce urmărește intervievatorul: Se verifică dacă înțelegi că algoritmii nu gestionează dimensiunea containerelor. Este una dintre cele mai frecvente greșeli la cod live cu STL.

63 Mid

Ce probleme are comparatorul de mai jos, folosit cu std::sort și cu std::set?

C++
auto cmp = [](int a, int b) { return a <= b; };
std::sort(v.begin(), v.end(), cmp);
std::set<int, decltype(cmp)> s(cmp);
s.insert(5);
s.insert(5);

Răspuns scurt: Comparatorul nu este o ordine strictă slabă, pentru că cmp(a, a) e true. La std::sort rezultatul este comportament nedefinit, inclusiv citiri în afara vectorului. La std::set, două valori 5 nu mai sunt considerate echivalente, deci apar duplicate, iar find(5) nu le găsește.

Algoritmii și containerele ordonate din STL cer ca un comparator să fie o strict weak ordering:

  • ireflexiv: cmp(a, a) este fals;
  • asimetric: dacă cmp(a, b), atunci nu cmp(b, a);
  • tranzitiv;
  • echivalența, definită ca !cmp(a, b) && !cmp(b, a), este și ea tranzitivă.

Sortarea și containerele ordonate nu folosesc niciodată ==. Două elemente sunt considerate egale dacă niciunul nu e „mai mic” decât celălalt. Cu <=, pentru a == b ambele apeluri întorc true, deci elementele nu sunt niciodată echivalente.

Efecte:

  • std::sort: implementările se bazează pe faptul că un element nu e „mai mic” decât pivotul cu care e egal. În libstdc++, o partiție fără verificarea limitelor poate continua după capătul vectorului când există multe elemente egale, deci programul poate citi memorie străină și crăpa. E UB, deci orice e posibil.
  • std::set: la al doilea insert(5), setul caută un element echivalent, nu găsește (fiindcă 5 nu e echivalent cu 5) și inserează un duplicat. s.find(5) și s.count(5) se bazează pe aceeași echivalență, deci nu vor găsi nimic.

Corect:

C++
auto cmp = [](int a, int b) { return a < b; };      // sau std::less<>{}
auto desc = [](int a, int b) { return a > b; };     // descrescător, tot strict

Pentru double, valorile NaN strică ordinea chiar și cu <, deoarece orice comparație cu NaN e falsă. Le filtrezi înainte sau folosești std::strong_order din C++20. În build-urile de debug, GCC cu -D_GLIBCXX_DEBUG și MSVC detectează unele comparatoare invalide.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi cerințele formale ale comparatorilor și consecințele încălcării lor. Puțini candidați știu că std::sort poate crăpa din cauza unui <=.

64 Mid

Cum folosești o structură proprie Punct { int x, y; } drept cheie într-un std::unordered_map? Ce se întâmplă dacă funcția hash e slabă?

Răspuns scurt: Ai nevoie de egalitate (operator==) și de o funcție hash, dată ca al treilea parametru de template sau ca specializare std::hash<Punct>. Un hash slab, care pune multe chei în aceeași găleată, degradează operațiile de la O(1) în medie spre O(n).

std::unordered_map<K, V, Hash, KeyEqual> folosește Hash ca să aleagă găleata (bucket) și KeyEqual (implicit std::equal_to<K>, adică ==) ca să compare cheile din aceeași găleată. Biblioteca are hash-uri pentru tipurile de bază și std::string, dar nu și pentru structurile tale.

C++
#include <cstddef>
#include <functional>
#include <unordered_map>

struct Punct {
    int x, y;
    bool operator==(const Punct&) const = default;   // C++20
};

struct PunctHash {
    std::size_t operator()(const Punct& p) const noexcept {
        std::size_t h1 = std::hash<int>{}(p.x);
        std::size_t h2 = std::hash<int>{}(p.y);
        return h1 ^ (h2 + 0x9e3779b9 + (h1 << 6) + (h1 >> 2));
    }
};

int main() {
    std::unordered_map<Punct, int, PunctHash> vizitat;
    vizitat[{1, 2}] = 3;
}

Combinarea urmează formula din boost::hash_combine. Varianta naivă h1 ^ h2 dă același hash pentru (1, 2) și (2, 1) și 0 pentru toate punctele de pe diagonală.

Alternativa este specializarea std::hash în namespace-ul std, ca să nu mai dai al treilea parametru:

C++
template <> struct std::hash<Punct> {
    std::size_t operator()(const Punct& p) const noexcept { return PunctHash{}(p); }
};

Reguli obligatorii: chei egale trebuie să aibă hash egal, iar câmpurile care participă la hash nu se mai modifică după inserare.

Dacă multe chei ajung în aceeași găleată, căutarea devine o parcurgere liniară a ei. În cazul cel mai rău, toate operațiile devin O(n). Pentru seturi mici sau când ai nevoie de ordine, std::map cu operator< (sau <=>) poate fi mai simplu și la fel de rapid.

Ce urmărește intervievatorul: Se verifică dacă știi cum funcționează intern o tabelă hash și ce cere ea de la cheie. Greșeala tipică este un hash x ^ y, cu coliziuni masive.

Eroarea, în practică:implicitly-deleted default constructor of std::hash

65 Mid

De ce nu compilează bool& b = v[0]; când v este un std::vector<bool>? Ce alte particularități are acest tip?

Răspuns scurt: std::vector<bool> stochează fiecare valoare pe un bit, deci v[0] întoarce un obiect proxy, nu bool&. Nu are bool* în data(), auto x = v[0] nu face copie, iar elementele diferite nu se pot scrie sigur din thread-uri diferite.

Standardul cere o specializare pentru std::vector<bool>, gândită pentru economie de memorie: 8 valori pe octet. Un bit nu are adresă proprie, deci operatorul [] întoarce un obiect std::vector<bool>::reference, care știe să citească și să scrie bitul corespunzător.

Consecințe:

C++
std::vector<bool> v{true, false};
// bool& r = v[0];      // eroare: nu există bool real
auto x = v[0];          // x este proxy, nu bool!
v[0] = false;
std::cout << x;         // 0: x „vede” modificarea

for (auto& b : v) {}    // eroare: proxy temporar nu se leagă de auto&
for (auto&& b : v) b = true;   // funcționează

Alte diferențe față de un std::vector<T> normal:

  • nu are data(), deci nu poți trimite memoria la o funcție C care așteaptă bool*;
  • nu e sigur să scrii din două thread-uri în elemente diferite, pentru că pot fi biți din același octet. La orice alt vector, elementele diferite sunt obiecte separate;
  • codul generic template <class T> void f(std::vector<T>& v) { T& x = v[0]; } nu compilează pentru bool;
  • accesul la un element e mai lent, pentru că necesită operații pe biți.

Alternative, după nevoie:

  • std::vector<char> sau std::vector<std::uint8_t>, ca să ai un octet per valoare și comportament normal;
  • std::deque<bool>, care nu e specializat;
  • std::bitset<N> când dimensiunea e cunoscută la compilare și vrei operații pe biți rapide;
  • boost::dynamic_bitset pentru biți cu dimensiune variabilă.

Specializarea este considerată o greșeală istorică, dar a rămas pentru compatibilitate.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi una dintre capcanele clasice ale STL. Problema cu thread-urile arată că înțelegi consecințele dincolo de eroarea de compilare.

66 Mid

Folosind ranges din C++20, afișează pătratele numerelor pare dintr-un vector și sortează un vector de studenți după notă, fără comparator scris de mână.

Răspuns scurt: Compui view-uri cu |: v | std::views::filter(par) | std::views::transform(patrat), evaluate leneș, la parcurgere. Pentru sortare, std::ranges::sort(studenti, {}, &Student::nota) folosește o proiecție, adică funcția care extrage cheia de comparat.

C++
#include <algorithm>
#include <iostream>
#include <ranges>
#include <string>
#include <vector>

struct Student { std::string nume; int nota; };

int main() {
    std::vector<int> v{1, 2, 3, 4, 5, 6};

    auto r = v | std::views::filter([](int x) { return x % 2 == 0; })
               | std::views::transform([](int x) { return x * x; });
    for (int x : r) std::cout << x << ' ';      // 4 16 36
    std::cout << '\n';

    std::vector<Student> s{{"Ion", 8}, {"Ana", 10}, {"Dan", 9}};
    std::ranges::sort(s, {}, &Student::nota);           // crescător
    std::ranges::sort(s, std::ranges::greater{}, &Student::nota); // descrescător

    auto it = std::ranges::find(s, "Dan", &Student::nume);
}

Ce aduce C++20:

  • algoritmi pe range-uri: std::ranges::sort(v) în loc de std::sort(v.begin(), v.end()), cu verificare prin concepte și mesaje de eroare mai clare;
  • proiecții: al treilea argument spune după ce se compară. Elimină majoritatea lambda-urilor de tip a.nota < b.nota;
  • view-uri: adaptoare leneșe, care nu copiază datele și nu alocă. r nu conține nimic; elementele se calculează abia la parcurgere.

Capcane:

  • un view nu deține datele. Dacă v dispare sau se realocă, view-ul devine invalid;
  • views::filter memorează intern primul element găsit, deci un view filtrat nu se poate parcurge printr-un const&. Tot de aceea, modificarea elementelor astfel încât să nu mai treacă filtrul este comportament nedefinit;
  • algoritmii std::ranges nu acceptă temporare dacă ar întoarce iteratori agățați: std::ranges::find(getVector(), 3) întoarce std::ranges::dangling, care nu se poate dereferenția.

Pentru a materializa rezultatul într-un vector, C++23 adaugă std::ranges::to<std::vector>().

Ce urmărește intervievatorul: Se verifică familiaritatea cu C++20 și înțelegerea evaluării leneșe. Proiecțiile sunt un detaliu pe care îl folosesc doar cei care au scris cod real cu ranges.

67 Mid

Ce este std::span (C++20) și de ce e o semnătură mai bună decât double medie(const double* p, std::size_t n)?

Răspuns scurt: std::span<T> este o vedere neproprietară peste elemente contigue: pointer plus lungime, într-un obiect. Un parametru std::span<const double> acceptă std::vector, std::array, tablouri C sau porțiuni din ele, fără copiere și fără lungimi decalate.

Varianta cu pointer și lungime are două probleme: apelantul poate trimite o lungime greșită și nimic nu leagă cele două valori. Varianta const std::vector<double>& rezolvă asta, dar nu acceptă un std::array, un tablou C sau o porțiune de vector fără copiere. std::span le acceptă pe toate:

C++
#include <array>
#include <numeric>
#include <span>
#include <vector>

double medie(std::span<const double> v) {
    if (v.empty()) return 0.0;
    return std::accumulate(v.begin(), v.end(), 0.0) / v.size();
}

int main() {
    std::vector<double> a{1, 2, 3, 4};
    std::array<double, 3> b{5, 6, 7};
    double c[] = {8, 9};

    medie(a);
    medie(b);
    medie(c);
    medie(std::span(a).subspan(1, 2));   // doar 2 și 3
}

Caracteristici:

  • copierea unui span e ieftină (doi membri), deci se transmite prin valoare;
  • std::span<const T> doar citește, std::span<T> permite modificarea elementelor, dar nu și adăugarea sau ștergerea lor;
  • există și varianta cu dimensiune fixă, std::span<int, 4>, care ține doar pointerul și verifică dimensiunea la compilare când e posibil.

Riscuri, ca la orice vedere neproprietară (la fel ca std::string_view):

  • dacă vectorul se realocă sau e distrus, span-ul devine agățat;
  • operator[] nu verifică limitele. C++26 adaugă at(), iar implementările au moduri de „hardening” care adaugă verificări.

Regula practică: pentru parametrii care doar parcurg o secvență contiguă, std::span înlocuiește perechile pointer-lungime și reduce numărul de supraîncărcări.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi tipurile-vedere din C++ modern și compromisurile lor. Greșeala tipică este păstrarea unui span după ce containerul s-a modificat.

Eroarea, în practică:cannot build range expression with array parametersizeof on array function parameter

68 Senior

Ce este small string optimization (SSO)? Ce consecințe practice are pentru performanță și pentru pointerii în interiorul unui std::string?

Răspuns scurt: Un std::string scurt își ține caracterele în obiect, într-un buffer intern, fără alocare. Copierea string-urilor scurte e ieftină, dar mutarea lor nu e mai rapidă decât copierea, iar pointerii la caractere se invalidează la mutare sau swap.

Un std::string conține de obicei un pointer, o dimensiune și o capacitate. Implementările folosesc spațiul acesta, plus eventual câțiva octeți, ca buffer pentru șiruri scurte. Capacitatea internă nu e fixată de standard. Pe platforme de 64 de biți, libstdc++ (GCC) și MSVC păstrează până la 15 caractere, iar libc++ (Clang) până la 22.

C++
std::string a = "scurt";                    // fără alocare
std::string b(100, 'x');                    // alocare pe heap
std::cout << sizeof(std::string) << '\n';   // depinde de implementare: 32 sau 24

Consecințe pentru performanță:

  • multe string-uri reale (coduri, nume, chei) încap în buffer, deci crearea și copierea lor nu ating alocatorul;
  • mutarea unui string scurt copiază caracterele, deci costă cât o copiere. Avantajul mutării apare doar la string-uri lungi;
  • sizeof(std::string) mai mare decât trei pointeri înseamnă containere de string-uri mai mari în memorie.

Consecințe pentru corectitudine:

C++
std::string s = "abc";
const char* p = s.data();
std::string t = std::move(s);
// p arată în bufferul intern al lui s, nu în t: datele lui t sunt în alt loc

La std::vector, mutarea sau swap transferă bufferul, iar pointerii la elemente rămân valizi (acum în noul vector). La std::string, standardul permite explicit invalidarea iteratorilor și pointerilor la swap și la mutare, tocmai din cauza SSO. Codul care păstrează const char* sau std::string_view spre un string care apoi e mutat funcționează cu string-uri lungi și se strică cu cele scurte, un bug care apare doar cu anumite date.

Idei similare există și în afara lui std::string: small buffer optimization în std::function și containere ca boost::small_vector.

Ce urmărește intervievatorul: Se verifică înțelegerea implementării reale a bibliotecii standard. Un senior știe că mutarea nu e mereu mai ieftină și cunoaște bug-ul cu pointerii invalidați.

Lambda, excepții și C++ modern

69 Junior

Ce afișează codul următor (C++17)?

C++
int n = 0;
auto inc = [n]() mutable { return ++n; };
std::cout << inc() << inc() << ' ' << n << '\n';

Răspuns scurt: Afișează 12 0. Lambda capturează o copie a lui n, iar mutable îi permite să modifice copia proprie, care se păstrează între apeluri. Variabila n din afară rămâne 0. Din C++17, operanzii lui << se evaluează de la stânga la dreapta.

O lambda este un obiect al unei clase generate de compilator. Capturile devin membri ai acelei clase, iar corpul devine operator(). Codul de mai sus este aproximativ echivalent cu:

C++
struct Lambda {
    int n;                                   // copia capturată
    int operator()() { return ++n; }         // fără const, datorită lui mutable
};
Lambda inc{n};

Implicit, operator() al unei lambda este const, deci o captură prin valoare nu poate fi modificată. mutable elimină acel const. Copia trăiește cât trăiește obiectul inc, deci primul apel întoarce 1, al doilea 2. n din main nu este atins, de aceea apare 0.

Înainte de C++17, ordinea de evaluare a operanzilor într-un lanț << era nespecificată, deci inc() putea fi apelat în altă ordine. C++17 a fixat ordinea stânga-dreapta pentru <<, >>, atribuire și accesul la membri.

Alte variante utile:

C++
auto inc2 = [&n] { return ++n; };   // modifică n din afară
auto copie = inc;                   // copiază și starea: copie() întoarce 3

Ultimul detaliu surprinde des: copierea unei lambda cu stare copiază starea. Dacă transmiți o lambda mutable prin valoare unui algoritm (de exemplu std::generate), algoritmul lucrează pe propria copie, iar starea din lambda ta originală nu se schimbă. Pentru stare partajată, folosești capturi prin referință sau std::ref(lambda).

O lambda fără capturi se poate converti implicit la un pointer la funcție, util pentru API-uri C.

Ce urmărește intervievatorul: Se verifică dacă înțelegi modelul lambda ca obiect cu membri. Greșeala tipică este să crezi că mutable modifică variabila originală.

Eroarea, în practică:cannot assign to a variable captured by copy

70 Junior

Scrie o funcție care caută vârsta unei persoane într-un std::map și semnalează clar lipsa ei. De ce std::optional e mai bun decât să întorci -1?

Răspuns scurt: Funcția întoarce std::optional<int>: std::nullopt când persoana lipsește, valoarea când există. Tipul spune explicit că rezultatul poate lipsi și nu mai rezervă o valoare „magică”, pe care apelantul ar putea uita să o verifice sau care ar putea deveni validă mai târziu.

C++
#include <iostream>
#include <map>
#include <optional>
#include <string>

std::optional<int> varsta(const std::map<std::string, int>& m,
                          const std::string& nume) {
    auto it = m.find(nume);
    if (it == m.end()) return std::nullopt;
    return it->second;
}

int main() {
    std::map<std::string, int> m{{"Ana", 30}};

    if (auto v = varsta(m, "Ana"))
        std::cout << *v << '\n';                  // 30

    std::cout << varsta(m, "Dan").value_or(0) << '\n';   // 0

    try {
        varsta(m, "Dan").value();                 // aruncă
    } catch (const std::bad_optional_access&) {}
}

Ce oferă std::optional<T> (C++17):

  • conversie la bool și has_value() pentru verificare;
  • *opt și opt->membru fără verificare: pe un optional gol sunt comportament nedefinit;
  • value() cu verificare, care aruncă std::bad_optional_access;
  • value_or(implicit) pentru o valoare de rezervă.

Valoarea este păstrată în interiorul obiectului, fără alocare pe heap, deci sizeof(std::optional<int>) este de obicei 8.

De ce nu -1 sau nullptr: valoarea specială nu apare în tip, deci nimic nu-l obligă pe apelant să o verifice; nu există mereu o valoare liberă (o temperatură poate fi -1); iar un pointer ar complica proprietatea.

Limitări: std::optional<T&> nu e permis (apare abia în C++26), iar pentru a explica de ce lipsește valoarea ai nevoie de altceva: excepții sau std::expected (C++23). C++23 adaugă și operațiile and_then, transform și or_else pentru înlănțuire.

Ce urmărește intervievatorul: Intervievatorul verifică dacă folosești tipuri care exprimă intenția în locul convențiilor. Greșeala tipică este dereferențierea cu * fără verificare.

Eroarea, în practică:uncaught exception std::bad_optional_access

71 Junior

Ce sunt structured bindings (C++17)? Folosește-le la parcurgerea unui std::map și la rezultatul lui insert.

Răspuns scurt: Structured bindings permit desfacerea unui obiect compus (pair, tuple, struct, array) în variabile cu nume: auto [cheie, valoare] = pereche;. Fac codul mai lizibil decât .first și .second; auto& evită copia.

C++
#include <iostream>
#include <map>
#include <string>

struct Punct { int x, y; };

int main() {
    std::map<std::string, int> stoc{{"mere", 5}, {"pere", 0}};

    for (const auto& [produs, cantitate] : stoc)
        std::cout << produs << ": " << cantitate << '\n';

    auto [it, inserat] = stoc.insert({"mere", 10});
    std::cout << inserat << ' ' << it->second << '\n';   // 0 5

    auto [x, y] = Punct{1, 2};
    int arr[2] = {7, 8};
    auto& [a, b] = arr;
    a = 70;                                             // modifică arr[0]
}

insert întoarce std::pair<iterator, bool>. Cheia există deja, deci inserat este false, iar it arată spre elementul existent, cu valoarea neschimbată 5. Fără structured bindings, ai fi scris rez.first->second și rez.second.

Cum funcționează: compilatorul creează un obiect ascuns, inițializat din expresia din dreapta, iar numele dintre paranteze devin aliasuri pentru membrii lui. Calificatorii se aplică obiectului ascuns:

  • auto [a, b] = p; copiază p, iar a și b se referă la copie;
  • auto& [a, b] = p; se referă direct la p, deci modificările se văd în original;
  • const auto& [a, b] este alegerea uzuală la parcurgerea containerelor.

Funcționează pentru tablouri, pentru tipuri cu membri publici nestatici (toți în aceeași clasă) și pentru tipuri care implementează protocolul std::tuple_size și get.

Limitări: nu poți ignora un element (trebuie să-i dai un nume; C++26 permite _), nu poți da tipuri diferite elementelor, iar până la C++20 numele nu puteau fi capturate într-o lambda.

Ce urmărește intervievatorul: Se verifică folosirea curentă a C++17. Detaliul despre obiectul ascuns și efectul lui auto& arată că știi ce se copiază.

Eroarea, în practică:decomposes into 2 elements, but 3 names provided

72 Junior

Cum funcționează try/catch în C++? De ce prinzi excepțiile prin const& și contează ordinea blocurilor catch?

Răspuns scurt: throw creează un obiect excepție și derulează stiva până la primul catch compatibil, apelând destructorii obiectelor locale. Prinderea prin const& evită copia și tăierea (slicing) obiectului derivat. Ordinea contează: se alege primul catch potrivit, deci tipurile specifice se pun înaintea celor generale.

C++
#include <iostream>
#include <stdexcept>
#include <vector>

int elementLa(const std::vector<int>& v, std::size_t i) {
    return v.at(i);                       // aruncă std::out_of_range
}

int main() {
    try {
        std::vector<int> v{1, 2, 3};
        std::cout << elementLa(v, 10);
    } catch (const std::out_of_range& e) {
        std::cerr << "index invalid: " << e.what() << '\n';
    } catch (const std::exception& e) {
        std::cerr << "eroare: " << e.what() << '\n';
    } catch (...) {
        std::cerr << "eroare necunoscută\n";
    }
}

Când se aruncă excepția, are loc stack unwinding: se iese din funcții, iar destructorii obiectelor locale se apelează în ordine inversă construcției. Acesta e motivul pentru care RAII funcționează și la erori.

De ce prin const&:

  • prin valoare (catch (std::exception e)) se face o copie, iar dacă excepția reală e std::out_of_range, copia păstrează doar partea std::exception. Metodele virtuale suprascrise, inclusiv what(), s-ar pierde;
  • prin referință nu se copiază nimic, iar polimorfismul funcționează.

Ordinea: blocurile se încearcă de sus în jos și se execută primul care se potrivește, chiar dacă unul mai jos ar fi mai exact. Dacă pui catch (const std::exception&) primul, ramura pentru out_of_range nu se mai execută niciodată. GCC avertizează în acest caz.

Pentru a rearunca aceeași excepție dintr-un catch, scrii throw;. throw e; aruncă o copie de tipul static al lui e, adică tot o formă de slicing. Dacă nicio excepție nu e prinsă, se apelează std::terminate.

Ce urmărește intervievatorul: Intervievatorul verifică mecanica excepțiilor și cele două capcane clasice: slicing și ordinea blocurilor. Diferența dintre throw; și throw e; e un bonus.

Eroarea, în practică:uncaught exception of type std::out_of_rangestd::invalid_argument: stoi: no conversion

73 Junior

Definește o excepție proprie SoldInsuficient pentru o aplicație bancară. Din ce clasă o derivezi și ce informații pui în ea?

Răspuns scurt: O derivezi din std::runtime_error (sau din altă clasă din ierarhia std::exception), dai mesajul către constructorul bazei și adaugi câmpuri cu datele utile pentru tratarea erorii. Așa poate fi prinsă specific sau generic, prin const std::exception&.

Ierarhia standard are două ramuri principale:

  • std::logic_error (cu invalid_argument, out_of_range, length_error): erori care țin de logica programului, care ar fi putut fi evitate prin verificări;
  • std::runtime_error (cu overflow_error, range_error, iar din alte headere std::system_error): situații care apar la rulare și nu pot fi prevenite din cod, de exemplu un sold insuficient sau un fișier lipsă.
C++
#include <stdexcept>
#include <string>

class SoldInsuficient : public std::runtime_error {
public:
    SoldInsuficient(double necesar, double disponibil)
        : std::runtime_error("sold insuficient: necesar " + std::to_string(necesar) +
                             ", disponibil " + std::to_string(disponibil)),
          necesar_(necesar), disponibil_(disponibil) {}

    double necesar() const noexcept { return necesar_; }
    double disponibil() const noexcept { return disponibil_; }

private:
    double necesar_;
    double disponibil_;
};

void retrage(double& sold, double suma) {
    if (suma > sold) throw SoldInsuficient(suma, sold);
    sold -= suma;
}

De ce așa:

  • derivarea din std::runtime_error oferă gratuit what() și stocarea mesajului, iar codul care prinde const std::exception& o tratează corect;
  • câmpurile proprii permit tratarea programatică (de exemplu oferirea unei sume mai mici), fără să parsezi textul mesajului;
  • getterii sunt noexcept, pentru că sunt folosiți în timpul tratării unei erori.

Ce să nu faci: să arunci int, const char* sau std::string. Nu pot fi prinse unitar prin std::exception și nu poartă tipul erorii. Și nu folosi excepții pentru fluxul normal al programului, cum ar fi terminarea unei bucle.

Ce urmărește intervievatorul: Se verifică dacă știi ierarhia standard și proiectezi excepții utile pentru cine le tratează. Greșeala tipică este aruncarea de string-uri sau coduri numerice.

74 Junior

Ce fac atributele [[nodiscard]], [[maybe_unused]], [[fallthrough]] și [[deprecated]]? Dă un exemplu în care [[nodiscard]] previne un bug.

Răspuns scurt: Atributele sunt indicații standard pentru compilator. [[nodiscard]] avertizează când valoarea întoarsă e ignorată, [[maybe_unused]] oprește avertismentul pentru variabile nefolosite, [[fallthrough]] marchează intenționat trecerea la următorul case, iar [[deprecated]] avertizează la folosirea unui API vechi.

Atributele standard au apărut în C++11, iar majoritatea celor utile zilnic în C++14 și C++17. Ele nu schimbă semantica programului, dar transformă convenții în verificări făcute de compilator.

[[nodiscard]] (C++17) este cel mai valoros:

C++
[[nodiscard]] bool salveaza(const std::string& cale);

enum class [[nodiscard]] CodEroare { Ok, Disc, Permisiuni };
CodEroare scrie();

int main() {
    salveaza("date.txt");   // avertisment: valoarea ignorată
    scrie();                // avertisment: tipul e nodiscard
    std::vector<int> v;
    v.empty();              // avertisment în bibliotecile moderne
}

Ultima linie e un bug real: cineva a vrut clear(), dar empty() doar verifică. Biblioteca standard marchează empty() cu [[nodiscard]] din C++20. Din C++20 poți da și motivul: [[nodiscard("verifică dacă salvarea a reușit")]]. Dacă ignori intenționat rezultatul, scrii static_cast<void>(salveaza(...)); sau std::ignore = salveaza(...);.

Celelalte:

  • [[maybe_unused]]: pentru parametri sau variabile folosite doar în anumite configurații, de exemplu doar în assert;
  • [[fallthrough]]; în switch: spune compilatorului și cititorului că lipsa lui break e voită, deci -Wimplicit-fallthrough nu mai avertizează;
  • [[deprecated("folosește noua_functie")]]: avertisment la fiecare utilizare, util când migrezi un API;
  • [[likely]] și [[unlikely]] (C++20): indicii pentru ramuri; folosite rar și doar după măsurători.

Compilatoarele mai au atribute proprii, ca [[gnu::always_inline]], care nu sunt portabile.

Ce urmărește intervievatorul: Intervievatorul verifică dacă folosești compilatorul ca aliat pentru prevenirea bug-urilor. Exemplul cu empty() în loc de clear() arată experiență practică.

Eroarea, în practică:unannotated fall-through between switch labelsignoring return value of 'nodiscard' function

75 Junior

Scrie o funcție constexpr care calculează factorialul, folosește-o într-un static_assert și apoi cu o valoare citită de la tastatură. Unde se execută fiecare apel?

Răspuns scurt: O funcție constexpr poate fi evaluată la compilare când argumentele sunt constante și rezultatul e cerut într-un context constant, ca static_assert sau un constexpr local. Cu un argument citit la rulare, aceeași funcție se execută normal, la rulare.

C++
#include <iostream>

constexpr long long factorial(int n) {
    long long r = 1;
    for (int i = 2; i <= n; ++i)
        r *= i;
    return r;
}

int main() {
    static_assert(factorial(5) == 120);   // verificat la compilare
    constexpr long long f10 = factorial(10);   // calculat la compilare
    int tablou[factorial(3)];             // dimensiune 6, constantă

    int n;
    std::cin >> n;
    std::cout << factorial(n) << '\n';    // calculat la rulare
}

constexpr pe o funcție nu înseamnă „se execută mereu la compilare”, ci „poate fi folosită într-o expresie constantă”. Evaluarea la compilare e garantată doar acolo unde limbajul cere o constantă: static_assert, inițializarea unei variabile constexpr, dimensiuni de tablouri, argumente de template. Pentru factorial(n) cu n citit, apelul e unul obișnuit. Dacă vrei să forțezi evaluarea la compilare, C++20 oferă consteval.

Ce poate conține o funcție constexpr a evoluat mult:

  • C++11: practic un singur return, de aceea factorialul se scria recursiv;
  • C++14: variabile locale, bucle, if, mai multe instrucțiuni;
  • C++17: lambda-uri constexpr, if constexpr;
  • C++20: try, funcții virtuale, std::vector și std::string folosite temporar în timpul evaluării.

Un beneficiu important: comportamentul nedefinit nu e permis la evaluarea la compilare. Dacă factorial(25) depășește long long, static_assert(factorial(25) > 0) dă eroare de compilare în loc să producă tăcut un rezultat greșit. Astfel, testele cu static_assert prind și UB-ul.

Ce urmărește intervievatorul: Se verifică dacă înțelegi că constexpr e o posibilitate, nu o obligație. Greșeala tipică este să crezi că orice apel al unei funcții constexpr se face la compilare.

Eroarea, în practică:constexpr variable must be initialized by a constant

76 Mid

Ce sunt lambda-urile generice și capturile cu inițializare (C++14)? Cum muți un std::unique_ptr într-o lambda?

Răspuns scurt: O lambda generică are parametri auto și devine un operator() template. Captura cu inițializare ([c = std::move(ptr)]) creează un membru nou, inițializat din orice expresie. Lambda rezultată e doar mutabilă, deci nu intră într-un std::function.

Lambda generică (C++14):

C++
auto afiseaza = [](const auto& x) { std::cout << x << '\n'; };
afiseaza(3);          // instanțiere pentru int
afiseaza("text");     // instanțiere pentru const char[5]

// C++20: listă explicită de parametri de template
auto primul = []<typename T>(const std::vector<T>& v) -> const T& { return v.front(); };

Compilatorul generează un operator() template, deci fiecare tip de argument produce o instanțiere separată. Este util cu algoritmi STL, unde nu mai repeți tipul elementelor: std::sort(v.begin(), v.end(), [](const auto& a, const auto& b) { return a.id < b.id; });.

Captura cu inițializare (init capture):

C++
auto cfg = std::make_unique<Config>();
auto task = [c = std::move(cfg)] { return c->port; };
// cfg este acum nullptr; task deține configurația

auto cuNume = [prefix = std::string("log: ")](const std::string& m) {
    return prefix + m;
};

Captura simplă [cfg] ar încerca să copieze unique_ptr-ul și n-ar compila. Init capture rezolvă mutarea și permite și calcule ([n = v.size()]), redenumiri sau capturarea unui membru prin valoare ([nume = this->nume_]), ceea ce evită captura implicită a lui this.

Lambda care deține un unique_ptr are constructorul de copiere șters. std::function cere obiecte copiabile, deci std::function<int()> f = std::move(task); nu compilează. Soluțiile sunt std::move_only_function (C++23), un template sau trecerea la std::shared_ptr. Când trimiți un astfel de task unui thread sau unei cozi, verifică întâi ce tip de callable acceptă API-ul.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi facilitățile lambda de după C++11 și problema tipurilor doar mutabile. Greșeala tipică este încercarea de a pune o lambda cu unique_ptr într-un std::function.

Eroarea, în practică:variable cannot be implicitly captured in a lambda

77 Mid

Folosește std::variant ca să ții într-un vector valori de tip int, double sau std::string și afișează-le cu std::visit. Ce se întâmplă la std::get cu tipul greșit?

Răspuns scurt: std::variant<int, double, std::string> ține exact una dintre alternative, fără alocare pe heap. std::visit apelează un vizitator potrivit tipului curent. std::get<T> cu tipul greșit aruncă std::bad_variant_access; varianta fără excepții este std::get_if<T>.

C++
#include <iostream>
#include <string>
#include <variant>
#include <vector>

template <class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template <class... Ts> overloaded(Ts...) -> overloaded<Ts...>;  // necesar în C++17

using Valoare = std::variant<int, double, std::string>;

int main() {
    std::vector<Valoare> vals{42, 3.14, std::string("abc")};

    for (const auto& v : vals)
        std::visit([](const auto& x) { std::cout << x << '\n'; }, v);

    for (const auto& v : vals)
        std::visit(overloaded{
            [](int i)                { std::cout << "int " << i << '\n'; },
            [](double d)             { std::cout << "double " << d << '\n'; },
            [](const std::string& s) { std::cout << "text " << s << '\n'; },
        }, v);

    Valoare v = 10;
    if (auto p = std::get_if<int>(&v)) std::cout << *p << '\n';
    std::cout << std::holds_alternative<double>(v) << '\n';   // 0
    // std::get<double>(v);   // aruncă std::bad_variant_access
}

std::variant (C++17) este o uniune cu tip sigur: știe ce alternativă conține (index()), apelează constructorii și destructorii corecți și nu permite citirea alternativei greșite. Dimensiunea lui este aproximativ cea a celei mai mari alternative plus un discriminant.

Idiomul overloaded combină mai multe lambda-uri într-un singur obiect cu mai multe operator(). Avantajul față de un if pe index(): dacă adaugi o alternativă nouă și uiți s-o tratezi, codul nu compilează.

Comparat cu moștenirea: variant e potrivit când setul de tipuri e închis și cunoscut, iar operațiile se schimbă des. Moștenirea e potrivită când tipurile sunt deschise (pluginuri) și operațiile stabile.

Capcană veche: înainte de corecturile din C++20, std::variant<std::string, bool> v = "abc"; alegea bool, pentru că conversia pointerului la bool e standard. Compilatoarele actuale aleg std::string.

Ce urmărește intervievatorul: Se verifică dacă știi alternativa modernă la ierarhii și la uniuni C. Idiomul overloaded arată că ai folosit std::visit în cod real.

Eroarea, în practică:uncaught exception of type std::bad_variant_access

78 Mid

Ce se întâmplă dacă o funcție marcată noexcept aruncă totuși o excepție? Când merită să marchezi o funcție noexcept?

Răspuns scurt: Excepția nu iese din funcție: se apelează std::terminate și programul se oprește, fără garanția derulării stivei. noexcept se pune unde poți promite cu adevărat că nu arunci și unde contează: destructori, operații de mutare, swap, funcții simple care nu alocă.

noexcept este o promisiune, nu o verificare. Compilatorul nu refuză codul care ar putea arunca într-o funcție noexcept, dar dacă excepția ajunge la granița funcției, se apelează std::terminate. Standardul lasă la latitudinea implementării dacă stiva se derulează înainte, deci destructorii obiectelor locale pot să nu ruleze.

C++
void f() noexcept {
    std::vector<int> v;
    v.at(5);          // aruncă std::out_of_range -> std::terminate
}

Operatorul noexcept(expresie) întoarce, la compilare, dacă expresia e declarată că nu aruncă. E folosit în cod generic, inclusiv pentru specificații condiționale:

C++
template <typename T>
void schimba(T& a, T& b) noexcept(std::is_nothrow_move_constructible_v<T> &&
                                  std::is_nothrow_move_assignable_v<T>) {
    T tmp = std::move(a);
    a = std::move(b);
    b = std::move(tmp);
}

static_assert(noexcept(std::declval<std::string&>().size()));

Când pui noexcept:

  • destructori: sunt deja implicit noexcept din C++11;
  • constructor și atribuire prin mutare, swap: containerele și algoritmii aleg varianta rapidă doar dacă acestea sunt noexcept;
  • funcții care, prin natura lor, nu pot eșua: getteri, calcule pe tipuri primitive.

Când nu:

  • funcții care alocă memorie sau apelează cod care poate arunca. Promisiunea falsă transformă o eroare tratabilă într-o oprire bruscă;
  • funcții din interfețe publice care ar putea să arunce în versiuni viitoare. Eliminarea lui noexcept mai târziu e o schimbare incompatibilă.

Din C++17, noexcept face parte din tipul funcției: un pointer la funcție noexcept e un tip diferit.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi consecința reală a încălcării promisiunii și criteriile de folosire. Greșeala tipică este să pui noexcept peste tot „pentru performanță”.

79 Mid

Ce se întâmplă dacă al doilea new din constructorul de mai jos aruncă? Cum repari clasa?

C++
class Conexiune {
    char* buffer_;
    Socket* sock_;
public:
    Conexiune() : buffer_(new char[4096]), sock_(new Socket()) {}
    ~Conexiune() { delete sock_; delete[] buffer_; }
};

Răspuns scurt: Dacă new Socket() aruncă, obiectul nu e construit complet, deci destructorul lui nu rulează. Se distrug doar membrii deja construiți, iar distrugerea pointerului brut buffer_ nu eliberează nimic: leak. Soluția sunt membri RAII, ca std::vector și std::unique_ptr.

Regula limbajului: un obiect începe să existe abia după ce constructorul lui se termină cu succes. Dacă un constructor aruncă:

  • destructorul clasei nu se apelează, pentru că nu există un obiect complet de distrus;
  • se distrug, în ordine inversă, toate subobiectele deja construite complet: clasele de bază și membrii inițializați înaintea punctului de eșec;
  • memoria pentru obiectul însuși, dacă a fost alocat cu new Conexiune, se eliberează automat.

În clasa dată, buffer_ este construit (pointerul are o valoare), dar distrugerea unui pointer brut nu face nimic. Cele 4096 de octeți rămân alocați. Un try/catch în corpul constructorului nu ajută, fiindcă excepția apare în lista de inițializare.

Repararea corectă mută responsabilitatea în membri:

C++
#include <memory>
#include <vector>

class Conexiune {
    std::vector<char> buffer_;
    std::unique_ptr<Socket> sock_;
public:
    Conexiune() : buffer_(4096), sock_(std::make_unique<Socket>()) {}
    // fără destructor: regula lui zero
};

Acum, dacă Socket() aruncă, buffer_ este un std::vector construit complet, deci destructorul lui se apelează automat și eliberează memoria.

Există și function-try-block, Conexiune() try : ... { } catch (...) { }, care prinde excepții din lista de inițializare. Totuși, nu poate „salva” obiectul: la ieșirea din catch excepția se rearuncă automat. E util pentru logare sau traducerea excepției, nu pentru eliberarea resurselor. Pentru asta rămâne RAII.

Regula generală: o clasă care gestionează mai mult de o resursă brută este aproape imposibil de scris corect la excepții. Fiecare resursă merită propriul obiect RAII.

Ce urmărește intervievatorul: Se verifică dacă știi ce se întâmplă la excepții în constructor și de ce RAII e soluția. Greșeala tipică este să crezi că destructorul se apelează oricum.

80 Senior

Ce variante ai pentru a primi un callback într-o funcție: std::function, parametru template, auto (C++20) sau pointer la funcție? Ce costă fiecare?

Răspuns scurt: Template-ul (sau auto) permite inlining fără cost suplimentar, dar generează cod per tip și stă în header. std::function acceptă orice callable și se poate stoca, cu apel indirect și posibilă alocare. Pointerul la funcție e ieftin, dar fără capturi.

C++
// 1. template: tipul exact al lambda-ului e cunoscut
template <typename F>
void pentruFiecare(const std::vector<int>& v, F f) { for (int x : v) f(x); }

// 2. C++20, echivalent cu 1
void pentruFiecare2(const std::vector<int>& v, auto f) { for (int x : v) f(x); }

// 3. type erasure
void pentruFiecare3(const std::vector<int>& v, const std::function<void(int)>& f) {
    for (int x : v) f(x);
}

// 4. pointer la funcție
void pentruFiecare4(const std::vector<int>& v, void (*f)(int)) { for (int x : v) f(x); }

Template / auto: fiecare lambda are tip unic, deci compilatorul vede corpul și îl poate integra direct în buclă. Este varianta folosită de algoritmii STL. Costuri: implementarea trebuie să stea în header, fiecare tip de callable produce o instanțiere nouă (cod mai mare, compilare mai lentă), iar funcția nu poate fi virtuală.

std::function: un singur tip pentru orice callable compatibil, deci poate fi membru de clasă, element de container sau parametru de funcție virtuală. Costuri: apel indirect, care de obicei blochează inlining-ul; posibilă alocare pe heap când callable-ul nu încape în bufferul intern (dimensiunea bufferului ține de implementare); cere callable copiabil.

Pointer la funcție: ieftin și compatibil cu C, dar acceptă doar funcții libere și lambda-uri fără capturi. De obicei se adaugă un void* context pentru date.

Recomandări:

  • algoritmi și funcții apelate în bucle strânse: template;
  • callback-uri stocate (evenimente, cozi de task-uri): std::function sau, pentru tipuri doar mutabile, std::move_only_function (C++23);
  • parametru folosit doar pe durata apelului, fără template: C++26 adaugă std::function_ref, o vedere neproprietară, fără alocare.

Ce urmărește intervievatorul: Intervievatorul verifică dacă alegi abstracția în funcție de costuri și de nevoia de stocare. Un senior menționează inlining-ul, alocarea și dimensiunea codului generat.

Eroarea, în practică:uncaught exception of type std::bad_function_call

81 Senior

De ce nu ar trebui să arunci excepții dintr-un destructor? Cum proiectezi o clasă a cărei eliberare a resursei poate eșua, de exemplu închiderea unui fișier cu flush pe disc?

Răspuns scurt: Destructorii sunt implicit noexcept din C++11, deci o excepție care iese din ei apelează std::terminate; iar o a doua excepție în timpul derulării stivei oprește oricum programul. Soluția: o metodă explicită close() care poate arunca, apelată de destructor într-un try/catch.

Două motive fac excepțiile din destructori periculoase:

  • implicit noexcept: din C++11, dacă nu declari altfel, destructorul nu are voie să arunce. Orice excepție care îl părăsește duce la std::terminate;
  • două excepții simultan: dacă un destructor se execută în timpul stack unwinding-ului provocat de o altă excepție și aruncă, programul se oprește. Nu există mecanism pentru tratarea a două excepții active.

În plus, containerele și algoritmii standard presupun destructori care nu aruncă. Un std::vector de astfel de obiecte nu are cum să ofere vreo garanție.

Designul recomandat separă operația care poate eșua de destructor:

C++
#include <cstdio>
#include <stdexcept>

class FisierScriere {
    std::FILE* f_;
public:
    explicit FisierScriere(const char* cale) : f_(std::fopen(cale, "w")) {
        if (!f_) throw std::runtime_error("nu pot deschide");
    }
    FisierScriere(const FisierScriere&) = delete;
    FisierScriere& operator=(const FisierScriere&) = delete;

    void inchide() {                      // apelantul poate trata eroarea
        if (!f_) return;
        int rez = std::fclose(f_);
        f_ = nullptr;
        if (rez != 0) throw std::runtime_error("flush esuat");
    }
    ~FisierScriere() {
        try { inchide(); }
        catch (...) { /* logare; nu propagăm */ }
    }
};

Codul care vrea să știe dacă datele au ajuns pe disc apelează explicit inchide(). Codul care uită sau iese printr-o excepție are măcar resursa eliberată.

Pentru gărzi de tip „commit sau rollback la ieșirea din domeniu”, C++17 oferă std::uncaught_exceptions(): compari numărul de excepții active la construcție și la distrugere ca să afli dacă ieși normal sau prin excepție. Pe acest principiu funcționează scope_success și scope_fail din Library Fundamentals TS.

Ce urmărește intervievatorul: Se verifică înțelegerea interacțiunii dintre destructori și excepții și capacitatea de a proiecta o interfață robustă. Un senior propune metoda explicită de închidere.

82 Senior

Ce este std::expected (C++23)? Când ai alege excepții, std::expected sau coduri de eroare? Scrie o funcție de parsare a unui număr care întoarce std::expected.

Răspuns scurt: std::expected<T, E> conține fie o valoare, fie o eroare, vizibil în tipul de retur. Se potrivește erorilor așteptate, tratate imediat (parsare, validare). Excepțiile rămân pentru erori rare, tratate departe, iar codurile de eroare pentru API-uri C sau cod fără excepții.

C++
#include <charconv>
#include <expected>
#include <string_view>

enum class EroareParsare { Gol, Invalid, Depasire };

std::expected<int, EroareParsare> parseaza(std::string_view s) {
    if (s.empty()) return std::unexpected(EroareParsare::Gol);
    int v = 0;
    auto [p, ec] = std::from_chars(s.data(), s.data() + s.size(), v);
    if (ec == std::errc::result_out_of_range)
        return std::unexpected(EroareParsare::Depasire);
    if (ec != std::errc{} || p != s.data() + s.size())
        return std::unexpected(EroareParsare::Invalid);
    return v;
}

// utilizare
if (auto r = parseaza("42")) { int n = *r; }
else if (r.error() == EroareParsare::Depasire) { /* ... */ }
int port = parseaza(text).value_or(8080);

std::from_chars (C++17) nu alocă, nu depinde de locale și nu aruncă, deci se potrivește bine cu stilul acesta.

Criterii de alegere:

  • Excepții: erori rare, care trebuie propagate prin multe niveluri până la un punct central (o cerere HTTP eșuată, o bază de date indisponibilă). Avantaje: codul principal rămâne curat și eroarea nu poate fi ignorată. Dezavantaje: costul aruncării e mare, iar fluxul de control e invizibil în semnătură.
  • std::expected: eșecul face parte din comportamentul normal (input de la utilizator, parsare, validare). Eroarea e vizibilă în tip, nu costă nimic suplimentar pe calea de succes și se poate înlănțui cu and_then, transform și or_else. Dezavantaj: fiecare nivel trebuie să o propage explicit.
  • Coduri de eroare (std::error_code, int): API-uri C, cod compilat cu -fno-exceptions (multe proiecte embedded sau jocuri), interfețe stabile între biblioteci.

Într-un proiect, contează consecvența: stabilește la nivel de echipă ce tip de eroare folosește fiecare strat. Înainte de C++23, același tipar se obține cu tl::expected sau boost::outcome.

Ce urmărește intervievatorul: Intervievatorul verifică dacă gândești strategia de tratare a erorilor la nivel de arhitectură. Un senior argumentează alegerea prin frecvența erorii și distanța până la tratare.

Comportament nedefinit și capcane

83 Junior

Ce e greșit în ambele funcții de mai jos?

C++
const std::string& numeImplicit() {
    return "anonim";
}

std::string& cuPrefix(std::string s) {
    s = "Dl. " + s;
    return s;
}

Răspuns scurt: Ambele întorc referințe spre obiecte care mor la ieșirea din funcție: primul spre un std::string temporar construit din literal, al doilea spre parametrul s. Orice folosire a rezultatului este comportament nedefinit. Corect este să întorci std::string prin valoare.

O referință nu ține în viață obiectul spre care arată. Când funcția se termină, obiectele ei locale și parametrii transmiși prin valoare sunt distruși, iar referința întoarsă devine agățată (dangling).

  • numeImplicit(): "anonim" nu este un std::string. Pentru a-l lega de const std::string&, compilatorul construiește un temporar, care e distrus la ieșirea din funcție. Regula prelungirii vieții temporarelor legate de const& nu se aplică la return.
  • cuPrefix(): s este o copie locală. Referința spre el e invalidă imediat ce funcția se termină.

Codul poate funcționa „din noroc” în teste, pentru că memoria de pe stivă nu e suprascrisă imediat, și poate crăpa sau afișa gunoi la prima modificare a codului din jur.

Compilatoarele avertizează: GCC cu -Wreturn-local-addr, Clang cu -Wreturn-stack-address (ambele active implicit), iar AddressSanitizer detectează stack-use-after-return cu opțiunea corespunzătoare.

Corect:

C++
std::string numeImplicit() { return "anonim"; }
std::string cuPrefix(const std::string& s) { return "Dl. " + s; }

// dacă vrei neapărat referință, obiectul trebuie să trăiască mai mult
const std::string& numeImplicit2() {
    static const std::string nume = "anonim";
    return nume;
}

Întoarcerea prin valoare nu costă o copie inutilă, datorită copy elision și mutării implicite. Aceeași problemă apare cu std::string_view, std::span sau pointeri întorși spre date locale: tipurile-vedere sunt, de fapt, referințe.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi durata de viață a obiectelor locale. Prima funcție e mai perfidă, pentru că temporarul creat implicit nu se vede în cod.

Eroarea, în practică:Segmentation faultaddress of stack memory of local variable returned

84 Junior

Ce se întâmplă la fiecare dintre liniile de mai jos?

C++
std::vector<int> v{1, 2, 3};
std::cout << v[3] << '\n';
std::cout << v.at(3) << '\n';
std::vector<int> gol;
std::cout << gol.front() << '\n';

Răspuns scurt: v[3] și gol.front() sunt comportament nedefinit: operator[] și front() nu verifică limitele. v.at(3) verifică și aruncă std::out_of_range. În practică, prima linie poate afișa o valoare oarecare fără nicio eroare.

STL urmează principiul „nu plătești pentru ce nu folosești”. operator[], front(), back() și dereferențierea iteratorilor nu verifică nimic, ca să fie la fel de rapide ca accesul într-un tablou C. Responsabilitatea respectării precondițiilor (i < size(), container nevid) este a apelantului. Încălcarea lor este comportament nedefinit: poți citi memorie vecină, poți strica date sau programul poate crăpa mult mai târziu, în alt loc.

at(i) face verificarea și aruncă std::out_of_range. E potrivit când indexul vine din surse nesigure, de exemplu din input.

Bug-ul tipic care duce aici:

C++
for (std::size_t i = 0; i <= v.size(); ++i)   // <= în loc de <
    suma += v[i];

Cum prinzi aceste erori în dezvoltare, fără să schimbi codul în at() peste tot:

  • AddressSanitizer (-fsanitize=address) detectează citiri în afara blocului alocat;
  • modurile de verificare ale bibliotecii: -D_GLIBCXX_ASSERTIONS în libstdc++ adaugă verificări de limite la operator[] cu cost mic, -D_GLIBCXX_DEBUG adaugă verificări complete, inclusiv de iteratori. libc++ are moduri de „hardening”, iar MSVC verifică în build-ul de debug;
  • range-for și algoritmi, care elimină indicii manuali.

Unele proiecte păstrează _GLIBCXX_ASSERTIONS activ și în producție, pentru securitate. Este un compromis acceptat între performanță și protecția împotriva citirilor în afara bufferului.

Ce urmărește intervievatorul: Se verifică dacă știi ce operații verifică limitele și cum prinzi erorile din cele care nu verifică. Greșeala tipică este să crezi că v[3] aruncă excepție.

Eroarea, în practică:Segmentation faultuncaught exception of type std::out_of_range

85 Junior

Ce afișează codul următor?

C++
struct Contor {
    int valoare;
    void inc() { ++valoare; }
};

int main() {
    Contor c;
    c.inc();
    std::cout << c.valoare << '\n';
}

Răspuns scurt: Nu se știe: valoare nu este inițializat, iar citirea lui este comportament nedefinit. Poate afișa 1, o valoare aleatoare sau altceva în build-uri optimizate. Repari cu un inițializator implicit de membru, int valoare = 0;, sau cu Contor c{};.

Pentru tipuri fundamentale (int, double, pointeri), default initialization nu face nimic. O variabilă locală Contor c; primește un constructor implicit generat, care nu inițializează valoare. Valoarea lui este nedeterminată, iar citirea ei este comportament nedefinit, nu doar „o valoare oarecare”. Optimizatorul poate presupune că așa ceva nu se întâmplă și poate produce rezultate incoerente.

Diferențe care contează:

  • Contor c; lasă membrul neinițializat (pentru variabile locale);
  • Contor c{}; sau Contor c = Contor(); face value initialization, deci valoare devine 0;
  • variabilele globale și static sunt inițializate cu zero automat, de aceea același cod pare că funcționează când c e global;
  • new Contor lasă membrul neinițializat, iar new Contor() îl face 0.

Soluția robustă, independentă de felul în care e creat obiectul, este inițializarea implicită a membrilor (default member initializer), din C++11:

C++
struct Contor {
    int valoare = 0;
    double medie{};          // 0.0
    std::string* sursa = nullptr;
    void inc() { ++valoare; }
};

Unelte: -Wall prinde unele cazuri (-Wuninitialized, -Wmaybe-uninitialized), Valgrind și MemorySanitizer (Clang, -fsanitize=memory) detectează folosirea valorilor neinițializate la rulare, iar clang-tidy are verificarea cppcoreguidelines-pro-type-member-init. C++26 schimbă statutul citirii unei variabile locale neinițializate din UB în „erroneous behavior”, cu o valoare definită de implementare, dar regula bună rămâne: inițializează totul.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi diferența dintre inițializarea implicită și cea prin valoare. Greșeala tipică este să crezi că membrii int pornesc de la 0.

86 Mid

Ce poate afișa codul următor și de ce? Când este legitim const_cast?

C++
const int limita = 10;
int* p = const_cast<int*>(&limita);
*p = 20;
std::cout << limita << ' ' << *p << '\n';

Răspuns scurt: Este comportament nedefinit: limita e definit const, iar modificarea lui pe orice cale e UB. Poate afișa 10 20, fiindcă compilatorul a propagat constanta 10, sau poate crăpa. const_cast e legitim doar dacă obiectul original nu e const.

const_cast elimină const din tipul unei expresii, dar nu schimbă natura obiectului. Regula standardului: dacă obiectul a fost definit const, orice încercare de a-l modifica este comportament nedefinit, indiferent de cast.

De ce poate apărea 10 20: limita este o constantă cu valoare cunoscută, deci compilatorul o propagă direct în cod (std::cout << 10) și nu o mai citește din memorie. Scrierea prin p modifică, eventual, celula de memorie, dar codul nu se mai uită acolo. Pentru un const global, compilatorul poate pune obiectul în secțiunea read-only a executabilului, iar scrierea produce un segmentation fault.

Când const_cast e corect:

  • Obiectul original nu e const, dar ai doar o referință sau un pointer const la el.
  • Interfața cu API-uri vechi care primesc char*, dar documentează că nu modifică datele: legacy_print(const_cast<char*>(s.c_str()));. E sigur doar dacă funcția chiar nu scrie.
  • Evitarea duplicării între getterul const și cel non-const:
C++
class Catalog {
    std::vector<Produs> produse_;
public:
    const Produs& gaseste(int id) const { /* căutare complexă */ return produse_.at(0); }
    Produs& gaseste(int id) {
        return const_cast<Produs&>(std::as_const(*this).gaseste(id));
    }
};

Aici *this nu e const (suntem în versiunea non-const), deci eliminarea lui const din rezultat e sigură. În C++23, „deducing this” permite o singură implementare, fără cast.

Dacă ai nevoie de const_cast ca să modifici ceva într-o metodă const, designul e greșit: membrul respectiv trebuie fie să nu fie const, fie să fie mutable.

Ce urmărește intervievatorul: Se verifică dacă faci diferența dintre tipul expresiei și obiectul real. Greșeala tipică este să crezi că const_cast „deblochează” orice obiect.

87 Mid

De ce pare că funcționează primul apel, dar al doilea crapă? E corect vreunul?

C++
struct Logger {
    int mesaje = 0;
    void salut() { std::cout << "salut\n"; }
    void inc()   { ++mesaje; }
};

int main() {
    Logger* p = nullptr;
    p->salut();
    p->inc();
}

Răspuns scurt: Ambele apeluri sunt comportament nedefinit. salut() pare să meargă pentru că nu citește niciun membru, deci pointerul this nul nu e dereferențiat efectiv în codul generat. inc() scrie la adresa this->mesaje, adică aproape de adresa 0, și produce segmentation fault.

O metodă nevirtuală este compilată ca o funcție obișnuită care primește un parametru ascuns, this. p->salut() devine, la nivel de cod mașină, ceva de felul Logger_salut(p). Dacă funcția nu folosește this, nicio instrucțiune nu atinge memoria de la adresa nulă, așa că programul afișează „salut”. inc() face ++this->mesaje, adică scrie la adresa 0 plus offsetul membrului, iar sistemul de operare oprește procesul.

Standardul spune însă că p->membru cu p nul este comportament nedefinit, indiferent dacă memoria e accesată. Consecințe reale:

  • optimizatorul poate deduce că după p->salut() pointerul p nu e nul, deci poate elimina verificări ulterioare de tipul if (p == nullptr);
  • dacă salut() devine virtuală, apelul citește vptr-ul din obiect și crapă imediat;
  • dacă cineva adaugă mai târziu un câmp folosit în salut(), bug-ul apare brusc într-un loc fără legătură cu modificarea.

Varianta „funcționează în teste” este cea mai periculoasă, pentru că ascunde bug-ul până la un refactoring.

Cum detectezi: UBSan (-fsanitize=undefined) raportează member call on null pointer. clang-tidy și analizatorul static al compilatorului semnalează multe dereferențieri posibile de pointeri nuli.

Cum previi în design:

  • dacă obiectul trebuie să existe, transmite-l prin referință, nu prin pointer;
  • dacă poate lipsi, verifică explicit înainte de apel sau folosește std::optional;
  • dacă metoda nu folosește starea obiectului, probabil ar trebui să fie static sau funcție liberă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi că „pare că merge” nu înseamnă „e corect” în C++. Explicația cu parametrul ascuns this arată că știi cum se compilează metodele.

Eroarea, în practică:Segmentation fault

88 Senior

De ce este periculoasă bucla de mai jos înainte de C++23 și cum o rescrii sigur?

C++
struct Comanda {
    std::vector<std::string> produse;
    const std::vector<std::string>& lista() const { return produse; }
};
Comanda incarca();

int main() {
    for (const auto& p : incarca().lista())
        std::cout << p << '\n';
}

Răspuns scurt: Range-for leagă rezultatul lui incarca().lista() de o referință, dar temporarul Comanda moare la finalul inițializării, deci bucla parcurge un vector distrus: UB. C++23 prelungește viața acestor temporare; înainte, păstrezi obiectul într-o variabilă.

Standardul definește range-for prin rescriere, aproximativ așa:

C++
{
    auto&& __range = incarca().lista();
    auto __begin = __range.begin();
    auto __end = __range.end();
    for (; __begin != __end; ++__begin) {
        const auto& p = *__begin;
        std::cout << p << '\n';
    }
}

Regula prelungirii vieții temporarelor se aplică doar obiectului legat direct de referință. Aici __range se leagă de rezultatul lui lista(), adică de o referință întoarsă de o funcție, nu de temporarul Comanda. Temporarul moare la finalul instrucțiunii de inițializare, iar __range arată spre un vector distrus. Dacă incarca() ar fi întors direct vectorul prin valoare, ar fi fost corect, pentru că atunci temporarul e legat direct.

Variante ale aceleiași probleme:

C++
for (char c : construiesteText().substr(0, 3)) {}  // OK: substr întoarce prin valoare
for (auto& x : obtineMap()["cheie"]) {}             // UB înainte de C++23
for (auto& x : std::optional<std::vector<int>>{}.value()) {}  // UB

C++23 (propunerea P2718) a schimbat regula: toate temporarele create în expresia de după : trăiesc până la finalul buclei. Codul devine corect doar dacă îl compilezi ca C++23 și compilatorul implementează schimbarea, deci nu te baza pe asta în cod portabil.

Rescrieri sigure:

C++
auto c = incarca();
for (const auto& p : c.lista()) {}

// C++20: instrucțiune de inițializare în range-for
for (auto c = incarca(); const auto& p : c.lista()) {}

Capcana apare des cu metode de tip getter care întorc referințe. Este un argument pentru ca API-urile să ofere și variante && care întorc prin valoare (ref-qualifiers). AddressSanitizer detectează problema ca heap-use-after-free.

Ce urmărește intervievatorul: Se verifică înțelegerea profundă a duratei de viață a temporarelor și a rescrierii range-for. Puțini candidați știu de schimbarea din C++23.

Eroarea, în practică:object backing the pointer will be destroyed

Concurență

Exersează capitolul cu exerciții reale: Curs C++ online →
89 Junior

De ce nu compilează codul următor și cum îl repari?

C++
void adauga(std::vector<int>& v) { v.push_back(1); }

int main() {
    std::vector<int> v;
    std::thread t(adauga, v);
    t.join();
}

Răspuns scurt: std::thread copiază argumentele în spațiul thread-ului și le transmite funcției ca rvalue, iar un rvalue nu se poate lega de std::vector<int>&. Ca să transmiți o referință reală, scrii std::thread t(adauga, std::ref(v)); și te asiguri că v trăiește până la join().

Constructorul std::thread funcționează ca std::bind: face o copie (decay copy) a fiecărui argument, stocată împreună cu thread-ul nou, și apelează funcția cu acele copii, transmise ca rvalue. Motivul e siguranța: thread-ul poate rula după ce funcția care l-a creat s-a terminat, așa că implicit nu ține referințe spre variabilele apelantului.

Pentru adauga(std::vector<int>&), copia temporară nu se poate lega de o referință lvalue neconstantă, deci compilarea eșuează cu un mesaj lung despre std::invoke. Varianta corectă:

C++
#include <functional>
#include <thread>
#include <vector>

void adauga(std::vector<int>& v) { v.push_back(1); }

int main() {
    std::vector<int> v;
    std::thread t(adauga, std::ref(v));   // std::reference_wrapper
    t.join();                             // v trăiește până aici
    // v.size() == 1
}

Capcana mai perfidă: dacă funcția ar primi const std::vector<int>&, codul ar compila fără std::ref, dar thread-ul ar lucra pe o copie. Modificările ar fi invizibile, iar pentru obiecte mari plătești o copie neașteptată.

Cu o lambda, aceeași decizie se ia la captură:

C++
std::thread t([&v] { v.push_back(1); });   // referință

Reguli de siguranță:

  • când transmiți o referință, obiectul trebuie să trăiască până la join(). Cu detach() sau cu un thread care trăiește mai mult decât funcția, referința devine agățată;
  • dacă mai multe thread-uri accesează același obiect și cel puțin unul îl modifică, ai nevoie de sincronizare (mutex sau atomic);
  • pentru tipuri doar mutabile, transmiți prin std::move: std::thread t(proceseaza, std::move(ptr));.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi semantica de copiere a argumentelor la std::thread. Varianta cu const& care copiază tăcut arată o înțelegere mai bună.

90 Junior

Care e diferența dintre std::lock_guard, std::unique_lock și std::scoped_lock? Care e problema în linia std::lock_guard<std::mutex>{m};?

Răspuns scurt: lock_guard blochează în constructor și eliberează în destructor, fără alte opțiuni. unique_lock e mutabil, permite deblocare și reblocare, blocare amânată sau încercată și e cerut de condition_variable. scoped_lock (C++17) blochează mai multe mutex-uri deodată fără deadlock. Linia fără nume creează un temporar care deblochează imediat.

Toate trei sunt gărzi RAII pentru mutex-uri, diferă prin flexibilitate și cost:

  • std::lock_guard<M>: cel mai simplu. Nu se poate copia sau muta și nu poți debloca manual înainte de sfârșitul domeniului.
  • std::unique_lock<M>: poate fi mutat (de exemplu întors dintr-o funcție), are unlock() și lock(), acceptă std::defer_lock, std::try_to_lock sau un timeout. std::condition_variable::wait cere obligatoriu un unique_lock, pentru că trebuie să elibereze și să reia mutex-ul. Ține un flag în plus, deci e puțin mai scump.
  • std::scoped_lock<M...> (C++17): primește oricâte mutex-uri și le blochează cu un algoritm care evită deadlock-ul, indiferent de ordinea în care sunt date. Cu un singur mutex se comportă ca lock_guard, deci e o alegere implicită bună în cod nou.
C++
struct Cont { std::mutex m; double sold = 0; };

void transfer(Cont& a, Cont& b, double suma) {
    std::scoped_lock lk(a.m, b.m);   // fără deadlock, chiar dacă alt thread face transfer(b, a)
    a.sold -= suma;
    b.sold += suma;
}

Exemplul presupune conturi diferite; blocarea aceluiași mutex de două ori este UB.

Capcana cu garda fără nume:

C++
std::lock_guard<std::mutex>{m};      // temporar: se deblochează la ';'
std::unique_lock<std::mutex>(m);     // declară o variabilă nouă numită m!
std::lock_guard lk(m);               // corect, cu nume (CTAD, C++17)

Prima linie blochează și deblochează imediat, deci secțiunea critică rămâne neprotejată. A doua e și mai ciudată: parantezele în jurul unui nume formează o declarație, deci creezi un unique_lock gol numit m, care ascunde mutex-ul. Ambele compilează. clang-tidy are verificarea bugprone-unused-raii.

Ce urmărește intervievatorul: Se verifică dacă alegi unealta potrivită de blocare și știi capcanele gărzilor RAII. Greșeala cu temporarul fără nume apare și în cod de producție.

91 Mid

Ce se întâmplă când un std::thread care încă rulează e distrus fără join() sau detach()? Ce aduc std::jthread și std::stop_token (C++20)?

Răspuns scurt: Destructorul unui std::thread încă joinable apelează std::terminate. std::jthread cere automat oprirea și face join() în destructor, iar prin std::stop_token funcția thread-ului poate verifica politicos dacă i s-a cerut să se oprească.

std::thread are o regulă strictă: dacă obiectul e distrus cât timp este „joinable” (thread pornit și nici join(), nici detach() apelate), programul se oprește prin std::terminate. Problema apare des la excepții:

C++
void proceseaza() {
    std::thread t(lucru);
    pas_care_poate_arunca();   // dacă aruncă, ~thread -> terminate
    t.join();
}

std::jthread („joining thread”) rezolvă două lucruri:

  • destructorul cere oprirea și apoi face join(), deci e sigur la excepții;
  • primește un mecanism standard de oprire cooperativă. Dacă funcția are ca prim parametru un std::stop_token, jthread i-l transmite automat.
C++
#include <chrono>
#include <iostream>
#include <thread>

int main() {
    using namespace std::chrono_literals;
    std::jthread worker([](std::stop_token st) {
        while (!st.stop_requested()) {
            std::cout << "lucrez\n";
            std::this_thread::sleep_for(100ms);
        }
        std::cout << "oprit curat\n";
    });
    std::this_thread::sleep_for(350ms);
}   // ~jthread: request_stop(), apoi join()

Oprirea e cooperativă: nimic nu întrerupe forțat thread-ul. Funcția trebuie să verifice token-ul la intervale rezonabile. Pentru așteptări, std::condition_variable_any::wait are o variantă care primește stop_token și se trezește la cererea de oprire. Cu std::stop_callback poți înregistra o acțiune, de exemplu închiderea unui socket blocat.

detach() rămâne posibil, dar rar justificat: thread-ul detașat nu mai poate fi așteptat, iar dacă folosește obiecte globale după ieșirea din main, comportamentul devine imprevizibil. În cod nou, std::jthread e alegerea implicită pentru thread-uri gestionate manual.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi regula std::terminate și soluția modernă. Menționarea opririi cooperative arată experiență cu thread-uri de lungă durată.

92 Mid

Este thread-safe inițializarea variabilei static din funcția de mai jos? Cum ai inițializa o singură dată o resursă care nu e static?

C++
Config& config() {
    static Config c = incarcaDinFisier("app.conf");
    return c;
}

Răspuns scurt: Da, din C++11: inițializarea unei variabile static locale e garantat thread-safe. Dacă mai multe thread-uri ajung simultan, unul face inițializarea și celelalte așteaptă. Pentru inițializare unică în alte contexte, folosești std::call_once cu un std::once_flag.

Standardul C++11 a introdus garanția numită informal „magic statics”: dacă un thread intră în declarația unei variabile static locale în timp ce alt thread o inițializează, primul așteaptă finalizarea. Inițializarea are loc exact o dată. Dacă aruncă o excepție, se reîncearcă la următorul apel. Compilatoarele implementează asta cu un flag verificat rapid și o blocare doar la prima trecere.

De aceea funcția de mai sus este și implementarea recomandată pentru singleton în C++ (Meyers singleton): simplu, leneș, thread-safe și fără probleme de ordine a inițializării globalelor.

Atenție, garanția privește doar inițializarea. Accesul ulterior la c din mai multe thread-uri are nevoie de sincronizare dacă cineva îl modifică.

Pentru inițializare unică a unui membru sau a unei resurse care nu poate fi static:

C++
#include <mutex>

class Serviciu {
    std::once_flag initFlag_;
    std::unique_ptr<Conexiune> con_;
public:
    Conexiune& conexiune() {
        std::call_once(initFlag_, [this] { con_ = std::make_unique<Conexiune>(); });
        return *con_;
    }
};

std::call_once garantează execuția o singură dată per once_flag, iar celelalte thread-uri văd efectele complete ale inițializării.

Ce nu trebuie făcut: „double-checked locking” scris de mână cu un pointer obișnuit:

C++
if (!ptr) { std::lock_guard lk(m); if (!ptr) ptr = new Config(); }

Prima citire a lui ptr se face fără sincronizare, deci e un data race (UB). Un alt thread poate vedea pointerul setat înaintea datelor obiectului. Varianta corectă cere std::atomic cu ordonare acquire/release, deci e mai simplu să folosești una dintre cele două soluții standard.

Ce urmărește intervievatorul: Se verifică dacă știi garanțiile C++11 pentru inițializarea static și alternativa call_once. Recunoașterea double-checked locking greșit arată experiență reală.

93 Mid

Ai un cache citit foarte des și modificat rar, accesat din multe thread-uri. Cum îl protejezi cu std::shared_mutex și ce capcane are?

Răspuns scurt: std::shared_mutex (C++17) permite mai mulți cititori cu std::shared_lock sau un singur scriitor cu std::unique_lock. Capcane: trecerea de la blocare partajată la exclusivă produce deadlock, nu e automat mai rapid decât un mutex simplu, iar prioritatea scriitorilor depinde de implementare.

C++
#include <mutex>
#include <optional>
#include <shared_mutex>
#include <string>
#include <unordered_map>

class Cache {
    mutable std::shared_mutex m_;
    std::unordered_map<std::string, std::string> date_;
public:
    std::optional<std::string> get(const std::string& k) const {
        std::shared_lock lk(m_);                // mai mulți cititori deodată
        if (auto it = date_.find(k); it != date_.end()) return it->second;
        return std::nullopt;
    }
    void put(std::string k, std::string v) {
        std::unique_lock lk(m_);                // exclusiv
        date_[std::move(k)] = std::move(v);
    }
};

Detalii importante:

  • get întoarce o copie. Dacă ar întoarce o referință în map, ea ar putea deveni invalidă după ce lacătul se eliberează și un alt thread face put cu rehash.
  • Mutex-ul e mutable, pentru că și o metodă const trebuie să-l blocheze.

Capcane:

  • Fără upgrade: dacă ții un shared_lock și încerci unique_lock pe același mutex, aștepți ca toți cititorii să elibereze, inclusiv pe tine: deadlock. Tiparul „citește, iar dacă lipsește, scrie” se face prin eliberarea lacătului partajat, apoi luarea celui exclusiv și reverificarea condiției.
  • Performanță: un shared_mutex e mai scump decât un std::mutex și folosește operații atomice chiar și la citire. Dacă secțiunile critice sunt foarte scurte, un mutex simplu poate fi mai rapid. Decizia se ia după măsurători.
  • Înfometare: standardul nu fixează dacă scriitorii au prioritate. Cu cititori continui, un scriitor poate aștepta mult pe unele implementări.

Alternative pentru citiri extrem de frecvente: date imutabile publicate printr-un std::shared_ptr înlocuit atomic (copy-on-write), sau partajarea cache-ului în mai multe segmente cu mutex-uri separate.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi lacătele cititor-scriitor și limitele lor reale. Deadlock-ul la upgrade este întrebarea de verificare uzuală.

94 Mid

Ce face thread_local? Dă un exemplu util și o situație în care poate produce bug-uri.

Răspuns scurt: O variabilă thread_local are câte o instanță separată în fiecare thread, distrusă la ieșirea lui. E utilă pentru stare per thread fără mutex, de exemplu un generator aleator. În thread pool-uri e periculoasă, pentru că starea rămâne de la un task la altul.

thread_local (C++11) este o durată de stocare: variabila se comportă ca una static, dar fiecare thread are propria copie. Accesul nu are nevoie de mutex, pentru că niciun alt thread nu vede aceeași instanță.

Exemplu tipic: generatorii de numere aleatoare din <random> nu sunt thread-safe, iar un mutex în jurul lor ar fi un punct de contenție.

C++
#include <random>

int aleator(int a, int b) {
    thread_local std::mt19937 gen{std::random_device{}()};
    std::uniform_int_distribution<int> d(a, b);
    return d(gen);
}

Alte utilizări: buffere temporare refolosite per thread, contoare locale agregate la final, contextul curent al unei cereri (ID de logare), errno din C.

Capcane:

  • Thread pool-uri: thread-urile sunt refolosite, deci o valoare thread_local lăsată de un task poate fi văzută de următorul. Un context de cerere neresetat poate face ca logurile sau chiar datele unui utilizator să ajungă la altă cerere.
  • Corutine și cod asincron: o funcție care se suspendă și se reia pe alt thread vede altă instanță a variabilei.
  • Pointeri spre thread_local dați altor thread-uri devin agățați când thread-ul proprietar se termină.
  • Cost: accesul, mai ales din biblioteci dinamice, poate implica un apel de funcție și verificări de inițializare.
  • Memorie: fiecare thread primește o copie, deci un buffer mare thread_local înmulțit cu sute de thread-uri contează.

Regulă practică: folosește thread_local pentru cache-uri și resurse fără semnificație logică între task-uri, nu pentru starea de business.

Ce urmărește intervievatorul: Se verifică dacă știi durata de stocare per thread și interacțiunea ei cu thread pool-urile. Greșeala tipică este tratarea thread_local ca pe o soluție universală pentru date partajate.

95 Senior

Implementează o funcție care actualizează atomic maximul global, std::atomic<int> maxim, cu o valoare nouă, fără mutex. Care e diferența dintre compare_exchange_weak și compare_exchange_strong?

Răspuns scurt: O buclă CAS: cât timp valoarea curentă e mai mică, încerci compare_exchange_weak(curent, v); la eșec, curent primește valoarea reală. weak poate eșua fals, dar e mai ieftin în bucle; strong eșuează doar dacă valoarea chiar diferă.

std::atomic nu are o operație „max” înainte de C++26 (fetch_max), deci o construiești din compare-and-swap (CAS):

C++
#include <atomic>

std::atomic<int> maxim{0};

void actualizeazaMaxim(int v) {
    int curent = maxim.load(std::memory_order_relaxed);
    while (curent < v &&
           !maxim.compare_exchange_weak(curent, v, std::memory_order_relaxed)) {
        // la eșec, curent a fost actualizat cu valoarea reală; reîncercăm
    }
}

compare_exchange_weak(expected, desired) face atomic: dacă valoarea este expected, o înlocuiește cu desired și întoarce true; altfel scrie valoarea actuală în expected și întoarce false. Bucla se oprește când reușește scrierea sau când alt thread a pus deja o valoare mai mare sau egală.

Diferența weak/strong:

  • pe arhitecturi cu instrucțiuni LL/SC (ARM, POWER), CAS-ul hardware poate eșua chiar dacă valoarea e cea așteptată, de exemplu din cauza unei întreruperi. weak expune acest eșec fals; strong îl ascunde cu o buclă internă;
  • în bucla ta, un eșec fals înseamnă doar o iterație în plus, deci weak e alegerea corectă;
  • pentru o singură încercare, fără buclă (de exemplu „preia lacătul dacă e liber”), folosești strong.

Ordonarea relaxed e suficientă aici, pentru că maximul nu publică alte date. Dacă valoarea atomică ar semnala că alte date sunt gata, ai avea nevoie de release la scriere și acquire la citire.

Capcane în algoritmii lock-free mai complecși:

  • problema ABA: la pointeri, valoarea poate trece din A în B și înapoi în A, iar CAS-ul reușește deși structura s-a schimbat. Se rezolvă cu contoare de versiune sau cu hazard pointers;
  • contenția: sub multe scrieri concurente, buclele CAS pot fi mai lente decât un mutex. Măsoară înainte să alegi.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți scrie corect o buclă CAS și dacă înțelegi semantica lui expected. Un senior menționează eșecurile false și problema ABA.

Situații din practică

96 Junior

Un coleg nou în echipă scrie peste tot new și delete, ca la facultate. Cum i-ai explica de ce în C++ modern se evită și ce să folosească în loc?

Răspuns scurt: I-aș arăta concret, pe codul lui, un leak la o excepție sau la un return timpuriu, apoi aceeași funcție rescrisă cu std::vector, std::unique_ptr sau un obiect pe stivă. Mesajul: proprietatea memoriei se exprimă prin tipuri, iar compilatorul face eliberarea corect, de fiecare dată.

Un răspuns bun este structurat și empatic, nu un monolog despre reguli.

  • Context: colegul nu greșește din neglijență, așa a învățat. Scopul nu e să-l corectez, ci să-i dau o regulă simplă pe care s-o aplice singur.
  • Exemplul concret: aleg o funcție din codul lui, de exemplu:
C++
void proceseaza() {
    Raport* r = new Raport();
    if (!r->valid()) return;          // leak
    r->genereaza();                   // dacă aruncă: leak
    delete r;
}

Îi arăt cele două ieșiri care pierd memoria și îl întreb cum le-ar repara. De obicei apare ideea de a adăuga delete înainte de fiecare return, ceea ce îmi permite să arăt cât de fragilă e soluția.

  • Alternativa:
C++
void proceseaza() {
    Raport r;                          // sau auto r = std::make_unique<Raport>();
    if (!r.valid()) return;
    r.genereaza();
}
  • Regula: obiecte pe stivă implicit; std::vector și std::string pentru colecții; std::unique_ptr când ai nevoie de heap sau de polimorfism; std::shared_ptr doar pentru proprietate cu adevărat partajată. Pointerul brut rămâne pentru observare.
  • Unelte: îi arăt cum rulează testele cu AddressSanitizer, ca să vadă singur leak-urile, și verificările clang-tidy din proiect.
  • Urmărire: la următorul code review, comentez prin trimitere la regula convenită, nu prin rescrierea codului în locul lui.

Dacă echipa nu are încă o regulă scrisă, propun s-o adăugăm în ghidul de stil, cu trimitere la C++ Core Guidelines (secțiunea R).

Ce urmărește intervievatorul: Se verifică dacă poți transmite cunoștințe tehnice clar și fără condescendență. Intervievatorii apreciază exemplul concret și mecanismul de urmărire.

Eroarea, în practică:double free detected in tcache 2

97 Mid

Un serviciu C++ a devenit vizibil mai lent după ultimele modificări. Cum investighezi și ce cauze tipice cauți?

Răspuns scurt: Reproduc pe un build de release cu simboluri de debug, compar cu versiunea anterioară, măsor cu un profiler (perf, VTune, Instruments) și citesc flame graph-ul, ca să găsesc unde se duce timpul. Abia apoi optimizez punctual și confirm câștigul cu un benchmark.

Un răspuns structurat urmează pașii unei investigații, nu ghicește cauza.

1. Reproducere și reper. Stabilesc un scenariu măsurabil (latență p99, timp pe un set fix de date) și compar versiunea veche cu cea nouă pe aceeași mașină. Verific întâi lucrurile banale: build de release (-O2), aceleași flag-uri, aceleași date. Dacă diferența e clară, git bisect găsește rapid commit-ul vinovat.

2. Profilare. Pe build-ul de release cu -g (și, pentru stive corecte, -fno-omit-frame-pointer) rulez perf record -g și generez un flame graph. Pe Windows folosesc profilerul din Visual Studio, pe macOS Instruments. Caut funcțiile care au crescut ca pondere față de versiunea veche.

3. Cauze tipice în C++:

  • copieri ascunse: parametri std::string sau std::vector prin valoare, for (auto x : container), std::move pe obiecte const, clase la care mutarea a dispărut după adăugarea unui destructor;
  • alocări în bucle: vectori fără reserve, string-uri construite repetat, std::function care alocă;
  • structuri nepotrivite: std::map sau std::list unde un vector sortat ar fi mai prietenos cu cache-ul, hash slab la unordered_map;
  • I/O: std::endl (flush la fiecare linie), loguri sincrone pe calea critică;
  • contenție: un mutex nou pe o cale fierbinte, false sharing.

4. Corectare și confirmare. Fac o singură modificare odată, măsor cu un microbenchmark (de exemplu Google Benchmark) și cu scenariul inițial. Adaug, dacă se poate, un test de performanță în CI, ca regresia să nu revină.

Concluzia comunicată echipei include cauza, cifrele măsurate înainte și după și ce am schimbat ca să nu se repete.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai o metodă bazată pe măsurători, nu pe intuiție. Greșeala tipică este să începi direct cu micro-optimizări fără profilare.

98 Mid

Build-ul proiectului C++ la care lucrezi durează foarte mult, iar echipa se plânge. Ce măsuri ai propune, în ce ordine?

Răspuns scurt: Întâi măsor unde se duce timpul (-ftime-trace în Clang). Apoi măsurile ieftine: ccache, Ninja, linker rapid. Pe urmă reduc dependențele dintre headere (forward declarations, include-uri minimale, PIMPL, precompiled headers) și, la final, extern template sau module C++20.

1. Măsurare. Fără date, optimizarea build-ului e la întâmplare. Clang are -ftime-trace, care produce pentru fiecare fișier un raport vizualizabil în Chrome tracing sau cu ClangBuildAnalyzer. Așa afli ce headere costă cel mai mult și ce template-uri se instanțiază de prea multe ori. Separ timpul de compilare de cel de linkare.

2. Câștiguri fără schimbări de cod:

  • ccache sau sccache evită recompilarea fișierelor neschimbate între build-uri și între colegi;
  • generatorul Ninja în CMake și paralelism complet (-j egal cu numărul de nuclee);
  • un linker mai rapid (lld sau mold);
  • în CI, cache distribuit și build incremental.

3. Reducerea dependențelor dintre headere, cea mai mare sursă de recompilare:

  • forward declarations în loc de #include acolo unde e nevoie doar de pointeri sau referințe;
  • principiul „include what you use”, verificabil cu unealta include-what-you-use;
  • mutarea implementărilor din headere în .cpp, inclusiv a funcțiilor mari declarate inline;
  • PIMPL pe clasele incluse peste tot, ca modificările private să nu recompileze tot proiectul.

4. Template-uri: extern template class Matrice<double>; în header și o instanțiere explicită într-un singur .cpp evită instanțierea repetată a acelorași template-uri în fiecare fișier.

5. Structural: precompiled headers (target_precompile_headers în CMake) pentru headerele stabile, cum sunt cele standard; împărțirea în biblioteci mai mici; unity builds; module C++20, dacă toolchain-ul le suportă bine.

Prezint echipei propunerile cu timpii măsurați înainte și după, încep cu cele care nu ating codul și stabilim împreună reguli de review pentru include-uri, ca problema să nu revină.

Ce urmărește intervievatorul: Se verifică experiența cu proiecte C++ reale, în care timpul de build e o problemă cotidiană. Răspunsul bun pornește de la măsurare și ordonează măsurile după cost și efect.

99 Senior

Preiei un proiect mare scris în C++98, cu pointeri bruți, macro-uri și fără teste. Cum îl modernizezi la C++17 fără să oprești livrarea de funcționalități?

Răspuns scurt: Incremental și protejat de teste: compilez cu C++17 și avertismente activate, adaug teste de caracterizare și sanitizere în CI, apoi modernizez pe zone, începând cu cele modificate des, cu clang-tidy (modernize-*) și reguli noi pentru codul atins.

Modelul de răspuns, pe etape:

1. Fundația, fără schimbări de comportament.

  • Trec compilarea pe -std=c++17, rezolv erorile (de exemplu std::auto_ptr, eliminat în C++17, și specificațiile dinamice de excepții throw(...)).
  • Activez -Wall -Wextra treptat, cu o listă de excepții care scade în timp, nu dintr-odată.
  • Adaug build-uri CI cu AddressSanitizer și UBSan. Primele rulări găsesc de obicei bug-uri reale, care justifică efortul în fața managementului.

2. Plasă de siguranță. Fără teste, orice refactorizare e riscantă. Scriu teste de caracterizare pentru zonele critice: fixez comportamentul actual, chiar și cu ciudățeniile lui, înainte de a schimba ceva.

3. Modernizare automată, în commit-uri separate. clang-tidy cu modernize-use-nullptr, modernize-use-override, modernize-loop-convert, modernize-make-unique face schimbări mecanice. Le pun în commit-uri dedicate, ușor de revizuit și de anulat, separate de funcționalități.

4. Modernizare manuală, pe zone. Prioritizez după frecvența modificărilor (regula „lasă codul mai curat decât l-ai găsit”) și după riscul de bug-uri:

  • proprietatea memoriei: unique_ptr la granițele modulelor, containere în locul tablourilor new[];
  • macro-uri de constante și funcții înlocuite cu constexpr, inline, template-uri;
  • enum class, override, = delete pentru clasele necopiabile.

5. Reguli pentru viitor. Un ghid de stil scurt, verificat automat în CI pentru codul nou, ca datoria tehnică să nu crească în continuare.

Ce nu fac: o rescriere completă, „big bang”. E lungă, blochează livrările și reintroduce bug-uri rezolvate de mult. Raportez periodic progresul, cu indicatori măsurabili: avertismente rămase, acoperire cu teste, bug-uri găsite de sanitizere.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți conduce o schimbare tehnică mare fără să blochezi echipa. Un senior pune pe primul loc testele, automatizarea și pașii incrementali.

100 Senior

Un coleg propune pentru un modul nou o soluție bazată pe template metaprogramming foarte complicat, „ca să fie totul calculat la compilare”. Restul echipei abia o înțelege. Cum procedezi?

Răspuns scurt: Discut cu el pe criterii măsurabile, nu pe gusturi: câștigul real de performanță, timpul de compilare, calitatea mesajelor de eroare și cine poate întreține codul. Propun o variantă mai simplă (constexpr, if constexpr, concepts), compar cele două cu date și decidem împreună, documentând decizia.

Model de răspuns, în pași:

1. Înțeleg motivația. Discut întâi cu colegul în privat. Îl întreb ce problemă rezolvă: performanță măsurată, siguranță la tipuri, eliminarea duplicării? Uneori există un motiv bun, de exemplu erori prinse la compilare în locul unor verificări la rulare.

2. Stabilesc criteriile. Propun să evaluăm soluția după:

  • câștigul de performanță, măsurat pe un benchmark relevant, nu presupus;
  • impactul asupra timpului de build, măsurat cu -ftime-trace;
  • mesajele de eroare când cineva folosește greșit API-ul;
  • câți membri ai echipei pot modifica sau depana codul fără autor (riscul „bus factor”).

3. Propun alternativa modernă. O mare parte din metaprogramarea clasică (SFINAE, recursivitate pe template-uri, type lists) se scrie astăzi mult mai lizibil:

C++
template <typename T>
auto serializeaza(const T& x) {
    if constexpr (std::is_arithmetic_v<T>) return std::to_string(x);
    else if constexpr (requires { x.toString(); }) return x.toString();
    else static_assert(sizeof(T) == 0, "tip nesuportat");
}

Funcțiile constexpr, if constexpr, concepts și fold expressions oferă calculul la compilare cu o fracțiune din complexitate.

4. Decid pe baza datelor. Facem un prototip mic pentru ambele variante. Dacă varianta complexă aduce un câștig clar pe o cale critică, o acceptăm, dar cu documentație, teste și o interfață simplă care ascunde complexitatea. Dacă nu, o alegem pe cea lizibilă.

5. Formalizez. Notez decizia (de exemplu într-un ADR, architecture decision record), ca discuția să nu se repete, și propun o regulă de echipă pentru cod generic.

Important e tonul: recunosc competența colegului și nu transform discuția într-un conflict de ego. Scopul comun e un cod pe care echipa îl poate întreține.

Ce urmărește intervievatorul: Se verifică maturitatea tehnică și capacitatea de a gestiona dezacorduri între colegi. Un senior folosește date și criterii comune, nu autoritate.

Întrebări de interviu pe meserie

Alte tehnologii

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de C++, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Algoritmi și structuri de date, explicați gratuit

Fiecare subiect are o animație pas cu pas, codul în Python, C++ și Java și întrebările care apar la interviuri și la BAC.

  1. Recursivitate
  2. Backtracking
  3. Metoda bulelor
  4. Căutarea binară
  5. Stiva și coada
  6. Arbori binari
  7. BFS și DFS
  8. Algoritmul lui Dijkstra
  9. Programare dinamică

Pe scurt, toate într-un loc: algoritmi explicați și structuri de date.

Învață C++ scriind cod, nu doar citind

Curs C++: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.

Ești la liceu și dai BAC la informatică? Vezi BAC Informatică: subiecte și exerciții rezolvate și pseudocodul explicat.