...
Pregătire interviuri

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

Întrebările care apar des la interviurile de Programator C / C++, 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.

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

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

Un interviu pentru un post de programator C sau C++ în România are de obicei trei etape: o discuție scurtă cu HR-ul sau cu recruiterul (motivație, disponibilitate, așteptări), unul sau două interviuri tehnice cu un programator senior sau cu un team lead și, des, un exercițiu practic: o problemă rezolvată live, un test online sau o mică temă de casă. Multe poziții sunt în embedded și automotive, unde se adaugă întrebări despre microcontrolere, volatile, întreruperi, alocare statică și standarde precum MISRA C. În zona de aplicații desktop, finanțe sau jocuri accentul cade pe C++ modern, STL, performanță și concurență.

La junior, intervievatorul verifică în primul rând că înțelegi cum funcționează memoria: pointeri, stivă și heap, durata de viață a obiectelor, ce este undefined behavior și de ce codul care „merge” poate fi greșit. Contează mai mult să explici clar decât să reciți definiții. La mid se așteaptă să stăpânești RAII, smart pointers, move semantics, costul real al containerelor STL, polimorfismul și vtable-ul, plus bazele de multithreading și de depanare cu gdb sau sanitizere.

Pagina e organizată pe teme, iar în fiecare temă întrebările merg de la junior la senior. Citește întâi răspunsul scurt și încearcă să formulezi singur explicația, apoi compară cu răspunsul detaliat. Compilează exemplele de cod (cu -Wall -Wextra și, unde e cazul, -fsanitize=address,undefined) și modifică-le: la interviu vei fi întrebat aproape sigur „ce se întâmplă dacă…”. La final ai câteva întrebări comportamentale cu un model de răspuns structurat.

Limbajul C: fundamente

1 Junior

Care sunt principalele diferențe dintre C și C++?

Răspuns scurt: C este un limbaj procedural, mic și apropiat de hardware. C++ pornește de la C și adaugă clase, moștenire, polimorfism, templates, excepții, referințe, RAII și o bibliotecă standard bogată (STL), fără să impună un cost la runtime pentru ce nu folosești.

C a fost proiectat ca un limbaj de sistem: funcții, structuri, pointeri și control direct asupra memoriei. C++ a început ca „C cu clase” și a devenit un limbaj multi-paradigmă: procedural, orientat pe obiecte și generic (templates).

Diferențe concrete pe care merită să le spui la interviu:

  • C++ are clase cu constructori și destructori, deci poate elibera automat resurse (RAII). În C, eliberarea e manuală, de obicei cu goto cleanup.
  • C++ are referințe (int&), supraîncărcarea funcțiilor și a operatorilor, namespace-uri și excepții.
  • C++ are templates și STL (std::vector, std::map, algoritmi), pe când în C scrii singur structurile de date sau folosești void*.
  • C++ e mai strict la tipuri: în C, int *p = malloc(4); e valid, în C++ trebuie cast explicit.
  • Nu orice cod C e cod C++ valid: cuvinte ca new sau class pot fi nume de variabile în C, iar C99 are restrict și designated initializers (în C++ apar abia în C++20, cu restricții).

Principiul de design al C++ este „zero-overhead”: dacă nu folosești o funcționalitate (excepții, funcții virtuale), nu plătești pentru ea. Din acest motiv C++ e folosit în aceleași zone ca C (embedded, sisteme), dar și în aplicații mari unde abstracțiile ajută la organizarea codului.

Ce urmărește intervievatorul: Verifică dacă înțelegi că C++ nu e doar „C cu clase”. Greșeala tipică: a spune că C++ e mai lent sau că orice cod C compilează în C++.

2 Junior

Ce se întâmplă, pas cu pas, când compilezi un program C cu gcc?

Răspuns scurt: Sunt patru etape: preprocesarea (expandează #include și macro-uri), compilarea (transformă codul în asamblare), asamblarea (produce fișiere obiect .o) și linkarea (unește fișierele obiect și bibliotecile într-un executabil).

Comanda gcc main.c -o app ascunde patru etape distincte, pe care le poți rula separat:

BASH
gcc -E main.c -o main.i   # preprocesare
gcc -S main.i -o main.s   # compilare la asamblare
gcc -c main.s -o main.o   # asamblare -> fișier obiect
gcc main.o util.o -o app  # linkare
  • Preprocesarea e pur textuală: copiază conținutul fișierelor din #include, înlocuiește macro-urile #define, evaluează #if/#ifdef și elimină comentariile. Rezultatul e o unitate de traducere (translation unit).
  • Compilarea verifică sintaxa și tipurile, optimizează (la -O2, de exemplu) și generează cod de asamblare pentru arhitectura țintă.
  • Asamblarea transformă asamblarea în cod mașină într-un fișier obiect, care conține simboluri încă nerezolvate (de exemplu, apelul la printf).
  • Linkarea rezolvă aceste simboluri, căutându-le în celelalte fișiere obiect și în biblioteci (libc), și produce executabilul.

Contează să știi etapele pentru că erorile arată diferit: o eroare de sintaxă apare la compilare, pe când „undefined reference to foo” e o eroare de linkare, adică funcția a fost declarată, dar nu există nicio definiție în fișierele legate. Fiecare fișier .c se compilează independent, motiv pentru care ai nevoie de headere cu declarații.

Ce urmărește intervievatorul: Arată dacă poți interpreta corect mesajele de eroare. Mulți candidați confundă erorile de compilare cu cele de linkare.

3 Junior

Care e diferența dintre declarare și definire și ce rol au include guards?

Răspuns scurt: Declararea anunță compilatorului că un nume există și ce tip are; definirea îl creează efectiv (alocă memorie sau dă corpul funcției). Include guards împiedică includerea de două ori a aceluiași header în aceeași unitate de traducere.

O declarare spune „există o funcție int sum(int, int)” sau „există o variabilă globală extern int count; definită în altă parte”. O definire furnizează implementarea sau alocă memoria: int sum(int a, int b) { return a + b; }, int count = 0;. Poți declara de oricâte ori, dar poți defini o singură dată în tot programul (altfel linkerul raportează „multiple definition”).

De aceea headerele conțin declarații, iar fișierele .c/.cpp conțin definiții:

C
/* util.h */
#ifndef UTIL_H
#define UTIL_H
int sum(int a, int b);
extern int count;
#endif

Include guard-ul (#ifndef ... #define ... #endif) rezolvă o problemă de preprocesare: dacă a.h și b.h includ ambele util.h, iar main.c le include pe amândouă, fără guard tipurile din util.h ar fi definite de două ori în aceeași unitate de traducere și compilarea ar eșua. Alternativa #pragma once e mai scurtă și suportată de toate compilatoarele mari, dar nu face parte din standard.

Atenție: include guards nu protejează împotriva definirii unei variabile globale în header. Dacă scrii int count = 0; într-un header inclus în două fișiere .c, fiecare fișier va avea propria definiție și linkerul va da eroare. În header pui extern, iar definiția într-un singur .c.

Ce urmărește intervievatorul: Verifică dacă înțelegi modelul de compilare separată. Greșeala tipică: a crede că include guards rezolvă și definițiile multiple la linkare.

4 Junior

Ce înseamnă cuvântul cheie static în C, în funcție de context?

Răspuns scurt: Pe o variabilă locală, static o face să-și păstreze valoarea între apeluri (durată de viață statică). Pe o variabilă globală sau pe o funcție, static restrânge vizibilitatea la fișierul curent (linkare internă).

static are două efecte diferite, în funcție de unde apare.

În interiorul unei funcții schimbă durata de stocare: variabila nu mai e pe stivă, ci în zona de date a programului, e inițializată o singură dată și își păstrează valoarea între apeluri.

C
int next_id(void) {
    static int id = 0;  /* inițializată o singură dată */
    return ++id;        /* 1, 2, 3, ... la apeluri succesive */
}

La nivel de fișier (pe variabile globale și funcții) schimbă linkarea: numele devine vizibil doar în unitatea de traducere curentă. Două fișiere pot avea fiecare o funcție static void log_error(void) fără conflict la linkare. E echivalentul unui „private” la nivel de modul și e o practică bună pentru funcțiile ajutătoare care nu trebuie expuse.

C
static int counter;            /* vizibil doar în acest .c */
static void helper(void) { }   /* la fel */

În C++ apare un al treilea sens: un membru static al unei clase aparține clasei, nu fiecărui obiect, iar o metodă statică nu are pointer this.

Detaliu util: variabilele statice neinițializate explicit sunt inițializate cu zero, spre deosebire de variabilele locale automate, care au valoare nedeterminată. În cod multithreaded, o variabilă locală static modificată de mai multe thread-uri are nevoie de sincronizare.

Ce urmărește intervievatorul: Testează dacă separi durata de viață de vizibilitate. Mulți candidați cunosc doar sensul „își păstrează valoarea”.

5 Junior

Care e diferența dintre const int *p, int *const p și const int *const p?

Răspuns scurt: const int *p e un pointer către o valoare constantă (nu poți modifica *p, dar poți muta p). int *const p e un pointer constant (nu-l poți muta, dar poți modifica *p). const int *const p le interzice pe amândouă.

Regula practică: citește declarația de la dreapta la stânga, iar const se aplică lucrului din stânga lui (sau din dreapta, dacă e primul).

C
int a = 1, b = 2;

const int *p1 = &a;   /* „p1 e pointer la int constant” */
/* *p1 = 5;  eroare: nu poți modifica prin p1 */
p1 = &b;              /* OK: pointerul se poate muta */

int *const p2 = &a;   /* „p2 e pointer constant la int” */
*p2 = 5;              /* OK */
/* p2 = &b;  eroare: pointerul e fix */

const int *const p3 = &a; /* nimic nu se poate schimba prin p3 */

int const *p înseamnă exact același lucru ca const int *p.

De ce contează: const în parametri e un contract. size_t strlen(const char *s) promite că funcția nu modifică șirul și îți permite să-i trimiți și literali de tip șir. În C++, metodele const (int size() const;) promit că nu modifică obiectul și pot fi apelate pe obiecte constante.

Atenție: const int *p nu înseamnă că valoarea nu se poate schimba deloc, ci doar că nu o schimbi prin p. Dacă a nu e const, altcineva o poate modifica direct. Iar a modifica un obiect definit inițial const (prin cast care elimină const) este undefined behavior.

Ce urmărește intervievatorul: Este o întrebare clasică de filtrare. Greșeala tipică: inversarea sensurilor sau ideea că const garantează că valoarea nu se schimbă niciodată.

6 Junior

Care e diferența dintre struct și union în C?

Răspuns scurt: Într-un struct fiecare membru are propria zonă de memorie, iar dimensiunea e cel puțin suma membrilor. Într-un union toți membrii împart aceeași zonă, dimensiunea e cea a celui mai mare membru și doar un membru are valoare validă la un moment dat.

Un struct grupează câmpuri care există simultan:

C
struct Point { int x; int y; };   /* x și y au adrese diferite */

Un union suprapune membrii la aceeași adresă:

C
#include <stdio.h>
union Value { int i; float f; char bytes[4]; };

int main(void) {
    union Value v;
    v.i = 65;
    printf("%zu\n", sizeof v);   /* 4, dimensiunea celui mai mare membru */
    return 0;
}

Uniunile se folosesc pentru a economisi memorie când știi că doar unul dintre câmpuri e relevant, de obicei împreună cu un câmp care spune ce tip e activ (tagged union):

C
struct Token {
    enum { NUM, OP } kind;
    union { double num; char op; } as;
};

Mai apar în embedded, pentru a vedea același registru fie ca un întreg, fie ca octeți separați. În C, citirea altui membru decât cel scris ultima dată (type punning prin union) e permisă, cu rezultat dependent de reprezentare (endianness). În C++, același lucru este undefined behavior; acolo folosești std::memcpy sau std::bit_cast (C++20), iar pentru tagged union ai std::variant (C++17), care ține evidența tipului activ și apelează corect constructorii și destructorii.

Ce urmărește intervievatorul: Verifică înțelegerea modelului de memorie. Un detaliu care face diferența: type punning prin union e valid în C, dar nu în C++.

7 Junior

Cum sunt reprezentate șirurile de caractere în C și care e diferența dintre strlen și sizeof?

Răspuns scurt: Un șir în C este un tablou de char terminat cu caracterul nul '\0'. strlen numără caracterele până la terminator, la runtime; sizeof dă dimensiunea în octeți a tipului sau a tabloului, la compilare, inclusiv terminatorul.

C nu are un tip „string”. Un șir este o secvență de char care se termină cu '\0', iar funcțiile din <string.h> merg octet cu octet până îl găsesc.

C
#include <stdio.h>
#include <string.h>

int main(void) {
    char s[] = "abc";        /* 4 octeți: 'a','b','c','\0' */
    const char *p = "abc";
    printf("%zu %zu\n", strlen(s), sizeof s);  /* 3 4 */
    printf("%zu\n", sizeof p);                 /* 8 pe 64 de biți: dimensiunea pointerului */
    return 0;
}

Consecințe importante:

  • Când aloci un șir, rezervă un octet în plus pentru terminator: malloc(strlen(src) + 1).
  • strlen are cost O(n), deci nu-l pune în condiția unei bucle care rulează de n ori.
  • Dacă terminatorul lipsește, strlen și printf("%s") citesc dincolo de buffer: undefined behavior.
  • strcpy și strcat nu verifică dimensiunea destinației și sunt o sursă clasică de buffer overflow. Preferă snprintf sau funcții care primesc dimensiunea. strncpy nu adaugă terminatorul dacă sursa e prea lungă, o capcană frecventă.
  • Un literal de tip șir ("abc") stă de obicei în memorie read-only; a-l modifica prin char *p = "abc"; p[0] = 'x'; este undefined behavior.

În C++ folosești std::string, care ține lungimea și gestionează memoria singur.

Ce urmărește intervievatorul: Verifică atenția la terminatorul nul și la siguranța bufferelor. Greșeala tipică: sizeof pe un pointer crezând că dă lungimea șirului.

8 Junior

Ce afișează codul următor și de ce: o funcție care primește un tablou și face sizeof pe el?

Răspuns scurt: În funcție, parametrul declarat ca tablou este de fapt un pointer (array decay), deci sizeof dă dimensiunea pointerului, nu a tabloului. Dimensiunea trebuie transmisă separat ca parametru.

C
#include <stdio.h>

void f(int arr[10]) {
    printf("%zu\n", sizeof arr);  /* 8 pe un sistem de 64 de biți */
}

int main(void) {
    int a[10];
    printf("%zu\n", sizeof a);    /* 40, dacă int are 4 octeți */
    f(a);
    return 0;
}

Programul afișează 40 și apoi 8 (pe o platformă tipică de 64 de biți). Motivul este array decay: în majoritatea expresiilor, un tablou se convertește automat într-un pointer către primul element. Mai mult, un parametru declarat int arr[10] sau int arr[] este rescris de compilator ca int *arr; numărul 10 e ignorat. GCC chiar avertizează cu -Wall (-Wsizeof-array-argument).

Excepțiile de la decay sunt operatorii sizeof, & (adresa întregului tablou, de tip int (*)[10]) și inițializarea unui tablou de char cu un literal.

Soluțiile corecte:

  • În C, transmite dimensiunea: void f(int *arr, size_t n), iar la apel f(a, sizeof a / sizeof a[0]).
  • În C++, folosește std::array<int, 10>, std::vector<int> sau std::span<int> (C++20), care păstrează dimensiunea, ori o referință la tablou: template <size_t N> void f(int (&arr)[N]).

Macro-ul clasic #define COUNT(a) (sizeof(a)/sizeof((a)[0])) dă rezultate greșite dacă primește un pointer, deci nu-l folosi în funcția care a primit deja tabloul ca parametru.

Ce urmărește intervievatorul: Testează înțelegerea relației tablou-pointer. E una dintre cele mai frecvente surse de bug-uri la cei care vin din alte limbaje.

9 Junior

De ce ar fi mai bună o funcție inline decât un macro? Ce problemă are #define MAX(a, b) ((a) > (b) ? (a) : (b))?

Răspuns scurt: Macro-urile sunt înlocuiri textuale, fără verificare de tip, și își pot evalua argumentele de mai multe ori. MAX(i++, j) incrementează i de două ori dacă i e mai mare. O funcție inline (sau un template în C++) evaluează argumentele o dată și verifică tipurile.

Preprocesorul nu știe nimic despre tipuri sau expresii: copiază textul. Asta produce trei categorii de probleme.

1. Evaluare multiplă:

C
#define MAX(a, b) ((a) > (b) ? (a) : (b))
int i = 5, j = 3;
int m = MAX(i++, j);  /* devine ((i++) > (j) ? (i++) : (j)) */
/* m este 6, iar i ajunge 7 */

2. Precedența operatorilor, dacă lipsesc parantezele: cu #define SQ(x) x * x, SQ(1 + 2) devine 1 + 2 * 1 + 2, adică 5, nu 9. De aceea fiecare parametru și întreaga expresie se pun în paranteze.

3. Lipsa verificării de tip și a scope-ului: macro-urile nu respectă namespace-uri, apar greu în debugger și dau mesaje de eroare confuze.

O funcție static inline int max_int(int a, int b) { return a > b ? a : b; } evaluează fiecare argument o singură dată, are tipuri și, la optimizare, e la fel de rapidă, pentru că compilatorul o poate integra la locul apelului. Cuvântul inline e doar o sugestie pentru optimizare; în C++ rolul lui principal este să permită definirea funcției în header fără erori de definiție multiplă.

Macro-urile rămân utile pentru compilare condiționată (#ifdef DEBUG), include guards, __FILE__/__LINE__ în funcții de logging și generare de cod repetitiv. În C++ ai alternative mai sigure: constexpr, templates, std::max.

Ce urmărește intervievatorul: Verifică dacă știi că preprocesorul lucrează textual. Greșeala tipică: a uita de evaluarea multiplă a argumentelor.

10 Mid

Ce este padding-ul într-o structură și cum poți reduce dimensiunea unei structuri?

Răspuns scurt: Compilatorul inserează octeți de umplutură între câmpuri ca fiecare să fie aliniat la o adresă potrivită tipului său, ceea ce face accesul mai rapid sau chiar posibil pe unele procesoare. Ordonând câmpurile de la cel mai mare la cel mai mic reduci padding-ul.

Majoritatea arhitecturilor citesc eficient un int de 4 octeți doar dacă e la o adresă multiplu de 4. Unele (multe nuclee ARM mai vechi) generează chiar excepție la acces nealiniat. De aceea compilatorul aliniază câmpurile.

C
#include <stdio.h>

struct A { char c; int i; char d; };   /* 1 + 3 padding + 4 + 1 + 3 padding = 12 */
struct B { int i; char c; char d; };   /* 4 + 1 + 1 + 2 padding = 8 */

int main(void) {
    printf("%zu %zu\n", sizeof(struct A), sizeof(struct B));  /* 12 8, tipic pe x86-64 */
    return 0;
}

Padding-ul de la final există pentru ca într-un tablou de structuri fiecare element să fie la rândul lui aliniat. Alinierea exactă depinde de platformă și de ABI, deci valorile de mai sus sunt tipice, nu garantate de standard.

Cum reduci dimensiunea:

  • Ordonează câmpurile descrescător după aliniere (pointeri și double, apoi int, short, char).
  • Folosește tipuri cu dimensiune exactă (uint8_t, uint16_t din <stdint.h>).
  • #pragma pack(1) sau __attribute__((packed)) elimină padding-ul, dar accesul la câmpuri nealiniate poate fi mai lent sau periculos, iar pointerii la acele câmpuri pot fi invalizi. Se folosește pentru formate de protocol sau de fișier, nu pentru structuri de lucru.

Nu compara structuri cu memcmp: octeții de padding au valori nedeterminate. În C11 și C++11 poți verifica alinierea cu _Alignof/alignof și o poți impune cu alignas.

Ce urmărește intervievatorul: Verifică înțelegerea layout-ului în memorie, important în embedded și la protocoale binare. Greșeala tipică: a presupune că sizeof e suma câmpurilor.

11 Mid

Scrie funcții care setează, șterg, comută și testează un bit, plus o funcție care numără biții de 1 dintr-un întreg.

Răspuns scurt: Folosești măști: x | (1u << n) setează bitul n, x & ~(1u << n) îl șterge, x ^ (1u << n) îl comută, (x >> n) & 1u îl testează. Pentru numărare, x &= x - 1 elimină câte un bit setat.

Operațiile pe biți sunt pâine zilnică în embedded (registre, flag-uri) și apar des la interviuri.

C
#include <stdint.h>
#include <stdio.h>

static inline uint32_t set_bit(uint32_t x, unsigned n)    { return x | (1u << n); }
static inline uint32_t clear_bit(uint32_t x, unsigned n)  { return x & ~(1u << n); }
static inline uint32_t toggle_bit(uint32_t x, unsigned n) { return x ^ (1u << n); }
static inline int      test_bit(uint32_t x, unsigned n)   { return (x >> n) & 1u; }

int popcount(uint32_t x) {
    int count = 0;
    while (x) {
        x &= x - 1;   /* elimină bitul de 1 cel mai puțin semnificativ */
        count++;
    }
    return count;
}

int main(void) {
    uint32_t r = 0;
    r = set_bit(r, 3);              /* 0b1000 */
    printf("%d %d\n", test_bit(r, 3), popcount(0xF0u));  /* 1 4 */
    return 0;
}

Detalii pe care intervievatorul le urmărește:

  • Folosește tipuri unsigned. Deplasarea unui 1 cu semn în bitul de semn (1 << 31 pe int de 32 de biți) e undefined behavior în C și în C++ înainte de C++20.
  • n trebuie să fie mai mic decât numărul de biți ai tipului; 1u << 32 pe un uint32_t este tot undefined behavior.
  • Trucul x & (x - 1) rulează de atâtea ori câți biți de 1 are numărul, nu de 32 de ori.
  • În producție există variante optimizate: __builtin_popcount în GCC/Clang sau std::popcount (C++20, <bit>), care folosesc instrucțiunea hardware dacă există.

Ce urmărește intervievatorul: Verifică fluența cu măștile de biți și atenția la tipurile cu semn. Greșeala tipică: deplasări pe int cu semn sau peste lățimea tipului.

12 Senior

Ce este un ABI și de ce ai nevoie de extern "C" când combini cod C și C++?

Răspuns scurt: ABI (Application Binary Interface) definește cum arată codul la nivel binar: convenția de apel, layout-ul structurilor, numele simbolurilor. C++ modifică numele funcțiilor (name mangling) pentru supraîncărcare, iar extern "C" cere nume în stil C, ca un cod C să le poată găsi la linkare.

API-ul e contractul la nivel de cod sursă; ABI-ul e contractul la nivel binar. Include convenția de apel (în ce registre sau pe stivă se transmit argumentele), dimensiunea și alinierea tipurilor, layout-ul claselor și al vtable-ului, modul de propagare a excepțiilor și forma numelor de simboluri.

Pentru că C++ permite supraîncărcarea, compilatorul codifică tipurile parametrilor în numele simbolului. În ABI-ul Itanium (GCC, Clang), int add(int, int) devine _Z3addii. O bibliotecă C exportă simplu add, deci linkerul nu le potrivește. Soluția:

C++
// mathlib.h, utilizabil din C și din C++
#ifdef __cplusplus
extern "C" {
#endif
int add(int a, int b);
#ifdef __cplusplus
}
#endif

Funcțiile extern "C" nu pot fi supraîncărcate și nu ar trebui să lase excepțiile C++ să treacă prin codul C.

De ce contează ABI-ul la nivel senior:

  • O bibliotecă partajată (.so, .dll) trebuie să rămână compatibilă binar între versiuni. Adăugarea unui câmp într-o clasă publică sau a unei funcții virtuale schimbă layout-ul și strică programele compilate cu versiunea veche, chiar dacă API-ul pare identic.
  • Tehnici precum pImpl (pointer la implementare) sau interfețe C stabile izolează clienții de schimbări interne.
  • Biblioteci compilate cu compilatoare sau setări diferite (de exemplu, ABI-ul std::string din GCC 5, _GLIBCXX_USE_CXX11_ABI) pot fi incompatibile.

Ce urmărește intervievatorul: Verifică experiența cu biblioteci și integrarea C/C++. Greșeala tipică: confuzia între compatibilitatea la nivel de sursă și cea binară.

Pointeri și memorie

13 Junior

Ce este un pointer și ce fac operatorii * și &?

Răspuns scurt: Un pointer este o variabilă care conține adresa altei variabile. Operatorul & dă adresa unui obiect, iar * (dereferențierea) accesează obiectul de la adresa respectivă. Un pointer nul (NULL sau nullptr) nu indică niciun obiect valid.

Memoria e o succesiune de octeți cu adrese. Un pointer reține o astfel de adresă, iar tipul lui spune compilatorului ce fel de obiect se află acolo și câți octeți să citească.

C
#include <stdio.h>

void increment(int *p) {
    (*p)++;              /* modifică variabila apelantului */
}

int main(void) {
    int x = 10;
    int *p = &x;         /* p reține adresa lui x */
    *p = 20;             /* scrie în x prin pointer */
    increment(&x);
    printf("%d\n", x);   /* 21 */
    return 0;
}

Observă că * are două roluri: în declarație (int *p) arată că p e pointer, iar într-o expresie (*p) înseamnă dereferențiere.

De ce există pointerii:

  • C transmite argumentele prin valoare. Ca o funcție să modifice o variabilă a apelantului, primește adresa ei.
  • Permit lucrul cu memorie alocată dinamic și cu structuri de date înlănțuite (liste, arbori).
  • Evită copierea structurilor mari: transmiți 8 octeți (adresa), nu întreaga structură.
  • În embedded, accesezi registre hardware la adrese fixe.

Reguli de siguranță: inițializează mereu un pointer (cu o adresă validă sau cu NULL), verifică dacă e nul înainte de dereferențiere când acest lucru e posibil și nu-l folosi după ce obiectul spre care arată a dispărut. Dereferențierea unui pointer nul sau neinițializat este undefined behavior și, de obicei, produce un segmentation fault.

Ce urmărește intervievatorul: E o întrebare de bază, dar se urmărește claritatea explicației. Greșeala tipică: confuzia între pointer și valoarea indicată.

14 Junior

Care e diferența dintre stivă (stack) și heap?

Răspuns scurt: Stiva ține variabilele locale și cadrele de apel; alocarea e automată, foarte rapidă și se eliberează la ieșirea din funcție, dar e mică. Heap-ul ține memoria alocată dinamic (malloc, new), e mare și flexibilă, dar o eliberezi tu, iar alocarea e mai lentă.

Stiva este o zonă continuă de memorie, una per thread. La apelul unei funcții se rezervă un cadru (stack frame) cu parametrii, adresa de întoarcere și variabilele locale; la ieșire, cadrul dispare. Alocarea înseamnă practic mutarea unui registru (stack pointer), deci e aproape gratuită. Dimensiunea e limitată: pe Linux, implicit de ordinul câtorva megaocteți pentru thread-ul principal (vezi ulimit -s), pe microcontrolere uneori doar câțiva kiloocteți. Recursivitatea prea adâncă sau un tablou local imens produc stack overflow.

Heap-ul (free store în C++) e gestionat de alocator. Ceri memorie cu malloc/new și o eliberezi cu free/delete. Obiectele trăiesc cât vrei tu, pot avea dimensiunea decisă la runtime și pot fi mari. Costurile: alocarea implică căutarea unui bloc liber și, uneori, apeluri de sistem; apar fragmentare, leak-uri și acces mai puțin prietenos cu cache-ul.

C++
void f(int n) {
    int local[16];                 // pe stivă, eliberat automat
    int *dyn = new int[n];         // pe heap, dimensiune de runtime
    std::vector<int> v(n);         // obiectul e pe stivă, elementele pe heap
    delete[] dyn;                  // altfel: memory leak
}

Exemplul cu std::vector e important: obiectul în sine (pointer, dimensiune, capacitate) e pe stivă, iar destructorul lui eliberează automat datele de pe heap. Regula practică în C++: preferă obiecte automate și containere, iar alocarea manuală doar când e nevoie.

Ce urmărește intervievatorul: Verifică înțelegerea duratei de viață și a costurilor. Greșeala tipică: a spune că heap-ul e „mai lent la acces”, când diferența ține de alocare și de localitate.

15 Junior

Care e diferența dintre malloc, calloc, realloc și free?

Răspuns scurt: malloc alocă un bloc neinițializat, calloc alocă pentru n elemente și umple memoria cu zero, realloc redimensionează un bloc existent (poate să-l mute), iar free eliberează un bloc. Toate pot eșua și returnează NULL, cu excepția lui free.

Toate sunt în <stdlib.h>:

  • malloc(size) întoarce un bloc de size octeți cu conținut nedeterminat.
  • calloc(count, size) alocă count * size octeți inițializați cu zero și verifică depășirea la înmulțire.
  • realloc(ptr, new_size) schimbă dimensiunea. Poate extinde blocul pe loc sau poate aloca unul nou, copia datele și elibera blocul vechi. Cu ptr == NULL se comportă ca malloc.
  • free(ptr) eliberează blocul; free(NULL) nu face nimic.

Capcana clasică e la realloc:

C
#include <stdlib.h>

int grow(int **arr, size_t new_count) {
    int *tmp = realloc(*arr, new_count * sizeof **arr);
    if (tmp == NULL) {
        return -1;      /* *arr e încă valid, nu s-a pierdut */
    }
    *arr = tmp;
    return 0;
}

Dacă scrii direct arr = realloc(arr, n) și realocarea eșuează, pierzi singurul pointer către blocul vechi: memory leak. De asemenea, după un realloc reușit, orice alt pointer către blocul vechi poate fi invalid.

Alte reguli: verifică mereu rezultatul pentru NULL; eliberează exact pointerul primit de la alocator, nu unul deplasat; nu elibera de două ori; după free, setează pointerul la NULL ca să eviți folosirea accidentală. În C nu faci cast la rezultatul lui malloc, pentru că void* se convertește implicit și cast-ul poate ascunde lipsa lui #include <stdlib.h> în codul vechi.

Ce urmărește intervievatorul: Verifică experiența practică cu memoria dinamică. Greșeala tipică: ptr = realloc(ptr, n) fără variabilă temporară.

16 Junior

Care e diferența dintre malloc/free și new/delete în C++?

Răspuns scurt: new alocă memorie și apelează constructorul, delete apelează destructorul și eliberează memoria; malloc și free doar alocă și eliberează octeți. new aruncă std::bad_alloc la eșec, nu întoarce NULL, iar new[] trebuie pereche cu delete[].

Diferențele importante:

  • Constructori și destructori: new T(args) alocă și construiește obiectul; delete p apelează ~T() și apoi eliberează. malloc îți dă doar octeți brut, fără obiect construit, deci pentru un tip cu std::string în el ar fi greșit să-l folosești direct.
  • Tip: new întoarce T*; malloc întoarce void*, care în C++ cere cast.
  • Eșec: new aruncă std::bad_alloc. Varianta new (std::nothrow) T întoarce nullptr.
  • Tablouri: new T[n] trebuie eliberat cu delete[]. Amestecarea (delete pe ce a venit din new[], free pe ce a venit din new sau invers) este undefined behavior.
  • Personalizare: operator new poate fi supraîncărcat per clasă, iar placement new (new (buffer) T) construiește un obiect într-o memorie deja alocată, util în embedded și în alocatoare custom.
C++
#include <string>

struct User {
    std::string name;
    explicit User(std::string n) : name(std::move(n)) {}
};

int main() {
    User *u = new User("Ana");   // alocare + constructor
    delete u;                    // destructor + eliberare

    int *arr = new int[10]{};    // inițializat cu zero
    delete[] arr;
}

În cod C++ modern rareori scrii new/delete direct. Folosești std::make_unique, std::make_shared sau containere, care eliberează automat memoria și sunt sigure la excepții. malloc mai apare doar la interfațarea cu biblioteci C care se așteaptă să elibereze ele memoria cu free.

Ce urmărește intervievatorul: Verifică dacă știi legătura dintre alocare și durata de viață a obiectelor. Greșeala tipică: amestecarea new[] cu delete.

17 Junior

Cum funcționează aritmetica pointerilor și de ce a[i] este echivalent cu *(a + i)?

Răspuns scurt: Adunarea unui întreg la un pointer îl mută cu atâtea elemente, nu octeți: p + 1 avansează cu sizeof(*p) octeți. Standardul definește a[i] exact ca *(a + i), iar tabloul se convertește în pointer la primul element.

Când scrii p + n, compilatorul calculează adresa(p) + n * sizeof(*p). Diferența dintre doi pointeri din același tablou dă numărul de elemente dintre ei, de tip ptrdiff_t.

C
#include <stdio.h>

int main(void) {
    int a[] = {10, 20, 30, 40};
    int *p = a;                    /* array decay: &a[0] */
    printf("%d\n", *(p + 2));      /* 30 */
    printf("%d\n", p[3]);          /* 40 */
    printf("%td\n", &a[3] - p);    /* 3 */
    printf("%d\n", 2[a]);          /* 30: tot *(2 + a) */
    return 0;
}

Ultimul rând e un truc de interviu: pentru că a[i] e definit ca *(a + i), iar adunarea e comutativă, 2[a] e valid. Nu-l scrie în cod real.

Reguli care țin de corectitudine:

  • Aritmetica e validă doar în interiorul aceluiași tablou și până la poziția „unul după ultimul element”. Poți calcula a + 4, dar nu-l poți dereferenția. a + 5 sau a - 1 sunt undefined behavior chiar fără dereferențiere.
  • Scăderea a doi pointeri din tablouri diferite este undefined behavior.
  • Pe void* aritmetica nu e permisă în standard (GCC o acceptă ca extensie, cu pas de 1 octet). Pentru octeți, folosește char* sau unsigned char*.

Aceeași logică stă la baza iteratorilor din STL: un iterator de std::vector se comportă ca un pointer, cu ++, + n și diferență între iteratori.

Ce urmărește intervievatorul: Verifică înțelegerea modelului tablou-pointer. Candidații buni știu și limitele în care aritmetica e definită.

18 Junior

Ce sunt un dangling pointer, un memory leak și un double free?

Răspuns scurt: Un dangling pointer indică memorie care nu mai e validă. Un memory leak e memorie alocată pe care nu o mai poți elibera, pentru că ai pierdut pointerul. Double free e eliberarea de două ori a aceluiași bloc, undefined behavior.

Sunt cele trei erori clasice de gestionare manuală a memoriei.

C
#include <stdlib.h>

int *dangling(void) {
    int x = 5;
    return &x;              /* x dispare la ieșirea din funcție */
}

void probleme(void) {
    int *p = malloc(sizeof *p);
    free(p);
    /* *p = 3;   use-after-free: p e acum dangling */
    /* free(p);  double free */

    int *q = malloc(100);
    q = NULL;               /* memory leak: blocul nu mai poate fi eliberat */
}
  • Dangling pointer / use-after-free: memoria poate fi refolosită de alt obiect, deci o scriere strică date fără legătură, iar bug-ul apare departe de cauză. E o vulnerabilitate de securitate frecventă.
  • Memory leak: programul nu crapă, dar consumul de memorie crește. Contează mult la servicii care rulează luni sau la dispozitive cu memorie mică.
  • Double free: corupe structurile interne ale alocatorului; glibc detectează uneori și oprește programul cu „double free detected”.

Cum le previi:

  • În C: un singur „proprietar” clar pentru fiecare bloc, eliberare într-un singur loc, p = NULL după free.
  • În C++: RAII. std::unique_ptr și containerele eliberează automat și o singură dată.
  • Detectare: compilează cu -fsanitize=address (AddressSanitizer) sau rulează sub Valgrind, care raportează exact linia de alocare și cea de folosire invalidă.

Ce urmărește intervievatorul: Verifică dacă știi să recunoști erorile de memorie și cum le previi. Greșeala tipică: a crede că un program care nu crapă nu are astfel de bug-uri.

19 Junior

Care e diferența dintre o referință și un pointer în C++?

Răspuns scurt: O referință este un alias pentru un obiect existent: trebuie inițializată, nu poate fi nulă (în cod corect) și nu poate fi reasociată. Un pointer este un obiect separat care reține o adresă, poate fi nul, poate fi mutat și suportă aritmetică.

C++
#include <iostream>

void by_ref(int &r) { r += 1; }   // nu e nevoie de verificare de nul
void by_ptr(int *p) { if (p) *p += 1; }

int main() {
    int a = 1, b = 2;
    int &r = a;     // r este a
    r = b;          // NU reasociază: îi atribuie lui a valoarea 2
    int *p = &a;
    p = &b;         // pointerul se mută pe b
    by_ref(a);
    by_ptr(&b);
    std::cout << a << ' ' << b << '\n';  // 3 3
}

Diferențe pe care merită să le enumeri:

  • Referința trebuie inițializată la declarare și rămâne legată de același obiect. r = b copiază valoarea, nu schimbă legătura.
  • Nu există „referință nulă” în cod valid; poți obține una doar printr-o dereferențiere de pointer nul, care e deja undefined behavior.
  • Pointerii au aritmetică, pot exista pointeri la pointeri, iar referințele la referințe nu există ca tip.
  • Sintaxa: referința se folosește ca obiectul însuși, fără * și ->.

Când alegi ce: referința const T& pentru parametri de intrare mari (evită copia), T& pentru parametri de ieșire obligatorii, pointer (sau std::optional) când „lipsa valorii” e un caz legitim sau când trebuie să schimbi ținta. Atenție la referințele care trăiesc mai mult decât obiectul: a întoarce const std::string& către o variabilă locală produce o referință dangling, la fel de periculoasă ca un pointer dangling.

Ce urmărește intervievatorul: Verifică dacă înțelegi semantica, nu doar sintaxa. Greșeala tipică: a crede că r = b face referința să indice spre b.

20 Mid

Ce sunt pointerii la pointeri și pointerii la funcții? Dă un exemplu practic pentru fiecare.

Răspuns scurt: Un pointer la pointer (int **) reține adresa unui pointer și permite unei funcții să modifice pointerul apelantului. Un pointer la funcție reține adresa unei funcții și permite apelarea ei indirect, de exemplu ca callback, cum face qsort cu funcția de comparare.

Pointer la pointer. Exemplul clasic: o funcție care alocă memorie și trebuie să modifice pointerul apelantului.

C
#include <stdlib.h>

int make_buffer(char **out, size_t n) {
    *out = malloc(n);
    return *out ? 0 : -1;
}
/* apel: char *buf; make_buffer(&buf, 64); ... free(buf); */

Dacă funcția ar primi char *out, ar modifica doar copia locală. Tot char ** apare la argv și la tablouri de șiruri.

Pointer la funcție. Sintaxa int (*cmp)(const void *, const void *) declară cmp ca pointer către o funcție care primește doi const void* și întoarce int. Cu el scrii cod generic în C:

C
#include <stdio.h>
#include <stdlib.h>

static int cmp_int(const void *a, const void *b) {
    int x = *(const int *)a, y = *(const int *)b;
    return (x > y) - (x < y);   /* evită overflow-ul lui x - y */
}

int main(void) {
    int v[] = {5, 2, 9, 1};
    qsort(v, 4, sizeof v[0], cmp_int);
    for (int i = 0; i < 4; i++) printf("%d ", v[i]);   /* 1 2 5 9 */
    return 0;
}

Alte utilizări: tabele de dispatch (un tablou de pointeri la funcții indexat după tipul comenzii), callback-uri pentru evenimente și tabele de vectori de întrerupere în embedded. Un typedef face codul lizibil: typedef void (*handler_t)(int);.

În C++ poți folosi tot pointeri la funcții, dar și std::function, lambda-uri sau functori, care pot reține și stare.

Ce urmărește intervievatorul: Verifică dacă stăpânești indirecția pe mai multe niveluri. Detaliul cu comparatorul care face x - y și poate da overflow e un bonus apreciat.

21 Mid

Scrie o funcție care inversează o listă simplu înlănțuită.

Răspuns scurt: Parcurgi lista o dată cu trei pointeri: prev, curr și next. La fiecare nod reții următorul, întorci legătura curentă spre prev, apoi avansezi. La final prev e noul cap. Complexitatea e O(n) timp și O(1) memorie suplimentară.

Soluția iterativă e cea așteptată la interviu:

C
#include <stdio.h>
#include <stdlib.h>

struct Node { int value; struct Node *next; };

struct Node *reverse(struct Node *head) {
    struct Node *prev = NULL;
    struct Node *curr = head;
    while (curr != NULL) {
        struct Node *next = curr->next;  /* salvează restul listei */
        curr->next = prev;               /* întoarce legătura */
        prev = curr;
        curr = next;
    }
    return prev;                         /* noul cap */
}

static struct Node *push(struct Node *head, int v) {
    struct Node *n = malloc(sizeof *n);
    if (!n) exit(1);
    n->value = v;
    n->next = head;
    return n;
}

int main(void) {
    struct Node *h = NULL;
    for (int i = 1; i <= 4; i++) h = push(h, i);   /* 4 3 2 1 */
    h = reverse(h);                                /* 1 2 3 4 */
    for (struct Node *p = h; p; p = p->next) printf("%d ", p->value);
    while (h) { struct Node *n = h->next; free(h); h = n; }
    return 0;
}

Ce urmărește intervievatorul:

  • Cazurile limită: listă goală (head == NULL) și listă cu un singur nod funcționează fără cod special.
  • Salvarea lui next înainte de a modifica curr->next; fără ea pierzi restul listei.
  • Complexitatea: O(n) timp, O(1) spațiu.

Există și o variantă recursivă, mai scurtă, dar folosește O(n) spațiu pe stivă și poate produce stack overflow la liste lungi, un argument important în embedded. Dacă ai timp, menționează testarea: o listă de 0, 1, 2 și n elemente și verificarea cu AddressSanitizer că nu ai leak-uri.

Ce urmărește intervievatorul: Verifică manipularea pointerilor sub presiune și atenția la cazurile limită. Greșeala tipică: pierderea restului listei prin ordinea greșită a atribuirilor.

22 Mid

Ce probleme are codul următor: o funcție care întoarce un pointer la un buffer local și o funcție care face p = realloc(p, n)?

Răspuns scurt: Primul caz întoarce adresa unei variabile de pe stivă, care dispare la ieșirea din funcție: dangling pointer. Al doilea pierde blocul original dacă realloc eșuează și întoarce NULL: memory leak, plus pointerul devine nul.

C
#include <stdio.h>
#include <stdlib.h>

char *format_id(int id) {
    char buf[32];
    snprintf(buf, sizeof buf, "ID-%d", id);
    return buf;              /* GREȘIT: buf e pe stivă */
}

void append(int *data, size_t n) {
    data = realloc(data, (n + 1) * sizeof *data);  /* GREȘIT, de două ori */
    data[n] = 42;
}

Problema 1. buf are durată automată. După return, cadrul de stivă e refolosit de următorul apel, iar apelantul primește un pointer dangling. Programul poate părea că funcționează în teste și să afișeze gunoi mai târziu. GCC avertizează („function returns address of local variable”). Soluții: apelantul transmite bufferul (void format_id(int id, char *out, size_t size)), aloci dinamic și documentezi că apelantul face free, sau, în C++, întorci std::string. Un buffer static local „rezolvă” problema, dar funcția nu mai e reentrantă și nici sigură la thread-uri.

Problema 2. Sunt două bug-uri:

  • Dacă realloc eșuează, data devine NULL, blocul vechi rămâne alocat fără referință (leak), iar data[n] = 42 dereferențiază NULL.
  • data e transmis prin valoare. Chiar dacă realocarea reușește și mută blocul, apelantul păstrează adresa veche, deja eliberată: use-after-free la următorul acces.

Versiunea corectă primește int **data, folosește o variabilă temporară și întoarce un cod de eroare. Acest tip de exercițiu („găsește bug-urile”) testează exact gândirea pe care o vei folosi la code review.

Ce urmărește intervievatorul: Verifică dacă poți citi critic codul și explica durata de viață a memoriei. Mulți candidați găsesc doar unul dintre cele două bug-uri din a doua funcție.

23 Mid

Cum detectezi memory leaks și erorile de acces la memorie într-un program C/C++?

Răspuns scurt: Folosești unelte de analiză dinamică: AddressSanitizer și LeakSanitizer (flag-ul -fsanitize=address la GCC/Clang) sau Valgrind Memcheck. Le completezi cu avertismentele compilatorului, analiză statică (clang-tidy, cppcheck) și, în C++, cu RAII ca să eviți problema din start.

AddressSanitizer (ASan) instrumentează codul la compilare:

BASH
g++ -g -O1 -fsanitize=address -fno-omit-frame-pointer main.cpp -o app
./app

La un acces invalid (heap overflow, use-after-free, stack overflow pe un buffer local) programul se oprește cu un raport care conține linia accesului, linia unde blocul a fost alocat și linia unde a fost eliberat. LeakSanitizer, inclus pe Linux, raportează la final blocurile neeliberate. Costul e o încetinire de aproximativ două ori și consum mai mare de memorie, deci e potrivit pentru teste și CI, nu pentru producție.

Valgrind Memcheck rulează programul neschimbat într-o mașină virtuală:

BASH
valgrind --leak-check=full --show-leak-kinds=all ./app

Nu necesită recompilare (dar -g ajută la numele liniilor), detectează și citiri din memorie neinițializată, însă e mult mai lent decât ASan și există doar pe anumite platforme.

Alte unelte utile:

  • UBSan (-fsanitize=undefined) pentru overflow pe întregi cu semn, deplasări invalide, acces nealiniat.
  • MemorySanitizer (Clang) pentru citiri neinițializate.
  • Analiză statică: clang-tidy, cppcheck, avertismentele -Wall -Wextra.
  • Pentru leak-uri „logice” (memorie încă referită, dar care crește): profilare de heap cu heaptrack sau Massif.

Abordarea profesională: sanitizere rulate automat pe testele din CI, plus RAII în cod ca să nu ai ce detecta. Pe microcontrolere, unde nu ai aceste unelte, se folosesc alocare statică și testarea logicii pe PC.

Ce urmărește intervievatorul: Verifică dacă ai lucrat practic cu uneltele de diagnoză. Greșeala tipică: a ști doar de Valgrind sau doar de „caut cu ochiul”.

24 Senior

Ce este fragmentarea memoriei și când ai scrie un alocator propriu (de exemplu, un pool allocator)?

Răspuns scurt: Fragmentarea apare când memoria liberă e împărțită în multe bucăți mici, încât o cerere mare eșuează deși totalul liber ajunge. Un pool allocator prealocă blocuri de dimensiune fixă și le refolosește, oferind alocare în timp constant și fără fragmentare, util în embedded și low-latency.

Fragmentarea externă: după multe alocări și eliberări de dimensiuni diferite, heap-ul are găuri mici între blocuri ocupate. Ai, de exemplu, 10 KB liberi în total, dar niciun bloc continuu de 2 KB. Fragmentarea internă: aloci mai mult decât ceri (rotunjire, antete), iar diferența e irosită. Pe un server cu memorie multă e de obicei tolerabilă; pe un microcontroler cu 64 KB de RAM care rulează ani fără restart poate duce la eșecuri imprevizibile.

Pe lângă fragmentare, malloc generic are timp de execuție nedeterminist, o problemă în sisteme real-time.

Un pool allocator rezervă la pornire N blocuri de aceeași dimensiune și le ține într-o listă de blocuri libere:

C++
#include <cstddef>

template <typename T, std::size_t N>
class Pool {
    union Slot { Slot *next; alignas(T) unsigned char storage[sizeof(T)]; };
    Slot slots_[N];
    Slot *free_ = nullptr;
public:
    Pool() { for (std::size_t i = 0; i < N; ++i) { slots_[i].next = free_; free_ = &slots_[i]; } }
    void *allocate() { if (!free_) return nullptr; Slot *s = free_; free_ = s->next; return s; }
    void deallocate(void *p) { Slot *s = static_cast<Slot *>(p); s->next = free_; free_ = s; }
};

Obiectele se construiesc cu placement new în blocul primit. Alocarea și eliberarea sunt O(1), deterministe, fără fragmentare.

Alte variante: arena (bump allocator, eliberezi tot deodată) și pool-uri pe clase de dimensiune. În C++17 ai std::pmr (monotonic_buffer_resource, unsynchronized_pool_resource) ca să le folosești cu containere standard. Scrii un alocator propriu doar după ce profilarea arată că alocarea e problema reală.

Ce urmărește intervievatorul: Verifică experiența cu sisteme cu resurse limitate sau cu cerințe de latență. Un răspuns senior include și când NU merită un alocator propriu.

Undefined behavior, compilare și linkare

25 Junior

Ce este undefined behavior și de ce e periculos? Dă câteva exemple.

Răspuns scurt: Undefined behavior (UB) este o situație pentru care standardul nu impune niciun comportament: programul poate crăpa, poate da rezultate greșite sau poate părea că merge. Exemple: dereferențierea unui pointer nul, acces în afara unui tablou, overflow pe întregi cu semn, folosirea unei variabile neinițializate.

Standardele C și C++ descriu ce face un program corect. Pentru anumite operații spun explicit că, dacă se întâmplă, comportamentul este nedefinit. Asta îi permite compilatorului să presupună că ele nu apar niciodată și să optimizeze pe baza acestei presupuneri.

Exemple frecvente:

  • dereferențierea unui pointer nul sau dangling;
  • acces în afara limitelor unui tablou (a[10] pentru int a[10]);
  • overflow pe întregi cu semn (INT_MAX + 1); la unsigned, depășirea e definită și se face modulo 2^n;
  • citirea unei variabile locale neinițializate;
  • împărțirea la zero, deplasarea cu mai mulți biți decât lățimea tipului;
  • modificarea unui obiect const sau a unui literal de tip șir;
  • data race: două thread-uri care accesează aceeași variabilă, cel puțin unul scriind, fără sincronizare.
C++
int a[4] = {1, 2, 3, 4};
int sum = 0;
for (int i = 0; i <= 4; ++i) sum += a[i];   // UB la i == 4

De ce e periculos: UB nu înseamnă „crapă”. Codul poate merge în debug și să eșueze la -O2, poate funcționa pe un compilator și nu pe altul, sau poate deveni o vulnerabilitate de securitate. Testele care trec nu dovedesc absența UB.

Cum te protejezi: avertismente (-Wall -Wextra), sanitizere (-fsanitize=address,undefined), analiză statică, containere cu acces verificat la nevoie (at()), tipuri unsigned pentru operații pe biți și reguli de cod precum MISRA în zonele critice.

Ce urmărește intervievatorul: Verifică dacă înțelegi că UB nu e doar „un crash”. Greșeala tipică: „la mine merge, deci e corect”.

26 Junior

Ce afișează int i = 1; i = i++ + ++i; printf("%d", i);?

Răspuns scurt: Nu există un răspuns corect: în C și în C++ înainte de C++17, expresia modifică i de mai multe ori fără ordine definită între modificări, deci este undefined behavior. Compilatoare diferite pot afișa valori diferite.

Întrebarea e o capcană. Mulți candidați încep să calculeze „1 + 3 = 4” sau „2 + 3 = 5”, dar intervievatorul vrea să audă că expresia nu are un rezultat definit.

Motivul: în expresia i++ + ++i, standardul nu stabilește ordinea în care se evaluează cei doi operanzi ai lui +, iar efectele secundare (incrementările) și atribuirea către i nu sunt ordonate unele față de altele. Regula generală, formulată în C cu „sequence points” și în C++11 cu relația „sequenced before”, este: dacă un obiect scalar e modificat de două ori, sau modificat și citit pentru alt scop, fără ordine între operații, comportamentul este nedefinit.

C++17 a introdus reguli de ordine mai stricte pentru unele cazuri (i = i++ + 1 a devenit definit, pentru că partea dreaptă a atribuirii e evaluată înaintea celei stângi), dar operanzii lui + rămân neordonați, deci i++ + ++i e UB și în C++17 și C++20. În C rămâne UB.

Exemple similare:

C
a[i] = i++;         /* UB în C; definit doar de la C++17 */
f(i++, i++);        /* argumentele nu au ordine definită */
printf("%d %d", i, i++);   /* UB */

Avertismentul -Wsequence-point (inclus în -Wall la GCC) prinde multe dintre aceste cazuri. Regula practică: nu modifica aceeași variabilă de mai multe ori într-o expresie și nu combina citirea și modificarea ei; scrie pașii pe rânduri separate. Codul devine și mai ușor de citit.

Ce urmărește intervievatorul: Verifică dacă recunoști UB în loc să ghicești un rezultat. Greșeala tipică: calcularea sigură a unei valori „corecte”.

27 Mid

Care e diferența dintre undefined behavior, unspecified behavior și implementation-defined behavior?

Răspuns scurt: Implementation-defined înseamnă că implementarea alege și documentează comportamentul (de exemplu, sizeof(int)). Unspecified înseamnă că există mai multe variante valide, iar implementarea nu trebuie să spună pe care o alege (ordinea evaluării argumentelor). Undefined înseamnă că standardul nu impune nimic.

Standardul C++ (și cel C) folosește trei categorii distincte:

  • Implementation-defined behavior: comportamentul variază între platforme, dar compilatorul trebuie să-l documenteze și să fie consecvent. Exemple: sizeof(int), dacă char e cu semn sau fără, rezultatul deplasării la dreapta a unui număr negativ (în C; C++20 îl definește ca deplasare aritmetică), modul de reprezentare al lui wchar_t. Programul e corect, dar portabilitatea depinde de aceste valori.
  • Unspecified behavior: standardul oferă un set de rezultate posibile, implementarea alege fără să documenteze, iar alegerea poate diferi chiar între două rulări sau două locuri din cod. Exemplu: ordinea în care se evaluează argumentele unei funcții.
C++
#include <cstdio>
int a() { std::puts("a"); return 1; }
int b() { std::puts("b"); return 2; }
int sum(int x, int y) { return x + y; }
int main() { return sum(a(), b()) == 3 ? 0 : 1; }  // poate afișa „a b” sau „b a”

Programul e valid, dar nu te poți baza pe ordinea afișării.

  • Undefined behavior: nu există nicio cerință. Exemple: overflow pe int, acces în afara unui tablou, data race. Compilatorul poate presupune că nu se întâmplă.

Există și „ill-formed, no diagnostic required”, de exemplu încălcări ale One Definition Rule, unde programul e invalid, dar compilatorul nu e obligat să raporteze.

Practic: implementation-defined se gestionează cu tipuri de dimensiune fixă (int32_t) și static_assert; unspecified se evită nescriind cod care depinde de ordine; UB se elimină complet.

Ce urmărește intervievatorul: Verifică precizia cu care cunoști standardul. Răspunsurile vagi („toate înseamnă că nu știi ce face”) arată lipsă de profunzime.

28 Mid

Ce este regula strict aliasing și cum poate strica un cast de pointer?

Răspuns scurt: Strict aliasing spune că un obiect poate fi accesat doar printr-un lvalue de tipul lui (sau compatibil), char/unsigned char/std::byte sau varianta signed/unsigned. Accesarea unui float printr-un int* este undefined behavior, iar compilatorul optimizează presupunând că pointerii de tipuri diferite nu indică aceeași memorie.

Regula permite compilatorului să presupună că un int* și un float* nu indică același obiect. Așa poate păstra valori în registre și reordona citiri și scrieri.

Codul clasic de „type punning” încalcă regula:

C++
#include <cstdint>
#include <cstring>

std::uint32_t bits_bad(float f) {
    return *reinterpret_cast<std::uint32_t *>(&f);   // UB: strict aliasing
}

std::uint32_t bits_ok(float f) {
    std::uint32_t u;
    static_assert(sizeof u == sizeof f);
    std::memcpy(&u, &f, sizeof u);                   // corect, optimizat la o singură instrucțiune
    return u;
}

În C++20 ai și std::bit_cast<std::uint32_t>(f), care e chiar constexpr.

Cum se manifestă bug-ul: o funcție care primește int *a și float *b scrie prin b, apoi recitește *a. Compilatorul la -O2 poate refolosi valoarea veche a lui *a din registru, pentru că „un float nu poate modifica un int”. Rezultatul diferă între debug și release.

Excepții permise: accesul prin char, unsigned char sau std::byte (de aceea memcpy și serializarea octet cu octet sunt valide), prin varianta signed/unsigned a aceluiași tip și prin tipul dinamic real al obiectului.

În embedded, mult cod mai vechi face cast la structuri peste buffere de octeți primite pe rețea. Pe lângă aliasing, apar și probleme de aliniere. Unele proiecte compilează cu -fno-strict-aliasing (cum face kernelul Linux), dar codul portabil folosește memcpy sau parsare explicită pe octeți.

Ce urmărește intervievatorul: Verifică dacă știi de ce un cast „evident” poate fi incorect. Greșeala tipică: reinterpret_cast pentru conversii între float și int.

29 Mid

Care e diferența dintre linkarea statică și cea dinamică și ce înseamnă eroarea „undefined reference to …”?

Răspuns scurt: La linkare statică, codul bibliotecii (.a) se copiază în executabil. La linkare dinamică, executabilul referă biblioteca partajată (.so, .dll), încărcată la rulare. „Undefined reference” e o eroare de linkare: un simbol e declarat și folosit, dar linkerul nu găsește nicio definiție.

Biblioteca statică (libfoo.a pe Linux, .lib pe Windows) e o arhivă de fișiere obiect. Linkerul copiază în executabil doar obiectele folosite. Avantaje: un singur fișier de livrat, fără dependențe la rulare, uneori pornire mai rapidă. Dezavantaje: executabile mai mari, iar o corecție de securitate în bibliotecă cere recompilarea aplicației.

Biblioteca partajată (libfoo.so, .dll, .dylib) e încărcată de dynamic loader la pornire sau cu dlopen. Mai multe procese pot împărți același cod în memorie, iar biblioteca se poate actualiza separat, cu condiția să păstreze ABI-ul. Dezavantaj: trebuie găsită la rulare (LD_LIBRARY_PATH, rpath, ldconfig), altfel apare „error while loading shared libraries”.

BASH
g++ -c util.cpp -fPIC -o util.o
ar rcs libutil.a util.o              # statică
g++ -shared util.o -o libutil.so     # partajată
g++ main.cpp -L. -lutil -o app       # linkare
ldd ./app                            # ce biblioteci dinamice folosește

Cauze tipice pentru undefined reference:

  • ai uitat să adaugi fișierul .cpp sau biblioteca (-lm, -lpthread) la linkare;
  • ordinea greșită a bibliotecilor statice: cu GNU ld, biblioteca trebuie să apară după obiectele care o folosesc;
  • funcția e declarată, dar definită cu altă semnătură (de exemplu, const lipsă), deci numele „mangled” diferă;
  • cod C apelat din C++ fără extern "C";
  • un template definit în .cpp în loc de header.

Unelte de investigare: nm -C libutil.a sau objdump -t ca să vezi ce simboluri exportă un fișier.

Ce urmărește intervievatorul: Verifică dacă poți depana probleme de build reale. Greșeala tipică: a trata o eroare de linkare ca pe una de sintaxă.

30 Mid

Ce este One Definition Rule (ODR) și de ce pot pune funcții inline și template-uri în headere?

Răspuns scurt: ODR cere ca fiecare variabilă și funcție non-inline să aibă exact o definiție în tot programul, iar clasele, funcțiile inline și template-urile să aibă definiții identice în fiecare unitate de traducere în care apar. Cuvântul inline permite definiții multiple identice, pe care linkerul le unifică.

Fiecare fișier .cpp se compilează separat. Dacă un header conține o definiție de funcție obișnuită și e inclus în două fișiere, ambele fișiere obiect vor avea acel simbol și linkerul raportează „multiple definition”.

C++
// util.h
#pragma once
int square(int x) { return x * x; }          // eroare la linkare dacă e inclus în 2 .cpp
inline int cube(int x) { return x * x * x; } // OK: inline permite definiții multiple
inline int counter = 0;                      // C++17: variabilă inline, o singură instanță

Pentru funcțiile și variabilele marcate inline, standardul permite o definiție în fiecare unitate de traducere, cu condiția să fie identice; linkerul păstrează una singură. Funcțiile definite în corpul unei clase sunt implicit inline, la fel și template-urile (instanțierile lor sunt unificate de linker). Funcțiile constexpr sunt și ele implicit inline.

Partea periculoasă a ODR: dacă două unități de traducere au definiții diferite pentru aceeași clasă sau funcție inline, programul este invalid, dar compilatorul și linkerul nu sunt obligați să te anunțe. Asta se poate întâmpla când:

  • un header e compilat cu macro-uri diferite (#ifdef DEBUG care adaugă un câmp într-o clasă);
  • două biblioteci au fiecare o clasă Logger în namespace-ul global;
  • versiuni diferite ale aceluiași header sunt folosite în module diferite.

Simptomele sunt bizare: layout greșit al obiectelor, funcții care se comportă diferit în funcție de fișier. Prevenire: namespace-uri pentru tot codul, static sau namespace anonim pentru funcțiile locale fișierului și flag-uri de compilare consecvente.

Ce urmărește intervievatorul: Verifică înțelegerea modelului de compilare C++. Candidații buni știu că încălcările ODR pot trece neobservate de unelte.

31 Senior

Cum poate compilatorul să-ți „șteargă” o verificare din cod din cauza undefined behavior? Dă un exemplu.

Răspuns scurt: Compilatorul presupune că UB nu apare și deduce fapte din cod. Dacă dereferențiezi un pointer înainte să verifici că nu e nul, poate concluziona că pointerul nu e nul și elimină verificarea. La fel, poate elimina o verificare de overflow pe int cu semn.

Optimizatorul nu „vede” UB și apoi face ceva rău intenționat; pur și simplu raționează: „dacă programul e corect, situația X nu se poate întâmpla”, și simplifică pe baza acestui fapt.

Exemplul 1: verificare de nul după dereferențiere.

C++
int read(int *p) {
    int v = *p;          // dacă p ar fi nul, ar fi UB
    if (p == nullptr)    // deci compilatorul deduce că p nu e nul
        return -1;       // și poate elimina acest bloc
    return v;
}

Un caz real de acest tip a produs o vulnerabilitate în kernelul Linux în 2009, după care kernelul a adoptat -fno-delete-null-pointer-checks.

Exemplul 2: verificare de overflow.

C++
bool will_overflow(int x) {
    return x + 1 < x;    // overflow pe int cu semn e UB, deci la -O2 devine „return false”
}

Corect: return x == INT_MAX; sau, în GCC/Clang, __builtin_add_overflow.

Exemplul 3: bucle. În C++, o buclă fără efecte observabile (fără I/O, operații volatile sau atomice) se presupune că se termină, deci poate fi eliminată sau transformată.

Lecțiile pentru un programator senior:

  • Un program cu UB poate funcționa la -O0 și eșua la -O2, sau la upgrade de compilator.
  • Testele nu sunt suficiente; folosește UBSan în CI, avertismente stricte și analiză statică.
  • Verifică precondițiile înainte de operația care ar produce UB, nu după.
  • Flag-uri precum -fwrapv (overflow cu semn definit ca wrap) există, dar fac codul dependent de compilator.

Ce urmărește intervievatorul: Verifică dacă înțelegi cum interacționează UB cu optimizările. E un subiect care separă candidații seniori de cei care cunosc doar definiția.

32 Senior

Ce este static initialization order fiasco și cum îl eviți?

Răspuns scurt: Ordinea în care se inițializează variabilele globale și statice definite în fișiere .cpp diferite nu e specificată. Dacă inițializarea uneia folosește alta, încă neinițializată, apar bug-uri care depind de ordinea linkării. Soluții: funcții care întorc o variabilă statică locală, constinit/constexpr sau evitarea globalelor.

În interiorul unei unități de traducere, variabilele globale se inițializează în ordinea definirii. Între unități de traducere diferite, ordinea inițializării dinamice nu e specificată.

C++
// config.cpp
#include <string>
std::string g_prefix = "app_";

// logger.cpp
#include <string>
extern std::string g_prefix;
std::string g_logname = g_prefix + "log";   // g_prefix poate fi încă neconstruit

Dacă logger.cpp se inițializează primul, g_prefix e un obiect neconstruit și programul are UB. Schimbarea ordinii fișierelor în comanda de linkare poate face bug-ul să apară sau să dispară.

Soluția clasică (Construct On First Use): o funcție care întoarce o referință la un obiect static local.

C++
const std::string &prefix() {
    static const std::string p = "app_";   // inițializat la primul apel
    return p;
}

Din C++11, inițializarea variabilelor statice locale e garantat sigură la thread-uri (compilatorul adaugă o gardă). Costul este o verificare la fiecare apel și o ordine de distrugere care poate genera aceeași problemă la ieșire, dacă un destructor global folosește un obiect deja distrus. Uneori se alege intenționat un obiect alocat cu new și niciodată distrus.

Alte soluții:

  • constexpr sau constinit (C++20) pentru variabile care pot fi inițializate la compilare; inițializarea constantă are loc înaintea oricărei inițializări dinamice.
  • Injectarea dependențelor: obiectele sunt create explicit în main, în ordinea dorită.
  • Reducerea stării globale, care oricum complică testarea și concurența.

Ce urmărește intervievatorul: Verifică experiența cu proiecte mari, cu multe module. Răspunsul senior menționează și problema simetrică a ordinii de distrugere.

OOP în C++: clase, moștenire, polimorfism

33 Junior

Care e diferența dintre class și struct în C++?

Răspuns scurt: Singura diferență tehnică este accesul implicit: membrii și moștenirea sunt public implicit la struct și private implicit la class. Prin convenție, struct se folosește pentru agregate simple de date, iar class pentru tipuri cu invarianți și interfață.

Mulți candidați spun că struct „nu poate avea metode” sau „nu poate moșteni”, ceea ce e fals în C++. Ambele pot avea constructori, metode, funcții virtuale, membri statici și moștenire.

C++
struct Point {           // membrii sunt public implicit
    int x = 0;
    int y = 0;
    int dist2() const { return x * x + y * y; }
};

class Account {          // membrii sunt private implicit
    double balance_ = 0;
public:
    void deposit(double v) { if (v > 0) balance_ += v; }
    double balance() const { return balance_; }
};

struct Derived : Point {};   // moștenire public implicit
class Other : Point {};      // moștenire private implicit

Convenția larg folosită (inclusiv în C++ Core Guidelines): folosește struct când datele sunt independente și orice combinație de valori e validă, deci câmpurile pot fi publice; folosește class când există un invariant de protejat. În exemplul de mai sus, Account garantează că soldul nu scade printr-un depozit negativ, deci câmpul e privat și se modifică doar prin metode.

Detalii utile:

  • Un struct simplu, fără constructori definiți de utilizator, este un agregat și se poate inițializa cu acolade: Point p{1, 2};. În C++20 ai și designated initializers: Point p{.x = 1, .y = 2};.
  • Pentru compatibilitate cu C, structurile cu layout standard pot fi transmise funcțiilor C.
  • Poți declara înainte cu class și defini cu struct (e legal, dar MSVC avertizează); fii consecvent.

Ce urmărește intervievatorul: Verifică dacă știi diferența reală, nu un mit. Greșeala tipică: „struct nu are metode”.

34 Junior

Ce tipuri de constructori există și de ce să folosești lista de inițializare?

Răspuns scurt: Ai constructorul implicit, constructori cu parametri, de copiere, de mutare (C++11) și constructori de conversie. Lista de inițializare construiește membrii direct cu valoarea dorită, în loc să-i construiască implicit și apoi să le atribuie; e obligatorie pentru membri const, referințe și membri fără constructor implicit.

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

class User {
    const int id_;
    std::string name_;
    int &counter_;
public:
    User(int id, std::string name, int &counter)
        : id_(id), name_(std::move(name)), counter_(counter) {   // lista de inițializare
        ++counter_;
    }
    User(const User &other) = default;   // constructor de copiere
    User(User &&other) = default;        // constructor de mutare
};

Fără lista de inițializare, în corpul constructorului membrii sunt deja construiți. Un std::string ar fi construit gol și apoi i s-ar atribui valoarea, adică două operații în loc de una. Pentru un membru const sau o referință, atribuirea nici nu e posibilă, deci codul nu compilează.

Lucruri pe care intervievatorul vrea să le auzi:

  • Membrii se inițializează în ordinea declarării în clasă, nu în ordinea din lista de inițializare. Dacă b_(a_) apare primul în listă, dar a_ e declarat după b_, folosești o valoare neinițializată. -Wall (-Wreorder) avertizează.
  • Un constructor cu un singur parametru e și constructor de conversie. Marchează-l explicit ca să eviți conversii implicite surprinzătoare, de exemplu void f(Buffer b); f(42);.
  • Dacă declari orice constructor, compilatorul nu mai generează constructorul implicit; îl poți cere cu = default.
  • Inițializatorii de membri în clasă (int x_ = 0;) dau valori implicite, iar constructorii delegați (User() : User(0, "", g) {}) evită duplicarea.

Ce urmărește intervievatorul: Verifică înțelegerea ciclului de viață al obiectelor. Greșeala tipică: ignorarea ordinii de inițializare dată de declarații.

35 Junior

Când se apelează destructorul unui obiect?

Răspuns scurt: Automat, când se încheie durata de viață a obiectului: la ieșirea din scope pentru obiectele locale, la delete pentru cele create cu new, la sfârșitul programului pentru cele statice și odată cu obiectul care îl conține. Ordinea e inversă construirii.

Destructorul (~T()) eliberează resursele obiectului: memorie, fișiere, mutex-uri, conexiuni. Momentul apelului depinde de durata de stocare:

  • Obiecte automate (locale): la ieșirea din bloc, inclusiv prin return, break sau o excepție aruncată (stack unwinding). Se distrug în ordinea inversă creării.
  • Obiecte dinamice: la delete p. Dacă uiți delete, destructorul nu rulează niciodată.
  • Obiecte statice și globale: după ieșirea din main sau la apelul exit(), în ordinea inversă inițializării. La std::abort() sau _exit() nu rulează.
  • Temporare: la sfârșitul expresiei complete, cu excepția cazului în care sunt legate de o referință const&, care le prelungește viața.
  • Membri și clase de bază: după corpul destructorului clasei, membrii se distrug în ordinea inversă declarării, apoi bazele.
C++
#include <iostream>

struct Trace {
    const char *n;
    explicit Trace(const char *name) : n(name) { std::cout << "+" << n << ' '; }
    ~Trace() { std::cout << "-" << n << ' '; }
};

int main() {
    Trace a("a");
    {
        Trace b("b");
    }                        // -b
    Trace *c = new Trace("c");
    delete c;                // -c
}                            // -a
// Afișează: +a +b -b +c -c -a

Reguli importante: destructorii nu ar trebui să arunce excepții (din C++11 sunt implicit noexcept, iar o excepție care iese dintr-un destructor duce la std::terminate). Garanția apelului automat la ieșirea din scope este fundamentul RAII.

Ce urmărește intervievatorul: Verifică înțelegerea duratei de viață, baza pentru RAII. Greșeala tipică: a uita de stack unwinding la excepții.

36 Junior

Care e diferența dintre supraîncărcare (overloading) și suprascriere (overriding)? La ce folosește cuvântul override?

Răspuns scurt: Overloading: funcții cu același nume și parametri diferiți, alese la compilare. Overriding: derivata redefinește o funcție virtuală a bazei, aleasă la runtime. override cere compilatorului să verifice că funcția chiar suprascrie una virtuală.

Supraîncărcarea este polimorfism la compilare. Compilatorul alege varianta după tipurile argumentelor:

C++
void print(int x);
void print(double x);
void print(const std::string &s);
print(3);      // print(int)
print(2.5);    // print(double)

Tipul de return singur nu diferențiază supraîncărcările. Supraîncărcarea operatorilor (operator+, operator<<) este tot o formă de overloading.

Suprascrierea se aplică funcțiilor virtuale. Clasa derivată furnizează propria implementare cu aceeași semnătură, iar apelul printr-un pointer sau o referință la bază alege implementarea după tipul real al obiectului:

C++
#include <iostream>

struct Shape {
    virtual double area() const { return 0; }
    virtual ~Shape() = default;
};

struct Circle : Shape {
    double r;
    explicit Circle(double radius) : r(radius) {}
    double area() const override { return 3.14159 * r * r; }
};

int main() {
    Circle c(1.0);
    const Shape &s = c;
    std::cout << s.area() << '\n';   // 3.14159, varianta din Circle
}

De ce override (C++11): fără el, o mică diferență de semnătură, de exemplu double area() fără const, creează o funcție nouă care ascunde funcția bazei în loc s-o suprascrie. Codul compilează, dar polimorfismul nu funcționează. Cu override, compilatorul dă eroare. final interzice suprascrierea ulterioară sau derivarea din clasă.

O capcană conexă este name hiding: o funcție f(int) declarată în derivată ascunde toate supraîncărcările f din bază; le readuci cu using Base::f;.

Ce urmărește intervievatorul: Verifică dacă distingi legarea statică de cea dinamică. Mulți candidați nu știu de capcana semnăturii ușor diferite, pe care o rezolvă override.

37 Junior

Ce este o funcție virtuală și cum obții polimorfism la runtime în C++?

Răspuns scurt: O funcție marcată virtual se apelează în funcție de tipul real al obiectului, nu de tipul pointerului sau al referinței prin care o apelezi. Polimorfismul la runtime apare când lucrezi cu obiecte derivate prin pointeri sau referințe la clasa de bază.

Fără virtual, funcția apelată se decide la compilare, după tipul static al expresiei. Cu virtual, decizia se ia la rulare, după tipul dinamic al obiectului.

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

struct Sensor {
    virtual double read() const = 0;
    void info() const { std::cout << "Sensor\n"; }  // nevirtuală
    virtual ~Sensor() = default;
};

struct Temperature : Sensor {
    double read() const override { return 21.5; }
    void info() const { std::cout << "Temperature\n"; }
};

struct Pressure : Sensor {
    double read() const override { return 1013.0; }
};

int main() {
    std::vector<std::unique_ptr<Sensor>> sensors;
    sensors.push_back(std::make_unique<Temperature>());
    sensors.push_back(std::make_unique<Pressure>());
    for (const auto &s : sensors) {
        std::cout << s->read() << '\n';  // 21.5, apoi 1013
        s->info();                       // „Sensor” de fiecare dată
    }
}

read() e virtuală, deci se apelează implementarea din clasa reală. info() nu e virtuală, deci prin Sensor* se apelează mereu Sensor::info, chiar dacă Temperature are propria variantă.

Condiții pentru polimorfism: funcția e virtuală în bază, apelul se face printr-un pointer sau o referință (cu un obiect copiat prin valoare se pierde tipul derivat, fenomen numit slicing) și semnătura se potrivește (verificat cu override).

Avantajul principal: codul care folosește Sensor nu trebuie modificat când adaugi un senzor nou (principiul open/closed). Costul: un apel indirect și, de obicei, imposibilitatea de a face inline, neglijabil în cele mai multe aplicații, dar relevant în bucle critice.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismului de bază al OOP în C++. Greșeala tipică: așteptarea de comportament polimorfic de la funcții nevirtuale sau de la obiecte transmise prin valoare.

38 Junior

De ce trebuie să fie virtual destructorul unei clase de bază?

Răspuns scurt: Dacă ștergi un obiect derivat printr-un pointer la bază și destructorul bazei nu e virtual, comportamentul este nedefinit; în practică se apelează doar destructorul bazei, iar resursele derivatei nu se eliberează. Orice clasă proiectată pentru polimorfism trebuie să aibă destructor virtual.

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

struct Base {
    ~Base() { std::cout << "~Base\n"; }          // NEvirtual: problemă
};

struct Derived : Base {
    std::vector<int> data = std::vector<int>(1000);
    ~Derived() { std::cout << "~Derived\n"; }
};

int main() {
    Base *p = new Derived;
    delete p;   // UB; tipic afișează doar „~Base”, iar vectorul nu e eliberat
}

Expresia delete p trebuie să știe ce destructor să apeleze. Fără virtual, compilatorul folosește tipul static Base și apelează doar ~Base. Standardul spune explicit că ștergerea unui obiect derivat printr-un pointer la bază fără destructor virtual este undefined behavior. În practică, membrii derivatei nu sunt distruși (leak de memorie, fișiere rămase deschise) și se poate elibera o dimensiune greșită de memorie.

Soluția:

C++
struct Base {
    virtual ~Base() = default;
};

Odată ce destructorul e virtual, delete p apelează ~Derived, care apoi apelează automat ~Base.

Reguli practice:

  • O clasă cu cel puțin o funcție virtuală ar trebui să aibă destructor virtual. GCC avertizează cu -Wnon-virtual-dtor și -Wdelete-non-virtual-dtor.
  • Dacă nu vrei ca o clasă de bază să fie ștearsă polimorfic, fă destructorul protected și nevirtual (recomandare din C++ Core Guidelines).
  • std::shared_ptr<Base> creat cu std::make_shared<Derived>() reține deleter-ul corect chiar și fără destructor virtual, dar std::unique_ptr<Base> nu; nu te baza pe această diferență.

Ce urmărește intervievatorul: Este una dintre cele mai frecvente întrebări de C++. Se urmărește dacă știi că e UB, nu doar „un leak”.

39 Junior

Ce este o clasă abstractă și cum definești o interfață în C++?

Răspuns scurt: O clasă abstractă are cel puțin o funcție pur virtuală (declarată cu = 0) și nu poate fi instanțiată. O interfață în C++ este, prin convenție, o clasă abstractă care conține doar funcții pur virtuale și un destructor virtual.

C++ nu are cuvântul cheie interface, ca Java sau C#. Folosești o clasă cu funcții pur virtuale:

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

class Transport {                       // interfață
public:
    virtual ~Transport() = default;
    virtual bool send(const std::string &payload) = 0;
    virtual std::size_t mtu() const = 0;
};

class UartTransport : public Transport {
public:
    bool send(const std::string &payload) override {
        std::cout << "UART: " << payload << '\n';
        return true;
    }
    std::size_t mtu() const override { return 64; }
};

void publish(Transport &t) { t.send("temp=21.5"); }

int main() {
    UartTransport uart;
    publish(uart);
    // Transport t;  eroare: clasa e abstractă
}

O clasă derivată care nu implementează toate funcțiile pur virtuale rămâne abstractă.

De ce e util: codul (publish) depinde de o abstracție, nu de o implementare concretă. Poți înlocui UART cu CAN sau cu un transport fals în teste (mock) fără să modifici logica. Este baza dependency inversion și a testării unitare în C++, de exemplu cu GoogleTest și GoogleMock.

Detalii mai puțin cunoscute:

  • O funcție pur virtuală poate avea totuși o implementare, apelabilă explicit cu Transport::send(...).
  • Un destructor pur virtual (virtual ~X() = 0;) trebuie totuși definit, pentru că destructorii derivatelor îl apelează.
  • Pentru moștenirea mai multor interfețe, moștenirea multiplă e sigură, pentru că interfețele nu au date.

Alternativa fără funcții virtuale este polimorfismul static (templates, concepts), când tipul e cunoscut la compilare.

Ce urmărește intervievatorul: Verifică dacă știi să proiectezi cod testabil și extensibil. Greșeala tipică: uitarea destructorului virtual în interfață.

40 Mid

Cum funcționează vtable și vptr? Care e costul unei funcții virtuale?

Răspuns scurt: Fiecare clasă cu funcții virtuale are o tabelă (vtable) cu adresele implementărilor, iar fiecare obiect are un pointer ascuns (vptr) către ea. Un apel virtual citește vptr, apoi adresa din tabelă. Cost: un pointer per obiect, o indirecție, de obicei fără inline.

Standardul C++ nu impune vtable-uri, dar toate compilatoarele majore le folosesc (ABI-ul Itanium pentru GCC și Clang, propriul ABI la MSVC).

Cum arată conceptual:

  • Pentru clasa Shape cu funcțiile virtuale area și ~Shape, compilatorul generează o tabelă statică: [&Shape::~Shape, &Shape::area].
  • Circle are propria tabelă, în care intrarea pentru area indică Circle::area.
  • Constructorul fiecărei clase setează vptr-ul obiectului către tabela ei.
  • Apelul s->area() devine aproximativ (*(s->vptr[1]))(s).
C++
#include <iostream>

struct A { int x; void f(); };
struct B { int x; virtual void f() {} virtual ~B() = default; };

int main() {
    std::cout << sizeof(A) << ' ' << sizeof(B) << '\n';  // tipic 4 16 pe x86-64
}

B are în plus un pointer de 8 octeți, iar alinierea ridică dimensiunea la 16.

Costurile reale:

  • Memorie: un vptr per obiect (și pentru fiecare bază polimorfă, la moștenire multiplă), plus o tabelă per clasă.
  • Timp: două citiri din memorie și un salt indirect. Problema principală nu e saltul, ci faptul că funcția nu poate fi integrată inline, deci se pierd optimizările ulterioare. Branch predictor-ul face apelurile cu țintă stabilă destul de ieftine.
  • Devirtualizare: dacă compilatorul știe tipul exact (clasă final, obiect local, optimizare la linkare cu -flto), poate transforma apelul în unul direct.

În bucle foarte strânse (procesare de semnal, jocuri) se preferă polimorfismul static (templates, CRTP) sau gruparea obiectelor după tip.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismului de sub abstracție. Răspunsul bun cuantifică costul fără să-l exagereze.

41 Mid

Ce sunt Rule of Three, Rule of Five și Rule of Zero?

Răspuns scurt: Rule of Three: dacă definești destructorul, copierea sau atribuirea prin copiere, probabil ai nevoie de toate trei. Rule of Five adaugă cele două operații de mutare (C++11). Rule of Zero: nu definești niciuna și lași membrii RAII să gestioneze resursele.

Dacă o clasă gestionează direct o resursă (un pointer brut, un descriptor de fișier), versiunile generate de compilator copiază doar pointerul. Două obiecte ajung să dețină aceeași memorie și o eliberează de două ori.

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

class Buffer {                    // Rule of Five
    std::size_t size_;
    char *data_;
public:
    explicit Buffer(std::size_t n) : size_(n), data_(new char[n]{}) {}
    ~Buffer() { delete[] data_; }
    Buffer(const Buffer &o) : size_(o.size_), data_(new char[o.size_]) {
        std::memcpy(data_, o.data_, size_);
    }
    Buffer &operator=(Buffer o) noexcept {      // copy-and-swap: acoperă copierea și mutarea
        std::swap(size_, o.size_);
        std::swap(data_, o.data_);
        return *this;
    }
    Buffer(Buffer &&o) noexcept : size_(std::exchange(o.size_, 0)), data_(std::exchange(o.data_, nullptr)) {}
};

Operatorul de atribuire primește parametrul prin valoare, deci se construiește prin copiere sau prin mutare, după caz. Astfel tratează corect și autoatribuirea, și siguranța la excepții.

Rule of Zero e recomandarea modernă: clasele de business nu gestionează resurse direct, ci folosesc membri care o fac deja.

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

class Report {
    std::string title_;
    std::vector<char> data_;   // copiere, mutare și distrugere corecte, automat
};

Atenție: dacă declari un destructor, compilatorul nu mai generează operațiile de mutare, iar clasa va fi copiată acolo unde te așteptai la mutare. Dacă ai nevoie de toate operațiile implicite, cere-le explicit cu = default; dacă obiectul nu trebuie copiat (un mutex, un socket), folosește = delete.

Ce urmărește intervievatorul: Verifică dacă înțelegi semantica de copiere și mutare. Greșeala tipică: o clasă cu pointer brut și destructor, dar fără constructor de copiere.

42 Mid

Ce este object slicing și cum îl eviți?

Răspuns scurt: Slicing apare când un obiect derivat e copiat într-un obiect de tipul bazei (prin valoare): se copiază doar partea de bază, iar datele și comportamentul derivat se pierd. Îl eviți transmițând obiectele polimorfe prin referință sau pointer și interzicând copierea în clasele de bază.

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

struct Animal {
    virtual const char *sound() const { return "..."; }
    virtual ~Animal() = default;
};
struct Dog : Animal {
    int tricks = 3;
    const char *sound() const override { return "Ham"; }
};

void by_value(Animal a)        { std::cout << a.sound() << '\n'; }  // „...”
void by_ref(const Animal &a)   { std::cout << a.sound() << '\n'; }  // „Ham”

int main() {
    Dog d;
    by_value(d);                 // slicing: se construiește un Animal nou
    by_ref(d);
    std::vector<Animal> zoo;
    zoo.push_back(d);            // slicing și aici
    std::cout << zoo[0].sound() << '\n';   // „...”
}

La transmiterea prin valoare, constructorul de copiere al lui Animal construiește un Animal din partea Animal a lui Dog. Câmpul tricks dispare, iar vptr-ul noului obiect indică vtable-ul lui Animal, deci și comportamentul virtual se pierde. Nu e o eroare de compilare, de aceea e o capcană.

Cum previi:

  • Transmite obiectele polimorfe prin const Base&, Base& sau pointeri.
  • Pentru colecții, folosește std::vector<std::unique_ptr<Animal>>.
  • Interzice copierea publică în bazele polimorfe: Animal(const Animal&) = delete; sau constructor de copiere protected. Astfel by_value(d) nu mai compilează. C++ Core Guidelines recomandă explicit acest lucru (C.67).
  • Dacă ai nevoie de copii polimorfe, adaugă o metodă virtuală clone() care întoarce std::unique_ptr<Animal>.

Există și o formă mai subtilă: atribuirea Base &r = d1; r = d2; copiază doar partea de bază dintr-un obiect derivat în altul.

Ce urmărește intervievatorul: Verifică dacă înțelegi interacțiunea dintre semantica valorilor și polimorfism. Mulți candidați nu au auzit de termen deși au întâlnit bug-ul.

43 Mid

Ce este problema diamantului la moștenirea multiplă și cum o rezolvă moștenirea virtuală?

Răspuns scurt: Dacă B și C moștenesc din A, iar D din B și C, D conține două subobiecte A: ambiguitate și date duplicate. Cu moștenire virtuală (class B : virtual public A) există un singur A partajat, construit de clasa cea mai derivată.

C++
#include <iostream>

struct Device { int id = 0; Device() { std::cout << "Device "; } };
struct Readable : virtual Device {};
struct Writable : virtual Device {};
struct Port : Readable, Writable {};

int main() {
    Port p;            // afișează „Device ” o singură dată
    p.id = 5;          // fără „virtual” ar fi ambiguu: Readable::id sau Writable::id?
    std::cout << sizeof(Port) << '\n';
}

Fără virtual, Port ar conține două copii ale lui Device. p.id nu ar compila (ambiguitate), conversia Device *d = &p; ar fi ambiguă, iar starea s-ar putea desincroniza între copii.

Cu moștenire virtuală:

  • Există un singur subobiect Device, partajat de Readable și Writable.
  • Constructorul bazei virtuale e apelat de clasa cea mai derivată (Port). Dacă Readable transmite argumente constructorului lui Device, acestea sunt ignorate când construiești un Port; dacă Device nu are constructor implicit, Port trebuie să-l apeleze explicit în lista de inițializare.
  • Costul: un nivel suplimentar de indirecție la accesul membrilor bazei virtuale (prin offset-uri din vtable), obiecte mai mari și layout mai complicat. static_cast de la bază virtuală la derivată nu mai e permis; ai nevoie de dynamic_cast.

Exemplul real din biblioteca standard: std::iostream moștenește din std::istream și std::ostream, care moștenesc virtual din std::basic_ios.

Recomandarea practică: moștenirea multiplă de interfețe (clase fără date) e sigură și utilă; moștenirea multiplă de implementări cu stare se evită de obicei, în favoarea compoziției.

Ce urmărește intervievatorul: Verifică înțelegerea modelului de obiect C++. Un detaliu care diferențiază: cine construiește baza virtuală.

44 Mid

Care sunt diferențele dintre static_cast, dynamic_cast, const_cast și reinterpret_cast?

Răspuns scurt: static_cast face conversii verificate la compilare (numerice, pe ierarhie, fără verificare la runtime). dynamic_cast verifică la runtime conversiile în ierarhii polimorfe. const_cast adaugă sau elimină const. reinterpret_cast reinterpretează biții.

Cast-ul în stil C (T)x încearcă pe rând mai multe dintre acestea și poate face o conversie periculoasă fără să observi. Cast-urile C++ sunt explicite și ușor de căutat în cod.

C++
#include <cstdint>
#include <iostream>

struct Base { virtual ~Base() = default; };
struct Derived : Base { void hello() { std::cout << "Derived\n"; } };
struct Other : Base {};

int main() {
    double d = 3.7;
    int i = static_cast<int>(d);                 // 3, conversie numerică

    Base *b = new Other;
    if (auto *p = dynamic_cast<Derived *>(b))    // nullptr: b nu e Derived
        p->hello();

    auto addr = reinterpret_cast<std::uintptr_t>(b);   // adresa ca număr
    std::cout << i << ' ' << (addr != 0) << '\n';
    delete b;
}
  • static_cast: conversii numerice, void* la T*, upcast și downcast. Downcast-ul fără verificare e UB dacă obiectul nu are de fapt tipul derivat.
  • dynamic_cast: necesită o clasă polimorfă (cu funcții virtuale) și RTTI activat. Pentru pointeri întoarce nullptr la eșec, pentru referințe aruncă std::bad_cast. Are cost la runtime. Folosirea frecventă indică adesea un design care ar trebui să folosească funcții virtuale.
  • const_cast: util pentru API-uri vechi care nu sunt const-corecte. Modificarea prin el a unui obiect definit const rămâne UB.
  • reinterpret_cast: pointeri la întregi și invers, pointeri între tipuri fără legătură. Ușor de transformat în încălcare de strict aliasing; în embedded apare la registre mapate în memorie.

În embedded, RTTI și excepțiile sunt adesea dezactivate (-fno-rtti), deci dynamic_cast nu e disponibil.

Ce urmărește intervievatorul: Verifică dacă știi ce garanții oferă fiecare cast. Greșeala tipică: folosirea cast-ului C peste tot sau a lui static_cast pentru downcast nesigur.

45 Senior

Ce se întâmplă dacă apelezi o funcție virtuală din constructorul sau din destructorul unei clase de bază?

Răspuns scurt: În timpul constructorului și destructorului bazei, obiectul are tipul bazei, deci apelul virtual se rezolvă la implementarea bazei, nu la cea a derivatei. Dacă funcția e pur virtuală, comportamentul este nedefinit (de obicei „pure virtual function call” și oprirea programului).

C++
#include <iostream>

struct Base {
    Base() { init(); }                  // apel virtual în constructor
    virtual void init() { std::cout << "Base::init\n"; }
    virtual ~Base() { cleanup(); }
    virtual void cleanup() { std::cout << "Base::cleanup\n"; }
};

struct Derived : Base {
    int *buf = new int[8];
    void init() override { std::cout << "Derived::init\n"; buf[0] = 1; }
    void cleanup() override { std::cout << "Derived::cleanup\n"; }
    ~Derived() override { delete[] buf; }
};

int main() {
    Derived d;   // afișează „Base::init”
}                // afișează „Base::cleanup”

De ce: un obiect Derived se construiește de la bază spre derivată. Când rulează Base(), membrii lui Derived (aici buf) nu sunt încă inițializați. Dacă s-ar apela Derived::init, ar folosi memorie neinițializată. De aceea limbajul tratează obiectul ca fiind de tip Base pe durata constructorului bazei: vptr-ul indică vtable-ul lui Base. Simetric, la distrugere, partea Derived e deja distrusă când rulează ~Base.

Alte limbaje (Java, C#) apelează varianta derivată din constructorul bazei, cu riscul de a lucra pe câmpuri neinițializate, deci cei care vin din Java au intuiția greșită.

Cazul periculos: dacă init ar fi pur virtuală și apelată indirect din constructor (printr-o altă funcție nevirtuală), programul are UB; GCC și Clang opresc de obicei programul cu „pure virtual method called”.

Soluții de design:

  • O funcție de fabrică (static std::unique_ptr<Derived> create()) care construiește obiectul și apoi apelează init().
  • Transmiterea informației necesare ca parametri către constructorul bazei.
  • Inițializare în doi pași, documentată clar, doar dacă nu există alternativă.

Ce urmărește intervievatorul: Verifică înțelegerea ordinii de construcție și a modelului de obiect. Candidații care vin din Java greșesc des aici.

C++ modern: RAII, smart pointers, move semantics

46 Junior

Ce este RAII și de ce e considerat cel mai important idiom din C++?

Răspuns scurt: RAII (Resource Acquisition Is Initialization) leagă durata de viață a unei resurse de durata de viață a unui obiect: constructorul o obține, destructorul o eliberează. Pentru că destructorii rulează automat la ieșirea din scope, inclusiv la excepții, resursa nu poate fi uitată.

Resursele nu sunt doar memorie: fișiere, socket-uri, mutex-uri, tranzacții, handle-uri de hardware. În C, eliberarea se face manual pe fiecare ramură de ieșire, iar o ramură uitată produce un leak sau un mutex blocat.

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

class File {
    std::FILE *f_;
public:
    File(const char *path, const char *mode) : f_(std::fopen(path, mode)) {
        if (!f_) throw std::runtime_error("cannot open file");
    }
    ~File() { std::fclose(f_); }
    File(const File &) = delete;              // o singură proprietate
    File &operator=(const File &) = delete;
    std::FILE *get() const { return f_; }
};

void write_log(const char *msg) {
    File f("app.log", "a");
    std::fputs(msg, f.get());
    // orice return sau excepție de aici în jos închide fișierul
}

De ce e atât de important:

  • Siguranță la excepții: la o excepție, stiva se derulează și destructorii obiectelor locale rulează. Fără RAII, codul cu excepții ar avea leak-uri peste tot.
  • Un singur loc de eliberare: codul de curățenie e scris o dată, în destructor, nu la fiecare return.
  • Proprietate clară: tipul spune cine deține resursa.

Exemple din biblioteca standard: std::vector și std::string (memorie), std::unique_ptr și std::shared_ptr, std::lock_guard și std::scoped_lock (mutex-uri), std::fstream (fișiere), std::jthread (C++20, face join în destructor).

O regulă utilă: dacă scrii new, fopen sau lock() în cod de aplicație, întreabă-te ce obiect deține resursa. Numele idiomului e nefericit; o descriere mai bună ar fi „eliberarea resurselor în destructor”.

Ce urmărește intervievatorul: Este întrebarea care arată dacă gândești în C++ sau în „C cu clase”. Greșeala tipică: a reduce RAII la smart pointers.

47 Junior

Care e diferența dintre std::unique_ptr, std::shared_ptr și std::weak_ptr?

Răspuns scurt: unique_ptr are un singur proprietar, se poate doar muta și nu costă mai mult decât un pointer brut. shared_ptr permite mai mulți proprietari prin numărare de referințe. weak_ptr observă un obiect deținut de shared_ptr fără să-l țină în viață.

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

struct Engine { ~Engine() { std::cout << "engine distrus\n"; } };

int main() {
    std::unique_ptr<Engine> u = std::make_unique<Engine>();
    // auto u2 = u;            eroare: unique_ptr nu se copiază
    auto u2 = std::move(u);    // proprietatea se mută, u devine nul

    std::shared_ptr<Engine> s1 = std::make_shared<Engine>();
    std::shared_ptr<Engine> s2 = s1;          // use_count == 2
    std::weak_ptr<Engine> w = s1;             // use_count rămâne 2

    s1.reset();
    s2.reset();                               // aici se distruge al doilea Engine
    if (auto locked = w.lock()) {             // obiectul nu mai există
        std::cout << "încă trăiește\n";
    } else {
        std::cout << "expirat\n";
    }
}   // la final se distruge Engine-ul deținut de u2

unique_ptr e alegerea implicită. Are aceeași dimensiune ca un pointer brut (cu deleter-ul implicit) și exprimă clar proprietatea. Îl folosești pentru membri care dețin obiecte polimorfe, pentru funcții de fabrică și pentru containere de obiecte polimorfe. Suportă și deleter-e custom, de exemplu pentru FILE*.

shared_ptr se folosește când durata de viață chiar e partajată și nu poți stabili un proprietar unic (de exemplu, un obiect folosit de mai multe thread-uri sau de un cache). Costă un bloc de control și incrementări atomice ale contorului la fiecare copie.

weak_ptr rezolvă două probleme: ciclurile de referințe (două obiecte care se țin reciproc prin shared_ptr nu se eliberează niciodată) și observarea unui obiect care poate dispărea, ca un cache sau un observer. Accesul se face prin lock(), care întoarce un shared_ptr gol dacă obiectul nu mai există.

Pentru parametrii de funcție care doar folosesc obiectul, transmite T& sau T*, nu smart pointer.

Ce urmărește intervievatorul: Verifică dacă alegi proprietatea în mod conștient. Greșeala tipică: shared_ptr folosit peste tot „ca să fie sigur”.

48 Junior

Când e util auto și când te poate păcăli? Ce se întâmplă cu for (auto x : v)?

Răspuns scurt: auto deduce tipul din inițializator și reduce zgomotul, mai ales la iteratori și tipuri lungi. Capcana: auto elimină referința și const-ul de la nivelul superior, deci for (auto x : v) copiază fiecare element. Folosește const auto& pentru citire și auto& pentru modificare.

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

int main() {
    std::vector<std::string> names{"Ana", "Ion"};

    for (auto n : names) n += "!";          // modifică o copie; names rămâne neschimbat
    for (auto &n : names) n += "!";         // modifică elementele
    for (const auto &n : names) std::cout << n << ' ';   // citire fără copii

    std::map<std::string, int> ages{{"Ana", 30}};
    for (const auto &[name, age] : ages)    // structured bindings, C++17
        std::cout << name << '=' << age << '\n';

    auto it = ages.find("Ana");             // în loc de std::map<std::string,int>::iterator
    if (it != ages.end()) std::cout << it->second << '\n';
}

Reguli de deducție de reținut:

  • auto x = expr; elimină referința și const-ul de nivel superior (ca la transmiterea prin valoare a unui template).
  • auto &x și const auto &x păstrează referința.
  • auto &&x e o referință de forwarding, folosită în cod generic.
  • auto x = {1, 2}; deduce std::initializer_list<int>, nu int.

Capcane frecvente:

  • Pentru std::map, elementul e std::pair<const Key, T>. Dacă scrii explicit const std::pair<std::string, int>&, fără const la cheie, se creează o copie temporară la fiecare pas; cu auto problema nu apare.
  • Tipuri proxy: auto b = vec_bool[0]; pentru std::vector<bool> dă un obiect proxy, nu un bool, care poate deveni invalid.
  • auto pe un rezultat numeric poate ascunde conversii; auto n = v.size(); e size_t, nu int.

auto nu e „tipare dinamică”: tipul e fixat la compilare. Folosește-l când tipul e evident sau irelevant, nu când ascunde informație importantă pentru cititor.

Ce urmărește intervievatorul: Verifică înțelegerea regulilor de deducție și atenția la copii inutile. Greșeala tipică: for (auto x : v) pe obiecte mari.

49 Junior

De ce folosim nullptr în loc de NULL sau 0 în C++?

Răspuns scurt: nullptr (C++11) are un tip propriu, std::nullptr_t, care se convertește la orice tip de pointer, dar nu la întregi. NULL e de obicei 0 sau 0L, adică un întreg, ceea ce poate alege supraîncărcarea greșită sau poate deduce un tip întreg în templates.

Înainte de C++11, pointerul nul se scria 0 sau NULL, un macro definit de obicei ca 0 sau 0L (în C poate fi ((void*)0), dar în C++ nu, pentru că void* nu se convertește implicit la alte tipuri de pointer). Problema apare la supraîncărcare:

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

void handle(int)          { std::cout << "int\n"; }
void handle(const char *) { std::cout << "pointer\n"; }

int main() {
    handle(0);          // int
    // handle(NULL);    // int sau eroare de ambiguitate, în funcție de definiția lui NULL
    handle(nullptr);    // pointer
}

Intenția era evident să transmiți un pointer nul, dar 0 e un int, deci se alege handle(int).

Problema e și mai vizibilă în templates și în forwarding:

C++
template <typename F, typename A>
void call(F f, A arg) { f(arg); }

void take(int *p) { std::cout << (p == nullptr) << '\n'; }

// call(take, 0);        eroare: A e dedus ca int, iar int nu se convertește la int*
// call(take, nullptr);  OK: std::nullptr_t se convertește la int*

Avantajele lui nullptr:

  • E un literal de tip std::nullptr_t, convertibil la orice pointer (inclusiv pointeri la membri), dar nu la int.
  • Codul e mai clar: if (p == nullptr) arată că p e pointer.
  • Elimină o clasă de ambiguități la supraîncărcare și deducție.

În cod C rămâi la NULL. C23 a introdus și el nullptr, dar suportul în compilatoarele de embedded variază, deci verifică versiunea standardului folosită de proiect.

Ce urmărește intervievatorul: Verifică dacă înțelegi motivația schimbărilor din C++11. Răspunsul bun include exemplul cu supraîncărcarea.

50 Junior

De ce se recomandă std::make_unique și std::make_shared în loc de new direct?

Răspuns scurt: Sunt mai scurte, evită new/delete în codul de aplicație și sunt sigure la excepții în expresii complexe. make_shared face în plus o singură alocare pentru obiect și blocul de control, deci e mai rapid și folosește mai puțină memorie.

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

struct Widget { explicit Widget(std::string n) : name(std::move(n)) {} std::string name; };

int main() {
    auto a = std::make_unique<Widget>("a");               // C++14
    auto b = std::make_shared<Widget>("b");               // C++11
    std::unique_ptr<Widget> c(new Widget("c"));           // funcționează, dar e mai verbos
}

Motivele, în ordinea importanței:

1. Nu repeți tipul și nu scrii new. Regula „niciun new/delete în codul de aplicație” devine ușor de verificat la code review.

2. Siguranță la excepții (istoric). Înainte de C++17, într-un apel ca f(std::unique_ptr<A>(new A), g()), compilatorul putea evalua new A, apoi g(), apoi constructorul lui unique_ptr. Dacă g() arunca o excepție, obiectul A rămânea fără proprietar: leak. C++17 a restrâns ordinea de evaluare, astfel încât acest caz concret nu mai produce leak, dar make_unique rămâne forma recomandată.

3. O singură alocare la make_shared. Un shared_ptr are nevoie de un bloc de control (contoarele). Cu std::shared_ptr<T>(new T) se fac două alocări; make_shared le face pe amândouă într-un singur bloc, cu localitate mai bună în cache.

Situații în care nu poți sau nu vrei să le folosești:

  • Deleter custom: make_unique și make_shared nu acceptă deleter; scrii std::unique_ptr<FILE, decltype(&fclose)> f(fopen(...), &fclose);.
  • Constructor privat: funcția make_* nu-l poate apela.
  • weak_ptr care trăiesc mult: cu make_shared, memoria obiectului (nu și destructorul, care rulează la timp) se eliberează abia când dispare și ultimul weak_ptr, pentru că e în același bloc cu contoarele. Pentru obiecte mari, poate conta.
  • Inițializare cu acolade: make_unique<std::vector<int>>(3, 1) folosește paranteze, nu {}.

Ce urmărește intervievatorul: Verifică dacă știi motivele, nu doar regula. Detaliul despre alocarea unică la make_shared și efectul weak_ptr e apreciat.

51 Mid

Ce sunt lvalues și rvalues și ce este o referință rvalue (T&&)?

Răspuns scurt: Un lvalue are identitate și adresă stabilă, de exemplu o variabilă cu nume. Un rvalue e de obicei un temporar care urmează să dispară. O referință rvalue (T&&, C++11) se leagă doar de rvalues și permite preluarea resurselor lor.

O regulă practică: dacă poți lua adresa expresiei cu &, e lvalue; dacă nu, e rvalue.

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

void take(const std::string &) { std::cout << "lvalue sau const\n"; }
void take(std::string &&)      { std::cout << "rvalue\n"; }

std::string make() { return "temp"; }

int main() {
    std::string s = "abc";
    take(s);              // s e lvalue
    take(make());         // rezultatul e un temporar: rvalue
    take(s + "d");        // temporar: rvalue
    take(std::move(s));   // std::move transformă s în xvalue (rvalue)

    std::string &&r = make();
    take(r);              // atenție: r are nume, deci e lvalue
}

Ultimul rând e punctul pe care intervievatorii îl urmăresc: o variabilă de tip std::string&& este ea însăși un lvalue, pentru că are nume. Ca s-o transmiți mai departe ca rvalue, trebuie din nou std::move(r).

Standardul împarte expresiile în lvalue, xvalue (expiring value, de exemplu rezultatul lui std::move) și prvalue (temporare pure, literali); xvalue și prvalue formează împreună categoria rvalue.

De ce contează: înainte de C++11, un temporar se putea lega doar de const T&, deci funcția nu putea ști că obiectul urmează să dispară și trebuia să-l copieze. Cu T&&, poți scrie o supraîncărcare care „fură” resursele temporarului (pointerul intern al unui std::string sau std::vector) în loc să le copieze. Aceasta este baza move semantics. Referința const T& rămâne valabilă pentru ambele categorii și e alegerea implicită când doar citești.

Ce urmărește intervievatorul: Verifică dacă înțelegi fundamentul move semantics. Greșeala tipică: a crede că o variabilă de tip T&& este rvalue.

52 Mid

Ce face un move constructor și ce face de fapt std::move?

Răspuns scurt: Un move constructor construiește un obiect nou preluând resursele unui rvalue (de exemplu pointerul intern), lăsând sursa într-o stare validă, dar nespecificată. std::move nu mută nimic: este un cast la rvalue reference care permite selectarea operațiilor de mutare.

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

class Packet {
    std::vector<unsigned char> bytes_;
public:
    explicit Packet(std::size_t n) : bytes_(n) {}
    Packet(const Packet &o) : bytes_(o.bytes_) { std::cout << "copy\n"; }
    Packet(Packet &&o) noexcept : bytes_(std::move(o.bytes_)) { std::cout << "move\n"; }
    std::size_t size() const { return bytes_.size(); }
};

int main() {
    Packet a(1024);
    Packet b = a;              // copy: 1024 de octeți copiați
    Packet c = std::move(a);   // move: se preia doar bufferul intern, O(1)
    std::cout << a.size() << ' ' << c.size() << '\n';  // tipic 0 1024
}

Mutarea unui std::vector înseamnă copierea a trei pointeri și resetarea lor în sursă, indiferent câte elemente are. Copierea înseamnă o alocare nouă și copierea tuturor elementelor.

Despre std::move: implementarea este practic static_cast<T&&>(x). Nu generează cod. Mutarea reală o face constructorul sau operatorul de atribuire selectat datorită tipului rvalue. Dacă tipul nu are operații de mutare, se apelează copierea, iar std::move nu are niciun efect. La fel, std::move pe un obiect const produce const T&&, care se leagă de copy constructor: obiectul se copiază.

Reguli practice:

  • După mutare, sursa e „validă, dar nespecificată”: o poți distruge sau îi poți atribui o valoare nouă, dar nu te baza pe conținutul ei.
  • Nu scrie return std::move(local);: împiedică eliminarea copiei (NRVO); return local; mută oricum automat dacă nu se aplică NRVO.
  • Marchează move constructorul noexcept, altfel std::vector va copia elementele la realocare.

Ce urmărește intervievatorul: Verifică dacă știi că std::move e doar un cast. Greșeala tipică: std::move pe obiecte const sau la return.

53 Mid

Unde este memory leak-ul în codul următor, cu doi părinți și copii legați prin shared_ptr, și cum îl repari?

Răspuns scurt: Când două obiecte se referă reciproc prin shared_ptr, contorul fiecăruia nu ajunge niciodată la zero, deci niciunul nu se distruge. Soluția este ca una dintre legături, de obicei cea spre „părinte” sau spre „proprietar”, să fie std::weak_ptr.

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

struct Node {
    std::vector<std::shared_ptr<Node>> children;
    std::shared_ptr<Node> parent;        // PROBLEMA: legătură „înapoi” puternică
    ~Node() { std::cout << "~Node\n"; }
};

int main() {
    auto root = std::make_shared<Node>();
    auto child = std::make_shared<Node>();
    root->children.push_back(child);
    child->parent = root;
}   // nu se afișează niciun „~Node”

La ieșirea din main, variabilele root și child dispar, dar root are încă contorul 1 (ținut de child->parent), iar child are contorul 1 (ținut de root->children). Ciclul se ține singur în viață. Nu e nicio eroare și niciun crash; memoria pur și simplu nu se mai eliberează. LeakSanitizer îl raportează.

Repararea: legătura spre părinte nu exprimă proprietate, deci devine weak_ptr.

C++
struct Node {
    std::vector<std::shared_ptr<Node>> children;
    std::weak_ptr<Node> parent;          // nu crește contorul
    void print_parent() const {
        if (auto p = parent.lock()) std::cout << "am părinte\n";
    }
    ~Node() { std::cout << "~Node\n"; }
};

Acum root se distruge (contor 0), își eliberează vectorul children, apoi child ajunge la 0 și se distruge.

Unde mai apar cicluri: observeri care rețin shared_ptr la subiect și invers, callback-uri (lambda-uri) care capturează un shared_ptr la obiectul care le deține, grafuri. Întrebarea de design utilă: cine deține pe cine? De multe ori, un arbore e mai simplu cu unique_ptr pentru copii și un pointer brut ne-proprietar spre părinte, a cărui durată de viață e garantată de structură.

Ce urmărește intervievatorul: Verifică dacă înțelegi limitele numărării de referințe. Mulți candidați cred că shared_ptr elimină orice leak.

54 Mid

Cum funcționează capturile în lambda-uri și ce pericole au [&] și [=]?

Răspuns scurt: O lambda e un obiect funcție; capturile copiază ([=], [x]) sau referă ([&], [&x]) variabile. [&] e periculos când lambda trăiește mai mult decât variabilele (dangling). [=] într-o metodă capturează this, nu membrii, cu același risc.

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

std::function<int()> make_counter_bad() {
    int count = 0;
    return [&count] { return ++count; };    // count dispare la return: dangling
}

std::function<int()> make_counter_ok() {
    int count = 0;
    return [count]() mutable { return ++count; };   // copie proprie, modificabilă
}

struct Sensor {
    int id = 7;
    std::function<void()> callback() {
        return [this] { std::cout << id << '\n'; };   // depinde de durata de viață a lui *this
    }
};

int main() {
    auto c = make_counter_ok();
    c(); std::cout << c() << '\n';   // 2

    auto data = std::make_shared<std::vector<int>>(3, 1);
    auto task = [data] { return data->size(); };     // copiază shared_ptr: datele trăiesc cât task
    std::cout << task() << '\n';
}

Ce se întâmplă intern: compilatorul generează o clasă cu un operator(), iar capturile devin membri. Captura prin valoare face o copie la crearea lambda-ului, nu la apel. Implicit, operator() e const, deci pentru a modifica copiile ai nevoie de mutable.

Pericole:

  • [&] în callback-uri asincrone: o lambda trimisă unui thread, unui timer sau stocată într-un std::function poate rula după ce variabilele locale au dispărut.
  • [=] și this: în C++11–C++17, [=] într-o metodă capturează pointerul this, nu o copie a membrilor. Dacă obiectul e distrus, lambda accesează memorie eliberată. C++20 a depreciat captura implicită a lui this prin [=]; scrie explicit [this] sau [*this] (C++17, copie a obiectului).

Regula practică: [&] doar pentru lambda-uri folosite imediat (algoritmi STL), capturi explicite pentru tot ce iese din scope.

Ce urmărește intervievatorul: Verifică înțelegerea duratei de viață în cod asincron. Greșeala tipică: [&] într-un callback care rulează mai târziu.

55 Mid

Care e diferența dintre const și constexpr? Ce aduc consteval și constinit?

Răspuns scurt: const: valoarea nu se schimbă după inițializare, dar poate fi calculată la runtime. constexpr: calculabil la compilare (variabile) sau evaluabil la compilare (funcții). consteval (C++20) obligă evaluarea la compilare; constinit (C++20) garantează inițializare statică.

C++
#include <array>
#include <cstdio>

int read_config() { return 42; }

constexpr int square(int x) { return x * x; }       // poate rula la compilare sau la runtime
consteval int cube(int x) { return x * x * x; }      // C++20: doar la compilare

const int runtime_value = read_config();             // const, dar calculat la runtime
constexpr int table_size = square(4);                // 16, la compilare
std::array<int, table_size> table{};                 // OK: dimensiune constantă
// std::array<int, runtime_value> bad;               eroare: nu e constantă de compilare

constinit int counter = square(3);                   // C++20: inițializat static, dar modificabil

int main() {
    int n = 5;
    std::printf("%d %d %d\n", square(n), cube(3), counter);   // square(n) rulează la runtime
    counter++;
}

Diferențele esențiale:

  • const e o promisiune de nemodificare. Poate fi inițializat cu orice expresie.
  • constexpr pe variabilă implică const și cere o expresie constantă. Poate fi folosită ca dimensiune de tablou, argument de template, în static_assert.
  • constexpr pe funcție înseamnă „se poate evalua la compilare dacă argumentele sunt constante”. Regulile s-au relaxat treptat: C++11 permitea doar un return, C++14 permite bucle și variabile locale, C++20 permite chiar alocare dinamică temporară și funcții virtuale.
  • consteval creează o „funcție imediată”: fiecare apel trebuie evaluat la compilare.
  • constinit rezolvă static initialization order fiasco pentru variabile globale modificabile.

De ce contează în embedded: tabelele de lookup (CRC, sinus) calculate cu constexpr ajung direct în memoria flash, fără cost la pornire și fără RAM consumat.

Ce urmărește intervievatorul: Verifică dacă distingi constanța de evaluarea la compilare. Greșeala tipică: a crede că o funcție constexpr rulează mereu la compilare.

56 Senior

Ce este perfect forwarding și cum funcționează std::forward cu forwarding references?

Răspuns scurt: Perfect forwarding înseamnă transmiterea argumentelor unei funcții template către altă funcție păstrând categoria lor (lvalue sau rvalue) și const-ul. Se face cu un parametru T&& dedus (forwarding reference) și std::forward<T>(arg), care face cast la rvalue doar dacă argumentul original era rvalue.

Problema: o funcție wrapper (de exemplu o fabrică) primește argumente și le trimite unui constructor. Dacă le primește prin const T&, rvalue-urile se copiază în loc să se mute. Dacă le primește prin T& nu poate primi temporare.

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

struct Widget {
    Widget(const std::string &) { std::cout << "copy\n"; }
    Widget(std::string &&)      { std::cout << "move\n"; }
};

template <typename T, typename... Args>
std::unique_ptr<T> create(Args &&...args) {               // forwarding references
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

int main() {
    std::string name = "w";
    auto a = create<Widget>(name);              // copy: name e lvalue
    auto b = create<Widget>(std::string("t"));  // move: temporar
}

Mecanismul are două piese:

  • Reference collapsing: când T&& apare într-un context de deducție și primește un lvalue de tip std::string, T se deduce ca std::string&, iar std::string& && devine std::string&. Pentru un rvalue, T e std::string, iar parametrul e std::string&&.
  • std::forward<T>(x): dacă T e tip referință lvalue, întoarce lvalue; altfel face cast la rvalue, ca std::move. Informația despre categoria originală e păstrată în T.

Detalii importante:

  • T&& e forwarding reference doar dacă T e dedus chiar în acea funcție. În template<class T> struct Box { void set(T&&); };, set primește o referință rvalue obișnuită. La fel, auto&& e forwarding reference.
  • Nu folosi un argument după ce l-ai transmis cu std::forward, pentru că poate fi fost mutat.
  • Exemple din standard: std::make_unique, emplace_back, std::thread, std::invoke.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismelor de deducție. Diferența dintre referința rvalue și forwarding reference separă un senior de un mid.

57 Senior

Ce garanții de siguranță la excepții cunoști și de ce contează noexcept pentru move constructor în std::vector?

Răspuns scurt: Garanțiile sunt: nothrow (nu aruncă niciodată), strong (la excepție, starea rămâne cea dinainte), basic (la excepție, obiectele rămân valide și nu există leak-uri) și nicio garanție. std::vector folosește move la realocare doar dacă move constructorul e noexcept; altfel copiază, ca să păstreze garanția strong.

Garanțiile, formulate de Dave Abrahams și folosite de biblioteca standard:

  • Nothrow: operația nu aruncă. Destructorii, swap, eliberarea memoriei, mutarea ar trebui să fie așa.
  • Strong: ori reușește complet, ori nu schimbă nimic (comportament de tip tranzacție). Exemplu: std::vector::push_back.
  • Basic: dacă aruncă, nu ai leak-uri și invarianții se păstrează, dar starea poate fi modificată.
  • Fără garanție: după excepție, obiectul poate fi corupt. Nu e acceptabil în cod de calitate.

Legătura cu std::vector: când capacitatea e depășită, vectorul alocă un buffer nou și transferă elementele. Dacă ar muta elementele și mutarea celui de-al cincilea ar arunca, primele patru ar fi deja mutate (golite) în bufferul nou, iar starea inițială nu mai poate fi refăcută. Ca să păstreze garanția strong, vectorul folosește std::move_if_noexcept: mută doar dacă move constructorul e noexcept (sau dacă tipul nu se poate copia).

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

struct A { A() = default; A(const A &) { std::cout << "copy "; } A(A &&) { std::cout << "move "; } };
struct B { B() = default; B(const B &) { std::cout << "copy "; } B(B &&) noexcept { std::cout << "move "; } };

int main() {
    std::vector<A> va(2); va.reserve(10);   // afișează „copy copy ”
    std::cout << '\n';
    std::vector<B> vb(2); vb.reserve(10);   // afișează „move move ”
}

Consecință practică: un move constructor scris manual fără noexcept face ca fiecare realocare să copieze totul, cu un cost mare de performanță și fără niciun avertisment. Operațiile generate implicit (= default) sunt noexcept dacă membrii au operații noexcept. Poți verifica cu static_assert(std::is_nothrow_move_constructible_v<T>);.

Ce urmărește intervievatorul: Verifică dacă știi legătura dintre excepții, noexcept și performanță. Puțini candidați cunosc move_if_noexcept.

58 Senior

Cât costă un std::shared_ptr și este thread-safe?

Răspuns scurt: Un shared_ptr are doi pointeri: obiectul și blocul de control (contoare, deleter). Copierea incrementează atomic contorul. Contorul e thread-safe, dar obiectul indicat nu e protejat, iar aceeași instanță modificată din mai multe thread-uri e data race.

Costul în memorie: sizeof(std::shared_ptr<T>) e tipic de două ori dimensiunea unui pointer. Blocul de control e alocat separat (cu new) sau împreună cu obiectul (cu make_shared).

Costul în timp: fiecare copie face un increment atomic, fiecare distrugere un decrement atomic. Pe un singur core, operațiile atomice sunt ieftine, dar când multe thread-uri copiază același shared_ptr, linia de cache a contorului circulă între core-uri și devine un punct de contenție. De aceea:

  • transmite shared_ptr prin const& sau ca T& când funcția nu preia proprietatea;
  • mută (std::move) în loc să copiezi când predai proprietatea.

Thread safety, în trei afirmații: 1. Contorul de referințe e sigur: thread-uri diferite pot copia și distruge copii diferite ale aceluiași shared_ptr. 2. Obiectul indicat nu e protejat: dacă două thread-uri modifică *p, ai nevoie de mutex. 3. Aceeași instanță shared_ptr citită și scrisă din mai multe thread-uri e un data race. Pentru asta există std::atomic<std::shared_ptr<T>> (C++20) sau funcțiile std::atomic_load/std::atomic_store (depreciate în C++20).

Alte detalii senior:

  • enable_shared_from_this permite unui obiect să obțină un shared_ptr la el însuși (util în callback-uri asincrone, ca în Boost.Asio). Funcționează doar dacă obiectul e deja deținut de un shared_ptr; altfel shared_from_this() aruncă std::bad_weak_ptr (din C++17).
  • Deleter-ul custom e stocat în blocul de control, deci nu face parte din tipul shared_ptr, spre deosebire de unique_ptr.

Concluzie: shared_ptr e o unealtă pentru proprietate partajată reală, nu un înlocuitor general pentru pointeri.

Ce urmărește intervievatorul: Verifică înțelegerea profundă a costurilor și a garanțiilor de concurență. Greșeala tipică: „shared_ptr e thread-safe” fără nuanțe.

STL și templates

59 Junior

Care e diferența dintre std::vector, std::list și std::deque și când alegi fiecare?

Răspuns scurt: vector: elemente contigue, acces aleator O(1), inserare la final amortizat O(1), prietenos cu cache-ul. list: dublu înlănțuită, inserare și ștergere O(1) cu iterator, fără acces aleator. deque: inserare rapidă la ambele capete și acces aleator.

std::vector e alegerea implicită. Elementele sunt într-un singur bloc continuu, deci parcurgerea profită de prefetching-ul procesorului și de cache. Inserarea la final e O(1) amortizat (capacitatea crește geometric); inserarea sau ștergerea la mijloc e O(n), pentru că elementele se deplasează. Realocarea invalidează iteratorii și pointerii.

std::list are noduri alocate separat, fiecare cu doi pointeri. Inserarea și ștergerea sunt O(1) dacă ai deja iteratorul, iar iteratorii celorlalte elemente rămân valizi. Are splice (muți noduri între liste fără copiere). Dezavantaje: fără acces prin index, 16 octeți suplimentari per element pe 64 de biți, o alocare per element și parcurgere lentă (fiecare nod poate fi oriunde în memorie).

std::deque ține elementele în blocuri de dimensiune fixă, plus un index de blocuri. push_front și push_back sunt O(1), accesul prin index e O(1) (cu o indirecție în plus). Inserarea la capete nu mută elementele existente, deci referințele la ele rămân valide (iteratorii însă se invalidează). E containerul implicit sub std::queue și std::stack.

C++
#include <deque>
#include <list>
#include <vector>

int main() {
    std::vector<int> v{1, 2, 3};
    v.push_back(4);            // rapid
    std::deque<int> d{2, 3};
    d.push_front(1);           // rapid; la vector ar fi O(n)
    std::list<int> l{1, 3};
    auto it = std::next(l.begin());
    l.insert(it, 2);           // O(1), iteratorii rămân valizi
}

Nuanța importantă: complexitatea asimptotică nu spune totul. Pentru câteva mii de elemente mici, un vector cu inserări la mijloc bate adesea un list, pentru că deplasarea memoriei contigue e foarte rapidă, iar căutarea poziției în listă e lentă. Alege list doar când chiar ai nevoie de stabilitatea iteratorilor sau de splice, și măsoară.

Ce urmărește intervievatorul: Verifică dacă alegi containere pe baza costurilor reale. Greșeala tipică: list pentru „inserări multe” fără a lua în calcul cache-ul.

60 Junior

Care e diferența dintre std::map și std::unordered_map?

Răspuns scurt: std::map e un arbore echilibrat (de obicei red-black): chei sortate, operații O(log n), cere operator<. std::unordered_map e un hash table: O(1) în medie, O(n) în cel mai rău caz, ordine arbitrară, cere hash și operator==.

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

int main() {
    std::map<std::string, int> ordered{{"zeta", 1}, {"alfa", 2}};
    for (const auto &[k, v] : ordered) std::cout << k << ' ';   // alfa zeta: sortat

    std::unordered_map<std::string, int> hashed{{"zeta", 1}, {"alfa", 2}};
    hashed.reserve(1000);                 // evită rehash-uri repetate
    std::cout << hashed.count("alfa") << '\n';

    auto it = ordered.lower_bound("b");   // prima cheie >= „b”: doar la map
    if (it != ordered.end()) std::cout << it->first << '\n';
}

Când alegi std::map:

  • ai nevoie de chei sortate, de parcurgere în ordine sau de căutări pe interval (lower_bound, upper_bound);
  • ai nevoie de performanță predictibilă (O(log n) garantat), important în sisteme real-time;
  • cheia nu are o funcție hash bună, dar are o relație de ordine.

Când alegi std::unordered_map:

  • faci multe căutări după cheie exactă și nu-ți pasă de ordine;
  • tabela e mare, iar O(1) în medie contează.

Detalii care contează la interviu:

  • operator[] inserează un element construit implicit dacă cheia lipsește. Pentru citire folosește find, count, contains (C++20) sau at (aruncă std::out_of_range).
  • Rehash-ul la unordered_map invalidează iteratorii, dar nu și referințele la elemente. La map, inserarea nu invalidează nimic.
  • Pentru o cheie custom în unordered_map trebuie să specializezi std::hash sau să dai un functor. O funcție hash slabă (toate cheile în același bucket) degradează totul la O(n) și poate fi exploatată ca atac de tip denial of service.
  • Ambele alocă un nod per element. Pentru seturi mici, un std::vector sortat cu std::lower_bound poate fi mai rapid decât ambele.

Ce urmărește intervievatorul: Verifică dacă știi structura de date din spate și consecințele ei. Greșeala tipică: folosirea operator[] pentru verificarea existenței unei chei.

61 Junior

Ce înseamnă invalidarea iteratorilor la std::vector? Ce e greșit în codul care face push_back într-o buclă peste același vector?

Răspuns scurt: Un iterator, pointer sau referință devine invalid când containerul mută sau elimină elementul. La vector, o realocare (push_back peste capacitate) invalidează tot, iar insert/erase invalidează de la poziția modificată până la final. Folosirea lor după aceea e undefined behavior.

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

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

    int &first = v[0];
    v.push_back(4);           // poate realoca: first devine dangling
    // std::cout << first;    UB

    for (auto it = v.begin(); it != v.end(); ++it) {
        if (*it == 2) {
            // v.push_back(20);   UB: it poate fi invalidat
        }
    }

    // Ștergere corectă în timpul parcurgerii: folosești iteratorul întors de erase
    for (auto it = v.begin(); it != v.end();) {
        if (*it % 2 == 0) it = v.erase(it);
        else ++it;
    }
    for (int x : v) std::cout << x << ' ';   // 1 3
}

De ce: un vector ține elementele într-un bloc continuu. Când size() == capacity(), push_back alocă un bloc nou, mută elementele și eliberează blocul vechi. Orice iterator sau pointer către blocul vechi indică acum memorie eliberată. Bucla for (auto x : v) v.push_back(x); are exact această problemă, pentru că range-for folosește iteratori intern.

Regulile pentru vector:

  • realocare (push_back, insert, reserve, resize care depășesc capacitatea): totul se invalidează;
  • insert/erase fără realocare: se invalidează iteratorii de la poziția modificată până la end();
  • pop_back: doar ultimul element și end().

Soluții: parcurge cu index (for (size_t i = 0; i < v.size(); ++i)) dacă adaugi elemente, apelează reserve înainte dacă știi dimensiunea finală, folosește valoarea întoarsă de erase sau, cel mai bine, idiomul erase-remove / std::erase_if (C++20). În debug, -D_GLIBCXX_DEBUG (libstdc++) detectează multe folosiri de iteratori invalizi.

Ce urmărește intervievatorul: Verifică dacă știi una dintre cele mai frecvente surse de UB în C++. Greșeala tipică: referințe la elemente păstrate peste un push_back.

62 Junior

Cum ștergi dintr-un std::vector toate elementele care îndeplinesc o condiție? Explică idiomul erase-remove.

Răspuns scurt: std::remove_if mută elementele care rămân la începutul vectorului și întoarce un iterator la noul sfârșit logic, fără să schimbe dimensiunea. Apoi erase taie coada. Din C++20 poți scrie direct std::erase_if(v, pred). Complexitatea este O(n), față de O(n²) la ștergeri repetate cu erase.

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

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

    // Idiomul clasic (C++98 și mai nou)
    v.erase(std::remove_if(v.begin(), v.end(), [](int x) { return x % 2 == 0; }), v.end());

    // C++20: o singură funcție, întoarce numărul de elemente șterse
    std::vector<int> w{1, 2, 3, 4};
    auto removed = std::erase_if(w, [](int x) { return x > 2; });

    for (int x : v) std::cout << x << ' ';    // 1 3 5
    std::cout << "| " << removed << '\n';     // 2
}

De ce e nevoie de doi pași: algoritmii STL lucrează pe iteratori, nu pe containere, deci remove_if nu poate schimba dimensiunea vectorului. El parcurge o singură dată elementele și le copiază (mută) pe cele păstrate peste pozițiile celor eliminate, menținând ordinea. Ce rămâne după iteratorul întors are valori „valide, dar nespecificate”. Doar erase eliberează efectiv acele poziții.

Comparația de performanță: dacă apelezi v.erase(it) pentru fiecare element de șters, fiecare apel mută toate elementele de după el, deci în cel mai rău caz faci O(n²) mutări. Erase-remove face O(n).

Capcane:

  • std::remove_if(...) fără erase nu micșorează vectorul; e o greșeală des întâlnită.
  • Predicatul nu trebuie să aibă efecte secundare care depind de ordinea apelurilor.
  • Pentru std::list folosește metoda l.remove_if(pred), care reconectează nodurile fără să mute valorile.
  • Pentru containere asociative (std::map, std::set), remove_if nu funcționează, pentru că cheile sunt const; în C++20 există std::erase_if(map, pred), iar înainte se folosea bucla cu it = m.erase(it).

Ce urmărește intervievatorul: Verifică dacă știi cum se combină algoritmii cu containerele. Greșeala tipică: remove_if fără erase.

63 Junior

Care e diferența dintre un tablou C, std::array și std::vector?

Răspuns scurt: Un tablou C are dimensiune fixă și se convertește în pointer, pierzând dimensiunea. std::array are dimensiune fixă la compilare, dar e un container: știe size(), se copiază, se compară. std::vector are dimensiune variabilă și elementele pe heap.

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

int sum_c(const int *a, std::size_t n) { return std::accumulate(a, a + n, 0); }

template <std::size_t N>
int sum_arr(const std::array<int, N> &a) { return std::accumulate(a.begin(), a.end(), 0); }

int main() {
    int c[3] = {1, 2, 3};                 // dimensiunea se pierde la transmitere
    std::array<int, 3> a{1, 2, 3};        // dimensiunea face parte din tip
    std::vector<int> v{1, 2, 3};          // dimensiunea se poate schimba
    v.push_back(4);

    std::array<int, 3> b = a;             // copiere: imposibilă direct la tabloul C
    std::cout << (a == b) << ' ' << sum_c(c, 3) << ' ' << sum_arr(a) << ' ' << v.size() << '\n';
}

Comparația:

  • Tablou C: fără overhead, dar cu array decay, fără copiere directă și fără size().
  • std::array<T, N>: un struct care conține un tablou C. Același layout și aceeași performanță, dar fără decay; oferă size(), iteratori, at() cu verificare, comparații, copiere, structured bindings.
  • std::vector<T>: dimensiune dinamică, elementele pe heap, are o alocare (sau mai multe la creștere). Obiectul în sine are trei pointeri.

Când alegi ce:

  • Dimensiune fixă și mică, cunoscută la compilare (coordonate, buffere de dimensiune fixă, tabele de lookup): std::array. E preferat în embedded, unde alocarea dinamică e adesea interzisă.
  • Dimensiune cunoscută doar la runtime: std::vector.
  • Tablou C: doar la interfața cu cod C.

Atenție: un std::array mare ca variabilă locală consumă stivă, la fel ca un tablou C. Iar pentru a transmite oricare dintre ele unei funcții fără template, std::span (C++20) acceptă tablouri C, std::array și std::vector.

Ce urmărește intervievatorul: Verifică familiaritatea cu C++ modern în locul tablourilor C. Greșeala tipică: a crede că std::array alocă pe heap.

64 Junior

Ce este un template de funcție și de ce codul template-urilor stă de obicei în header?

Răspuns scurt: Un template este un șablon din care compilatorul generează cod separat pentru fiecare tip folosit (instanțiere). Pentru că instanțierea se face în fiecare unitate de traducere care folosește template-ul, compilatorul are nevoie de definiția completă acolo, deci definiția stă în header.

C++
// max_of.h
#pragma once
#include <vector>

template <typename T>
const T &max_of(const std::vector<T> &v) {      // presupune că v nu e gol
    const T *best = &v[0];
    for (const T &x : v)
        if (*best < x) best = &x;
    return *best;
}
C++
// main.cpp
#include <iostream>
#include <string>
#include "max_of.h"

int main() {
    std::vector<int> a{3, 9, 2};
    std::vector<std::string> b{"ana", "zoe", "ion"};
    std::cout << max_of(a) << ' ' << max_of(b) << '\n';   // 9 zoe
}

Compilatorul deduce T din argument și generează două funcții distincte: max_of<int> și max_of<std::string>. Codul generat e la fel de eficient ca o funcție scrisă de mână pentru fiecare tip, fără void* și fără apeluri virtuale.

De ce în header: fiecare .cpp se compilează separat. Dacă în max_of.cpp ai doar definiția template-ului și nu folosești niciun tip concret, compilatorul nu generează nimic. Când main.cpp vede doar declarația, presupune că instanțierea există în altă parte, iar linkerul raportează „undefined reference to max_of<int>”.

Soluții posibile:

  • Definiția în header (cea mai comună).
  • Instanțiere explicită: în .cpp scrii template const int &max_of<int>(const std::vector<int>&); pentru tipurile suportate. Reduce timpul de compilare, dar limitează tipurile.
  • În C++20, modulele schimbă parțial acest model.

Costurile template-urilor: timp de compilare mai mare, cod binar mai mare (fiecare instanțiere e cod separat, numit code bloat) și mesaje de eroare lungi. Conceptele din C++20 fac erorile mult mai clare, pentru că cerințele asupra lui T (aici, operator<) sunt scrise explicit.

Ce urmărește intervievatorul: Verifică înțelegerea instanțierii și a modelului de compilare. Greșeala tipică: definirea template-ului într-un .cpp separat.

65 Junior

Care e diferența dintre reserve și resize la std::vector și ce înseamnă capacity?

Răspuns scurt: size() e numărul de elemente existente, capacity() e câte încap fără realocare. reserve(n) mărește doar capacitatea, fără să creeze elemente. resize(n) schimbă numărul de elemente, construind sau distrugând elemente. Accesul v[i] e valid doar pentru i < size().

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

int main() {
    std::vector<int> a;
    a.reserve(100);                           // capacity >= 100, size == 0
    std::cout << a.size() << ' ' << a.capacity() << '\n';   // 0 100
    // a[5] = 1;                              UB: elementul nu există
    for (int i = 0; i < 100; ++i) a.push_back(i);           // fără realocări

    std::vector<int> b;
    b.resize(100);                            // 100 de elemente cu valoarea 0
    b[5] = 1;                                 // OK
    b.resize(10);                             // păstrează primele 10, capacitatea rămâne

    b.shrink_to_fit();                        // cerere (neobligatorie) de a reduce capacitatea
    std::cout << b.size() << '\n';            // 10
}

De ce există capacitatea: dacă vectorul ar realoca la fiecare push_back, inserarea a n elemente ar costa O(n²). Implementările cresc capacitatea geometric (libstdc++ o dublează, MSVC o crește cu 1,5), astfel încât costul amortizat al unui push_back e O(1).

Când folosești reserve: știi dinainte câte elemente vei adăuga (de exemplu, citești n valori). Eviți realocările repetate, copierile și invalidarea iteratorilor în timpul umplerii.

Când folosești resize: vrei să ai efectiv n elemente, de exemplu pentru a scrie prin index sau pentru a da bufferul unei funcții C (read(fd, buf.data(), buf.size())).

Capcane:

  • reserve urmat de scriere prin index (a[i] = x) e UB, chiar dacă memoria există; e o greșeală frecventă.
  • resize urmat de push_back adaugă după cele n elemente deja create, deci vectorul ajunge la 2n.
  • clear() distruge elementele, dar nu reduce capacitatea. Pentru a elibera memoria: shrink_to_fit() sau std::vector<int>().swap(v).

Ce urmărește intervievatorul: Verifică înțelegerea modelului de memorie al vectorului. Greșeala tipică: scrierea prin index după reserve.

66 Mid

Scrie o funcție care primește un text și afișează cele mai frecvente 3 cuvinte, folosind STL.

Răspuns scurt: Numeri aparițiile într-un std::unordered_map<std::string, int>, copiezi perechile într-un vector și folosești std::partial_sort (sau sort) după frecvență descrescătoare, cu un criteriu secundar alfabetic pentru egalități. Complexitatea e O(n + m log k), unde m e numărul de cuvinte distincte.

C++
#include <algorithm>
#include <cctype>
#include <iostream>
#include <sstream>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>

std::vector<std::pair<std::string, int>> top_words(const std::string &text, std::size_t k) {
    std::unordered_map<std::string, int> freq;
    std::istringstream in(text);
    std::string word;
    while (in >> word) {
        std::string clean;
        for (unsigned char ch : word)
            if (std::isalpha(ch)) clean += static_cast<char>(std::tolower(ch));
        if (!clean.empty()) ++freq[clean];
    }

    std::vector<std::pair<std::string, int>> items(freq.begin(), freq.end());
    k = std::min(k, items.size());
    std::partial_sort(items.begin(), items.begin() + k, items.end(),
                      [](const auto &a, const auto &b) {
                          if (a.second != b.second) return a.second > b.second;
                          return a.first < b.first;      // ordine stabilă la egalitate
                      });
    items.resize(k);
    return items;
}

int main() {
    for (const auto &[w, c] : top_words("The cat and the dog. The cat ran!", 3))
        std::cout << w << ' ' << c << '\n';   // the 3, cat 2, and 1
}

Puncte urmărite de intervievator:

  • Clarificarea cerințelor înainte de cod: contează majusculele? punctuația? ce faci la egalitate?
  • unsigned char la std::isalpha: transmiterea unui char negativ (caractere non-ASCII) e UB.
  • partial_sort sortează doar primele k elemente: O(m log k) în loc de O(m log m). Pentru k foarte mic față de m, alternativa e un min-heap (std::priority_queue) de dimensiune k.
  • Diacriticele românești în UTF-8 au mai mulți octeți, deci isalpha pe octeți nu le tratează corect; e bine să spui că ai nevoie de o bibliotecă Unicode (ICU) pentru text real.

Ce urmărește intervievatorul: Verifică fluența cu STL și obiceiul de a clarifica cerințele. Mulți candidați uită cazul cu mai puțin de k cuvinte sau departajarea la egalitate.

67 Mid

Ce este specializarea unui template (completă și parțială)? Dă un exemplu.

Răspuns scurt: Specializarea completă furnizează o implementare separată pentru un set exact de argumente (de exemplu, Serializer<bool>). Specializarea parțială, permisă doar la template-uri de clasă și de variabilă, tratează o familie de tipuri (de exemplu, toate tipurile pointer T*).

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

template <typename T>
struct TypeName { static std::string get() { return "necunoscut"; } };

template <>                                  // specializare completă
struct TypeName<int> { static std::string get() { return "int"; } };

template <typename T>                        // specializare parțială: orice pointer
struct TypeName<T *> { static std::string get() { return "pointer la " + TypeName<T>::get(); } };

template <typename T>                        // specializare parțială: orice vector
struct TypeName<std::vector<T>> { static std::string get() { return "vector de " + TypeName<T>::get(); } };

int main() {
    std::cout << TypeName<double>::get() << '\n';               // necunoscut
    std::cout << TypeName<int **>::get() << '\n';               // pointer la pointer la int
    std::cout << TypeName<std::vector<int *>>::get() << '\n';   // vector de pointer la int
}

Compilatorul alege cea mai specializată variantă care se potrivește. Așa funcționează multe trăsături din <type_traits> (std::is_pointer<T>, std::remove_reference<T>) și std::hash<T>, pe care o specializezi pentru tipurile tale ca să le folosești în unordered_map.

Reguli importante:

  • Template-urile de funcție nu suportă specializare parțială. Pentru funcții folosești supraîncărcare (template<class T> void f(T*)), care interacționează mai previzibil cu rezoluția supraîncărcării decât specializarea completă a unei funcții.
  • Specializarea trebuie declarată înainte de prima folosire care ar instanția template-ul general; altfel programul e invalid.
  • În biblioteca standard există o specializare celebră și controversată: std::vector<bool>, care stochează biți împachetați și întoarce un obiect proxy în loc de bool&.

Alternativa modernă pentru multe cazuri e if constexpr (C++17), care ramifică la compilare în același corp de funcție, fără clase separate.

Ce urmărește intervievatorul: Verifică înțelegerea metaprogramării de bază. Greșeala tipică: încercarea de specializare parțială a unei funcții.

68 Mid

Ce este std::string_view, când îl folosești și care e pericolul lui?

Răspuns scurt: std::string_view (C++17) este o vedere ne-proprietară asupra unui șir: un pointer și o lungime. Permite funcțiilor să primească std::string, literali sau bucăți de șir fără copiere. Pericolul: nu ține în viață datele, deci poate rămâne dangling dacă șirul original dispare.

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

bool starts_with_id(std::string_view s) {          // acceptă orice fel de șir, fără copie
    return s.substr(0, 3) == "ID-";                // substr pe view: O(1), fără alocare
}

std::string_view bad() {
    std::string local = "temporar";
    return local;                                  // dangling: local dispare
}

int main() {
    std::string s = "ID-42";
    std::cout << starts_with_id(s) << starts_with_id("ID-7") << '\n';   // 11

    std::string_view v = std::string("abc") + "d";  // dangling imediat: temporarul dispare
    (void)v;
}

Avantaje:

  • Un parametru const std::string& primit dintr-un literal creează un std::string temporar (posibil cu alocare). std::string_view nu alocă.
  • substr, remove_prefix, remove_suffix sunt O(1), utile la parsare (protocoale, fișiere de configurare, linii de log).
  • Funcționează și cu char*, buffere C și fragmente din alte șiruri.

Pericole și reguli:

  • Durata de viață: e ca un pointer. Nu întoarce string_view către date locale și nu-l stoca într-un membru de clasă dacă nu controlezi durata de viață a șirului.
  • Nu e garantat terminat cu '\0': printf("%s", v.data()) sau fopen(v.data(), ...) pot citi dincolo de final. Pentru API-uri C, construiește un std::string.
  • Modificarea sau realocarea șirului original (de exemplu s += "...") invalidează view-ul.

Regula practică: std::string_view pentru parametri de funcție care doar citesc; std::string pentru valori întoarse și pentru membri. Aceeași idee, generalizată pentru tablouri, este std::span (C++20).

Ce urmărește intervievatorul: Verifică dacă înțelegi tipurile ne-proprietare. Greșeala tipică: string_view întors dintr-o funcție sau construit dintr-un temporar.

69 Mid

Care e diferența dintre push_back și emplace_back?

Răspuns scurt: push_back primește un obiect deja construit și îl copiază sau îl mută în container. emplace_back primește argumentele constructorului și construiește obiectul direct în memoria vectorului, evitând un temporar. Diferența contează la tipuri scumpe de mutat sau imposibil de mutat.

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

struct Order {
    std::string product;
    int qty;
    Order(std::string p, int q) : product(std::move(p)), qty(q) { std::cout << "ctor "; }
    Order(const Order &o) : product(o.product), qty(o.qty) { std::cout << "copy "; }
    Order(Order &&o) noexcept : product(std::move(o.product)), qty(o.qty) { std::cout << "move "; }
};

int main() {
    std::vector<Order> v;
    v.reserve(4);
    v.push_back(Order("laptop", 1));   // ctor move
    v.emplace_back("mouse", 2);        // ctor
    Order o("kbd", 1);
    v.push_back(o);                    // ctor copy
    v.emplace_back(std::move(o));      // move
    std::cout << '\n';
}

emplace_back folosește perfect forwarding: transmite argumentele către constructorul lui Order, care rulează direct în locul din vector. push_back cu un temporar construiește întâi temporarul, apoi îl mută. Pentru tipuri cu mutare ieftină (std::string, std::vector), diferența e mică; pentru tipuri fără mutare sau cu mutare scumpă, e semnificativă. Din C++17, emplace_back întoarce și o referință la elementul creat.

Capcane, pentru care multe ghiduri recomandă push_back ca implicit:

  • emplace_back poate apela constructori explicit. std::vector<std::unique_ptr<int>> v; v.emplace_back(new int(5)); compilează, dar dacă realocarea aruncă excepție, pointerul brut se pierde (leak). push_back(std::make_unique<int>(5)) e sigur.
  • std::vector<std::vector<int>> m; m.emplace_back(1000000); creează un vector cu un milion de elemente, nu un vector cu valoarea 1000000; cu push_back codul nu ar compila.

Regula practică: push_back când ai deja obiectul; emplace_back când construiești pe loc din argumente și știi ce constructor se apelează.

Ce urmărește intervievatorul: Verifică înțelegerea construcției pe loc și a forwarding-ului. Răspunsul bun menționează și capcanele, nu doar „emplace e mai rapid”.

70 Senior

Ce este SFINAE și cum îl înlocuiesc concepts din C++20?

Răspuns scurt: SFINAE (Substitution Failure Is Not An Error): dacă substituirea argumentelor într-un template eșuează, template-ul e eliminat din candidați fără eroare; se folosea cu std::enable_if. Concepts (C++20) exprimă direct cerințele, cu erori lizibile.

Problema: vrei o funcție template care acceptă doar tipuri numerice întregi.

Cu SFINAE (C++11/14/17):

C++
#include <type_traits>

template <typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
T gcd_old(T a, T b) { while (b) { T t = a % b; a = b; b = t; } return a; }

Dacă T e double, std::enable_if_t<false> nu are tip, substituirea eșuează, iar funcția dispare din rezoluție. Apelul dă „no matching function”, adesea cu zeci de rânduri de explicații.

Cu concepts (C++20):

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

template <std::integral T>
T gcd(T a, T b) { while (b) { T t = a % b; a = b; b = t; } return a; }

template <typename T>
concept Serializable = requires(const T &t, std::ostream &os) {
    { t.serialize(os) } -> std::same_as<void>;
};

struct Msg { void serialize(std::ostream &os) const { os << "msg\n"; } };

void send(const Serializable auto &m) { m.serialize(std::cout); }

int main() {
    std::cout << gcd(12, 18) << '\n';   // 6
    send(Msg{});
    // gcd(1.5, 2.0);   eroare clară: double nu satisface std::integral
}

Ce aduc conceptele:

  • Cerințele fac parte din interfață și se citesc ușor.
  • Mesajele de eroare spun ce cerință nu e îndeplinită.
  • Supraîncărcarea după concepte: o variantă pentru std::random_access_iterator, alta pentru restul; compilatorul o alege pe cea mai restrictivă.
  • requires expressions permit verificarea existenței metodelor, a operatorilor și a tipurilor asociate.

SFINAE rămâne important de recunoscut, pentru că apare în biblioteci scrise înainte de C++20 și în proiecte care nu au trecut la C++20.

Ce urmărește intervievatorul: Verifică experiența cu cod generic și cu evoluția limbajului. Un senior știe să citească SFINAE, dar preferă concepts când standardul o permite.

71 Senior

Ce este CRTP și cum oferă polimorfism static?

Răspuns scurt: CRTP (Curiously Recurring Template Pattern) înseamnă că o clasă derivată se transmite ca argument de template clasei de bază: class Derived : Base<Derived>. Baza poate apela metode ale derivatei prin static_cast la compilare, fără funcții virtuale, deci fără vtable și cu posibilitate de inline.

C++
#include <iostream>

template <typename Derived>
class Filter {
public:
    double process(double x) {
        // apel rezolvat la compilare, poate fi integrat inline
        return static_cast<Derived *>(this)->apply(x);
    }
};

class LowPass : public Filter<LowPass> {
    double prev_ = 0;
public:
    double apply(double x) { prev_ = 0.9 * prev_ + 0.1 * x; return prev_; }
};

class Gain : public Filter<Gain> {
public:
    double apply(double x) { return 2 * x; }
};

template <typename F>
double run(Filter<F> &f, double x) { return f.process(x); }

int main() {
    LowPass lp;
    Gain g;
    std::cout << run(lp, 10.0) << ' ' << run(g, 10.0) << '\n';   // 1 20
}

Ce câștigi: baza definește algoritmul comun, iar derivatele furnizează pașii specifici, ca la funcțiile virtuale, dar fără vptr în fiecare obiect și fără apel indirect. În bucle de procesare de semnal, filtre sau sisteme de jocuri, compilatorul poate integra și vectoriza codul.

Ce pierzi:

  • Nu mai ai o bază comună reală: Filter<LowPass> și Filter<Gain> sunt tipuri diferite, deci nu le poți pune în același std::vector. Pentru asta ai nevoie de polimorfism dinamic, de std::variant cu std::visit sau de type erasure.
  • Codul e mai greu de citit, iar erorile de compilare sunt mai lungi.
  • O greșeală de tipul class Gain : public Filter<LowPass> compilează și produce UB la static_cast. Protecția clasică: constructorul bazei e privat, iar Derived e declarat friend.

Utilizări cunoscute: mixin-uri, std::enable_shared_from_this<T>. C++23 aduce „deducing this” (this auto &self), care face multe utilizări CRTP mai simple.

Ce urmărește intervievatorul: Verifică dacă știi alternativele la funcțiile virtuale și compromisurile lor. Răspunsul bun spune clar când CRTP nu e potrivit.

Concurență și multithreading

72 Junior

Care e diferența dintre un proces și un thread?

Răspuns scurt: Un proces are propriul spațiu de adrese, propriile resurse (fișiere deschise, memorie) și e izolat de alte procese. Un thread rulează în interiorul unui proces și împarte memoria și resursele cu celelalte thread-uri ale procesului, având doar stivă și registre proprii.

Procesul e o instanță a unui program în execuție. Sistemul de operare îi dă un spațiu de adrese virtual separat, deci un proces nu poate citi direct memoria altuia. Comunicarea se face prin mecanisme IPC: pipe-uri, socket-uri, memorie partajată, cozi de mesaje. Pe Linux, un proces nou se creează cu fork() (eventual urmat de exec).

Thread-ul e o unitate de execuție într-un proces. Toate thread-urile unui proces văd aceleași variabile globale, același heap și aceleași fișiere deschise. Fiecare are propria stivă, propriul set de registre și propriul thread_local.

C++
#include <iostream>
#include <thread>
#include <vector>

int main() {
    std::vector<int> results(4);
    std::vector<std::thread> workers;
    for (int i = 0; i < 4; ++i)
        workers.emplace_back([&results, i] { results[i] = i * i; });  // fiecare scrie în alt element
    for (auto &t : workers) t.join();
    for (int r : results) std::cout << r << ' ';   // 0 1 4 9
}

Compilezi cu g++ -std=c++17 -pthread main.cpp.

Compromisuri:

  • Izolare: un crash într-un thread (segfault) oprește tot procesul; un proces care crapă nu le afectează pe celelalte. De aceea browserele moderne folosesc procese separate pentru tab-uri.
  • Cost: crearea și comutarea între thread-uri sunt mai ieftine decât între procese, iar comunicarea prin memorie comună e foarte rapidă.
  • Complexitate: memoria comună aduce race conditions, deci ai nevoie de sincronizare (mutex-uri, atomics).

Pe Linux, ambele sunt „task-uri” pentru scheduler; diferența e ce resurse partajează (apelul clone cu diferite flag-uri). Comenzi utile: ps -eLf sau top -H arată thread-urile, iar htop le afișează pe fiecare.

Ce urmărește intervievatorul: Verifică înțelegerea modelului de execuție. Răspunsul bun menționează compromisul dintre izolare și cost.

73 Junior

Ce este un race condition și cum îl previi cu std::mutex și std::lock_guard?

Răspuns scurt: Un race condition apare când rezultatul depinde de ordinea în care thread-urile accesează date comune. Un data race (două accese neprotejate, cel puțin unul scriere) este undefined behavior în C++. Previi protejând secțiunea critică cu un std::mutex, blocat prin RAII cu std::lock_guard.

C++
#include <iostream>
#include <mutex>
#include <thread>

int counter = 0;
std::mutex m;

void unsafe() { for (int i = 0; i < 100000; ++i) ++counter; }   // data race

void safe() {
    for (int i = 0; i < 100000; ++i) {
        std::lock_guard<std::mutex> lock(m);   // blocat aici, deblocat la ieșirea din bloc
        ++counter;
    }
}

int main() {
    std::thread a(safe), b(safe);
    a.join();
    b.join();
    std::cout << counter << '\n';   // 200000 garantat; cu unsafe() ar fi adesea mai puțin
}

De ce pierde unsafe() incrementări: ++counter înseamnă trei pași (citește, adună, scrie). Dacă două thread-uri citesc simultan valoarea 5, ambele scriu 6 și o incrementare se pierde. Formal, e un data race, deci UB: compilatorul poate chiar păstra valoarea într-un registru pe toată durata buclei.

Despre unelte:

  • std::lock_guard e RAII pentru mutex: deblocarea e garantată și la excepții sau la return. Nu apela niciodată m.lock()/m.unlock() manual în cod obișnuit.
  • std::unique_lock e mai flexibil (deblocare temporară, transfer, folosit cu condition_variable), cu un mic cost în plus.
  • std::scoped_lock (C++17) blochează mai multe mutex-uri simultan fără deadlock.
  • Pentru un simplu contor, std::atomic<int> e mai eficient.

Bune practici: secțiunea critică cât mai scurtă (nu face I/O sau apeluri lente cu mutex-ul blocat), mutex-ul lângă datele pe care le protejează (de preferat ca membru privat al aceleiași clase) și ThreadSanitizer (-fsanitize=thread) în teste, pentru detectarea data race-urilor.

Ce urmărește intervievatorul: Verifică înțelegerea fundamentelor de sincronizare. Greșeala tipică: lock/unlock manual sau credința că ++ pe int e atomic.

74 Junior

Ce este un deadlock și cum îl previi?

Răspuns scurt: Un deadlock apare când două sau mai multe thread-uri așteaptă fiecare o resursă ținută de celălalt, deci niciunul nu avansează. Previi prin blocarea mutex-urilor mereu în aceeași ordine, prin std::scoped_lock pentru mai multe mutex-uri deodată și prin evitarea apelurilor externe cu un mutex blocat.

Exemplul clasic: transferul între două conturi.

C++
#include <mutex>
#include <thread>

struct Account { std::mutex m; double balance = 100; };

void transfer_bad(Account &from, Account &to, double amount) {
    std::lock_guard<std::mutex> a(from.m);
    std::lock_guard<std::mutex> b(to.m);     // T1: A apoi B; T2: B apoi A, deci deadlock
    from.balance -= amount;
    to.balance += amount;
}

void transfer_ok(Account &from, Account &to, double amount) {
    std::scoped_lock lock(from.m, to.m);     // C++17: le blochează pe amândouă fără deadlock
    from.balance -= amount;
    to.balance += amount;
}

int main() {
    Account x, y;
    std::thread t1(transfer_ok, std::ref(x), std::ref(y), 10.0);
    std::thread t2(transfer_ok, std::ref(y), std::ref(x), 5.0);
    t1.join();
    t2.join();
}

Cele patru condiții (Coffman) care trebuie îndeplinite simultan: excludere mutuală, „hold and wait” (ții o resursă și aștepți alta), fără preempțiune și așteptare circulară. Eliminarea oricăreia previne deadlock-ul.

Tehnici practice:

  • Ordine globală a blocărilor: de exemplu, mereu după ID-ul contului sau după adresă.
  • std::scoped_lock / std::lock: folosesc un algoritm care evită deadlock-ul la blocarea mai multor mutex-uri.
  • Nu apela cod necunoscut (callback-uri, funcții virtuale ale utilizatorului) cu un mutex blocat; acel cod poate încerca să blocheze același mutex sau altul.
  • Blocare cu timeout (std::timed_mutex::try_lock_for) pentru detectare și recuperare.
  • Un std::mutex blocat de două ori de același thread e tot deadlock (de fapt UB); std::recursive_mutex există, dar indică de obicei un design care trebuie revizuit.

Depanare: atașezi gdb la proces și rulezi thread apply all bt, ca să vezi ce mutex așteaptă fiecare thread. ThreadSanitizer raportează și inversiuni de ordine a blocărilor.

Ce urmărește intervievatorul: Verifică dacă poți recunoaște și preveni un bug de concurență clasic. Greșeala tipică: soluții bazate pe sleep sau pe noroc.

75 Mid

Cum funcționează std::condition_variable? Implementează o coadă producer-consumer.

Răspuns scurt: O condition_variable permite unui thread să aștepte eficient (fără busy-waiting) până când o condiție devine adevărată. Thread-ul ține un unique_lock pe mutex, apelează wait cu un predicat, iar producătorul modifică starea sub același mutex și apelează notify_one sau notify_all.

C++
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <optional>
#include <queue>
#include <thread>

template <typename T>
class BlockingQueue {
    std::queue<T> q_;
    std::mutex m_;
    std::condition_variable cv_;
    bool closed_ = false;
public:
    void push(T v) {
        { std::lock_guard<std::mutex> lk(m_); q_.push(std::move(v)); }
        cv_.notify_one();
    }
    void close() {
        { std::lock_guard<std::mutex> lk(m_); closed_ = true; }
        cv_.notify_all();
    }
    std::optional<T> pop() {
        std::unique_lock<std::mutex> lk(m_);
        cv_.wait(lk, [this] { return !q_.empty() || closed_; });   // tratează spurious wakeups
        if (q_.empty()) return std::nullopt;                        // închisă și goală
        T v = std::move(q_.front());
        q_.pop();
        return v;
    }
};

int main() {
    BlockingQueue<int> q;
    std::thread consumer([&q] { while (auto v = q.pop()) std::cout << *v << ' '; });
    for (int i = 0; i < 5; ++i) q.push(i);
    q.close();
    consumer.join();   // 0 1 2 3 4
}

Ce face wait(lk, pred): verifică predicatul; dacă e fals, deblochează atomic mutex-ul și adoarme. La trezire reblochează mutex-ul și verifică din nou. Echivalent cu while (!pred()) cv.wait(lk);.

De ce predicatul e obligatoriu:

  • Spurious wakeups: standardul permite treziri fără notificare.
  • Lost wakeup: dacă producătorul notifică înainte ca consumatorul să aștepte, fără o stare verificată notificarea se pierde și consumatorul doarme pentru totdeauna.

Detalii: starea partajată se modifică întotdeauna sub mutex, chiar dacă e un bool. Notificarea după eliberarea mutex-ului (ca mai sus) evită ca thread-ul trezit să se blocheze imediat. Mecanismul close() rezolvă oprirea curată a consumatorilor, o cerință pe care candidații o uită des.

Ce urmărește intervievatorul: Verifică dacă poți scrie cod concurent corect, nu doar folosi primitivele. Greșeala tipică: wait fără predicat și lipsa unui mecanism de oprire.

76 Mid

Când folosești std::atomic în loc de un mutex?

Răspuns scurt: std::atomic face operații indivizibile pe o singură variabilă (contoare, flag-uri, pointeri) fără blocare, de obicei cu o singură instrucțiune hardware. Mutex-ul e necesar când trebuie să modifici consistent mai multe variabile sau o structură întreagă.

C++
#include <atomic>
#include <iostream>
#include <thread>
#include <vector>

std::atomic<int> hits{0};
std::atomic<bool> stop{false};

int main() {
    std::vector<std::thread> ts;
    for (int i = 0; i < 4; ++i)
        ts.emplace_back([] { for (int k = 0; k < 1000; ++k) hits.fetch_add(1); });
    for (auto &t : ts) t.join();
    stop.store(true);
    std::cout << hits.load() << '\n';   // 4000
}

fetch_add, exchange și compare_exchange_weak/strong sunt operații read-modify-write atomice. compare_exchange e baza algoritmilor lock-free: „scrie valoarea nouă doar dacă valoarea curentă e cea pe care o aștept”.

Când atomic e potrivit:

  • contoare de statistică, flag-uri de oprire, generatoare de ID-uri;
  • publicarea unui pointer către date deja construite (cu ordinea de memorie potrivită).

Când ai nevoie de mutex:

  • invariantul implică mai multe variabile (de exemplu, head și size ale unei cozi). Două atomice separate nu fac operația combinată atomică;
  • operații pe containere STL, care nu sunt thread-safe;
  • secțiuni critice cu logică complexă.

Capcane:

  • std::atomic<T> pentru tipuri mari poate folosi intern un lock; verifică cu is_lock_free() sau is_always_lock_free (C++17).
  • x = x + 1 pe un atomic face o citire și o scriere atomice separate, deci nu e atomic ca întreg; folosește ++x sau fetch_add.
  • Algoritmii lock-free scriși de mână sunt foarte greu de făcut corect (problema ABA, eliberarea memoriei). În practică se folosesc biblioteci testate.

volatile nu e o alternativă la std::atomic: nu garantează nici atomicitate, nici ordine între thread-uri.

Ce urmărește intervievatorul: Verifică dacă alegi primitiva potrivită. Greșeala tipică: mai multe atomice crezând că protejează un invariant comun.

77 Mid

Care e diferența dintre join și detach la std::thread și ce oferă std::async și std::future?

Răspuns scurt: join așteaptă terminarea thread-ului; detach îl lasă să ruleze independent, fără a mai putea fi așteptat. Un std::thread distrus fără join sau detach apelează std::terminate. std::async rulează o funcție și întoarce un std::future, prin care obții rezultatul sau excepția.

C++
#include <future>
#include <iostream>
#include <numeric>
#include <stdexcept>
#include <thread>
#include <vector>

long sum_range(const std::vector<int> &v, std::size_t b, std::size_t e) {
    return std::accumulate(v.begin() + b, v.begin() + e, 0L);
}

int main() {
    std::vector<int> data(1000, 1);

    std::thread t([] { std::cout << "lucrez\n"; });
    t.join();                              // fără join: std::terminate la distrugere

    auto left = std::async(std::launch::async, sum_range, std::cref(data), 0, 500);
    long right = sum_range(data, 500, 1000);
    std::cout << left.get() + right << '\n';   // 1000

    auto failing = std::async(std::launch::async, [] { throw std::runtime_error("eroare"); return 0; });
    try { failing.get(); } catch (const std::exception &e) { std::cout << e.what() << '\n'; }
}

Despre detach: thread-ul continuă după ce obiectul std::thread dispare. Dacă folosește variabile locale ale funcției care l-a creat, ajunge să acceseze memorie eliberată. La ieșirea din main, thread-urile detașate sunt oprite brusc, fără destructori. Se folosește rar.

std::jthread (C++20) face automat join în destructor și suportă oprire cooperativă prin std::stop_token, deci e alegerea mai sigură.

Despre std::async și std::future:

  • get() blochează până la rezultat și rearuncă excepția din thread. Poate fi apelat o singură dată; pentru mai mulți consumatori există std::shared_future.
  • Fără std::launch::async, implementarea poate amâna execuția până la get() (lansare deferred).
  • Destructorul unui future întors de std::async blochează până la terminarea task-ului. std::async(...) fără să păstrezi rezultatul rulează, deci, sincron.
  • std::promise permite setarea manuală a valorii unui future, de exemplu dintr-un callback.

Ce urmărește intervievatorul: Verifică dacă gestionezi corect durata de viață a thread-urilor. Greșeala tipică: detach folosit ca „rezolvare” pentru std::terminate.

78 Mid

Ce este un thread pool și de ce nu creezi un thread nou pentru fiecare cerere?

Răspuns scurt: Un thread pool e un set fix de thread-uri care preiau task-uri dintr-o coadă comună. Crearea unui thread costă (apel de sistem, stivă), iar prea multe thread-uri produc comutări de context și contenție. Pool-ul limitează concurența la numărul de core-uri.

Costurile unui thread nou per cerere:

  • crearea și distrugerea implică apeluri de sistem și alocarea unei stive (pe Linux, implicit câțiva MB de memorie virtuală);
  • la sute sau mii de thread-uri, scheduler-ul petrece mult timp comutând între ele, iar cache-ul procesorului se golește des;
  • nu ai control asupra încărcării: un vârf de trafic creează un vârf de thread-uri și poate epuiza memoria.

Un pool simplu:

C++
#include <condition_variable>
#include <functional>
#include <mutex>
#include <queue>
#include <thread>
#include <vector>

class ThreadPool {
    std::vector<std::thread> workers_;
    std::queue<std::function<void()>> tasks_;
    std::mutex m_;
    std::condition_variable cv_;
    bool stop_ = false;
public:
    explicit ThreadPool(unsigned n) {
        for (unsigned i = 0; i < n; ++i)
            workers_.emplace_back([this] {
                for (;;) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lk(m_);
                        cv_.wait(lk, [this] { return stop_ || !tasks_.empty(); });
                        if (stop_ && tasks_.empty()) return;
                        task = std::move(tasks_.front());
                        tasks_.pop();
                    }
                    task();                     // rulează fără mutex blocat
                }
            });
    }
    void submit(std::function<void()> f) {
        { std::lock_guard<std::mutex> lk(m_); tasks_.push(std::move(f)); }
        cv_.notify_one();
    }
    ~ThreadPool() {
        { std::lock_guard<std::mutex> lk(m_); stop_ = true; }
        cv_.notify_all();
        for (auto &w : workers_) w.join();
    }
};

Dimensionare: pentru task-uri de calcul, aproximativ std::thread::hardware_concurrency(); pentru task-uri care așteaptă I/O, mai multe sau un model asincron. Detalii de producție: coadă limitată (backpressure), propagarea excepțiilor prin std::packaged_task/std::future și oprire controlată. În practică se folosesc biblioteci existente (Boost.Asio thread_pool, Intel TBB).

Ce urmărește intervievatorul: Verifică înțelegerea costurilor concurenței și a designului. Răspunsul bun include oprirea curată și execuția task-ului fără mutex blocat.

79 Senior

Ce înseamnă memory ordering în C++ (memory_order_relaxed, acquire, release, seq_cst)?

Răspuns scurt: Compilatorul și procesorul pot reordona citiri și scrieri. Ordinea de memorie a unei operații atomice spune ce reordonări sunt permise. seq_cst (implicit) dă o ordine globală unică; release/acquire sincronizează un producător și un consumator; relaxed garantează doar atomicitatea.

Exemplul clasic: un thread pregătește date și ridică un flag, altul așteaptă flag-ul și citește datele.

C++
#include <atomic>
#include <cassert>
#include <thread>

int payload = 0;                    // date obișnuite, neatomice
std::atomic<bool> ready{false};

void producer() {
    payload = 42;
    ready.store(true, std::memory_order_release);    // nimic de dinainte nu trece după
}

void consumer() {
    while (!ready.load(std::memory_order_acquire)) {} // nimic de după nu trece înainte
    assert(payload == 42);                             // garantat
}

int main() {
    std::thread a(producer), b(consumer);
    a.join();
    b.join();
}

Când load-ul cu acquire citește valoarea scrisă de store-ul cu release, toate scrierile făcute de producător înainte de release devin vizibile consumatorului după acquire (relația „synchronizes-with”). Cu memory_order_relaxed pe ambele, payload ar putea fi citit încă 0: pe ARM sau POWER reordonarea chiar se întâmplă, iar pe x86 o poate face compilatorul.

Nivelurile:

  • relaxed: doar atomicitate. Potrivit pentru contoare de statistică.
  • release / acquire: pereche pentru publicarea datelor. acq_rel pentru operații read-modify-write.
  • seq_cst: implicit. Toate operațiile seq_cst apar în aceeași ordine globală pentru toate thread-urile. Cel mai ușor de raționat, uneori mai scump (pe x86, store-urile seq_cst folosesc o instrucțiune cu barieră).
  • memory_order_consume există, dar compilatoarele îl tratează ca acquire și utilizarea e descurajată.

Sfatul senior: folosește seq_cst implicit și mutex-uri; coboară la acquire/release doar în cod măsurat ca fiind critic, cu teste sub ThreadSanitizer și, ideal, pe hardware ARM. volatile nu oferă nicio garanție de ordine între thread-uri.

Ce urmărește intervievatorul: Verifică înțelegerea modelului de memorie C++11. Greșeala tipică: a crede că pe x86 ordinea nu contează, uitând de compilator.

80 Senior

Ce este false sharing și cum îl detectezi și îl elimini?

Răspuns scurt: False sharing: thread-uri diferite scriu variabile diferite aflate în aceeași linie de cache (de obicei 64 de octeți). Linia se mută între core-uri la fiecare scriere și performanța scade, deși nu există date partajate logic. Se elimină prin aliniere sau padding.

Procesorul nu mută variabile individuale între cache-uri, ci linii întregi. Dacă core-ul 1 scrie counters[0] și core-ul 2 scrie counters[1], iar ambele sunt în aceeași linie, fiecare scriere invalidează linia în cache-ul celuilalt core (protocol MESI). Codul e corect, dar poate rula de câteva ori mai lent decât varianta pe un singur thread.

C++
#include <atomic>
#include <new>
#include <thread>
#include <vector>

struct Bad  { std::atomic<long> value{0}; };                    // 8 octeți, vecinii împart linia
struct alignas(64) Good { std::atomic<long> value{0}; };        // fiecare pe linia lui

template <typename Counter>
void run(std::vector<Counter> &c) {
    std::vector<std::thread> ts;
    for (std::size_t i = 0; i < c.size(); ++i)
        ts.emplace_back([&c, i] { for (int k = 0; k < 10'000'000; ++k) c[i].value.fetch_add(1, std::memory_order_relaxed); });
    for (auto &t : ts) t.join();
}

int main() {
    std::vector<Bad> bad(4);
    std::vector<Good> good(4);
    run(bad);    // semnificativ mai lent pe majoritatea procesoarelor multi-core
    run(good);
}

C++17 definește std::hardware_destructive_interference_size în <new> pentru valoarea portabilă, dar suportul în compilatoare a venit târziu (GCC 12) și valoarea poate diferi între procesoare, de aceea mulți folosesc 64 explicit. Un std::vector de tip supra-aliniat cere C++17 pentru alocare aliniată corectă.

Detectare:

  • profilare cu perf c2c pe Linux, care raportează liniile de cache disputate între core-uri;
  • scalare proastă: adăugarea de thread-uri nu crește performanța;
  • Intel VTune are o analiză dedicată.

Soluții: padding sau alignas per thread; acumulare în variabile locale ale fiecărui thread și combinare la final (de obicei cea mai bună); gruparea datelor după thread-ul care le scrie. Fenomenul opus, true sharing, se rezolvă doar prin reducerea scrierilor partajate.

Ce urmărește intervievatorul: Verifică experiența cu optimizare reală pe hardware multi-core. Candidații seniori știu că problema e invizibilă în cod și apare doar la măsurare.

Embedded și automotive

81 Junior

Ce înseamnă volatile în C și C++ și când trebuie folosit?

Răspuns scurt: volatile cere compilatorului să facă efectiv fiecare citire și scriere, pentru că valoarea se poate schimba în afara fluxului programului. Se folosește la registre hardware și variabile modificate în întreruperi. Nu e un mecanism de sincronizare între thread-uri.

Fără volatile, compilatorul poate presupune că o variabilă se schimbă doar prin codul pe care îl vede. Bucla de mai jos ar putea deveni infinită la -O2, pentru că citirea lui flag e scoasă din buclă:

C
#include <stdbool.h>
#include <stdint.h>

volatile bool data_ready = false;   /* setat în ISR */

void uart_isr(void) {               /* rutina de întrerupere */
    data_ready = true;
}

void wait_for_data(void) {
    while (!data_ready) { }         /* citire reală din memorie la fiecare iterație */
    data_ready = false;
}

#define GPIO_ODR (*(volatile uint32_t *)0x40020014u)   /* adresă ilustrativă de registru */
void led_on(void) { GPIO_ODR |= (1u << 5); }

Cazurile legitime:

  • registre mapate în memorie: citirea unui registru de stare poate schimba hardware-ul (de exemplu, șterge un flag), iar două scrieri consecutive trebuie să ajungă ambele la periferic;
  • variabile partajate cu o rutină de întrerupere pe un microcontroler cu un singur core;
  • variabile modificate de setjmp/longjmp sau de handlere de semnal (cu volatile sig_atomic_t).

Ce NU face volatile:

  • nu face operațiile atomice: counter++ pe un volatile uint32_t e tot citește-modifică-scrie și poate fi întrerupt la mijloc de un ISR;
  • nu împiedică procesorul să reordoneze accesele față de memoria normală;
  • nu oferă sincronizare între thread-uri; pentru asta folosești std::atomic, _Atomic (C11) sau mutex-uri.

Pentru variabile partajate cu un ISR care au mai mult de un cuvânt, sau pentru operații compuse, dezactivezi temporar întreruperile pe durata accesului ori folosești operații atomice ale platformei.

Ce urmărește intervievatorul: Este întrebarea clasică de embedded. Greșeala tipică: a folosi volatile ca înlocuitor pentru atomic sau mutex.

82 Junior

Care e diferența dintre un microcontroler și un microprocesor și ce înseamnă cross-compilare?

Răspuns scurt: Un microcontroler integrează pe un cip procesorul, flash-ul, RAM-ul și perifericele și rulează bare-metal sau cu RTOS. Un microprocesor folosește memorie și periferice externe și rulează des Linux. Cross-compilarea înseamnă compilarea pe PC pentru altă arhitectură.

Microcontroler (de exemplu, familii bazate pe ARM Cortex-M, AVR, RISC-V pentru embedded): cip complet, cu memorie de ordinul kiloocteților până la câțiva megaocteți, consum mic, pornire instantanee, comportament determinist. Codul rulează direct de la vectorul de reset, fără MMU (deci fără memorie virtuală). Folosit în senzori, controlere de motor, unități de control din automobile, electrocasnice.

Microprocesor / SoC aplicativ (de exemplu, ARM Cortex-A): mai puternic, cu MMU, memorie externă de ordinul gigaocteților, rulează Linux sau Android. Folosit în infotainment, gateway-uri, routere.

Cross-compilare: compilatorul rulează pe x86-64, dar generează cod pentru ținta ARM.

BASH
arm-none-eabi-gcc -mcpu=cortex-m4 -mthumb -O2 -g -c main.c -o main.o
arm-none-eabi-gcc -mcpu=cortex-m4 -mthumb -T linker.ld -nostartfiles main.o startup.o -o firmware.elf
arm-none-eabi-objcopy -O binary firmware.elf firmware.bin
arm-none-eabi-size firmware.elf      # text / data / bss: cât flash și cât RAM folosești

Elementele unui toolchain embedded:

  • compilatorul și binutils pentru țintă (arm-none-eabi-*, unde „none” înseamnă fără sistem de operare);
  • linker script-ul, care spune unde e flash-ul și RAM-ul și unde se pun secțiunile .text, .data, .bss;
  • codul de startup, care copiază .data din flash în RAM, golește .bss și apelează main;
  • o bibliotecă C redusă (newlib, newlib-nano);
  • unelte de programare și depanare: un debugger hardware (J-Link, ST-LINK) prin SWD/JTAG, cu OpenOCD și gdb.

La interviu, contează să știi ce se întâmplă înainte de main și să citești ieșirea comenzii size.

Ce urmărește intervievatorul: Verifică dacă înțelegi mediul de execuție embedded. Mulți candidați veniți din aplicații desktop nu știu ce se întâmplă înainte de main.

83 Junior

Ce este endianness? Scrie o funcție care detectează ordinea octeților și una care citește un uint32_t big-endian dintr-un buffer.

Răspuns scurt: Endianness e ordinea în care se stochează octeții unui număr pe mai mulți octeți. Little-endian (x86, majoritatea ARM) pune octetul cel mai puțin semnificativ la adresa cea mai mică; big-endian îl pune pe cel mai semnificativ. Protocoalele de rețea folosesc de obicei big-endian.

Pentru valoarea 0x12345678, în memorie:

  • little-endian: 78 56 34 12
  • big-endian: 12 34 56 78
C
#include <stdint.h>
#include <stdio.h>
#include <string.h>

int is_little_endian(void) {
    uint32_t x = 1;
    unsigned char b;
    memcpy(&b, &x, 1);          /* primul octet din memorie */
    return b == 1;
}

uint32_t read_be32(const uint8_t *p) {
    return ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16) |
           ((uint32_t)p[2] << 8)  |  (uint32_t)p[3];
}

int main(void) {
    const uint8_t frame[4] = {0x12, 0x34, 0x56, 0x78};
    printf("%d %08X\n", is_little_endian(), (unsigned)read_be32(frame));   /* 1 12345678 pe x86 */
    return 0;
}

Observații importante:

  • read_be32 e corectă pe orice platformă, indiferent de endianness, pentru că lucrează cu valori, nu cu reprezentarea din memorie. E abordarea recomandată pentru parsarea protocoalelor (CAN, Modbus, formate de fișier).
  • Cast-ul uint32_t v = *(uint32_t *)buf; are trei probleme: dependență de endianness, posibil acces nealiniat și încălcarea strict aliasing.
  • Cast-urile (uint32_t) sunt necesare: fără ele, p[0] << 24 se face pe int, iar o valoare ≥ 0x80 deplasată în bitul de semn e UB.
  • Funcții standard: htonl, ntohl (POSIX), std::endian (C++20) pentru detectare la compilare și std::byteswap (C++23).

În automotive, semnalele CAN pot fi definite în fișiere DBC fie în format Intel (little-endian), fie Motorola (big-endian), deci această distincție apare în practică.

Ce urmărește intervievatorul: Verifică dacă poți lucra cu date binare portabil. Greșeala tipică: cast direct de pointer pe buffer.

84 Mid

Ce reguli respecți când scrii o rutină de tratare a întreruperii (ISR)?

Răspuns scurt: ISR-ul trebuie să fie scurt și determinist: citește sau confirmă perifericul, salvează datele, setează un flag sau pune datele într-un buffer, apoi iese. Fără funcții blocante, fără printf, fără malloc, fără operații lungi. Variabilele partajate cu codul principal sunt volatile și protejate la acces.

O întrerupere oprește codul principal în orice punct. Cât timp rulează ISR-ul, alte întreruperi de prioritate egală sau mai mică așteaptă, deci un ISR lent crește latența întregului sistem și poate pierde evenimente.

C
#include <stdint.h>

#define RX_SIZE 64u                      /* putere a lui 2 */
static volatile uint8_t rx_buf[RX_SIZE];
static volatile uint8_t rx_head = 0;     /* scris doar de ISR */
static volatile uint8_t rx_tail = 0;     /* scris doar de bucla principală */

extern uint8_t uart_read_data_register(void);   /* citirea confirmă întreruperea */

void USART2_IRQHandler(void) {
    uint8_t byte = uart_read_data_register();
    uint8_t next = (uint8_t)((rx_head + 1u) & (RX_SIZE - 1u));
    if (next != rx_tail) {               /* dacă bufferul e plin, octetul se pierde */
        rx_buf[rx_head] = byte;
        rx_head = next;
    }
}

int uart_get(uint8_t *out) {             /* apelată din bucla principală */
    if (rx_tail == rx_head) return 0;
    *out = rx_buf[rx_tail];
    rx_tail = (uint8_t)((rx_tail + 1u) & (RX_SIZE - 1u));
    return 1;
}

Bufferul circular cu un singur producător (ISR) și un singur consumator (main) funcționează fără dezactivarea întreruperilor, pentru că fiecare index e scris de o singură parte, iar indecșii de 8 biți se citesc atomic pe un MCU cu un singur core.

Reguli:

  • Confirmă (clear) sursa întreruperii, altfel ISR-ul se reexecută la nesfârșit.
  • Fără printf, malloc, mutex-uri blocante sau așteptări active.
  • Amână procesarea grea în bucla principală sau într-un task RTOS (cu API-uri dedicate, de tipul xQueueSendFromISR în FreeRTOS).
  • Variabilele partajate mai mari decât cuvântul procesorului sau modificate prin citește-modifică-scrie se accesează cu întreruperile dezactivate scurt.

Ce urmărește intervievatorul: Verifică experiența practică în embedded. Răspunsul bun include un mecanism concret de transfer al datelor către bucla principală.

85 Mid

De ce se evită alocarea dinamică și excepțiile în embedded și ce este MISRA C?

Răspuns scurt: Alocarea dinamică aduce fragmentare, timp nedeterminist și risc de eșec în funcționare, iar excepțiile cresc codul și au cost greu de estimat. MISRA C (și MISRA C++) e un set de reguli de codare pentru sisteme critice, folosit mult în automotive.

Un dispozitiv embedded rulează adesea ani fără restart, cu câțiva zeci de kiloocteți de RAM, iar o defecțiune poate avea consecințe fizice. De aici vin restricțiile.

Alocarea dinamică:

  • fragmentarea poate face ca, după luni de funcționare, o alocare să eșueze deși memorie liberă există;
  • timpul lui malloc variază, deci e greu de garantat un termen în sistemele real-time;
  • un eșec de alocare în timpul rulării nu are, de obicei, o reacție sigură.

Alternative: alocare statică (tablouri globale dimensionate la compilare), pool-uri de blocuri de dimensiune fixă, alocare doar la inițializare. În C++: std::array, containere cu capacitate fixă (de exemplu, din biblioteca ETL) și std::pmr cu buffere statice.

Excepțiile C++: cresc dimensiunea binarului (tabele de unwinding, suport runtime), iar timpul de propagare e greu de analizat. Multe proiecte compilează cu -fno-exceptions -fno-rtti și raportează erorile prin coduri de retur, std::optional sau tipuri de tip expected (std::expected din C++23).

MISRA C (ultima ediție majoră MISRA C:2012, cu amendamente și o consolidare în 2023) conține reguli „required”, „advisory” și „mandatory”. Exemple de spirit:

  • fără alocare dinamică din <stdlib.h>;
  • fără recursivitate;
  • conversii implicite restricționate între tipuri esențiale;
  • fiecare switch are default, fiecare if ... else if se termină cu else;
  • rezultatul funcțiilor non-void trebuie folosit.

Respectarea se verifică cu analizoare statice (de exemplu, Polyspace, PC-lint, Helix QAC, cppcheck cu addon MISRA), iar abaterile se documentează formal (deviation). Pentru C++ există MISRA C++:2023 și AUTOSAR C++14, folosite în proiectele auto moderne.

Ce urmărește intervievatorul: Verifică dacă înțelegi motivele din spatele regulilor din industrie. Răspunsul bun explică riscul, nu doar enumeră interdicții.

86 Mid

Cum accesezi un registru hardware mapat în memorie și ce probleme au câmpurile de biți (bit fields) pentru asta?

Răspuns scurt: Perifericele apar la adrese fixe; le accesezi printr-un pointer volatile la acea adresă, de obicei printr-o structură care descrie blocul de registre. Bit fields par comode, dar ordinea biților, alinierea și lățimea accesului sunt implementation-defined, deci se preferă măștile și deplasările.

Fișierele de la producător (headere CMSIS pentru ARM, de exemplu) definesc perifericele cam așa:

C
#include <stdint.h>

typedef struct {
    volatile uint32_t MODER;    /* offset 0x00: modul pinilor */
    volatile uint32_t OTYPER;   /* 0x04 */
    volatile uint32_t OSPEEDR;  /* 0x08 */
    volatile uint32_t PUPDR;    /* 0x0C */
    volatile uint32_t IDR;      /* 0x10: intrare, doar citire */
    volatile uint32_t ODR;      /* 0x14: ieșire */
} GPIO_TypeDef;

#define GPIOA ((GPIO_TypeDef *)0x40020000u)   /* adresa din datasheet */

#define PIN5_MODE_MASK (3u << (5u * 2u))
#define PIN5_MODE_OUT  (1u << (5u * 2u))

void led_init(void) {
    uint32_t v = GPIOA->MODER;          /* o citire */
    v &= ~PIN5_MODE_MASK;
    v |= PIN5_MODE_OUT;
    GPIOA->MODER = v;                   /* o scriere */
}

Tiparul citește-modifică-scrie printr-o variabilă locală face exact un acces de citire și unul de scriere, ceea ce contează pentru registrele cu efecte secundare.

De ce nu bit fields:

  • ordinea biților într-un cuvânt (de la LSB sau de la MSB) e implementation-defined;
  • compilatorul poate accesa câmpul cu o lățime diferită (de exemplu, un octet în loc de 32 de biți), iar unele periferice acceptă doar accese pe 32 de biți;
  • setarea a două câmpuri produce două operații citește-modifică-scrie separate, deci mai multe accese decât crezi;
  • portarea pe alt compilator poate schimba layout-ul fără niciun avertisment.

Alte detalii: registrele „write 1 to clear” nu se modifică prin |=, pentru că ai șterge accidental și alte flag-uri setate; unele microcontrolere au registre dedicate de set/reset (BSRR la STM32) sau bit-banding, care evită operația citește-modifică-scrie și problemele cu întreruperile.

Ce urmărește intervievatorul: Verifică experiența directă cu hardware. Greșeala tipică: bit fields pe registre sau |= pe registre de tip write-1-to-clear.

87 Mid

Când alegi un RTOS în locul unei bucle principale (superloop) bare-metal?

Răspuns scurt: Superloop-ul apelează funcțiile pe rând într-o buclă infinită: simplu și determinist, dar greu de extins la multe activități cu termene diferite. Un RTOS (FreeRTOS, Zephyr) oferă task-uri cu priorități, preempțiune, cozi și semafoare, cu cost de memorie și complexitate.

Superloop:

C
#include <stdbool.h>
void hw_init(void); void read_sensors(void); void update_control(void);
void handle_uart(void); void blink_led(void);
extern volatile bool tick_100ms;   /* setat de un timer ISR */

int main(void) {
    hw_init();
    for (;;) {
        read_sensors();      /* fiecare funcție trebuie să revină repede */
        update_control();
        handle_uart();
        if (tick_100ms) { tick_100ms = 0; blink_led(); }
    }
}

Avantaje: ușor de înțeles și de analizat, fără overhead, fără probleme de concurență între task-uri (doar cu ISR-urile). Dezavantaje: timpul de răspuns al unei funcții depinde de durata tuturor celorlalte; o operație lungă (scriere în flash, procesare de protocol) trebuie spartă manual în mașini de stare; codul se încurcă pe măsură ce crește.

RTOS: fiecare activitate devine un task cu stiva și prioritatea lui. Scheduler-ul preemptiv rulează mereu task-ul gata de execuție cu prioritatea cea mai mare, deci un task de control critic răspunde în timp limitat, chiar dacă un task de logging durează. Primitive tipice: cozi de mesaje, semafoare, mutex-uri cu moștenire de prioritate, timere software, notificări de task.

Costuri ale unui RTOS:

  • RAM pentru fiecare stivă de task și pentru structurile kernelului; stivele trebuie dimensionate și monitorizate (FreeRTOS are uxTaskGetStackHighWaterMark);
  • toate problemele concurenței: race conditions, deadlock, inversiune de priorități;

Criterii de decizie: numărul de activități independente, existența unor termene stricte diferite, nevoia de stive de comunicații (TCP/IP, USB, Bluetooth), care vin de obicei integrate cu un RTOS, și resursele disponibile. Pentru un senzor simplu, superloop-ul cu întreruperi e adesea alegerea corectă. În automotive, sistemele de operare sunt de obicei conforme AUTOSAR OS (bazat pe OSEK).

Ce urmărește intervievatorul: Verifică judecata arhitecturală în embedded. Un răspuns bun prezintă compromisurile, nu doar avantajele RTOS-ului.

88 Senior

Ce este inversiunea de priorități (priority inversion) și cum se rezolvă?

Răspuns scurt: Inversiunea apare când un task prioritar așteaptă un mutex ținut de un task de prioritate mică, iar unul de prioritate medie îl preemptează pe cel mic. Se rezolvă cu priority inheritance sau priority ceiling.

Scenariul, cu trei task-uri: H (prioritate mare), M (medie), L (mică).

1. L blochează un mutex care protejează o magistrală SPI. 2. H devine gata, preemptează L, încearcă să ia mutex-ul și se blochează. 3. M devine gata. Are prioritate mai mare decât L, deci rulează, iar L nu poate continua să elibereze mutex-ul. 4. H așteaptă, de fapt, după M, deși nu are nicio legătură cu el. Durata blocării e nelimitată.

Cazul cel mai cunoscut este Mars Pathfinder (1997): resetări repetate ale sistemului, cauzate de inversiunea de priorități în VxWorks, rezolvate prin activarea de la distanță a moștenirii de priorități pe mutex-ul implicat.

Soluții:

  • Priority inheritance: cât timp H așteaptă mutex-ul ținut de L, L rulează cu prioritatea lui H, deci M nu-l mai poate preempta. La eliberare, L revine la prioritatea inițială. În FreeRTOS, mutex-urile (xSemaphoreCreateMutex) au moștenire de prioritate, spre deosebire de semafoarele binare. Pe Linux, pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT).
  • Priority ceiling: fiecare resursă are o prioritate plafon egală cu cea mai mare prioritate a task-urilor care o folosesc; cine o ia, rulează la plafon. Previne și unele deadlock-uri, iar AUTOSAR OS / OSEK îl folosesc prin resurse.
  • Design: secțiuni critice foarte scurte, un singur task care deține perifericul și primește cereri prin cozi (așa nu mai există mutex partajat), evitarea partajării resurselor între niveluri de prioritate foarte diferite.

Ca idee pentru interviu: folosirea unui semafor binar în loc de mutex pentru excludere mutuală e o greșeală frecventă în cod RTOS, tocmai pentru că semaforul nu are proprietar și nu poate aplica moștenirea de prioritate.

Ce urmărește intervievatorul: Verifică înțelegerea sistemelor real-time. Răspunsul senior distinge mutex de semafor și menționează soluțiile de design, nu doar mecanismul.

89 Senior

Ce știi despre dezvoltarea software în automotive: CAN, AUTOSAR și ISO 26262?

Răspuns scurt: CAN este magistrala serială folosită pentru comunicarea între unitățile de control (ECU) dintr-un vehicul. AUTOSAR e o arhitectură software standardizată pentru ECU-uri (Classic pentru microcontrolere, Adaptive pentru sisteme mai puternice). ISO 26262 este standardul de siguranță funcțională, cu niveluri de risc ASIL A–D.

La un interviu pentru automotive nu se așteaptă să știi totul, dar trebuie să înțelegi contextul.

CAN (Controller Area Network): magistrală diferențială pe două fire, cu arbitraj pe baza identificatorului mesajului (ID mai mic înseamnă prioritate mai mare). Un cadru CAN clasic are până la 8 octeți de date, CAN FD până la 64. Mesajele și semnalele se descriu de obicei în fișiere DBC. În vehicule apar și LIN (ieftin, lent), FlexRay și Automotive Ethernet. Unelte frecvente: CANoe/CANalyzer și, pe Linux, SocketCAN cu candump și cansend.

AUTOSAR Classic împarte software-ul ECU-ului în straturi:

  • componentele aplicației (SWC), care comunică prin porturi și interfețe;
  • RTE (Runtime Environment), stratul generat care le leagă;
  • Basic Software: servicii (COM, diagnoză, memorie nevolatilă), abstractizarea ECU-ului și MCAL (driverele microcontrolerului), plus AUTOSAR OS. Mult cod se generează din configurări făcute cu unelte specifice, iar programatorul scrie logica din SWC-uri și integrează. AUTOSAR Adaptive rulează pe sisteme POSIX și se programează în C++ modern.

ISO 26262 cere un proces documentat pentru software-ul care poate afecta siguranța: analiză de risc, cerințe de siguranță, trasabilitate de la cerință la cod și test, revizii, acoperire a testelor (de exemplu MC/DC la ASIL D), reguli de codare (MISRA), analiză statică. Nivelul ASIL determină cât de strict e procesul.

Mai apar: ASPICE (model de maturitate a proceselor), diagnoză UDS (ISO 14229), testare HIL/SIL și securitate cibernetică (ISO/SAE 21434).

La interviu contează să arăți că înțelegi de ce există aceste procese: o eroare de software poate afecta frânarea sau direcția, deci cerințele, trasabilitatea și testarea sunt parte din meserie, nu birocrație.

Ce urmărește intervievatorul: Verifică familiaritatea cu domeniul, foarte prezent pe piața din România. Greșeala tipică: a privi procesele de siguranță ca birocrație inutilă.

Git, Linux și debugging

90 Junior

Care e fluxul tău zilnic cu Git și care e diferența dintre merge și rebase?

Răspuns scurt: Fluxul tipic: actualizezi ramura principală, creezi o ramură pentru task, faci commit-uri mici, aduci schimbările noi și deschizi un pull request pentru code review. merge unește istoriile printr-un commit de merge; rebase rescrie commit-urile tale peste vârful altei ramuri, rezultând un istoric liniar.

Un flux obișnuit:

BASH
git switch main && git pull --rebase       # ultima versiune
git switch -c feature/can-timeout          # ramură pentru task
# ... modifici cod ...
git add -p                                 # alegi bucățile de pus în commit
git commit -m "Handle CAN rx timeout in gateway"
git fetch origin
git rebase origin/main                     # îți aduci ramura la zi
git push -u origin feature/can-timeout     # apoi deschizi pull request

Merge: git merge main creează un commit cu doi părinți. Istoricul real e păstrat, nu se rescrie nimic, deci e sigur pe ramuri partajate. Dezavantaj: istoric cu multe ramificări, mai greu de citit.

Rebase: git rebase main ia commit-urile tale și le aplică din nou peste main, cu hash-uri noi. Istoricul devine liniar și ușor de urmărit cu git log și git bisect. Regula de aur: nu face rebase pe commit-uri pe care alții le-au preluat deja, pentru că le rescrii istoria. Pe ramura ta personală e în regulă, iar după rebase împingi cu git push --force-with-lease, care refuză să suprascrie modificări noi ale altcuiva.

Alte comenzi utile la interviu:

  • git rebase -i pentru a reordona, combina sau reformula commit-uri înainte de review;
  • git cherry-pick pentru a aduce o corecție pe o ramură de release;
  • git revert pentru a anula un commit publicat fără a rescrie istoria;
  • git blame pentru a înțelege istoricul unui fișier.

Un mesaj de commit bun spune ce s-a schimbat și de ce, nu doar „fix”. În proiectele auto, commit-ul e adesea legat de ID-ul cerinței sau al tichetului, pentru trasabilitate.

Ce urmărește intervievatorul: Verifică obișnuința de a lucra în echipă cu Git. Greșeala tipică: rebase pe ramuri partajate sau push --force fără precauție.

91 Junior

Ce flag-uri de compilare folosești de obicei cu gcc/g++ și cum arată un CMakeLists.txt minimal?

Răspuns scurt: Pentru dezvoltare: -std=c++17 (sau 20), -Wall -Wextra -Wpedantic pentru avertismente, -g pentru informații de depanare, -O0 sau -Og în debug și -O2 în release, plus -fsanitize=address,undefined în teste. CMake descrie proiectul independent de platformă și generează fișierele de build.

BASH
g++ -std=c++20 -Wall -Wextra -Wpedantic -Wshadow -Wconversion -g -Og \
    -fsanitize=address,undefined main.cpp util.cpp -o app

Ce face fiecare:

  • -std=c++20: versiunea standardului; fără el, compilatorul folosește valoarea lui implicită, care diferă între versiuni.
  • -Wall -Wextra -Wpedantic: avertismente pentru multe bug-uri reale (variabile neinițializate, comparații signed/unsigned, return lipsă). -Wall nu activează, în ciuda numelui, toate avertismentele.
  • -Werror: transformă avertismentele în erori; util în CI.
  • -g: simboluri pentru gdb; nu încetinește codul, doar mărește fișierul.
  • -O0/-Og pentru depanare, -O2/-O3 pentru release, -Os pentru dimensiune (des în embedded).
  • -DNDEBUG dezactivează assert.

CMake minimal:

cmake_minimum_required(VERSION 3.20)
project(gateway LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

add_library(core src/parser.cpp src/can.cpp)
target_include_directories(core PUBLIC include)
target_compile_options(core PRIVATE -Wall -Wextra -Wpedantic)

add_executable(app src/main.cpp)
target_link_libraries(app PRIVATE core)
BASH
cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug
cmake --build build -j

Ideea CMake modern: totul se setează pe target-uri (target_*), cu PUBLIC/PRIVATE pentru a controla ce se propagă către cei care folosesc biblioteca. Build-ul se face într-un director separat, nu în sursă.

Ce urmărește intervievatorul: Verifică dacă ai lucrat cu build-uri reale. Greșeala tipică: compilare fără avertismente activate sau CMake cu variabile globale în loc de target-uri.

92 Junior

Ce comenzi Linux folosești când lucrezi la un program C/C++ sau când investighezi o problemă?

Răspuns scurt: Pentru cod: grep sau rg pentru căutare, find, make/cmake, gdb. Pentru procese: ps, top/htop, kill. Pentru fișiere și resurse: ls -l (permisiuni), df, du, lsof. Pentru diagnoză: strace (apeluri de sistem), ldd (biblioteci), journalctl sau dmesg (loguri), file și nm pentru binare.

Câteva grupe de comenzi pe care e bine să le poți folosi fluent:

BASH
grep -rn "can_send" src/            # unde e folosită o funcție
find . -name "*.cpp" -newer build/app   # fișiere modificate după ultimul build
ps aux | grep gateway               # procesul și PID-ul lui
top -H -p 1234                      # thread-urile unui proces și consumul lor
kill -TERM 1234                     # oprire curată; -KILL doar dacă nu răspunde
ls -l /dev/ttyUSB0                  # permisiuni pe un port serial
lsof -p 1234                        # fișierele și socket-urile deschise
ss -tlnp                            # ce procese ascultă pe porturi TCP
strace -f -e trace=open,openat ./app    # ce fișiere încearcă să deschidă programul
ldd ./app                           # biblioteci dinamice și dacă lipsește vreuna
nm -C libcore.a | grep parse        # simbolurile dintr-o bibliotecă
dmesg | tail                        # mesaje de kernel, de exemplu despre un segfault
ulimit -c unlimited                 # permite generarea de core dump-uri

Ce urmărește intervievatorul:

  • Permisiunile: rwxr-x--- înseamnă citire/scriere/execuție pentru proprietar, citire/execuție pentru grup, nimic pentru ceilalți. chmod +x script.sh face un script executabil. Accesul la /dev/ttyUSB0 cere de obicei apartenența la grupul dialout.
  • Semnale: SIGTERM poate fi tratat pentru oprire curată, SIGKILL nu; SIGSEGV e trimis la acces invalid la memorie.
  • Pipe-uri și redirectare: ./app 2>&1 | tee run.log salvează și ieșirea de eroare.
  • Codul de ieșire: echo $? după rulare; 139 înseamnă terminare prin semnalul 11 (128 + 11), adică segmentation fault.

În embedded Linux, aceleași comenzi rulează pe țintă, de obicei prin SSH sau consolă serială (minicom, picocom), adesea cu BusyBox, care oferă variante reduse ale lor.

Ce urmărește intervievatorul: Verifică autonomia în mediul de lucru tipic pentru C/C++. Greșeala tipică: dependența totală de IDE.

93 Mid

Programul tău se oprește cu „Segmentation fault”. Cum îl depanezi?

Răspuns scurt: Reproduci problema cu un build de depanare (-g -O0), apoi rulezi sub gdb sau analizezi un core dump: comanda bt arată stiva de apeluri în momentul crash-ului. În paralel, compilezi cu AddressSanitizer, care indică exact accesul invalid și unde a fost alocată sau eliberată memoria.

Pașii, în ordinea în care îi aplic de obicei:

1. AddressSanitizer dă adesea răspunsul direct:

BASH
g++ -g -O1 -fsanitize=address,undefined -fno-omit-frame-pointer main.cpp -o app && ./app

Raportul spune tipul erorii (heap-use-after-free, stack-buffer-overflow, null dereference) și liniile relevante.

2. gdb pe build-ul de depanare:

BASH
gdb --args ./app config.json
(gdb) run
(gdb) bt                 # stiva de apeluri la crash
(gdb) frame 2            # mergi în cadrul care te interesează
(gdb) info locals        # variabilele locale
(gdb) print *msg         # inspectezi un obiect
(gdb) watch buf[15]      # te oprești când se scrie la această adresă

3. Core dump, când crash-ul apare la client sau rar:

BASH
ulimit -c unlimited
./app                     # crapă și scrie core (pe systemd: coredumpctl)
gdb ./app core            # apoi bt

Ai nevoie de exact același binar și de simbolurile lui (păstrezi fișierele de debug separate pentru build-urile de release).

4. Analiza cauzei, nu doar a locului: linia unde crapă e adesea doar victima. Dacă un obiect are valori absurde, întrebarea e cine l-a corupt și când. Aici ajută watch, sanitizerele și Valgrind.

Cauze frecvente: pointer nul, use-after-free, depășirea unui tablou, iterator invalidat, recursivitate infinită (stack overflow), date partajate fără sincronizare (folosește -fsanitize=thread).

În embedded, echivalentul e un HardFault: te conectezi cu debuggerul (J-Link/ST-LINK prin OpenOCD și gdb) și citești registrele de fault și adresa salvată pe stivă.

La final, scrii un test care reproduce bug-ul, ca să nu revină.

Ce urmărește intervievatorul: Verifică metoda de depanare, nu noroc. Greșeala tipică: adăugarea de printf-uri la întâmplare fără a citi stiva.

94 Senior

Un bug apare doar în build-ul de release (-O2) și numai uneori, iar în debug totul merge. Cum procedezi?

Răspuns scurt: Îl tratez ca semn aproape sigur de undefined behavior, data race sau memorie neinițializată, nu ca bug de compilator. Rulez sanitizerele (ASan, UBSan, TSan) pe build optimizat, activez avertismente stricte și folosesc git bisect pentru a găsi commit-ul vinovat.

De ce diferă debug de release: la -O0 fiecare variabilă stă în memorie, ordinea operațiilor urmează codul sursă, iar memoria neinițializată are adesea întâmplător valoarea zero. La -O2 compilatorul ține valori în registre, reordonează, elimină cod pe baza presupunerii că nu există UB și schimbă temporizarea între thread-uri.

Plan concret: 1. Reproducere stabilă: găsesc intrarea și condițiile care cresc frecvența (încărcare mare, mai multe core-uri, buclă de rulare automată). Fără reproducere nu pot verifica o corecție. 2. Sanitizere pe build optimizat: -O2 -g -fsanitize=address,undefined, apoi separat -fsanitize=thread, pentru că TSan nu se combină cu ASan. Data race-urile sunt suspectul principal când problema apare „uneori”. 3. Avertismente: -Wall -Wextra -Wuninitialized -Wmaybe-uninitialized funcționează mai bine cu optimizări activate. 4. Bisectare pe flag-uri: dacă problema dispare cu -O1 sau cu -fno-strict-aliasing ori -fwrapv, am un indiciu puternic despre tipul de UB. 5. git bisect, dacă știu o versiune bună:

BASH
git bisect start
git bisect bad HEAD
git bisect good v2.3.0
git bisect run ./scripts/repro.sh     # scriptul întoarce 0 dacă e bine, 1 dacă e rău

Git caută binar commit-ul vinovat. 6. Depanare pe codul optimizat: -O2 -g, cu atenție că unele variabile apar ca „optimized out”; ajută și -fno-omit-frame-pointer și citirea asamblării pentru funcția suspectă (Compiler Explorer e util pentru izolarea unui fragment).

Abia după ce am exclus UB-ul consider un bug de compilator, și atunci îl confirm cu un exemplu minimal pe mai multe versiuni de compilator. La final: test de regresie, sanitizere adăugate în CI și o explicație scrisă a cauzei.

Ce urmărește intervievatorul: Verifică maturitatea în depanare. Greșeala tipică a candidaților: a da vina pe compilator sau a lăsa build-ul de release cu -O0.

Comportamentale și HR

95 Junior

Povestește-mi despre cel mai greu bug pe care l-ai rezolvat.

Răspuns scurt: Alege un bug real, cu impact clar, și povestește-l structurat: contextul, simptomul, cum l-ai investigat (ipoteze, unelte), cauza reală, corecția și ce ai schimbat ca să nu se repete. Intervievatorul evaluează metoda, nu dificultatea în sine.

Folosește structura STAR (Situație, Sarcină, Acțiune, Rezultat), cu accent pe acțiune.

Model de răspuns (adaptează-l la experiența ta reală, fie din proiecte, fie din facultate sau din cursuri):

„Într-un proiect personal, un server C++ care primea date de la senzori pe TCP crăpa o dată la câteva ore, doar sub încărcare. În debug nu reușeam să reproduc problema.

Primul pas a fost reproducerea: am scris un script care trimitea date de la 50 de clienți simultan, iar crash-ul a apărut în câteva minute. Stiva din core dump arăta o eroare în std::vector::push_back, dar locul nu avea nimic evident greșit. Am compilat cu ThreadSanitizer, care a raportat un data race: un thread de procesare adăuga elemente în vector în timp ce thread-ul de raportare îl parcurgea. Mutex-ul exista, dar o funcție adăugată mai târziu îl ocolea.

Am corectat accesul, am mutat vectorul și mutex-ul într-o clasă care expune doar operații sincronizate, ca să nu mai fie posibil accesul direct, și am adăugat testul de încărcare și TSan în pipeline-ul de CI.

Am învățat două lucruri: că un crash într-un container STL e de obicei un simptom, nu cauza, și că sincronizarea trebuie impusă prin design, nu prin disciplină.”

Ce să eviți:

  • bug-uri banale (o virgulă lipsă) prezentate ca grele;
  • povești fără metodă („am încercat diverse până a mers”);
  • să dai vina pe colegi;
  • detalii inventate; intervievatorul va pune întrebări de aprofundare.

Ce să subliniezi: cum ai format ipoteze și le-ai verificat, uneltele folosite (gdb, sanitizere, loguri), ce ai învățat și ce ai schimbat în proces.

Ce urmărește intervievatorul: Evaluează gândirea sistematică și onestitatea. Greșeala tipică: o poveste fără pași de investigație sau fără lecție.

96 Junior

De ce vrei să lucrezi în C/C++ și, eventual, în embedded sau automotive?

Răspuns scurt: Răspunde concret: ce te atrage la nivelul de control oferit de C/C++ (performanță, înțelegerea memoriei, lucrul aproape de hardware), ce ai construit deja în acest sens și cum se leagă de domeniul firmei. Evită răspunsurile generice despre salariu sau „limbaj popular”.

Intervievatorul vrea să afle dacă motivația ta e durabilă. C și C++ au o curbă de învățare abruptă, iar în embedded munca include citirea documentațiilor tehnice (datasheet-uri), depanare pe hardware și procese stricte. Cineva care a ales domeniul doar pentru că „sunt multe joburi” poate renunța repede.

Structură recomandată: 1. Ce te atrage tehnic, cu un exemplu personal: „Îmi place să înțeleg ce se întâmplă de fapt în memorie. Când am implementat un alocator simplu la curs, am înțeles de ce contează layout-ul datelor pentru performanță.” 2. Ce ai făcut concret: un proiect pe o placă de dezvoltare (Arduino, STM32, Raspberry Pi Pico), un program care comunică pe UART sau CAN, contribuții la un proiect open source, exerciții de algoritmi în C++. 3. Legătura cu firma: ce știi despre produsele sau domeniul lor (fără să inventezi informații) și de ce ți se potrivește. De exemplu: „Mă interesează sistemele în care software-ul controlează ceva fizic, iar siguranța funcțională e o parte a muncii pe care vreau s-o învăț.” Exemplu scurt de răspuns: „Am început cu C la facultate și mi-a plăcut că trebuie să înțeleg exact ce face codul. Am construit o stație meteo pe un microcontroler, cu senzori pe I2C și date trimise pe UART, și cea mai interesantă parte a fost depanarea întreruperilor. Vreau să lucrez în embedded pentru că acolo calitatea codului are consecințe directe, iar pe termen lung mă interesează sistemele auto.”

Evită: răspunsuri învățate pe de rost, critici la adresa altor limbaje și afirmații pe care nu le poți susține când ți se cer detalii.

Ce urmărește intervievatorul: Evaluează motivația și potrivirea cu domeniul. Greșeala tipică: răspunsuri generice, fără niciun exemplu personal.

97 Junior

Descrie un proiect personal sau de facultate în C/C++ de care ești mândru.

Răspuns scurt: Prezintă un singur proiect, pe scurt: problema rezolvată, arhitectura, deciziile tehnice importante și de ce le-ai luat, o dificultate concretă și rezultatul. Fii pregătit să deschizi codul și să răspunzi la întrebări detaliate despre el.

Pentru un junior, proiectul personal ține locul experienței profesionale. Intervievatorul folosește discuția ca să vadă cât de adânc înțelegi ce ai construit și dacă ai luat decizii conștiente.

Structură de 2–3 minute: 1. Problema: ce face proiectul și pentru cine. „Un logger de date pentru un acvariu: citește temperatura și pH-ul și trimite valorile pe Wi-Fi.” 2. Tehnologii și arhitectură: limbajul și standardul (C11, C++17), platforma, bibliotecile, cum ai împărțit codul (drivere, logică, comunicație). 3. Decizii tehnice: „Am folosit un buffer circular static în loc de alocare dinamică, pentru că dispozitivul rulează continuu.” „Am separat logica de hardware printr-o interfață, ca s-o pot testa pe PC cu GoogleTest.” 4. O dificultate și cum ai rezolvat-o: un bug, o limitare de memorie, o problemă de temporizare. 5. Rezultat și ce ai face diferit: arată că poți evalua critic propria muncă.

Ce întrebări să aștepți:

  • „De ce ai ales X și nu Y?”
  • „Cum ai testat?”
  • „Ce se întâmplă dacă senzorul nu răspunde?”
  • „Arată-mi funcția cea mai complicată și explică-mi-o.”

Pregătire practică:

  • un repository curat pe GitHub, cu README (ce face, cum se compilează, o diagramă simplă), istoric de commit-uri cu mesaje clare și, ideal, teste și un fișier CMake;
  • dacă proiectul e făcut în echipă, spune clar ce parte ți-a aparținut.

Un proiect mic, terminat și bine explicat valorează mai mult decât unul ambițios, neterminat și pe care nu-l poți explica.

Ce urmărește intervievatorul: Verifică profunzimea înțelegerii și asumarea deciziilor. Greșeala tipică: un proiect copiat dintr-un tutorial, pe care candidatul nu-l poate explica.

98 Junior

Cum reacționezi când primești critici dure la code review?

Răspuns scurt: Separ critica la adresa codului de critica personală, citesc comentariile ca să înțeleg motivul, pun întrebări când nu sunt de acord sau nu înțeleg, corectez ce e justificat și discut argumentat restul. Scopul comun e un cod mai bun și mai ușor de întreținut.

Code review-ul e o parte zilnică a meseriei, iar în proiectele cu cerințe de siguranță (automotive, medical) e obligatoriu și documentat. Intervievatorul vrea să știe dacă poți primi feedback fără să devii defensiv și dacă poți susține o poziție tehnică fără conflict.

Structură de răspuns: 1. Atitudinea: „Comentariile sunt despre cod, nu despre mine. Un reviewer care găsește o problemă îmi economisește timp mai târziu.” 2. Procesul: citesc toate comentariile înainte să răspund; pentru fiecare, încerc să înțeleg motivul; corectez ce e clar; întreb când nu înțeleg („Poți să-mi explici ce scenariu te îngrijorează?”); dacă nu sunt de acord, aduc argumente concrete: standardul, un test, o măsurătoare, regulile proiectului. 3. Când discuția se blochează: propun o scurtă discuție directă în loc de 20 de comentarii scrise sau cer părerea unei a treia persoane (tech lead). Odată luată decizia, o aplic chiar dacă nu am avut dreptate. 4. Ce iau mai departe: dacă primesc de mai multe ori același tip de comentariu, îl adaug în lista proprie de verificare înainte de a deschide un pull request.

Exemplu: „La un proiect de echipă, un coleg mi-a respins un pull request spunând că o funcție de 150 de linii e greu de testat. Prima reacție a fost că funcționează, deci e bine. Am recitit și am văzut că avea dreptate: am spart-o în trei funcții și am adăugat teste pentru fiecare. De atunci împart codul înainte să-l trimit.”

Menționează și partea inversă: când faci tu review, comentezi codul, explici de ce, propui alternative și recunoști ce e bine făcut.

Ce urmărește intervievatorul: Evaluează maturitatea profesională și colaborarea. Greșeala tipică: „nu am primit niciodată critici” sau un ton defensiv.

99 Mid

Cum abordezi o bază de cod mare, veche, scrisă în C/C++, pe care nu o cunoști?

Răspuns scurt: Încep cu imaginea de ansamblu: cum se compilează și rulează, care sunt modulele și fluxurile principale. Apoi urmăresc un caz de utilizare concret prin cod cu debuggerul, citesc testele și istoricul Git și fac întâi modificări mici, sigure, înainte de schimbări mari.

Multe proiecte C/C++ au zeci de ani, cod scris de multe generații de programatori și documentație incompletă. Intervievatorul verifică dacă ai o metodă și dacă ești prudent.

Pașii pe care i-aș descrie: 1. Build și rulare: compilez proiectul local, rulez testele existente și aplicația. Dacă procesul e dificil, notez pașii și îi adaug în documentație; e o primă contribuție utilă. 2. Harta proiectului: structura directoarelor, punctele de intrare (main, task-uri, handlere de întrerupere), dependențele dintre module (CMake sau Makefile spun multe). Uneltele de navigare (clangd cu compile_commands.json, „go to definition”, „find references”) contează enorm. 3. Un fir concret: aleg o funcționalitate („ce se întâmplă când vine un mesaj CAN cu ID-ul X”) și o urmăresc cu debuggerul și cu breakpoint-uri, de la intrare la efect. 4. Istoricul: git log și git blame pe fișierele importante îmi arată de ce s-au făcut anumite schimbări și cine le cunoaște. 5. Modificări mici și sigure: o corecție mică sau un test în plus, ca să învăț procesul (review, CI, livrare).

La modificarea codului vechi:

  • adaug teste de caracterizare înainte să schimb comportamentul, mai ales dacă testele lipsesc;
  • refactorizez treptat, separat de schimbările de funcționalitate, ca review-ul să fie ușor;
  • nu rescriu de la zero ce funcționează doar pentru că arată vechi: codul vechi conține adesea corecturi pentru situații reale pe care nu le cunosc încă.

Un exemplu personal, chiar și dintr-un proiect open source, face răspunsul credibil.

Ce urmărește intervievatorul: Evaluează autonomia și prudența. Greșeala tipică: dorința de a rescrie tot sau lipsa unei metode clare de explorare.

100 Mid

Ai estimat un task la trei zile, dar după două zile îți dai seama că îți mai trebuie o săptămână. Ce faci?

Răspuns scurt: Anunț imediat echipa sau team lead-ul, nu în ultima zi: explic ce am descoperit, de ce estimarea s-a schimbat, ce opțiuni există (reducerea scopului, ajutor, altă prioritizare) și o nouă estimare cu nivelul de încredere. Apoi analizez de ce estimarea inițială a fost greșită.

Întrebarea verifică transparența și responsabilitatea. În proiectele C/C++, mai ales embedded, estimările sunt dificile: o problemă de hardware, un driver nedocumentat sau un bug de concurență pot transforma o zi de muncă într-o săptămână. Nimeni nu se așteaptă la estimări perfecte, dar toată lumea se așteaptă să afle din timp.

Structura răspunsului: 1. Comunicare devreme: „Imediat ce am realizat că estimarea nu mai e valabilă, i-am spus team lead-ului, nu la final.” Alții pot depinde de task-ul tău (testare, integrare, o livrare către client). 2. Explicație concretă: ce s-a descoperit. „Perifericul necesită o secvență de inițializare care nu era în documentația de la care am pornit, iar driverul existent nu o suporta.” 3. Opțiuni, nu doar problema:

  • livrez o versiune redusă la termenul inițial și restul ulterior;
  • primesc ajutor de la cineva care cunoaște modulul;
  • se reprioritizează alte task-uri;
  • acceptăm întârzierea, dacă nu blochează pe nimeni. 4. Estimare nouă, cu incertitudinea ei: „Cred că mai sunt patru-cinci zile; voi ști sigur după ce testez pe placă mâine și revin cu o actualizare.” 5. Lecția: „Acum, la task-urile cu hardware sau cod necunoscut, fac întâi o investigație scurtă (spike) înainte să dau o estimare fermă și spun explicit ce presupuneri am făcut.”

Exemplu din experiența de junior, dacă nu ai una profesională: un proiect de echipă la facultate în care o parte a durat mai mult și cum ați reorganizat munca.

Ce să eviți: să lucrezi noaptea în secret ca să recuperezi, să ascunzi problema până la termen sau să dai vina pe alții.

Ce urmărește intervievatorul: Evaluează transparența și gestionarea riscului. Greșeala tipică: ascunderea problemei până la termenul limită.

Întrebări de interviu pe tehnologii

Pregătire de interviu pentru alte meserii

Exerciții rezolvate pentru Programator C / C++

← 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 Programator C / C++, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

De la întrebări la primul job de Programator C / C++

Traseul de carieră îți pune cursurile în ordine, cu exerciții verificate automat și proiecte despre care poți vorbi la interviu. Primele lecții sunt gratuite.