...
Pregătire interviuri

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

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

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

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

La un interviu în care se verifică limbajul C, întrebările merg rar spre sintaxa de bază și mult mai des spre ce face C diferit: tipurile și conversiile implicite, pointerii și aritmetica lor, memoria alocată manual, șirurile terminate cu zero și comportamentul nedefinit. Pe lângă teorie, aproape mereu există cod: „ce afișează”, „unde e bug-ul”, o funcție scrisă live (strlen, o listă înlănțuită, un buffer circular) sau o temă de acasă evaluată și după avertismente, leak-uri și tratarea erorilor.

La nivel junior se verifică bazele: tipuri și operatori, funcții, tablouri, șiruri, malloc și free, citirea corectă a datelor. La nivel mid apar idiomurile și capcanele din cod real: realloc corect, snprintf, const correctness, preprocesorul, fișiere binare, teste și unelte ca gdb și valgrind. Întrebările de nivel senior ating aliniere, ABI, alocatoare, depanare post-mortem și sisteme embedded.

Pagina are 100 de întrebări grupate pe teme, de la junior la senior în cadrul fiecărei teme. Citește întâi răspunsul scurt și încearcă să explici singur restul, apoi compară cu răspunsul detaliat. Exemplele de cod sunt scrise pentru C99/C17 și compilează cu GCC sau Clang; rulează-le cu -Wall -Wextra și -fsanitize=address,undefined ca să vezi singur efectele descrise. Întrebările de C++ sunt pe pagina separată de C++ Developer.

Tipuri, conversii și operatori

1 Junior

Ce dimensiuni garantează standardul C pentru char, short, int, long și long long?

Răspuns scurt: Standardul nu fixează dimensiuni exacte, ci minime: char are cel puțin 8 biți, short și int cel puțin 16, long cel puțin 32, long long cel puțin 64, iar sizeof(char) == 1 mereu.

Standardul C impune intervale minime de valori (în limits.h) și o ordine: sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long). Concret:

  • char: cel puțin 8 biți (CHAR_BIT >= 8), iar sizeof(char) este 1 prin definiție
  • short și int: cel puțin 16 biți
  • long: cel puțin 32 de biți
  • long long (din C99): cel puțin 64 de biți

Restul depinde de platformă și de modelul de date. Pe Linux și macOS pe 64 de biți (modelul LP64) int are 32 de biți, iar long și pointerii 64. Pe Windows pe 64 de biți (modelul LLP64) long rămâne pe 32 de biți și doar long long și pointerii au 64. Pe multe microcontrolere pe 8 sau 16 biți int are 16 biți, deci int x = 40000; nu încape.

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

int main(void) {
    printf("int: %zu octeti, max %d\n", sizeof(int), INT_MAX);
    printf("long: %zu octeti\n", sizeof(long));
    return 0;
}

Consecința practică: dacă ai nevoie de o lățime exactă (protocoale, registre, fișiere binare), folosești tipurile din stdint.h, cum ar fi int32_t sau uint8_t, nu presupui că long are 64 de biți. Codul care memorează un pointer într-un long funcționează pe Linux și se strică pe Windows.

Ce urmărește intervievatorul: Verifică dacă știi diferența dintre ce garantează standardul și ce face compilatorul tău. Greșeala tipică: „int are 4 octeți” spus ca regulă universală.

2 Junior

Ce afișează codul următor?

C
#include <stdio.h>
int main(void) {
    printf("%d %d\n", 7 / 2, -7 / 2);
    printf("%d %d\n", 7 % 3, -7 % 3);
    printf("%.1f\n", 7 / 2.0);
    return 0;
}

Răspuns scurt: Afișează 3 -3, apoi 1 -1, apoi 3.5. Împărțirea a doi întregi trunchiază spre zero (garantat din C99), iar restul are semnul deîmpărțitului.

Când ambii operanzi sunt întregi, / face împărțire întreagă: rezultatul e trunchiat, partea fracționară se pierde. Din C99 trunchierea se face spre zero, deci -7 / 2 dă -3, nu -4 (în C89 era implementation-defined pentru operanzi negativi).

Operatorul % respectă identitatea (a / b) * b + a % b == a. Cu -7 / 2 == -3, restul lui -7 % 3 trebuie să fie -1, pentru că (-2) * 3 + (-1) == -7. Deci semnul restului urmează deîmpărțitul. De aici o capcană clasică: testul de paritate if (x % 2 == 1) nu prinde numerele negative impare, pentru că -3 % 2 este -1. Varianta corectă e x % 2 != 0.

În a treia linie, 2.0 este double, așa că 7 e convertit la double și rezultatul e 3.5. Dacă scriai printf("%f", 7 / 2), ai fi avut comportament nedefinit: %f așteaptă un double, dar primește un int, iar compilatorul nu convertește automat argumentele după specificator.

C
int suma = 7, n = 2;
double media = (double)suma / n;   /* 3.5 */
double gresit = suma / n;          /* 3.0, împărțirea s-a făcut întâi pe int */

Mai reține că împărțirea întreagă la zero și INT_MIN / -1 sunt comportament nedefinit.

Ce urmărește intervievatorul: Verifică regulile aritmetice de bază și cazurile cu numere negative. Mulți candidați spun -4 pentru -7 / 2 sau cred că % întoarce mereu valori pozitive.

3 Junior

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

C
#include <stdio.h>
int main(void) {
    int i = 5;
    size_t s = sizeof(i++);
    printf("%zu %d\n", s, i);
    return 0;
}

Răspuns scurt: sizeof dă dimensiunea în octeți a unui tip sau a unei expresii, de tip size_t, calculată la compilare. Expresia nu se evaluează, deci afișează 4 5 (pe platformele cu int pe 4 octeți).

sizeof este un operator, nu o funcție. Primește fie un tip între paranteze (sizeof(int)), fie o expresie (sizeof x sau sizeof(x)), și întoarce o valoare de tip size_t, un întreg fără semn definit în stddef.h.

Pentru expresii, compilatorul se uită doar la tipul expresiei; ea nu se execută. De aceea i++ din sizeof(i++) nu are efect și i rămâne 5. Singura excepție sunt tablourile de lungime variabilă (VLA, din C99), unde dimensiunea se calculează la rulare.

Câteva lucruri pe care le verifică intervievatorul aici:

  • size_t se afișează cu %zu, nu cu %d; un specificator greșit e comportament nedefinit
  • sizeof pe un tablou dă dimensiunea totală, deci numărul de elemente e sizeof a / sizeof a[0]
  • sizeof pe un pointer dă dimensiunea pointerului (8 octeți pe 64 de biți), nu a zonei spre care arată
  • sizeof(char) este 1 prin definiție
C
int a[10];
int *p = a;
printf("%zu %zu\n", sizeof a / sizeof a[0], sizeof p);  /* 10 8 */

Pentru că rezultatul e fără semn, o expresie ca if (i < sizeof a - 20) poate da rezultate surprinzătoare: sizeof a - 20 nu devine negativ, ci un număr uriaș.

Ce urmărește intervievatorul: Verifică dacă știi că sizeof lucrează la compilare și ce tip întoarce. Greșeala tipică e să răspunzi 4 6, crezând că expresia se evaluează.

Eroarea, în practică:sizeof on array function parameterformat 'int' but argument 'unsigned long' (%zu)

4 Junior

char este cu semn sau fără semn? Și de ce getchar() întoarce int, nu char?

Răspuns scurt: Depinde de implementare: char, signed char și unsigned char sunt trei tipuri distincte, iar semnul lui char simplu îl alege compilatorul. getchar() întoarce int ca să poată distinge orice octet de valoarea EOF.

Standardul spune că char simplu are același interval fie ca signed char, fie ca unsigned char, la alegerea implementării. Pe x86 cu GCC este de obicei cu semn, pe ARM Linux de obicei fără semn. De aceea un cod ca acesta se comportă diferit pe cele două platforme:

C
char c = 200;          /* pe x86: -56, pe ARM: 200 */
if (c > 127) puts("mare");

Când lucrezi cu octeți bruți (buffere, protocoale, fișiere binare) folosești unsigned char sau uint8_t, nu char.

getchar(), fgetc() și getc() întorc un int care conține fie un octet convertit la unsigned char (0–255), fie EOF, o valoare negativă (de obicei -1). Dacă salvezi rezultatul într-un char, pierzi distincția:

C
int c;                       /* corect: int */
while ((c = getchar()) != EOF) {
    putchar(c);
}

Cu char c apar două buguri, în funcție de platformă. Dacă char e fără semn, EOF devine 255 și comparația c != EOF e mereu adevărată, deci bucla nu se oprește. Dacă char e cu semn, octetul 0xFF (de exemplu litera „ÿ” în Latin-1) devine -1 și bucla se oprește prematur în mijlocul fișierului.

Ce urmărește intervievatorul: Verifică dacă știi că semnul lui char nu e garantat și că ai citit corect bucla clasică de citire. Bug-ul cu char c = getchar() apare des în codul candidaților.

Eroarea, în practică:char * passed as unsigned char * (-Wpointer-sign)comparison of -1 with unsigned char always true

5 Junior

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

C
#include <stdio.h>
int main(void) {
    int i = -1;
    unsigned int u = 1;
    if (i < u) puts("mai mic");
    else       puts("mai mare");
    return 0;
}

Răspuns scurt: Afișează mai mare. La compararea unui int cu un unsigned int, int-ul e convertit la unsigned, iar -1 devine UINT_MAX, mult mai mare decât 1.

Regula se numește conversiile aritmetice uzuale (usual arithmetic conversions). Când un operator binar primește doi operanzi de tipuri diferite, ei sunt aduși la un tip comun. Dacă unul este unsigned int și celălalt int, tipul comun este unsigned int. Conversia unui număr negativ la un tip fără semn este bine definită: se adună UINT_MAX + 1 până intră în interval, deci -1 devine 4294967295 pe un unsigned de 32 de biți.

Așa că i < u compară de fapt 4294967295 < 1, ceea ce e fals.

Aceeași capcană apare foarte des cu size_t:

C
int n = -1;
if (n < sizeof(int))      /* fals! n devine size_t uriaș */
    puts("niciodata");

for (size_t k = len - 1; k >= 0; k--)   /* bucla infinită: k >= 0 e mereu adevărat */
    ;

Cum te ferești:

  • compilezi cu -Wall -Wextra, care include -Wsign-compare și te avertizează
  • nu amesteci tipuri cu și fără semn în comparații; faci explicit un cast după ce ai verificat semnul (if (n >= 0 && (size_t)n < len))
  • pentru bucle descrescătoare pe size_t folosești forma for (size_t k = len; k-- > 0; )

Atenție: dacă tipul fără semn e mai mic decât int (de exemplu unsigned short), intervin întâi promovările întregi și comparația se face pe int, cu rezultatul „intuitiv”.

Ce urmărește intervievatorul: Verifică dacă știi regulile de conversie implicită, sursă de multe buguri reale. Candidații răspund de obicei „mai mic” fără să se gândească la tipul comun.

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

6 Junior

Ce sunt promovările întregi (integer promotions)? Ce afișează codul de mai jos?

C
#include <stdio.h>
int main(void) {
    unsigned char a = 200, b = 100;
    unsigned char c = a + b;
    printf("%d %d\n", a + b, c);
    printf("%d\n", (unsigned char)~a == 55);
    return 0;
}

Răspuns scurt: Înainte de aproape orice operație aritmetică, tipurile mai mici decât int (char, short, câmpuri de biți) sunt convertite la int. Codul afișează 300 44, apoi 1.

Promovările întregi spun că un operand de tip char, signed char, unsigned char, short sau unsigned short este convertit la int (sau la unsigned int dacă int nu poate reprezenta toate valorile lui) înainte de operatorii aritmetici, pe biți și de comparație. Procesorul lucrează natural pe int, iar standardul descrie exact acest lucru.

În exemplu:

  • a + b se calculează pe int: 200 + 100 = 300, fără overflow, și se afișează 300
  • la atribuirea în c, valoarea 300 e convertită la unsigned char, deci modulo 256: 300 - 256 = 44
  • ~a se aplică pe int-ul 200, deci rezultatul este ~0x000000C8 = 0xFFFFFF37, un int negativ; abia castul la unsigned char păstrează ultimul octet, 0x37 = 55

Fără cast, ~a == 55 ar fi fals, iar acesta e un bug frecvent în codul embedded:

C
uint8_t reg = 0x0F;
if (~reg == 0xF0) { }            /* niciodată adevărat */
if ((uint8_t)~reg == 0xF0) { }   /* corect */

Mai există o capcană: uint16_t x = 0xFFFF; x * x se face pe int (cu semn) și depășește INT_MAX, ceea ce e comportament nedefinit. Soluția e să forțezi aritmetica fără semn: (uint32_t)x * x.

Ce urmărește intervievatorul: Verifică înțelegerea modului real în care C face aritmetica pe tipuri mici, esențial în embedded. Majoritatea candidaților cred că unsigned char + unsigned char se calculează pe 8 biți.

7 Junior

Ce diferență este între & și &&, respectiv | și ||? Ce afișează printf("%d %d %d %d", 6 & 3, 6 && 3, 6 | 3, 6 ^ 3);?

Răspuns scurt: & și | lucrează bit cu bit și evaluează ambii operanzi; && și || sunt logici, întorc 0 sau 1 și se opresc devreme (short-circuit). Codul afișează 2 1 7 5.

Operatorii pe biți (&, |, ^, ~) aplică operația pe fiecare bit al operanzilor. Pentru 6 (110) și 3 (011):

  • 6 & 3 = 010 = 2 (bit setat doar unde e setat în ambii)
  • 6 | 3 = 111 = 7
  • 6 ^ 3 = 101 = 5 (XOR: bit setat unde diferă)

Operatorii logici (&&, ||, !) tratează orice valoare nenulă ca adevărată și întorc un int cu valoarea 0 sau 1. 6 && 3 dă 1.

Diferența importantă în practică e evaluarea scurtcircuitată. && nu mai evaluează operandul drept dacă cel stâng e fals, iar || nu îl evaluează dacă cel stâng e adevărat. Pe asta se bazează codul defensiv:

C
if (p != NULL && p->len > 0) { }   /* sigur */
if (p != NULL &  p->len > 0) { }   /* bug: p->len se citește și când p e NULL */

A doua capcană: & aplicat pe două condiții „adevărate” poate da fals. 2 && 1 e 1, dar 2 & 1 e 0. Dacă scrii if (flags & MASK_A & MASK_B), testezi altceva decât crezi.

Operatorii pe biți se folosesc pentru măști și flag-uri (if (flags & FLAG_READ)), cei logici pentru condiții. În cod de producție se recomandă paranteze explicite când le combini cu comparații, pentru că precedența lui & este mai mică decât a lui ==.

Ce urmărește intervievatorul: Verifică distincția dintre operații pe biți și logică, plus short-circuit. Greșeala tipică e folosirea lui & în loc de && într-o condiție cu pointer.

Eroarea, în practică:& has lower precedence than ==

8 Junior

Unde sunt bugurile în codul următor?

C
if (x & 1 == 0)  puts("par");
int y = a == b;
int z = *p++;     /* intenția: incrementez valoarea */

Răspuns scurt: Toate trei sunt probleme de precedență: == se leagă mai tare decât &, deci prima linie testează x & 0; a doua e corectă tehnic dar ambiguă la citire; a treia incrementează pointerul, nu valoarea.

Câteva niveluri de precedență din C sunt contraintuitive.

Prima linie. Operatorii pe biți &, ^, | au precedență mai mică decât == și != (moștenire istorică din limbajul B). Deci x & 1 == 0 înseamnă x & (1 == 0), adică x & 0, mereu 0. Corect:

C
if ((x & 1) == 0) puts("par");

GCC avertizează cu -Wparentheses (inclus în -Wall).

A doua linie. int y = a == b; atribuie lui y rezultatul comparației (0 sau 1), ceea ce e valid. Problema e lizibilitatea: un coleg poate crede că lipsește un =. Scrii int y = (a == b);.

A treia linie. Operatorii postfix (++, [], ->, apelul de funcție) au precedență mai mare decât cei unari prefix (*, &, !). Deci *p++ înseamnă *(p++): citește valoarea de la p, apoi mută pointerul. Ca să incrementezi valoarea scrii (*p)++ sau ++*p.

Alte capcane cunoscute:

  • a << 1 + 1 înseamnă a << 2, pentru că + are precedență mai mare decât <<
  • *s.field înseamnă *(s.field), nu (*s).field
  • operatorul ternar și atribuirea au precedență mică: x = cond ? a : b funcționează, dar combinații cu virgulă devin ilizibile

Regula practică: pune paranteze când combini operatori pe biți, shiftări și comparații.

Ce urmărește intervievatorul: Verifică atenția la detalii și experiența cu code review pe C. Candidații slabi spun că „toate trei sunt corecte”.

Eroarea, în practică:& has lower precedence than ==logical not is only applied to the left hand side

9 Mid

Care sunt capcanele operatorilor de shiftare << și >> în C?

Răspuns scurt: Shiftarea cu un număr negativ sau mai mare ori egal cu lățimea tipului e comportament nedefinit, shiftarea la stânga a unui număr cu semn în bitul de semn e nedefinită, iar shiftarea la dreapta a unui negativ e implementation-defined.

Pe tipuri fără semn, shiftările sunt simple: x << n înmulțește cu 2^n modulo 2^lățime, iar x >> n împarte întreg la 2^n. Problemele apar la margini și la tipurile cu semn.

Numărul de poziții. Dacă n este negativ sau n >= lățimea tipului promovat, comportamentul e nedefinit. Pe x86, 1u << 32 dă adesea 1, pentru că procesorul folosește doar ultimii 5 biți ai lui n, dar compilatorul poate face orice.

Shift la stânga cu semn. 1 << 31 pe un int de 32 de biți pune 1 în bitul de semn, rezultat nereprezentabil, deci comportament nedefinit în C99/C11/C17. Corect este 1u << 31 sau UINT32_C(1) << 31.

Shift la dreapta cu semn. -8 >> 1 este implementation-defined: majoritatea compilatoarelor fac shift aritmetic (rezultat -4), dar standardul nu garantează.

Promovarea. Operandul stâng e întâi promovat, iar tipul rezultatului e al lui, nu al lui n:

C
uint8_t b = 0x80;
uint32_t r = b << 24;          /* b devine int; 0x80 << 24 depășește INT_MAX: UB */
uint32_t ok = (uint32_t)b << 24;

uint64_t m = 1 << 40;          /* UB: 1 e int */
uint64_t m2 = UINT64_C(1) << 40;

Regula practică: shiftezi doar valori fără semn, de tipul suficient de lat, cu un număr de poziții verificat.

Ce urmărește intervievatorul: Verifică experiența cu cod pe biți, unde aceste buguri apar în registre și protocoale. Greșeala tipică e 1 << 31 cu literal cu semn.

Eroarea, în practică:shift count >= width of type'<<' has lower precedence than '+'

10 Mid

De ce 0.1 + 0.2 == 0.3 este fals în C și cum compari corect numere reale? Ce specificatori folosești pentru float și double în printf și scanf?

Răspuns scurt: 0.1, 0.2 și 0.3 nu au reprezentare exactă în binar (IEEE 754), deci suma diferă cu ultima cifră. Compari cu o toleranță. În printf folosești %f pentru ambele tipuri, în scanf %f pentru float și %lf pentru double.

Pe aproape toate platformele, double folosește formatul IEEE 754 pe 64 de biți: mantisă binară de 53 de biți. Fracția 0.1 în baza 2 este periodică (0.000110011...), deci se stochează cea mai apropiată valoare. 0.1 + 0.2 dă 0.30000000000000004, iar 0.3 e stocat ca 0.29999999999999999, așa că == întoarce 0.

Comparația corectă folosește o toleranță relativă:

C
#include <math.h>
#include <float.h>
#include <stdbool.h>

bool aproape_egal(double a, double b) {
    double diff = fabs(a - b);
    double mare = fmax(fabs(a), fabs(b));
    return diff <= mare * 1e-9 || diff < 1e-12;
}

O toleranță absolută fixă (fabs(a - b) < 1e-9) e prea strictă pentru numere mari și prea largă pentru numere foarte mici.

Despre specificatori: la funcțiile variadice, float e promovat automat la double (default argument promotions). De aceea printf("%f", x) merge pentru ambele tipuri, iar %lf în printf e acceptat din C99, dar inutil. În scanf se transmite un pointer, iar pointerii nu se promovează: %f cere float *, %lf cere double *. Confuzia dintre ele duce la valori greșite.

Pentru bani nu folosești double: lucrezi în unități întregi (bani, cenți) cu int64_t.

Ce urmărește intervievatorul: Verifică dacă știi de ce aritmetica în virgulă mobilă e aproximativă și dacă ai văzut bugul %f/%lf în scanf. Candidații propun adesea epsilon fix pentru orice interval.

Eroarea, în practică:comparing floating point with == or != is unsafeformat 'float *' but argument has type 'double *'

11 Mid

Ce aduc stdint.h și inttypes.h? Când folosești int32_t, int_fast16_t, intptr_t sau PRIu64?

Răspuns scurt: stdint.h (C99) definește tipuri întregi cu lățime exactă, minimă sau rapidă, plus intptr_t. inttypes.h adaugă macro-uri pentru printf/scanf, ca PRIu64, ca să afișezi portabil aceste tipuri.

stdint.h rezolvă problema dimensiunilor nesigure ale tipurilor clasice. Familiile principale:

  • int8_t, uint16_t, int32_t, uint64_t: lățime exactă, fără padding; sunt opționale, dar există pe orice platformă obișnuită
  • int_least16_t: cel mai mic tip cu cel puțin 16 biți, garantat mereu
  • int_fast16_t: cel mai rapid tip cu cel puțin 16 biți (poate avea 64 de biți pe x86-64)
  • intptr_t / uintptr_t: întreg în care încape un pointer la obiect, util pentru calcule de aliniere
  • intmax_t: cel mai lat întreg disponibil
  • constante ca INT32_MAX, UINT64_C(5)

Când alegi: lățime exactă pentru date care ies din program (fișiere binare, rețea, registre hardware), tipurile fast pentru contoare în bucle pe cod portabil, size_t pentru dimensiuni și indici de tablou.

Problema de afișare: printf("%ld", x) pentru un int64_t merge pe Linux 64 de biți (unde e long), dar pe Windows e long long. inttypes.h oferă macro-uri care se expandează la specificatorul corect:

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

int main(void) {
    uint64_t n = UINT64_C(18446744073709551615);
    int32_t t = -5;
    printf("%" PRIu64 " %" PRId32 "\n", n, t);
    return 0;
}

Macro-ul PRIu64 e un șir literal (de exemplu "lu"), iar C lipește automat literalele alăturate.

Ce urmărește intervievatorul: Verifică dacă scrii cod portabil și ai lucrat cu formate binare. Candidații știu de int32_t, dar puțini știu cum îl afișezi corect.

12 Mid

Ce valori primesc variabilele de mai jos? Care linii au comportament definit, care implementation-defined și care nedefinit?

C
int a = (int)3.99;
int b = (int)-3.99;
unsigned u = (unsigned)-1;
signed char c = 200;
int d = (int)1e20;

Răspuns scurt: a = 3 și b = -3 (trunchiere spre zero), u = UINT_MAX (definit), c e implementation-defined (de obicei -56), iar d e comportament nedefinit, pentru că valoarea nu încape în int.

Conversiile au reguli diferite în funcție de direcție:

Real → întreg. Partea fracționară se aruncă, cu trunchiere spre zero: 3.99 devine 3, -3.99 devine -3. Pentru rotunjire folosești lround() din math.h. Dacă partea întreagă nu încape în tipul destinație, cum e 1e20 în int, comportamentul e nedefinit. Pe x86 obții de obicei INT_MIN, pe ARM valoarea saturată, iar optimizatorul poate presupune că nu se întâmplă.

Orice întreg → întreg fără semn. Mereu definit: rezultatul e valoarea modulo 2^N. (unsigned)-1 este UINT_MAX, motiv pentru care idiomul e folosit pentru „toți biții pe 1”.

Întreg → întreg cu semn, valoare care nu încape. signed char c = 200 este implementation-defined (sau poate ridica un semnal definit de implementare). GCC documentează că face reducere modulo 2^N, deci 200 - 256 = -56. Din C23, reprezentarea în complement față de doi devine obligatorie, dar conversia rămâne implementation-defined.

Întreg → real. Dacă valoarea nu poate fi reprezentată exact (de exemplu int64_t mare în float), se rotunjește.

C
double x = 2.7;
long r = lround(x);        /* 3 */
int t = (int)x;            /* 2 */

Practic: verifici intervalul înainte de conversie (if (x >= INT_MIN && x < INT_MAX + 1.0)) și activezi -Wconversion ca să vezi conversiile implicite cu pierdere.

Ce urmărește intervievatorul: Verifică dacă distingi cele trei categorii de comportament pe exemple concrete. Mulți cred că toate conversiile „trunchiază biții”, inclusiv cele din real.

Eroarea, în practică:implicit conversion ... changes value

13 Senior

Scrie o funcție care adună două int-uri și raportează dacă rezultatul ar depăși intervalul, fără să provoace ea însăși comportament nedefinit.

Răspuns scurt: Verifici înainte de adunare: dacă b > 0 și a > INT_MAX - b, sau dacă b < 0 și a < INT_MIN - b, ar apărea overflow. Alternativ, GCC și Clang oferă __builtin_add_overflow, iar C23 standardizează ckd_add în stdckdint.h.

Overflow-ul pe întregi cu semn este comportament nedefinit, deci nu poți aduna întâi și verifica după. Un test ca if (a + b < a) poate fi eliminat de compilator: el presupune că overflow-ul nu există, iar pentru b > 0 condiția devine „mereu falsă”.

Varianta portabilă, în C99/C11/C17, verifică pe operanzi:

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

bool add_safe(int a, int b, int *out) {
    if ((b > 0 && a > INT_MAX - b) ||
        (b < 0 && a < INT_MIN - b)) {
        return false;            /* ar depăși */
    }
    *out = a + b;
    return true;
}

Expresiile INT_MAX - b (cu b > 0) și INT_MIN - b (cu b < 0) nu pot depăși ele însele intervalul, deci verificarea e sigură.

GCC și Clang au funcții încorporate care folosesc direct flag-ul de carry al procesorului:

C
int r;
if (__builtin_add_overflow(a, b, &r)) { /* overflow */ }

În C23 există varianta standard ckd_add(&r, a, b) din stdckdint.h.

Pentru înmulțire, verificarea manuală e mai complicată (semne combinate, INT_MIN * -1), de aceea built-in-urile sunt preferate. O altă tehnică e calculul într-un tip mai lat (int64_t pentru doi int32_t) și compararea cu limitele. La testare, rulezi cu -fsanitize=undefined, care raportează orice overflow cu semn la rulare.

Ce urmărește intervievatorul: Verifică dacă înțelegi că UB-ul nu se poate „detecta după” și dacă știi variantele moderne. Răspunsul tipic greșit este if (a + b < a).

Eroarea, în practică:overflow in expression; result with type 'int'

Control al fluxului și funcții

14 Junior

De ce funcția swap de mai jos nu schimbă valorile? Repar-o.

C
void swap(int a, int b) {
    int t = a; a = b; b = t;
}
int main(void) { int x = 1, y = 2; swap(x, y); }

Răspuns scurt: În C argumentele se transmit mereu prin valoare: swap primește copii ale lui x și y și schimbă copiile. Ca să modifici variabilele apelantului, transmiți adresele lor și lucrezi prin pointeri.

C nu are referințe ca C++. La apelul swap(x, y), valorile lui x și y sunt copiate în parametrii a și b, care sunt variabile locale ale funcției, cu viață doar pe durata apelului. Orice modificare asupra lor dispare la return.

Soluția este să transmiți adresele variabilelor. Pointerul în sine e tot transmis prin valoare, dar copia lui arată spre aceeași memorie:

C
#include <stdio.h>

void swap(int *a, int *b) {
    int t = *a;
    *a = *b;
    *b = t;
}

int main(void) {
    int x = 1, y = 2;
    swap(&x, &y);
    printf("%d %d\n", x, y);   /* 2 1 */
    return 0;
}

Consecințe importante ale transmiterii prin valoare:

  • o structură transmisă direct se copiază integral; pentru structuri mari transmiți const struct T *
  • un tablou nu se copiază niciodată: numele lui decade la pointer spre primul element, de aceea funcția poate modifica elementele
  • dacă vrei ca funcția să modifice un pointer al apelantului (de exemplu să-i aloce memorie), îi transmiți un pointer la pointer, int **

Varianta „fără variabilă temporară” cu XOR (*a ^= *b; *b ^= *a; *a ^= *b;) apare uneori la interviu, dar are un bug: dacă a == b (aceeași adresă), valoarea devine 0. Nu e mai rapidă pe procesoarele moderne și e mai greu de citit.

Ce urmărește intervievatorul: Verifică înțelegerea fundamentală a modelului de apel din C. Răspunsul greșit e că „trebuie returnate valorile” sau confuzia cu referințele din C++.

15 Junior

Ce diferență este în C între int f(); și int f(void);? Ce se întâmplă dacă apelezi o funcție fără să existe prototip înainte?

Răspuns scurt: Până la C17, int f(); declară o funcție cu parametri nespecificați, deci compilatorul nu verifică argumentele, iar int f(void); spune clar că nu are parametri. Apelul fără nicio declarație a fost scos din C99 și produce eroare sau avertisment.

Un prototip este o declarație care specifică tipurile parametrilor. Cu prototip, compilatorul verifică numărul și tipurile argumentelor și le convertește dacă e cazul.

int f(); în C89–C17 este o declarație în stil vechi (K&R): spune doar că f întoarce int, fără informații despre parametri. Apelul f(1, 2, 3) compilează fără eroare, chiar dacă definiția nu are parametri, iar comportamentul e nedefinit. De aceea în C scrii explicit int f(void); și int main(void). În C23 regula s-a schimbat și f() înseamnă și în C „fără parametri”, ca în C++.

Fără nicio declarație, C89 presupunea declarația implicită int f(). C99 a eliminat-o, iar GCC 14 o tratează implicit ca eroare. Problema reală era gravă:

C
/* fără #include <stdlib.h> în C89 */
int main(void) {
    char *p = malloc(100);   /* malloc presupus că întoarce int */
    return 0;
}

Pe 64 de biți, pointerul de 64 de biți era trunchiat la un int de 32, iar programul cădea aleatoriu. De aici venea și sfatul „nu face cast la rezultatul lui malloc”: castul ascundea avertismentul despre lipsa declarației.

Practica bună: fiecare funcție publică are prototipul într-un header inclus atât de fișierul care o definește, cât și de cel care o folosește; funcțiile interne sunt static și declarate sus în fișier. Compilezi cu -Wmissing-prototypes și -Wstrict-prototypes.

Ce urmărește intervievatorul: Verifică o particularitate a C care îl diferențiază de C++. Mulți candidați nu știu că f() și f(void) diferă până la C17.

Eroarea, în practică:call to undeclared functionconflicting types for 'medie'

16 Junior

Ce diferență este între domeniul de vizibilitate (scope) și durata de stocare (storage duration) a unei variabile? Ce valori inițiale au variabilele de mai jos?

C
int g;
void f(void) {
    int local;
    static int s;
    int *p = malloc(sizeof *p);
}

Răspuns scurt: Scope-ul spune unde e vizibil numele; durata de stocare spune cât trăiește obiectul. g și s au durată statică și sunt inițializate cu 0; local și *p au valori nedeterminate.

Scope-ul (domeniul) este regiunea din cod în care poți folosi un nume: de fișier (în afara funcțiilor), de bloc (între acolade), de prototip, de funcție (doar etichetele pentru goto).

Durata de stocare este intervalul în care obiectul există în memorie:

  • automatică: variabilele locale fără static; apar la intrarea în bloc și dispar la ieșire, de obicei pe stivă
  • statică: variabilele globale și cele locale cu static; există pe toată durata programului
  • alocată: memoria de la malloc, calloc, realloc; trăiește până la free
  • thread (C11): _Thread_local, câte o copie pe fiecare thread

Cele două noțiuni sunt independente. s are scope de bloc (vizibilă doar în f) dar durată statică, deci își păstrează valoarea între apeluri.

Inițializarea implicită:

  • obiectele cu durată statică fără inițializator sunt inițializate cu zero (0, NULL, 0.0); de aceea g și s sunt 0
  • variabilele automatice au valoare nedeterminată; citirea lui local înainte de atribuire e o eroare
  • malloc nu inițializează memoria; calloc o pune pe zero
C
int *contor(void) {
    static int n = 0;    /* inițializat o singură dată */
    n++;
    return &n;           /* corect: n trăiește după return */
}

Returnarea adresei unei variabile automatice ar fi fost un bug, pentru că obiectul nu mai există după return.

Ce urmărește intervievatorul: Verifică dacă separi corect două noțiuni pe care mulți le confundă. Greșeala tipică: „variabilele locale sunt inițializate cu 0”.

Eroarea, în practică:initializer element is not a compile-time constantaddress of stack memory ... returned

17 Junior

Cum funcționează recursivitatea în C, la nivel de stivă de apeluri? Ce problemă are implementarea de mai jos pentru n mare?

C
unsigned long long fib(int n) {
    return n < 2 ? n : fib(n - 1) + fib(n - 2);
}

Răspuns scurt: Fiecare apel creează un cadru (stack frame) cu parametrii, variabilele locale și adresa de întoarcere. Funcția de mai jos are complexitate exponențială, aproximativ O(1,6^n), pentru că recalculează aceleași valori, iar o recursivitate prea adâncă umple stiva.

La fiecare apel de funcție se creează pe stivă un cadru de apel (stack frame) care conține de obicei adresa de întoarcere, registrele salvate, parametrii care nu încap în registre și variabilele locale. La return, cadrul e eliberat. O funcție recursivă pune un cadru nou la fiecare nivel, iar stiva are dimensiune limitată: de obicei 8 MB pe Linux pentru threadul principal (ulimit -s), 1 MB pe Windows și uneori doar câțiva KB pe microcontrolere. Depășirea dă stack overflow, care pe Linux apare ca segmentation fault.

Funcția fib are două probleme:

  • timp exponențial: fib(n) apelează fib(n-1) și fib(n-2), care la rândul lor recalculează aceleași valori; pentru n = 50 sunt zeci de miliarde de apeluri
  • adâncimea maximă e doar n, deci stiva nu e problema aici, ci timpul

Versiunea iterativă e O(n) în timp și O(1) în memorie:

C
unsigned long long fib(int n) {
    unsigned long long a = 0, b = 1;
    for (int i = 0; i < n; i++) {
        unsigned long long t = a + b;
        a = b;
        b = t;
    }
    return a;
}

unsigned long long încape până la fib(93). Pentru recursivitate adâncă (parcurgerea unei liste lungi recursiv, DFS pe un graf mare), riscul de stack overflow e real. Standardul C nu garantează eliminarea recursivității de coadă (tail call); GCC o face doar la -O2, deci nu te bazezi pe ea.

Ce urmărește intervievatorul: Verifică înțelegerea modelului de execuție și a complexității. Candidații scriu varianta recursivă, dar nu pot explica de ce e lentă sau ce limitează adâncimea.

Eroarea, în practică:all paths through this function will call itself

18 Junior

Ce afișează codul următor pentru x = 2? Ce reguli are switch în C?

C
switch (x) {
    case 1: printf("unu ");
    case 2: printf("doi ");
    case 3: printf("trei ");
    default: printf("altul ");
}

Răspuns scurt: Afișează doi trei altul, pentru că fără break execuția continuă în cazurile următoare (fall-through). Etichetele case trebuie să fie expresii constante întregi distincte, deci nu poți folosi șiruri sau double.

switch evaluează expresia o singură dată și sare la eticheta case corespunzătoare. Etichetele sunt doar puncte de intrare, nu blocuri separate, așa că execuția continuă până la primul break, return sau finalul switch-ului. Acesta e fall-through-ul.

Regulile principale:

  • expresia trebuie să fie de tip întreg (inclusiv char și enum), după promovări
  • fiecare case are o expresie constantă întreagă; o variabilă const int nu e acceptată în C (în C++ da)
  • etichetele trebuie să fie distincte
  • default e opțional și poate sta oriunde
  • nu poți compara șiruri; pentru ele folosești if cu strcmp

Fall-through-ul e uneori util, pentru cazuri care împart același cod:

C
switch (c) {
    case 'a': case 'e': case 'i': case 'o': case 'u':
        vocale++;
        break;
    default:
        consoane++;
        break;
}

Când e intenționat după cod executat, se marchează cu un comentariu /* fall through */ sau, în C23, cu [[fallthrough]];, iar GCC avertizează cu -Wimplicit-fallthrough pentru restul.

O capcană mai puțin cunoscută: o declarație cu inițializare imediat după un case poate fi sărită de salt, deci variabila rămâne neinițializată. Dacă ai nevoie de variabile locale într-un case, pui codul între acolade.

Cu un enum fără default, -Wswitch te avertizează dacă ai uitat o valoare, motiv pentru care unele echipe evită intenționat default.

Ce urmărește intervievatorul: Verifică înțelegerea fall-through-ului și a restricțiilor lui switch. Greșeala tipică e să răspunzi doar doi.

Eroarea, în practică:duplicate case valuestatement requires expression of integer type

19 Junior

Codul de mai jos ar trebui să afișeze numerele de la 0 la 4, apoi „cinci” dacă x e 5. Ce afișează de fapt și unde sunt bugurile?

C
int x = 3;
for (int i = 0; i < 5; i++);
{
    printf("%d\n", i);
}
if (x = 5) printf("cinci\n");

Răspuns scurt: Nu compilează: ; de după for termină bucla, iar i nu mai e vizibil în blocul următor. Chiar cu i declarat afară, s-ar afișa doar 5. Apoi if (x = 5) atribuie, nu compară, deci condiția e mereu adevărată.

Primul bug: ; după for. Instrucțiunea for (...); are un corp gol, adică instrucțiunea vidă ;. Blocul dintre acolade nu mai face parte din buclă, e un bloc independent care rulează o dată, după buclă. Cum i e declarat în antetul lui for (C99), scope-ul lui se termină odată cu bucla, iar compilatorul dă eroare „i undeclared”. Dacă i ar fi fost declarat înainte de buclă, programul ar fi afișat o singură valoare, 5.

Același bug apare și cu while (cond); și if (cond);. GCC avertizează pentru if și else cu -Wempty-body (inclus în -Wextra), iar -Wmisleading-indentation (din -Wall) prinde multe cazuri.

Al doilea bug: = în loc de ==. x = 5 este o atribuire, iar valoarea expresiei e 5, nenulă, deci adevărată. Pe lângă condiția greșită, x a fost modificat. Corect:

C
for (int i = 0; i < 5; i++) {
    printf("%d\n", i);
}
if (x == 5) printf("cinci\n");

Unii programatori scriu comparațiile cu constanta în stânga (if (5 == x), „Yoda conditions”), ca să transforme greșeala în eroare de compilare. Astăzi e mai simplu să lași compilatorul să ajute: -Wall avertizează pentru o atribuire folosită drept condiție fără paranteze duble. Când atribuirea e intenționată, se scrie if ((c = getchar()) != EOF).

Ambele buguri sunt motivul pentru care multe standarde de cod cer acolade obligatorii și compilare cu -Wall -Wextra -Werror.

Ce urmărește intervievatorul: Verifică atenția la detalii și dacă știi de avertismentele compilatorului. Unii candidați nu observă deloc ; de după for.

Eroarea, în practică:expected ';' in 'for' statement specifierif statement has empty body

20 Mid

Scrie o funcție variadică int suma(int n, ...) care adună n numere întregi. Ce reguli trebuie să respecți la funcțiile variadice?

Răspuns scurt: Folosești va_list, va_start, va_arg și va_end din stdarg.h. Funcția nu știe singură câte argumente sau de ce tip a primit, deci îi transmiți explicit (prin număr, șir de format sau o valoare-terminator).

O funcție variadică are cel puțin un parametru numit, urmat de .... Argumentele suplimentare se citesc cu macro-urile din stdarg.h:

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

int suma(int n, ...) {
    va_list ap;
    va_start(ap, n);          /* începe după ultimul parametru numit */
    int total = 0;
    for (int i = 0; i < n; i++) {
        total += va_arg(ap, int);
    }
    va_end(ap);
    return total;
}

int main(void) {
    printf("%d\n", suma(4, 1, 2, 3, 4));   /* 10 */
    return 0;
}

Regulile importante:

  • funcția nu poate afla numărul sau tipul argumentelor; informația vine prin convenție, ca șirul de format la printf sau un NULL final la execl
  • argumentele variadice suferă default argument promotions: char și short devin int, float devine double; deci va_arg(ap, float) sau va_arg(ap, char) e greșit
  • dacă tipul cerut la va_arg nu corespunde celui transmis, comportamentul e nedefinit; suma(2, 1.5, 2.5) dă rezultate aleatorii
  • fiecare va_start are un va_end; pentru a parcurge lista de două ori folosești va_copy (C99)

Pentru funcții proprii de tip printf, primești va_list și apelezi vfprintf sau vsnprintf, iar cu atributul GCC __attribute__((format(printf, 1, 2))) compilatorul îți verifică argumentele ca la printf.

Ce urmărește intervievatorul: Verifică dacă înțelegi mecanismul din spatele lui printf și pericolele lui. Greșeala tipică e va_arg(ap, float).

Eroarea, în practică:va_arg of promotable type ('float', 'char')'va_start' used in function with fixed args

21 Mid

Care e diferența dintre return din main, exit(), _Exit() și abort()? Ce face atexit()?

Răspuns scurt: return x din main echivalează cu exit(x): rulează funcțiile înregistrate cu atexit, golește și închide fluxurile FILE. _Exit termină imediat, fără acestea, iar abort termină anormal prin semnalul SIGABRT, de obicei cu core dump.

Toate opresc programul, dar diferă prin ce curățenie fac.

exit(status) rulează în ordine inversă funcțiile înregistrate cu atexit(), golește bufferele tuturor fluxurilor FILE deschise (fflush), le închide, șterge fișierele create cu tmpfile() și predă codul de ieșire sistemului. EXIT_SUCCESS și EXIT_FAILURE sunt valorile portabile.

return n; din main are același efect ca exit(n). Din C99, ieșirea din main fără return întoarce 0. Diferența subtilă: după return, variabilele locale ale lui main nu mai există, deci un buffer local dat lui setvbuf devine invalid înainte ca exit să golească fluxul.

_Exit(status) (C99) termină imediat: nu rulează atexit, iar golirea bufferelor depinde de implementare (glibc nu le golește). Se folosește în procesul copil după fork(), ca să nu golești de două ori bufferele moștenite de la părinte.

abort() ridică SIGABRT; dacă semnalul nu e tratat, programul se termină anormal, de obicei cu core dump, fără atexit. Asta face și assert când eșuează.

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

static void la_final(void) { puts("curățenie"); }

int main(void) {
    atexit(la_final);
    printf("lucrez");      /* fără \n, rămâne în buffer */
    _Exit(0);              /* cu glibc nu apare nimic din cele două */
}

Cu exit(0) sau return 0 s-ar afișa ambele texte.

Ce urmărește intervievatorul: Verifică dacă știi ce se întâmplă cu bufferele și resursele la ieșire. Candidații nu știu de obicei de _Exit și de problema lui fork.

Eroarea, în practică:'main' must return 'int'

22 Senior

Ce fac setjmp și longjmp, la ce se folosesc și de ce sunt periculoase?

Răspuns scurt: setjmp salvează contextul de execuție, iar longjmp sare înapoi la el din orice funcție apelată ulterior, desfăcând stiva. Se folosesc pentru tratarea erorilor în parsere sau biblioteci ca libpng, dar ocolesc orice curățenie și au reguli stricte pentru variabilele locale.

setjmp(env) salvează în env (de tip jmp_buf) registrele și pointerul de stivă și întoarce 0. Mai târziu, longjmp(env, val) restaurează acel context, iar execuția continuă ca și cum setjmp ar fi întors val (dacă val e 0, întoarce 1). Toate cadrele de apel dintre cele două puncte sunt abandonate.

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

static jmp_buf eroare;

static void parseaza(const char *s) {
    if (*s == '\0') longjmp(eroare, 1);   /* „aruncă” */
}

int main(void) {
    if (setjmp(eroare) == 0) {
        parseaza("");
        puts("ok");
    } else {
        puts("eroare la parsare");
    }
    return 0;
}

Biblioteci reale (libpng, Lua, unele parsere) îl folosesc ca mecanism de excepții în C.

Pericolele:

  • nicio curățenie: memoria alocată, fișierele deschise sau mutexurile luate în funcțiile sărite rămân așa; trebuie să le ții evidența separat
  • variabilele locale: variabilele automatice ale funcției care a apelat setjmp, modificate între setjmp și longjmp, au valoare nedeterminată dacă nu sunt volatile, pentru că pot fi ținute în registre
  • longjmp către o funcție care a făcut deja return e comportament nedefinit
  • setjmp poate apărea doar în contexte limitate (condiția unui if, switch, o comparație simplă), nu în orice expresie
  • din handlere de semnal se folosesc sigsetjmp/siglongjmp (POSIX), ca să restaureze și masca de semnale

Într-un cod nou, un model cu coduri de eroare și goto cleanup e aproape mereu mai sigur.

Ce urmărește intervievatorul: Verifică profunzimea cunoștințelor despre modelul de execuție și despre biblioteci C reale. Puțini candidați știu regula cu volatile.

Pointeri și tablouri

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

Ce este NULL, ce este un pointer „sălbatic” (wild pointer) și de ce inițializezi mereu pointerii?

Răspuns scurt: NULL este constanta de pointer nul, o valoare care garantat nu arată spre niciun obiect valid. Un pointer sălbatic e unul neinițializat, cu o adresă aleatorie. Îl inițializezi cu NULL ca să poți testa dacă e valid înainte de folosire.

NULL e un macro (definit în stddef.h, stdio.h, stdlib.h) care se expandează la o constantă de pointer nul, de obicei ((void *)0). Un pointer nul compară diferit de adresa oricărui obiect sau funcție, deci e marcajul standard pentru „nu arată nicăieri”: malloc îl întoarce la eșec, strchr când nu găsește, iar listele înlănțuite se termină cu el.

Un pointer sălbatic este o variabilă pointer automatică neinițializată. Valoarea ei e ce a rămas pe stivă, deci poate arăta spre o zonă validă din programul tău. Scrierea prin el nu dă neapărat crash, ci poate corupe în tăcere alte date:

C
int *p;          /* sălbatic */
*p = 10;         /* comportament nedefinit: poate merge, poate strica altceva */

int *q = NULL;   /* sigur de testat */
if (q != NULL) *q = 10;

Dereferențierea lui NULL e și ea comportament nedefinit, dar pe sistemele cu memorie virtuală pagina de la adresa 0 nu e mapată, deci programul se oprește imediat cu segmentation fault. Un crash previzibil e mult mai ușor de depanat decât o corupere aleatorie.

Pe microcontrolere fără MMU, adresa 0 poate fi memorie validă (de exemplu tabela de vectori de întrerupere), deci accesul prin NULL nu dă crash și poate citi sau scrie date reale.

Regulile practice: inițializezi pointerul la declarare, pui NULL după free, verifici rezultatul funcțiilor care pot întoarce NULL și compilezi cu -Wall, care avertizează despre variabile folosite neinițializate.

Ce urmărește intervievatorul: Verifică disciplina de lucru cu pointeri. Greșeala tipică e să crezi că un pointer neinițializat e automat NULL.

Eroarea, în practică:Segmentation fault (core dumped)

24 Junior

Ce valori au x, y, z și tabloul la final?

C
int a[] = {10, 20, 30, 40};
int *p = a;
int x = *p++;
int y = *++p;
int z = ++*p;

Răspuns scurt: x = 10, y = 30, z = 31, iar tabloul devine {10, 20, 31, 40}. *p++ citește apoi mută pointerul, *++p mută apoi citește, iar ++*p incrementează valoarea, nu pointerul.

Cheia e precedența: ++ postfix se leagă mai tare decât *, iar operatorii unari prefix (++, *) se aplică de la dreapta la stânga.

Pas cu pas, cu p inițial la a[0]:

  • *p++ înseamnă *(p++): valoarea expresiei p++ e vechea adresă, deci x = a[0] = 10; apoi p arată spre a[1]
  • *++p înseamnă *(++p): p avansează întâi la a[2], apoi se citește, deci y = 30
  • ++*p înseamnă ++(*p): se incrementează a[2] de la 30 la 31, iar z = 31; p rămâne la a[2]

A patra variantă, (*p)++, ar fi incrementat tot valoarea, dar ar fi întors valoarea veche.

Idiomul *p++ apare peste tot în codul C clasic, de exemplu la copierea unui șir:

C
void copiaza(char *dst, const char *src) {
    while ((*dst++ = *src++) != '\0')
        ;
}

Atenție la o capcană înrudită: în aceeași expresie nu modifici și citești același obiect fără punct de secvență între ele. printf("%d %d", *p++, *p); e comportament nedefinit, pentru că ordinea evaluării argumentelor nu e specificată, iar p e modificat și citit fără secvențiere. De aceea exemplul de mai sus folosește instrucțiuni separate.

Ce urmărește intervievatorul: Verifică stăpânirea notației cu pointeri, foarte folosită în cod real. Confuzia dintre *p++ și (*p)++ e cea mai frecventă.

25 Junior

Pentru int a[5];, ce tip au și cu ce diferă a, &a[0] și &a? Ce dă (char *)(&a + 1) - (char *)(a + 1)?

Răspuns scurt: a decade la int *, ca &a[0], iar &a are tipul int (*)[5], pointer la tot tabloul. Adresa e aceeași, dar a + 1 avansează 4 octeți, iar &a + 1 20, deci diferența e 16 (cu int de 4 octeți).

Un tablou nu este un pointer. Numele tabloului, folosit într-o expresie, este convertit (array-to-pointer decay) la un pointer spre primul element, cu trei excepții: operandul lui sizeof, operandul lui & și un literal șir folosit pentru a inițializa un tablou.

Deci:

  • a într-o expresie obișnuită devine int *, cu valoarea &a[0]
  • &a[0] este explicit int *
  • &a nu decade, deci are tipul pointer la tablou de 5 int, int (*)[5]

Toate trei au aceeași valoare numerică a adresei, dar aritmetica pe pointeri se face în unități de dimensiunea tipului spre care arată:

C
#include <stdio.h>

int main(void) {
    int a[5];
    printf("%p %p\n", (void *)(a + 1), (void *)(&a + 1));
    /* a + 1 avansează sizeof(int) = 4, &a + 1 avansează sizeof a = 20 */
    printf("%td\n", (char *)(&a + 1) - (char *)(a + 1));   /* 16 */
    return 0;
}

&a + 1 e adresa imediat după tablou, care e validă pentru calcul (nu pentru dereferențiere). Un truc derivat, *(&a + 1) - a, dă numărul de elemente (5), deși formula clasică sizeof a / sizeof a[0] e mai clară.

Tipul pointer la tablou e exact ce primește o funcție când îi transmiți o matrice: int m[3][5] decade la int (*)[5].

Ce urmărește intervievatorul: Verifică înțelegerea precisă a decay-ului și a tipurilor, nu doar sloganul „tabloul e pointer”. Mulți candidați cred că a + 1 și &a + 1 dau același rezultat.

Eroarea, în practică:sizeof on array function parametercannot increment value of type 'char[11]'

26 Junior

Ce este un pointer void *? De ce nu îl poți dereferenția și de ce în C nu e nevoie de cast la rezultatul lui malloc?

Răspuns scurt: void * e un pointer generic, fără tip cunoscut, deci nu îl poți dereferenția și nu are aritmetică standard. În C se convertește implicit la orice pointer la obiect, așa că castul la rezultatul lui malloc e inutil.

void * este tipul folosit de C pentru „adresă a ceva”. Funcții ca malloc, memcpy, memset, qsort și bsearch lucrează cu el ca să fie generice.

De ce nu se poate dereferenția: *p trebuie să producă o valoare de un anumit tip și dimensiune, iar void e un tip incomplet. Din același motiv, p + 1 nu e definit standard; GCC îl acceptă ca extensie și îl tratează ca pe char *, dar -Wpointer-arith sau -pedantic avertizează. Ca să lucrezi pe octeți, convertești explicit la unsigned char *.

C
#include <stddef.h>

void zero(void *buf, size_t n) {
    unsigned char *b = buf;      /* conversie implicită, fără cast */
    for (size_t i = 0; i < n; i++)
        b[i] = 0;
}

În C, conversia între void * și orice pointer la obiect se face implicit, în ambele sensuri. Deci:

C
int *v = malloc(n * sizeof *v);       /* stil C recomandat */
int *w = (int *)malloc(n * sizeof *w); /* valid, dar castul e inutil */

Argumentele contra castului: e zgomot, iar în C89 ascundea lipsa lui #include <stdlib.h>. Castul e obligatoriu doar dacă același cod trebuie să compileze și ca C++, unde conversia implicită din void * nu există.

Limitări: void * nu e garantat compatibil cu pointerii la funcții (POSIX o cere totuși, pentru dlsym), iar când primești un void * înapoi, tu răspunzi pentru convertirea lui la tipul corect.

Ce urmărește intervievatorul: Verifică înțelegerea pointerilor generici și a diferențelor C față de C++. Mulți candidați cred că un cast la malloc e obligatoriu.

Eroarea, în practică:incomplete type 'void' is not assignablearithmetic on a pointer to void is a GNU extension

27 Junior

Cum transmiți o matrice int m[3][4] unei funcții? Ce variante de semnătură sunt corecte?

Răspuns scurt: Funcția trebuie să cunoască toate dimensiunile în afară de prima: void f(int m[][4], int linii) sau echivalent void f(int (*m)[4], int linii). Din C99 poți folosi și VLA: void f(int linii, int col, int m[linii][col]).

O matrice în C este un tablou de tablouri, stocat contiguu, linie după linie (row-major). Pentru m[i][j], compilatorul calculează adresa baza + (i * 4 + j) * sizeof(int), deci are nevoie să știe numărul de coloane. Când transmiți m, el decade la pointer spre primul element, adică spre prima linie: tipul e int (*)[4].

Semnături corecte:

C
void afis1(int m[][4], int linii);
void afis2(int (*m)[4], int linii);       /* identică cu prima */
void afis3(int linii, int col, int m[linii][col]);   /* C99, VLA */

Exemplu cu VLA, care merge pentru orice dimensiune:

C
#include <stdio.h>

void afis(int linii, int col, int m[linii][col]) {
    for (int i = 0; i < linii; i++) {
        for (int j = 0; j < col; j++)
            printf("%3d", m[i][j]);
        putchar('\n');
    }
}

int main(void) {
    int m[2][3] = {{1, 2, 3}, {4, 5, 6}};
    afis(2, 3, m);
    return 0;
}

Parametrii de dimensiune trebuie să apară înaintea matricei. VLA-urile sunt opționale din C11 (__STDC_NO_VLA__) și MSVC nu le suportă, dar ca tip de parametru sunt suportate de GCC și Clang.

Greșeala frecventă: void f(int m). Un int înseamnă pointer la pointer, iar o matrice statică nu conține pointeri spre linii, deci accesul m[i][j] interpretează valori întregi ca adrese. int ** e corect doar pentru matrici alocate ca tablou de pointeri spre linii separate.

Ce urmărește intervievatorul: Verifică înțelegerea layoutului matricilor în memorie. Greșeala clasică este să transmiți o matrice statică ca int **.

Eroarea, în practică:array has incomplete element type 'int[]'

28 Junior

Scrie o funcție care găsește minimul și maximul unui tablou dintr-o singură parcurgere și le întoarce apelantului. Cum semnalezi un tablou gol?

Răspuns scurt: Întorci rezultatele prin parametri de ieșire (pointeri), iar valoarea de return o folosești pentru succes sau eroare. Pentru n == 0 întorci un cod de eroare și nu atingi parametrii de ieșire.

O funcție C poate întoarce o singură valoare. Pentru mai multe rezultate ai două variante: o structură returnată sau parametri de ieșire (out-parameters), adică pointeri spre variabilele apelantului. A doua variantă e cea mai comună în API-urile C, pentru că lasă valoarea de return liberă pentru codul de eroare.

C
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>

bool min_max(const int *a, size_t n, int *min, int *max) {
    if (a == NULL || n == 0 || min == NULL || max == NULL)
        return false;
    int mn = a[0], mx = a[0];
    for (size_t i = 1; i < n; i++) {
        if (a[i] < mn) mn = a[i];
        else if (a[i] > mx) mx = a[i];
    }
    *min = mn;
    *max = mx;
    return true;
}

int main(void) {
    int v[] = {4, -2, 9, 0};
    int mn, mx;
    if (min_max(v, sizeof v / sizeof v[0], &mn, &mx))
        printf("%d %d\n", mn, mx);   /* -2 9 */
    return 0;
}

Detalii pe care le urmărește intervievatorul:

  • tabloul e const int *, semn că funcția nu îl modifică
  • dimensiunea e size_t, tipul natural pentru dimensiuni
  • minimul și maximul pornesc de la primul element, nu de la 0 sau de la constante arbitrare
  • tabloul gol e tratat explicit, nu printr-o valoare „magică”
  • rezultatele se scriu în variabile locale și se copiază la final, deci la eroare apelantul nu primește valori parțiale

Varianta cu struct { int min, max; } returnat prin valoare e la fel de corectă și uneori mai lizibilă.

Ce urmărește intervievatorul: Verifică folosirea idiomatică a pointerilor ca parametri de ieșire și tratarea cazurilor limită. Candidații uită adesea de tabloul gol sau inițializează maximul cu 0.

29 Mid

Cum citești declarațiile int *p[10];, int (*p)[10];, int (*f)(int); și void (*signal(int sig, void (*h)(int)))(int);?

Răspuns scurt: Pornești de la nume și citești spre dreapta, apoi spre stânga, respectând parantezele: tablou de 10 pointeri la int; pointer la tablou de 10 int; pointer la funcție care primește int și întoarce int; signal e o funcție care întoarce un pointer la funcție.

Declarațiile C urmează principiul „declarația imită folosirea”. Metoda practică e regula dreapta-stânga: pornești de la identificator, citești ce e în dreapta ([] = tablou, () = funcție), apoi ce e în stânga (* = pointer), ieșind din paranteze din interior spre exterior.

  • int *p[10];: p e un tablou de 10 (dreapta), de pointeri (stânga), la int
  • int (*p)[10];: parantezele forțează întâi *: p e un pointer la un tablou de 10 int
  • int (*f)(int);: f e un pointer la o funcție care primește int și întoarce int
  • int *f(int);: fără paranteze, f e o funcție care întoarce int *

Exemplul din signal.h: signal e o funcție care primește un int și un pointer la funcție void (*)(int) și întoarce un pointer la funcție de același tip, adică handlerul vechi.

În cod real, astfel de declarații se simplifică cu typedef:

C
typedef void (*handler_t)(int);

handler_t signal(int sig, handler_t h);

handler_t tabel[4];          /* tablou de 4 pointeri la funcții */

Utilitarul cdecl (și site-ul cdecl.org) traduce declarații în engleză, util când citești cod vechi. Intervievatorii pun întrebarea ca să vadă dacă poți citi headere de sistem și API-uri cu callback-uri fără să ghicești.

Ce urmărește intervievatorul: Verifică dacă poți citi declarații reale din biblioteci și headere de sistem. Greșeala tipică e confuzia dintre int *p[10] și int (*p)[10].

30 Mid

Scrie funcția de comparare pentru a sorta un tablou de int crescător cu qsort. Ce e greșit în varianta return *(int*)a - *(int*)b;?

Răspuns scurt: Comparatorul primește doi const void *, îi convertește la const int * și întoarce negativ, zero sau pozitiv. Diferența a - b poate depăși intervalul int (de exemplu INT_MIN - 1), ceea ce e comportament nedefinit, deci folosești comparații.

qsort din stdlib.h e generic: primește adresa tabloului, numărul de elemente, dimensiunea unui element și un pointer la funcție de comparare cu semnătura int (*)(const void *, const void *). Funcția trebuie să întoarcă o valoare negativă dacă primul element vine înainte, zero dacă sunt egale și pozitivă altfel.

Varianta corectă:

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

static int cmp_int(const void *pa, const void *pb) {
    int a = *(const int *)pa;
    int b = *(const int *)pb;
    return (a > b) - (a < b);
}

int main(void) {
    int v[] = {5, -3, 2147483647, -2147483647 - 1, 0};
    size_t n = sizeof v / sizeof v[0];
    qsort(v, n, sizeof v[0], cmp_int);
    for (size_t i = 0; i < n; i++) printf("%d ", v[i]);
    putchar('\n');
    return 0;
}

(a > b) - (a < b) dă -1, 0 sau 1, fără overflow.

De ce a - b e greșit: pentru a = INT_MAX și b = -1, diferența depășește intervalul. E comportament nedefinit, iar în practică rezultatul se întoarce pe negativ, deci sortarea iese greșită doar pentru anumite date, exact genul de bug care scapă la testare.

Alte observații:

  • pentru ordine descrescătoare inversezi operanzii, nu negi rezultatul (-INT_MIN e tot overflow)
  • pentru structuri, comparatorul convertește la const struct T * și compară câmpul dorit
  • qsort nu e stabil (nu păstrează ordinea elementelor egale); dacă ai nevoie de stabilitate, adaugi un criteriu secundar, de exemplu indexul inițial

Ce urmărește intervievatorul: Verifică lucrul practic cu pointeri la funcții și atenția la overflow. Aproape toți candidații scriu întâi varianta cu scădere.

Eroarea, în practică:incompatible function pointer types (qsort)

31 Mid

Ce operații cu pointeri sunt definite de standard? Poți compara sau scădea pointeri spre obiecte diferite? E valid un pointer spre elementul de după ultimul?

Răspuns scurt: Poți aduna sau scădea un întreg la un pointer și poți scădea sau compara cu < doi pointeri doar în cadrul aceluiași tablou, inclusiv poziția imediat de după ultimul element. Egalitatea (==) merge între orice pointeri compatibili. Restul e comportament nedefinit.

Aritmetica pe pointeri e definită doar în interiorul unui singur obiect tablou (un obiect simplu contează ca tablou de un element):

  • p + n și p - n sunt valide dacă rezultatul rămâne între primul element și poziția de după ultimul (one-past-the-end); doar calculul acestei adrese e permis, nu și dereferențierea ei
  • p - q e valid dacă ambii arată în același tablou; rezultatul e numărul de elemente dintre ei, de tip ptrdiff_t, afișat cu %td
  • <, <=, >, >= sunt definite doar în cadrul aceluiași tablou sau al aceleiași structuri
  • == și != merg pentru orice doi pointeri compatibili și cu NULL

Poziția one-past-the-end există ca să funcționeze idiomul de parcurgere cu interval semi-deschis:

C
int a[5] = {1, 2, 3, 4, 5};
int suma = 0;
for (const int *p = a, *end = a + 5; p != end; p++)
    suma += *p;

Ce e nedefinit, chiar dacă pare inofensiv:

  • a - 1 sau a + 6, chiar fără dereferențiere; de aceea o buclă descrescătoare for (p = a + 4; p >= a; p--) e tehnic UB la ultimul pas
  • compararea cu < a doi pointeri spre malloc-uri diferite

De ce contează: compilatorul folosește aceste reguli la optimizare. Pe arhitecturi segmentate istorice sau pe sisteme cu verificare hardware (CHERI), aceste operații chiar cad. Pentru adrese arbitrare (alocatoare, aliniere) convertești la uintptr_t și lucrezi cu întregi.

Ce urmărește intervievatorul: Verifică cunoașterea precisă a regulilor, importantă pentru cod de alocatoare și containere. Mulți nu știu că a - 1 e UB fără dereferențiere.

Eroarea, în practică:not pointers to compatible typesarithmetic on a pointer to void is a GNU extension

32 Mid

Ce înseamnă „const correctness” în C? De ce compilatorul refuză să convertească un char la const char ?

Răspuns scurt: Const correctness înseamnă să marchezi cu const tot ce o funcție nu modifică, astfel încât compilatorul să te protejeze. Conversia char → const char e interzisă pentru că ar permite să faci un char * să arate spre date constante, fără niciun cast.

În API-urile C, const pe ținta unui pointer e un contract: size_t strlen(const char *s) promite că nu modifică șirul. Beneficii:

  • poți transmite literali șir și date din memoria read-only fără avertismente
  • compilatorul dă eroare dacă funcția încearcă totuși să modifice datele
  • cititorul vede din semnătură ce e intrare și ce e ieșire

Conversia de la T * la const T * e implicită și sigură. Pe două niveluri, nu mai e, iar exemplul de mai jos arată de ce:

C
const char sursa[] = "nu ma modifica";
char *p;
const char **pp = &p;   /* dacă ar fi permis (în C nu e, fără cast) */
*pp = sursa;            /* acum p arată spre date const */
*p = 'X';               /* modificare a unui obiect const: UB */

Dacă char → const char ar fi implicit, ai avea o „spălare” a lui const fără niciun cast. De aceea C permite implicit doar adăugarea lui const la primul nivel. Conversia corectă și sigură e spre const char *const *: C++ o permite implicit, C nu, deci ai nevoie de cast.

Consecința practică apare la funcții ca int main(int argc, char argv) când vrei să transmiți argv unei funcții void f(const char ). Ori faci semnătura const char *const * și pui un cast explicit, ori lași char **.

O capcană înrudită: strchr primește const char * și întoarce char *, deci poate „pierde” const-ul; e o limitare istorică a bibliotecii standard, pe care C23 o corectează cu funcții generice.

Ce urmărește intervievatorul: Verifică profunzimea înțelegerii sistemului de tipuri, nu doar sintaxa const. Candidații mid știu de const char *, dar rar pot explica regula pe două niveluri.

Eroarea, în practică:passing 'const char *' ... discards qualifiers

33 Mid

Cum implementezi un automat de stări (state machine) folosind un tabel de pointeri la funcții? Ce avantaje are față de un switch mare?

Răspuns scurt: Definești câte o funcție pentru fiecare stare, cu aceeași semnătură, care primește evenimentul și întoarce starea următoare, apoi le pui într-un tablou indexat după enum-ul de stări. Codul devine extensibil și fiecare stare se poate testa separat.

Automatele de stări apar peste tot în C: parsere de protocoale, interfețe de dispozitive, firmware. Implementarea cu un tabel de pointeri la funcții separă logica fiecărei stări:

C
#include <stdio.h>

typedef enum { ST_IDLE, ST_RUN, ST_ERR, ST_COUNT } stare_t;
typedef enum { EV_START, EV_STOP, EV_FAIL } ev_t;

typedef stare_t (*handler_t)(ev_t ev);

static stare_t idle(ev_t ev) { return ev == EV_START ? ST_RUN : ST_IDLE; }
static stare_t run(ev_t ev) {
    if (ev == EV_STOP) return ST_IDLE;
    if (ev == EV_FAIL) return ST_ERR;
    return ST_RUN;
}
static stare_t err(ev_t ev) { return ev == EV_STOP ? ST_IDLE : ST_ERR; }

static const handler_t tabel[ST_COUNT] = {
    [ST_IDLE] = idle, [ST_RUN] = run, [ST_ERR] = err,
};

int main(void) {
    stare_t s = ST_IDLE;
    ev_t evenimente[] = {EV_START, EV_FAIL, EV_STOP};
    for (int i = 0; i < 3; i++) {
        s = tabel[s](evenimente[i]);
        printf("stare: %d\n", s);
    }
    return 0;
}

Avantaje:

  • adaugi o stare nouă cu o funcție și o intrare în tabel, fără să atingi restul
  • fiecare handler e testabil separat
  • tabelul e const, deci pe microcontrolere poate sta în flash
  • inițializatorii desemnați [ST_RUN] = run (C99) leagă clar indexul de funcție

Variante: un tabel bidimensional [stare][eveniment] cu stări următoare și acțiuni, sau o structură cu callback-uri on_enter/on_exit. Riscul principal e un index invalid: verifici s < ST_COUNT înainte de apel, pentru că un pointer la funcție nul sau aleator înseamnă salt la o adresă arbitrară.

Ce urmărește intervievatorul: Verifică dacă folosești pointerii la funcții pentru design, nu doar ca sintaxă. Candidații scriu de obicei un switch imbricat greu de extins.

34 Senior

Ce face cuvântul cheie restrict (C99)? Ce se întâmplă dacă promisiunea lui nu e respectată?

Răspuns scurt: restrict pe un pointer promite compilatorului că, pe durata blocului, obiectul accesat prin el nu e accesat prin niciun alt pointer. Compilatorul poate atunci reordona și vectoriza mai agresiv. Dacă promisiunea e încălcată, comportamentul e nedefinit.

Problema pe care o rezolvă restrict se numește aliasing: compilatorul trebuie să presupună că doi pointeri de același tip pot arăta spre aceeași memorie. În funcția de mai jos, fără restrict, după fiecare scriere în dst[i] compilatorul trebuie să recitească *k, pentru că dst ar putea să-l suprapună:

C
void scaleaza(float *restrict dst, const float *restrict src,
              const float *restrict k, size_t n) {
    for (size_t i = 0; i < n; i++)
        dst[i] = src[i] * *k;
}

Cu restrict, compilatorul poate încărca *k o singură dată și poate folosi instrucțiuni SIMD pe blocuri de elemente. În cod numeric, diferența poate fi mare.

Biblioteca standard îl folosește din C99 pentru a documenta contractul: memcpy(void *restrict dst, const void *restrict src, size_t n) spune că zonele nu au voie să se suprapună, iar memmove nu are restrict, pentru că suportă suprapunerea. La fel strcpy, sprintf și fopen.

Ce trebuie reținut:

  • restrict e o promisiune a programatorului, nu o verificare; compilatorul nu detectează încălcarea
  • dacă apelezi scaleaza(v, v, &v[0], n), rezultatul e nedefinit și poate diferi între -O0 și -O2
  • se aplică pointerului, deci se scrie după *: int *restrict p
  • C++ nu are restrict standard; GCC și Clang oferă __restrict__

Îl folosești în funcții de bibliotecă critice ca performanță, după ce ai confirmat cu profilerul că aliasing-ul blochează optimizarea, și documentezi clar contractul în header.

Ce urmărește intervievatorul: Verifică cunoștințele de performanță și înțelegerea contractelor din biblioteca standard. Puțini candidați leagă restrict de diferența memcpy/memmove.

Șiruri și string.h

35 Junior

Ce diferență este între char s[] = "salut"; și char *p = "salut";? Ce se întâmplă la s[0] = 'S'; și la p[0] = 'S';?

Răspuns scurt: s este un tablou de 6 caractere, inițializat cu o copie a literalului, deci îl poți modifica. p e un pointer spre literalul însuși, aflat de obicei în memorie read-only; modificarea lui e comportament nedefinit și de obicei dă segmentation fault.

Un literal șir ca "salut" este un tablou static de char, cu terminatorul '\0' adăugat automat, deci 6 caractere. Standardul spune că modificarea unui literal e comportament nedefinit, iar compilatoarele moderne îl pun în secțiunea .rodata, mapată doar pentru citire.

Cele două declarații fac lucruri diferite:

  • char s[] = "salut"; creează un tablou nou de 6 char și copiază caracterele în el; sizeof s e 6, iar s[0] = 'S' e perfect valid
  • char *p = "salut"; creează doar un pointer care reține adresa literalului; sizeof p e dimensiunea unui pointer (8 pe 64 de biți), iar p[0] = 'S' scrie în memorie read-only
C
#include <stdio.h>

int main(void) {
    char s[] = "salut";
    const char *p = "salut";
    s[0] = 'S';
    printf("%s %zu %zu\n", s, sizeof s, sizeof p);   /* Salut 6 8 */
    return 0;
}

În C, tipul unui literal e char[N], nu const char[N] (spre deosebire de C++), din motive istorice, așa că char *p = "..." compilează fără avertisment. De aceea bunele practici cer const char *p pentru literali; opțiunea GCC -Wwrite-strings tratează literalii ca const și prinde greșeala la compilare.

Încă o diferență: doi literali identici pot fi îmbinați de compilator într-un singur obiect, deci "abc" == "abc" poate fi adevărat sau fals. Tablourile s sunt mereu obiecte distincte.

Ce urmărește intervievatorul: Verifică înțelegerea memoriei pentru șiruri. Greșeala tipică e să crezi că ambele declarații sunt echivalente.

Eroarea, în practică:array type 'char[20]' is not assignableinitializer-string for char array is too long

36 Junior

Scrie propriile implementări pentru strlen și strcpy.

Răspuns scurt: strlen numără caracterele până la '\0' și întoarce size_t; strcpy copiază caracter cu caracter, inclusiv terminatorul, și întoarce destinația. Niciuna nu verifică dimensiunea bufferului, deci apelantul răspunde de spațiu.

Implementări simple, cu semnăturile din standard:

C
#include <stddef.h>

size_t my_strlen(const char *s) {
    const char *p = s;
    while (*p != '\0')
        p++;
    return (size_t)(p - s);
}

char *my_strcpy(char *restrict dst, const char *restrict src) {
    char *d = dst;
    while ((*d++ = *src++) != '\0')
        ;
    return dst;
}

Ce urmărește intervievatorul:

  • tipul de return al lui strlen e size_t, iar parametrul e const char *
  • strlen folosește diferența de pointeri, nu un contor int, care ar putea depăși intervalul pentru șiruri foarte lungi
  • strcpy copiază și terminatorul; bucla while ((*d++ = *src++) != '\0') se oprește după ce l-a scris
  • strcpy întoarce adresa de început a destinației, de aceea salvezi dst înainte să-l incrementezi
  • restrict arată că zonele nu au voie să se suprapună; dacă se suprapun, comportamentul e nedefinit

Întrebări de continuare care apar des:

  • de ce strlen e O(n)? Șirurile C nu își rețin lungimea, deci for (i = 0; i < strlen(s); i++) devine O(n²)
  • cum ar implementa glibc mai rapid? Citește câte 8 octeți odată, aliniat, și folosește trucuri pe biți sau SIMD ca să detecteze un octet zero
  • ce se întâmplă cu un pointer NULL? Comportament nedefinit; funcțiile standard nu verifică

Ce urmărește intervievatorul: Verifică stăpânirea pointerilor și a convenției de terminare cu '\0'. Greșelile tipice: lipsa terminatorului la copiere și returnarea pointerului deja incrementat.

37 Junior

De ce gets() a fost eliminată din standard și cum citești corect o linie de la tastatură?

Răspuns scurt: gets nu primește dimensiunea bufferului, deci orice linie mai lungă scrie dincolo de el, o vulnerabilitate clasică. A fost marcată învechită în C99 și eliminată în C11. În loc folosești fgets(buf, sizeof buf, stdin) și elimini caracterul '\n' de la final.

char *gets(char *s) citește până la newline și scrie tot în s. Nu are cum să știe cât de mare e bufferul, așa că o intrare de 1000 de caractere într-un char buf[64] suprascrie stiva, inclusiv adresa de întoarcere. Viermele Morris din 1988 a exploatat exact o astfel de citire în fingerd. C11 a scos funcția din standard, iar compilatoarele moderne avertizează sau refuză s-o lege.

fgets primește dimensiunea și citește cel mult n - 1 caractere, adăugând mereu '\0'. Păstrează însă '\n' dacă l-a citit:

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

int main(void) {
    char nume[32];
    if (fgets(nume, sizeof nume, stdin) == NULL) {
        return 1;                       /* EOF sau eroare */
    }
    nume[strcspn(nume, "\n")] = '\0';   /* elimină newline-ul, dacă există */
    printf("Salut, %s!\n", nume);
    return 0;
}

strcspn întoarce lungimea până la primul '\n' sau până la final, deci linia e sigură și pentru șiruri fără newline.

Cazuri de tratat:

  • dacă linia e mai lungă decât bufferul, nu există '\n' în ce ai citit, iar restul liniei rămâne în flux; îl consumi sau semnalezi eroare
  • scanf("%s", buf) are aceeași problemă ca gets; dacă îl folosești, pui lățime: scanf("%31s", buf)
  • pentru linii de lungime arbitrară, POSIX oferă getline(), care alocă singur memoria

Ce urmărește intervievatorul: Verifică conștientizarea securității în C. Mulți candidați folosesc fgets, dar uită de '\n' rămas sau de liniile prea lungi.

Eroarea, în practică:*** stack smashing detected ***'scanf' may overflow

38 Junior

De ce if (s1 == s2) nu compară conținutul a două șiruri? Ce întoarce exact strcmp?

Răspuns scurt: == compară adresele, nu caracterele. strcmp compară lexicografic octet cu octet, ca unsigned char, și întoarce o valoare negativă, zero sau pozitivă; standardul nu garantează -1 și 1.

Un șir în C este un tablou de caractere, iar într-o expresie numele lui decade la pointer spre primul caracter. Deci s1 == s2 întreabă dacă cei doi pointeri arată spre aceeași adresă, nu dacă textele sunt identice. Două tablouri cu același conținut au adrese diferite, iar comparația e falsă.

Pentru conținut folosești strcmp din string.h:

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

int main(void) {
    char a[] = "mar", b[] = "mar";
    printf("%d\n", a == b);              /* 0 */
    printf("%d\n", strcmp(a, b) == 0);   /* 1 */
    printf("%d\n", strcmp("Zebra", "abac") < 0);   /* 1: 'Z' (90) < 'a' (97) */
    return 0;
}

Ce trebuie știut despre strcmp:

  • întoarce un număr negativ dacă primul șir e mai mic, 0 dacă sunt egale, pozitiv altfel; glibc întoarce adesea diferența dintre caractere, deci if (strcmp(a, b) == 1) e un bug
  • comparația e pe valori de octeți, deci literele mari vin înaintea celor mici, iar caracterele cu diacritice în UTF-8 (pe mai mulți octeți) nu se sortează după regulile limbii române; pentru asta există strcoll cu locale setat
  • strncmp(a, b, n) compară cel mult n caractere, util pentru prefixe: strncmp(linie, "GET ", 4) == 0
  • comparațiile fără diferență între litere mari și mici (strcasecmp) sunt POSIX, nu C standard

Alternativa de a scrie !strcmp(a, b) e corectă, dar se citește invers („nu strcmp” = egale), de aceea multe ghiduri de stil cer == 0 explicit.

Ce urmărește intervievatorul: Verifică înțelegerea diferenței dintre pointer și conținut. Greșeala clasică este testarea strcmp(...) == 1 sau == -1.

Eroarea, în practică:invalid operands to binary expressioncomparison against a string literal is unspecified

39 Junior

Ce capcane au strncpy și strcat? Unde e bug-ul în codul de mai jos?

C
char dst[8];
strncpy(dst, "programare", sizeof dst);
strcat(dst, "!");

Răspuns scurt: strncpy nu pune '\0' dacă sursa are cel puțin n caractere, deci dst rămâne neterminat, iar strcat caută apoi terminatorul dincolo de buffer și scrie în afara lui. Ambele linii sunt buguri.

strncpy(dst, src, n) nu e o „variantă sigură” a lui strcpy. A fost proiectată pentru câmpuri de lungime fixă din vechile structuri Unix și are două comportamente surprinzătoare:

  • dacă strlen(src) >= n, copiază exact n caractere și nu adaugă terminatorul
  • dacă sursa e mai scurtă, umple restul cu zero până la n, deci copierea în buffere mari e lentă

În exemplu, "programare" are 10 caractere, deci dst primește "programa", fără '\0'. strcat caută sfârșitul lui dst citind dincolo de cele 8 octeți (comportament nedefinit), apoi scrie acolo "!". Chiar dacă dst ar fi fost terminat, nu mai era loc pentru încă un caracter.

Variante corecte:

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

char dst[8];

/* 1. snprintf: trunchiază și termină mereu */
int n = snprintf(dst, sizeof dst, "%s!", "programare");
if (n < 0 || (size_t)n >= sizeof dst) { /* trunchiat sau eroare */ }

/* 2. strncpy cu terminare manuală */
strncpy(dst, "programare", sizeof dst - 1);
dst[sizeof dst - 1] = '\0';

strcat are mereu riscul de overflow și e și ineficientă în bucle, pentru că reparcurge șirul de la început la fiecare apel. Dacă lipești multe bucăți, ții un pointer sau o lungime spre finalul curent.

Pe BSD și macOS există strlcpy și strlcat, care primesc dimensiunea totală și termină mereu șirul; glibc le are din versiunea 2.38, iar POSIX.1-2024 le standardizează.

Ce urmărește intervievatorul: Verifică dacă știi că strncpy nu garantează terminarea, o sursă frecventă de buguri de securitate. Mulți candidați o recomandă ca înlocuitor sigur pentru strcpy.

Eroarea, în practică:*** stack smashing detected ***

40 Junior

De ce atoi e considerată nepotrivită pentru cod de producție? Scrie o conversie sigură a unui șir în long cu strtol.

Răspuns scurt: atoi nu poate semnala erori: întoarce 0 atât pentru „0”, cât și pentru „abc”, iar o valoare în afara intervalului e comportament nedefinit. strtol raportează caracterele neconsumate prin endptr și overflow-ul prin errno == ERANGE.

atoi("123abc") întoarce 123, atoi("abc") întoarce 0, iar atoi("99999999999") are comportament nedefinit. Nu ai cum să afli dacă intrarea a fost validă.

strtol(const char *s, char **endptr, int baza) oferă tot ce-ți trebuie:

  • endptr primește adresa primului caracter neconsumat; dacă e egal cu s, nu s-a citit nicio cifră
  • la depășire întoarce LONG_MAX sau LONG_MIN și setează errno = ERANGE
  • baza poate fi 2–36 sau 0, caz în care detectează singur prefixele 0x și 0
C
#include <errno.h>
#include <stdbool.h>
#include <stdlib.h>
#include <ctype.h>

bool parse_long(const char *s, long *out) {
    char *end;
    errno = 0;
    long v = strtol(s, &end, 10);
    if (end == s) return false;                   /* nicio cifră */
    if (errno == ERANGE) return false;            /* în afara intervalului */
    while (isspace((unsigned char)*end)) end++;   /* acceptă spații la final */
    if (*end != '\0') return false;               /* caractere în plus */
    *out = v;
    return true;
}

errno trebuie pus pe 0 înainte, pentru că funcțiile reușite nu îl resetează.

Detalii la care merită atenție:

  • strtol acceptă spații la început și semn, deci " -42" e valid
  • pentru int, verifici în plus v >= INT_MIN && v <= INT_MAX înainte de conversie
  • strtoul acceptă "-1" și întoarce ULONG_MAX, deci pentru valori fără semn verifici explicit semnul minus
  • pentru numere reale există strtod, cu aceeași logică

Ce urmărește intervievatorul: Verifică validarea corectă a intrărilor, esențială în orice program care citește date. Candidații uită de obicei să reseteze errno sau să verifice endptr.

41 Mid

Ce întoarce snprintf și cum detectezi că un text a fost trunchiat? De ce sprintf e periculoasă?

Răspuns scurt: snprintf întoarce lungimea completă a rezultatului, fără terminator, sau o valoare negativă la eroare; dacă e cel puțin cât bufferul, textul a fost trunchiat. sprintf nu cunoaște dimensiunea bufferului, deci îl poate depăși.

snprintf(buf, n, fmt, ...) (C99) scrie cel mult n - 1 caractere și pune mereu '\0' dacă n > 0. Valoarea întoarsă e lungimea completă a rezultatului, indiferent de n. Asta permite două tehnici utile.

Detectarea trunchierii:

C
#include <stdio.h>

char cale[64];
int n = snprintf(cale, sizeof cale, "%s/%s.log", dir, nume);
if (n < 0) {
    /* eroare de codificare */
} else if ((size_t)n >= sizeof cale) {
    /* trunchiat: n + 1 octeți ar fi fost necesari */
}

Alocarea exactă, în două treceri:

C
int len = snprintf(NULL, 0, "%s-%d", prefix, id);
char *s = malloc((size_t)len + 1);
if (s) snprintf(s, (size_t)len + 1, "%s-%d", prefix, id);

Cu n = 0 și buffer NULL, funcția doar calculează lungimea.

sprintf scrie fără limită, deci un nume de utilizator lung depășește bufferul, exact ca gets. Mai e o problemă comună ambelor: șirul de format nu trebuie să vină niciodată de la utilizator. printf(input) în loc de printf("%s", input) e o vulnerabilitate de tip format string: un input cu %x citește stiva, iar %n scrie în memorie. GCC avertizează cu -Wformat-security.

Atenție și la implementarea MSVC dinainte de Visual Studio 2015, unde _snprintf nu punea terminator la trunchiere și întorcea -1; în cod portabil vechi vei vedea încă macro-uri de compatibilitate pentru asta.

Ce urmărește intervievatorul: Verifică dacă folosești corect valoarea de return, nu doar funcția. Candidații știu de snprintf, dar puțini verifică trunchierea sau știu de atacul format string.

42 Mid

Cum funcționează strtok și ce probleme are? Ce afișează codul de mai jos?

C
char s[] = "a,,b,c";
for (char *t = strtok(s, ","); t; t = strtok(NULL, ","))
    printf("[%s]", t);

Răspuns scurt: Afișează [a][b][c], pentru că strtok sare peste separatorii consecutivi, deci câmpurile goale dispar. Funcția modifică șirul (pune '\0' în locul separatorilor), ține starea într-o variabilă statică internă și nu e reentrantă.

La primul apel, strtok(s, delim) sare peste separatorii de la început, găsește sfârșitul primului token, pune acolo '\0' și reține intern poziția următoare. Apelurile cu NULL continuă de unde a rămas. După rulare, s conține "a\0,b\0c", deci șirul original e distrus.

Problemele:

  • modifică șirul: nu poți apela strtok pe un literal (strtok("a,b", ",") e UB) și pierzi textul inițial
  • câmpurile goale dispar: pentru CSV, "a,,b" ar trebui să dea trei câmpuri, unul gol
  • stare globală: dacă în buclă apelezi o funcție care folosește tot strtok, starea e suprascrisă și bucla exterioară se strică; în programe cu threaduri e și o cursă de date
  • nu spune ce separator a găsit

Alternative:

  • strtok_r (POSIX) sau strtok_s (Anexa K, C11) primesc starea ca parametru explicit și sunt reentrante
  • strsep (BSD, glibc) păstrează câmpurile goale
  • o funcție proprie cu strcspn, care nu modifică sursa:
C
#include <stdio.h>
#include <string.h>

void campuri(const char *s) {
    for (;;) {
        size_t n = strcspn(s, ",");
        printf("[%.*s]", (int)n, s);
        if (s[n] == '\0') break;
        s += n + 1;
    }
    putchar('\n');
}
/* campuri("a,,b,c") afișează [a][][b][c] */

%.*s afișează exact n caractere, fără să fie nevoie de copiere.

Ce urmărește intervievatorul: Verifică dacă știi ce face funcția în spate și dacă recunoști limitările ei. Mulți nu știu că strtok distruge șirul și nu păstrează câmpurile goale.

43 Mid

Scrie o funcție care inversează ordinea cuvintelor dintr-o propoziție, pe loc (in place), fără memorie suplimentară. Exemplu: „ana are mere” devine „mere are ana”.

Răspuns scurt: Inversezi întâi tot șirul caracter cu caracter, apoi inversezi fiecare cuvânt în parte. Complexitatea e O(n) în timp și O(1) memorie suplimentară.

Ideea e o dublă inversare. Dacă inversezi tot textul, cuvintele ajung în ordinea dorită, dar fiecare are literele de-a-ndoaselea; a doua trecere le repară.

„ana are mere” → „erem era ana” → „mere are ana”.

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

static void inverseaza(char *st, char *dr) {
    while (st < dr) {
        char t = *st;
        *st++ = *dr;
        *dr-- = t;
    }
}

void inverseaza_cuvinte(char *s) {
    size_t n = strlen(s);
    if (n == 0) return;
    inverseaza(s, s + n - 1);

    char *p = s;
    while (*p) {
        while (*p == ' ') p++;          /* sare peste spații */
        char *start = p;
        while (*p && *p != ' ') p++;    /* găsește finalul cuvântului */
        if (p > start) inverseaza(start, p - 1);
    }
}

int main(void) {
    char s[] = "ana are mere";
    inverseaza_cuvinte(s);
    printf("%s\n", s);   /* mere are ana */
    return 0;
}

Ce discuți cu intervievatorul:

  • șirul trebuie să fie modificabil (tablou), nu un literal
  • tratarea cazurilor limită: șir gol, un singur cuvânt, spații multiple sau la capete; codul de mai sus păstrează spațiile, dar le mută poziția
  • pentru UTF-8, inversarea pe octeți strică caracterele cu diacritice (ă, ș sunt pe 2 octeți), dar a doua inversare le reface pentru că sunt în interiorul cuvintelor; ar rămâne o problemă doar dacă separatorii ar fi multi-octet
  • complexitatea: fiecare caracter e atins de un număr constant de ori, deci O(n)

Ce urmărește intervievatorul: Verifică manipularea pointerilor pe șiruri și gândirea algoritmică. Candidații alocă adesea un buffer nou sau folosesc strtok, care pierde spațiile.

44 Mid

Ce e greșit în codul de mai jos, care pare să funcționeze pe texte în engleză?

C
#include <ctype.h>
void majuscule(char *s) {
    for (; *s; s++) *s = toupper(*s);
}

Răspuns scurt: Funcțiile din ctype.h primesc un int care trebuie să fie fie EOF, fie o valoare reprezentabilă ca unsigned char. Pe platformele cu char cu semn, octeții peste 127 (de exemplu din UTF-8) devin negativi și apelul e comportament nedefinit. Corect: toupper((unsigned char)*s).

Funcțiile isalpha, isdigit, isspace, toupper și celelalte sunt implementate adesea ca o căutare într-un tabel indexat după argument, de exemplu tabel[c + 1], cu o intrare pentru EOF. Standardul spune că argumentul trebuie să fie EOF sau o valoare în intervalul unsigned char (0–255). Orice altceva e comportament nedefinit.

Pe x86 cu GCC, char e cu semn. Litera „ș” în UTF-8 este perechea de octeți 0xC8 0x99; stocată în char, devine -56 și -103. toupper(-56) citește în afara tabelului: cu glibc de obicei merge din noroc, cu alte biblioteci (sau cu MSVC în debug) poate întoarce gunoi sau poate opri programul cu o aserțiune.

Varianta corectă:

C
#include <ctype.h>

void majuscule(char *s) {
    for (; *s; s++)
        *s = (char)toupper((unsigned char)*s);
}

Mai sunt două limitări de știut:

  • toupper lucrează pe un singur octet, deci nu poate transforma „ș” din UTF-8, care are doi octeți; pentru Unicode ai nevoie de wchar_t cu towupper sau de o bibliotecă precum ICU
  • rezultatul depinde de locale-ul curent (setlocale); în locale-ul implicit "C" sunt recunoscute doar literele ASCII

Același cast se aplică la isdigit(c) în parsere: un fișier cu un octet 0xFF poate produce comportament nedefinit într-un cod care pare complet sigur.

Ce urmărește intervievatorul: Verifică atenția la un detaliu care apare rar în cursuri, dar des în code review. Aproape nimeni nu pune castul la unsigned char din reflex.

45 Senior

Care e diferența dintre memcpy și memmove? Scrie o implementare de memmove.

Răspuns scurt: Ambele copiază n octeți, dar memcpy presupune că zonele nu se suprapun (altfel comportamentul e nedefinit), iar memmove funcționează corect și la suprapunere, copiind ca printr-un buffer intermediar.

memcpy(dst, src, n) are parametrii restrict, deci implementarea poate copia în orice ordine și în blocuri mari, cu SIMD. Dacă zonele se suprapun, rezultatul e nedefinit. Un caz cunoscut: la începutul anilor 2010, glibc a introdus pentru unele procesoare o variantă de memcpy care copia de la sfârșit spre început, iar programe care foloseau greșit memcpy pe zone suprapuse au început să strice date.

memmove garantează rezultatul ca și cum octeții ar fi fost copiați întâi într-un buffer temporar. În practică nu alocă nimic, ci alege direcția:

  • dacă dst e înainte de src, copiază de la început spre final
  • dacă dst e după src, copiază de la final spre început, ca să nu suprascrie octeți încă necitiți
C
#include <stddef.h>
#include <stdint.h>

void *my_memmove(void *dst, const void *src, size_t n) {
    unsigned char *d = dst;
    const unsigned char *s = src;
    if (d == s || n == 0) return dst;
    if ((uintptr_t)d < (uintptr_t)s) {
        for (size_t i = 0; i < n; i++) d[i] = s[i];
    } else {
        for (size_t i = n; i > 0; i--) d[i - 1] = s[i - 1];
    }
    return dst;
}

Comparația se face pe uintptr_t, pentru că compararea cu < a pointerilor din obiecte diferite e nedefinită în C. Implementările din biblioteca standard pot compara direct, fiindcă știu cum se comportă platforma.

Când alegi: memmove când zonele pot să se suprapună (ștergerea unui element dintr-un tablou prin mutarea restului), memcpy în rest. Diferența de viteză e mică pe bibliotecile moderne.

Ce urmărește intervievatorul: Verifică dacă înțelegi contractul de suprapunere și poți raționa pe direcția copierii. Greșeala tipică e o implementare care copiază mereu înainte.

Memorie dinamică

46 Junior

Care e forma corectă de a aloca un tablou de n structuri cu malloc? Ce e greșit în struct punct *v = malloc(n * sizeof(v));?

Răspuns scurt: Forma recomandată e v = malloc(n * sizeof *v); urmată de verificarea if (v == NULL). Varianta din întrebare alocă n pointeri în loc de n structuri, pentru că sizeof(v) e dimensiunea pointerului.

sizeof(v) dă dimensiunea variabilei v, care e un pointer: 8 octeți pe 64 de biți. Dacă struct punct are, să zicem, 24 de octeți, programul alocă o treime din cât îi trebuie și apoi scrie în afara blocului. Bug-ul poate să nu se vadă în teste mici, pentru că alocatorul rotunjește blocurile, dar corupe heap-ul.

Idiomul sigur este sizeof *v: dimensiunea obiectului spre care arată v. Dacă schimbi mai târziu tipul lui v, alocarea rămâne corectă fără să mai modifici linia.

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

struct punct { double x, y, z; };

int main(void) {
    size_t n = 100;
    struct punct *v = malloc(n * sizeof *v);
    if (v == NULL) {
        fprintf(stderr, "memorie insuficientă\n");
        return EXIT_FAILURE;
    }
    v[0].x = 1.0;
    free(v);
    return 0;
}

De ce verifici NULL: malloc poate eșua când memoria e epuizată, când ceri o dimensiune absurdă (de exemplu după un calcul greșit) sau pe sisteme embedded cu heap mic. Pe Linux, cu overcommit activ, malloc rareori întoarce NULL pentru cereri obișnuite, dar codul portabil nu se bazează pe asta. Dereferențierea rezultatului nul ar fi comportament nedefinit.

Alte detalii:

  • malloc(0) poate întoarce NULL sau un pointer unic care nu se dereferențiază, dar se eliberează cu free
  • memoria de la malloc nu e inițializată; dacă ai nevoie de zerouri, folosești calloc
  • n * sizeof *v poate depăși SIZE_MAX pentru n foarte mare, caz tratat separat

Ce urmărește intervievatorul: Verifică dacă ai idiomul corect de alocare în reflex. Bug-ul cu sizeof(pointer) apare des în cod scris în grabă.

Eroarea, în practică:'memset' size is based on a pointer type

47 Junior

Ce se întâmplă cu pointerul după free(p)? E sigur să apelezi free(NULL)? De ce se recomandă p = NULL; după eliberare?

Răspuns scurt: După free, pointerul păstrează aceeași adresă, dar devine invalid: orice citire, scriere sau al doilea free e comportament nedefinit. free(NULL) e garantat sigur și nu face nimic. Setarea pe NULL transformă folosirile ulterioare în crash-uri previzibile și face un al doilea free inofensiv.

free(p) returnează blocul alocatorului, care îl poate refolosi imediat pentru o altă alocare sau poate scrie în el metadate (de exemplu pointeri de listă liberă). Variabila p nu e modificată: conține în continuare aceeași adresă. Standardul spune chiar că valoarea unui pointer după free devine nedeterminată, deci nici compararea lui nu mai e garantată.

Ce se poate întâmpla dacă îl folosești:

  • citirea întoarce gunoi sau datele unei alte structuri alocate între timp
  • scrierea corupe un alt obiect sau metadatele alocatorului, iar crash-ul apare mult mai târziu, în alt loc
  • un al doilea free poate strica listele interne ale alocatorului; glibc detectează multe cazuri și oprește programul cu „free(): double free detected”

free(NULL) e definit explicit ca „nu face nimic”, deci nu e nevoie de if (p) free(p);. Asta permite un idiom curat:

C
#include <stdlib.h>

#define FREE_AND_NULL(p) do { free(p); (p) = NULL; } while (0)

void exemplu(void) {
    char *buf = malloc(64);
    /* ... */
    FREE_AND_NULL(buf);
    FREE_AND_NULL(buf);   /* al doilea apel e inofensiv */
}

Limita acestei practici: dacă mai există alte copii ale pointerului (de exemplu în altă structură), ele rămân invalide. Rezolvarea reală e o regulă clară de ownership: un singur proprietar eliberează, iar ceilalți doar împrumută. Pentru depistare folosești AddressSanitizer (-fsanitize=address), care raportează exact linia cu heap-use-after-free.

Ce urmărește intervievatorul: Verifică înțelegerea ciclului de viață al memoriei dinamice. Greșeala tipică e să crezi că free pune automat pointerul pe NULL.

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

48 Junior

Funcția de mai jos ar trebui să întoarcă o copie a șirului primit. Unde sunt bugurile?

C
char *copie(const char *s) {
    char *p = malloc(strlen(s));
    strcpy(p, s);
    return p;
}

Răspuns scurt: Lipsește un octet pentru terminatorul '\0', deci strcpy scrie cu un octet dincolo de bloc. În plus, rezultatul lui malloc nu e verificat. Corect: malloc(strlen(s) + 1) și test pe NULL.

strlen întoarce numărul de caractere fără terminator. Un șir de 5 litere ocupă 6 octeți, iar strcpy scrie toți 6. Scrierea cu un octet în plus e un off-by-one heap overflow. De cele mai multe ori nu se vede imediat: alocatorul rotunjește dimensiunea blocurilor (de exemplu la multipli de 16), deci octetul în plus nimerește în spațiul de rezervă. Când lungimea e exact multiplu, octetul suprascrie metadatele blocului următor și programul cade la un free ulterior, în alt fișier.

Varianta corectă:

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

char *copie(const char *s) {
    size_t n = strlen(s) + 1;
    char *p = malloc(n);
    if (p == NULL) return NULL;
    memcpy(p, s, n);
    return p;
}

memcpy cu lungimea cunoscută e puțin mai eficient decât strcpy, care ar reparcurge șirul.

Ce mai discuți:

  • funcția există ca strdup în POSIX și e standard din C23, împreună cu strndup
  • contractul trebuie documentat: apelantul primește proprietatea și trebuie să facă free
  • valgrind raportează bug-ul ca „Invalid write of size 1”, iar AddressSanitizer ca heap-buffer-overflow, cu linia exactă
  • dacă s poate fi NULL, fie verifici, fie documentezi că e interzis

Bug-ul e atât de comun încât e unul dintre primele lucruri pe care le cauți la code review lângă orice malloc(strlen(...)).

Ce urmărește intervievatorul: Verifică atenția la terminatorul șirului, cea mai frecventă greșeală de alocare în C. Unii candidați văd doar lipsa verificării pe NULL.

49 Junior

În ce zone de memorie se află variabilele din programul de mai jos: text, data, bss, heap sau stivă?

C
#include <stdlib.h>
int a = 5;
int b;
const char *msg = "hi";
int main(void) {
    static int c;
    int d = 1;
    int *e = malloc(sizeof *e);
}

Răspuns scurt: a e în .data (globală inițializată), b și c în .bss (statice inițializate cu zero), literalul "hi" în .rodata, pointerul msg în .data, d și pointerul e pe stivă, iar *e pe heap. Codul lui main e în .text.

Un executabil tipic (ELF pe Linux) și procesul rezultat au mai multe segmente:

  • .text: codul mașină, mapat read-only și executabil
  • .rodata: constante și literali șir, read-only
  • .data: variabile cu durată statică inițializate cu valori nenule; valorile sunt stocate în fișierul executabil
  • .bss: variabile cu durată statică inițializate cu zero sau neinițializate; ocupă loc doar în memorie, nu în fișier, pentru că sistemul le pune pe zero la încărcare
  • heap: memoria de la malloc, care crește la cerere
  • stiva: cadrele de apel, cu variabile locale automatice și parametri

În exemplu, msg e o variabilă pointer globală inițializată cu adresa unui literal, deci pointerul stă în .data, iar caracterele "hi" în .rodata. Dacă ar fi fost const char *const msg, compilatorul l-ar fi putut pune și pe el în .rodata.

Poți verifica singur:

BASH
gcc -c prog.c -o prog.o
size prog.o          # dimensiunile text, data, bss
nm prog.o            # simboluri: D = data, B = bss, T = text, R = rodata
objdump -h prog.o    # lista secțiunilor

De ce contează în practică:

  • un tablou global mare neinițializat (static char buf[1 << 20];) nu mărește executabilul, dar unul inițializat cu valori nenule da
  • pe microcontrolere, .text și .rodata stau în flash, iar .data trebuie copiată din flash în RAM la pornire, deci consumă ambele memorii
  • stiva e mică și fixă, deci tablourile locale mari se mută în .bss sau pe heap

Ce urmărește intervievatorul: Verifică modelul mental al memoriei unui program, important pentru depanare și embedded. Candidații știu de stivă și heap, dar confundă .data cu .bss.

Eroarea, în practică:address of stack memory ... returnedattempt to call free on non-heap object

50 Mid

Scrie o funcție care adaugă un element într-un tablou dinamic care crește la nevoie. Ce e greșit în v = realloc(v, n * sizeof *v);?

Răspuns scurt: Ții capacitatea separat de numărul de elemente și o dublezi când se umple, ca adăugarea să fie O(1) amortizat. v = realloc(v, ...) pierde blocul original dacă realloc eșuează și întoarce NULL, deci rezultatul se pune întâi într-un pointer temporar.

Dacă realloc nu poate mări blocul, întoarce NULL și lasă blocul vechi neatins. Cu v = realloc(v, ...) pierzi singura referință la el: memory leak, iar programul continuă cu v == NULL. Idiomul corect folosește un temporar:

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

typedef struct {
    int *data;
    size_t len, cap;
} vec_t;

bool vec_push(vec_t *v, int x) {
    if (v->len == v->cap) {
        size_t new_cap = v->cap ? v->cap * 2 : 8;
        if (new_cap > SIZE_MAX / sizeof *v->data) return false;
        int *tmp = realloc(v->data, new_cap * sizeof *tmp);
        if (tmp == NULL) return false;   /* v->data e încă valid */
        v->data = tmp;
        v->cap = new_cap;
    }
    v->data[v->len++] = x;
    return true;
}

Structura începe cu vec_t v = {0};, iar realloc(NULL, n) se comportă ca malloc(n), deci primul apel nu e caz special.

De ce dublare și nu +1: dacă mărești cu un element de fiecare dată, realloc poate copia tot tabloul la fiecare inserare, deci n inserări costă O(n²). Cu creștere geometrică (factor 2 sau 1,5), costul total al copierilor e O(n), adică O(1) amortizat pe inserare.

Alte detalii despre realloc:

  • poate muta blocul la altă adresă, deci orice pointer în interiorul tabloului devine invalid după apel
  • conținutul se păstrează până la minimul dintre dimensiunea veche și cea nouă; zona nouă nu e inițializată
  • realloc(p, 0) are comportament diferit între implementări, iar în C23 devine comportament nedefinit; pentru eliberare folosești free

Ce urmărește intervievatorul: Verifică idiomul realloc și înțelegerea costului amortizat. Majoritatea candidaților scriu p = realloc(p, ...) fără să vadă leak-ul.

51 Mid

Ce problemă de securitate are malloc(n * sizeof(struct item)) când n vine de la utilizator? Cum o previi?

Răspuns scurt: Înmulțirea se face pe size_t și poate depăși SIZE_MAX, rezultatul se întoarce la o valoare mică, malloc reușește, iar scrierile ulterioare depășesc bufferul. Verifici n > SIZE_MAX / sizeof(struct item) înainte sau folosești calloc, care face această verificare.

Aritmetica pe size_t e fără semn, deci la depășire rezultatul e redus modulo SIZE_MAX + 1, fără eroare. Pe un sistem de 32 de biți, cu un element de 16 octeți și n = 0x10000001, produsul 0x100000010 devine 16. malloc(16) reușește, iar bucla care scrie n elemente trece cu mult de bloc. E un integer overflow care duce la heap overflow, clasă de vulnerabilități găsită în multe biblioteci de imagini și parsere de formate.

Pe 64 de biți e mai greu de atins, dar calculele cu uint32_t sau int (lungimi citite dintr-un header de fișier) au aceeași problemă.

Variante de protecție:

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

struct item { int id; double val; };

struct item *aloca_items(size_t n) {
    if (n == 0 || n > SIZE_MAX / sizeof(struct item))
        return NULL;
    return malloc(n * sizeof(struct item));
}

/* sau: calloc verifică intern overflow-ul și pune memoria pe zero */
struct item *v = calloc(n, sizeof *v);

Standardul cere ca calloc să întoarcă NULL dacă produsul nu poate fi alocat, iar glibc, musl și bibliotecile moderne verifică overflow-ul explicit. Pentru realloc nu există o variantă standard cu doi parametri; BSD și glibc 2.26+ au reallocarray(p, n, size), care face verificarea.

Pe lângă aceasta, validezi n după logica aplicației: dacă un fișier declară 4 miliarde de elemente, dar are 2 KB, respingi intrarea înainte de orice alocare.

Ce urmărește intervievatorul: Verifică gândirea defensivă în fața datelor externe, tipică pentru cod de parsare. Puțini candidați se gândesc că înmulțirea dimensiunii poate depăși.

52 Mid

Când ai folosi un tablou de lungime variabilă (VLA), alloca sau malloc pentru un buffer temporar de dimensiune cunoscută doar la rulare?

Răspuns scurt: VLA și alloca alocă pe stivă, foarte rapid și eliberat automat, dar fără nicio semnalare a eșecului, deci doar pentru dimensiuni mici și limitate. Pentru dimensiuni mari sau controlate de utilizator folosești malloc, care poate raporta eșecul.

VLA (C99): double tmp[n]; alocă pe stivă la intrarea în bloc și eliberează la ieșire. Din C11 e o facilitate opțională (__STDC_NO_VLA__), MSVC nu o suportă, iar kernelul Linux a eliminat VLA-urile din cod în 2018 tocmai din cauza riscurilor.

alloca(n) nu e standard C (e în multe sisteme Unix și Windows). Alocă pe stivă, iar memoria trăiește până la ieșirea din funcție, nu din bloc. Folosită într-o buclă, consumă stivă la fiecare iterație.

malloc alocă pe heap, e mai lent (de obicei zeci de nanosecunde), cere free, dar întoarce NULL la eșec.

Problema comună a primelor două: dacă n e prea mare, nu primești o eroare, ci depășești stiva. Rezultatul e un crash sau, mai rău, scrieri peste alte zone de memorie, dacă alocarea sare peste pagina de gardă.

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

#define MAX_STIVA 256

int proceseaza(const char *s, size_t n) {
    char local[MAX_STIVA];
    char *buf = n < sizeof local ? local : malloc(n + 1);
    if (buf == NULL) return -1;
    memcpy(buf, s, n);
    buf[n] = '\0';
    /* ... lucru cu buf ... */
    if (buf != local) free(buf);
    return 0;
}

Acest model, cu buffer fix pe stivă pentru cazul comun și heap pentru cazul rar, combină viteza cu siguranța.

Regula practică: VLA sau alloca doar când dimensiunea are o limită superioară mică și verificată; altfel malloc. În embedded, unde stiva are câțiva KB, se evită ambele. GCC oferă -Wvla și -Wvla-larger-than= ca să le controlezi.

Ce urmărește intervievatorul: Verifică înțelegerea compromisurilor stivă/heap în cod real. Candidații propun des VLA fără să se gândească la dimensiuni controlate de utilizator.

Eroarea, în practică:variable-sized object may not be initialized

53 Mid

Cum aloci dinamic o matrice de linii × coloane întregi? Compară varianta cu tablou de pointeri spre linii cu varianta cu un singur bloc contiguu.

Răspuns scurt: Fie un tablou de pointeri plus câte o alocare pe linie (sintaxă m[i][j], linii de lungimi diferite), fie un singur bloc linii * coloane indexat cu m[i * coloane + j], mai rapid și cu o singură alocare și eliberare.

Varianta 1: tablou de pointeri. Aloci linii pointeri, apoi fiecare linie.

C
int **m = malloc(linii * sizeof *m);
for (size_t i = 0; i < linii; i++)
    m[i] = malloc(coloane * sizeof *m[i]);   /* + verificări */
/* eliberare: fiecare linie, apoi m */

Avantaje: sintaxa m[i][j], linii de lungimi diferite (jagged), poți schimba linii între ele prin schimbarea pointerilor. Dezavantaje: linii + 1 alocări, tratarea eșecului la mijloc (trebuie eliberate liniile deja alocate), date împrăștiate în memorie, deci mai multe cache miss-uri.

Varianta 2: bloc contiguu.

C
#include <stdlib.h>

int *m = malloc(linii * coloane * sizeof *m);
if (m) m[i * coloane + j] = 42;
free(m);

O singură alocare, date contigue, deci parcurgerea pe linii e prietenoasă cu cache-ul și poate fi vectorizată, iar matricea se poate copia cu un singur memcpy sau scrie într-un fișier dintr-o dată.

Varianta 3: bloc contiguu cu sintaxă de matrice, folosind un pointer la VLA (C99):

C
int (*a)[coloane] = malloc(linii * sizeof *a);
if (a) {
    a[2][3] = 7;      /* indexare naturală */
    free(a);
}

sizeof *a e dimensiunea unei linii întregi, calculată la rulare. Necesită suport VLA, deci nu merge pe MSVC.

În cod numeric și de procesare de imagini se folosește aproape mereu blocul contiguu, uneori cu un macro sau o funcție inline pentru indexare. Tabloul de pointeri se păstrează pentru structuri neregulate, cum ar fi liste de linii de text.

Ce urmărește intervievatorul: Verifică dacă înțelegi layoutul memoriei și impactul asupra performanței. Mulți știu doar varianta cu int ** și uită eliberarea liniilor.

54 Senior

Proiectezi API-ul unei biblioteci C care întoarce text de lungime variabilă. Cine alocă și cine eliberează memoria? Ce variante ai și ce alegi?

Răspuns scurt: Variantele clasice: apelantul dă bufferul și dimensiunea (ca snprintf), biblioteca alocă și oferă o funcție proprie de eliberare, sau biblioteca întoarce un pointer spre date interne cu durată limitată. Regula de bază e ca ownership-ul să fie explicit în semnătură și în documentație.

C nu are destructori, deci contractul de proprietate (ownership) trebuie decis și documentat. Trei modele apar în bibliotecile reale.

1. Apelantul alocă bufferul.

C
/* întoarce lungimea necesară, ca snprintf; scrie cel mult cap-1 caractere */
size_t lib_get_name(const lib_t *h, char *buf, size_t cap);

Avantaje: zero alocări în bibliotecă, merge cu buffere pe stivă, potrivit pentru embedded. Dezavantaj: apelantul poate fi nevoit să apeleze de două ori (întâi pentru lungime).

2. Biblioteca alocă, oferă funcția de eliberare.

C
char *lib_describe(const lib_t *h);   /* eliberezi cu lib_free() */
void lib_free(void *p);

Funcția proprie lib_free e importantă: pe Windows, o bibliotecă dinamică poate folosi alt runtime C și alt heap decât aplicația, iar un free din aplicație pe memoria bibliotecii corupe heap-ul. Tot așa poți schimba alocatorul intern mai târziu.

3. Pointer împrumutat. Biblioteca întoarce const char * spre date interne, valabile până la următorul apel sau până la distrugerea obiectului (ca strerror sau getenv). E simplu, dar nu e sigur cu threaduri și ușor de folosit greșit.

Ce aleg depinde de context: modelul 1 pentru biblioteci de nivel jos și embedded, modelul 2 pentru biblioteci de aplicație. În orice caz:

  • documentez în header cine eliberează și cum
  • folosesc const pentru date împrumutate
  • păstrez convenții de nume consecvente (_create/_destroy, _new/_free)
  • permit opțional un alocator personalizat prin pointeri la funcții, ca SQLite sau Lua

Ce urmărește intervievatorul: Verifică gândirea de design pentru cod reutilizabil, nu doar sintaxa. Un candidat senior trebuie să menționeze problema heap-urilor diferite între module.

55 Senior

Implementează un alocator de tip arenă (bump allocator): o zonă mare din care aloci rapid bucăți și pe care o eliberezi dintr-o dată. Cum tratezi alinierea?

Răspuns scurt: Arena ține un bloc, capacitatea și un offset; o alocare rotunjește offsetul în sus la alinierea cerută, verifică spațiul și avansează offsetul. Nu există free individual, ci doar resetarea întregii arene, ceea ce elimină leak-urile și fragmentarea pentru date cu aceeași durată de viață.

Arena e potrivită când multe obiecte mici au aceeași durată de viață: nodurile unui arbore de parsare, datele unei cereri HTTP, un cadru dintr-un joc. Alocarea devine câteva instrucțiuni, iar eliberarea înseamnă resetarea unui offset.

C
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>

typedef struct {
    unsigned char *base;
    size_t cap, off;
} arena_t;

int arena_init(arena_t *a, size_t cap) {
    a->base = malloc(cap);
    a->cap = cap;
    a->off = 0;
    return a->base ? 0 : -1;
}

void *arena_alloc(arena_t *a, size_t size, size_t align) {
    /* align trebuie să fie putere a lui 2 */
    uintptr_t cur = (uintptr_t)(a->base + a->off);
    uintptr_t aligned = (cur + (align - 1)) & ~(uintptr_t)(align - 1);
    size_t pad = (size_t)(aligned - cur);
    if (pad > a->cap - a->off || size > a->cap - a->off - pad)
        return NULL;
    a->off += pad + size;
    return (void *)aligned;
}

void arena_reset(arena_t *a) { a->off = 0; }
void arena_free(arena_t *a)  { free(a->base); a->base = NULL; }

/* folosire: struct nod *n = arena_alloc(&a, sizeof *n, _Alignof(struct nod)); */

Puncte de discutat:

  • alinierea: rotunjirea în sus cu masca (x + align - 1) & ~(align - 1) merge doar pentru puteri ale lui 2; _Alignof (C11) dă alinierea tipului, iar malloc garantează alinierea pentru max_align_t, deci și pentru baza arenei
  • verificarea spațiului e scrisă prin scăderi, ca să nu existe overflow la adunare
  • pentru arene care cresc, se înlănțuie blocuri noi în loc de realloc, care ar invalida pointerii deja dați

Ce urmărește intervievatorul: Verifică înțelegerea alinierii, a aritmeticii pe adrese și a compromisurilor de alocare. Greșeala tipică e ignorarea alinierii, care pe ARM poate da excepții la acces.

Structuri, union, enum și liste

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

Ce sunt inițializatorii desemnați (designated initializers) și literalii compuși (compound literals) din C99? Dă un exemplu de folosire pentru o structură.

Răspuns scurt: Inițializatorii desemnați îți permit să inițializezi membri după nume (.x = 1) sau elemente de tablou după index ([3] = 7), restul devenind zero. Literalii compuși, (struct punct){1, 2}, creează un obiect anonim pe loc, util ca argument de funcție sau la atribuire.

Înainte de C99, structurile se inițializau doar pozițional: struct config c = {8080, 1, 0, 30};. Dacă cineva adăuga un câmp în mijloc, toate inițializările se decalau în tăcere.

Inițializatorii desemnați numesc membrii:

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

typedef struct {
    int port;
    bool tls;
    int timeout_s;
    const char *host;
} config_t;

int main(void) {
    config_t c = { .host = "localhost", .port = 8080, .timeout_s = 30 };
    /* tls e false: membrii nemenționați sunt inițializați cu zero */

    int zile_luna[13] = { [1] = 31, [2] = 28, [3] = 31 };   /* restul 0 */

    printf("%s:%d tls=%d\n", c.host, c.port, c.tls);
    return 0;
}

Ordinea nu mai contează, codul e autodocumentat, iar membrii omiși primesc zero.

Literalii compuși creează un obiect fără nume, de tipul din paranteze:

C
typedef struct { int x, y; } punct_t;

void deseneaza(punct_t p);

deseneaza((punct_t){ .x = 3, .y = 4 });
punct_t p;
p = (punct_t){ 0 };   /* resetare rapidă la zero */
int *v = (int[]){ 1, 2, 3 };

Durata de viață a unui literal compus definit într-o funcție e automatică, legată de blocul în care apare, deci nu întorci adresa lui din funcție.

typedef struct { ... } nume_t; scurtează numele tipului. Unele ghiduri de stil, ca cel al kernelului Linux, preferă struct nume explicit, ca cititorul să vadă că e o structură.

Notă: inițializarea {0} este idiomul portabil pentru „totul pe zero”; {} gol e acceptat standard abia din C23.

Ce urmărește intervievatorul: Verifică dacă scrii C modern, nu doar stilul C89 din manualele vechi. Mulți candidați nu știu că membrii neinițializați explicit devin zero.

Eroarea, în practică:field designator does not refer to any fieldinitializer overrides prior initialization

57 Junior

Când folosești . și când ->? E mai bine să transmiți o structură unei funcții prin valoare sau prin pointer?

Răspuns scurt: . accesează un membru al unei structuri, iar -> al unei structuri prin pointer, fiind prescurtarea pentru (*p).membru. Transmiterea prin valoare copiază toată structura; pentru structuri mari sau când funcția le modifică transmiți pointer, cu const dacă doar citești.

Dacă s e o variabilă de tip struct student, scrii s.nota. Dacă p e de tip struct student *, scrii p->nota, echivalent cu (*p).nota. Parantezele sunt necesare pentru că . are precedență mai mare decât *; *p.nota ar însemna *(p.nota).

C
#include <stdio.h>

struct student {
    char nume[64];
    double medie;
};

/* prin valoare: primește o copie de ~72 de octeți */
void afiseaza(struct student s) {
    printf("%s %.2f\n", s.nume, s.medie);
}

/* prin pointer const: copiază doar adresa, garantează că nu modifică */
void afiseaza_p(const struct student *s) {
    printf("%s %.2f\n", s->nume, s->medie);
}

/* prin pointer: poate modifica originalul */
void majoreaza(struct student *s, double bonus) {
    s->medie += bonus;
}

Când alegi:

  • prin valoare pentru structuri mici (2–3 câmpuri, cum ar fi un punct sau un interval), unde copia e ieftină și convențiile de apel le transmit chiar în registre; funcția nu are cum să modifice originalul
  • **prin const T *** pentru structuri mari care doar se citesc
  • **prin T *** când funcția trebuie să modifice structura

Același raționament se aplică la return: returnarea unei structuri mici prin valoare e idiomatică (div() din stdlib.h întoarce div_t). Pentru structuri mari, apelantul dă de obicei un pointer de ieșire.

Atenție: o structură care conține un tablou se copiază integral la atribuire, cu tot cu tablou, spre deosebire de tablourile simple, care nu se pot atribui deloc.

Ce urmărește intervievatorul: Verifică bazele sintaxei și înțelegerea costului copierii. Candidații juniori transmit adesea structuri mari prin valoare fără să știe ce înseamnă.

Eroarea, în practică:member reference type ... is a pointer; use '->'member reference type ... is not a pointer; use '.'

58 Junior

De ce nu poți compara două structuri cu == în C? De ce e riscant memcmp(&a, &b, sizeof a)?

Răspuns scurt: C nu definește operatorul == pentru structuri. memcmp compară și octeții de padding, care pot avea valori diferite chiar dacă toți membrii sunt egali, iar pentru membri pointer sau double compară biți, nu valori. Corect e o funcție care compară membru cu membru.

Standardul permite atribuirea structurilor (a = b;), dar nu și comparația. Motivul principal e că egalitatea „naturală” nu e clară: doi membri char * sunt egali dacă au aceeași adresă sau același text? Două câmpuri double cu +0.0 și -0.0 sunt egale?

memcmp pare o scurtătură, dar are probleme:

  • padding: între membri și la final pot exista octeți de umplutură, cu valori nedeterminate. O structură pe stivă inițializată membru cu membru are în padding ce era înainte pe stivă, deci două structuri „egale” diferă la memcmp
  • pointeri: compari adrese, nu conținut
  • numere reale: 0.0 și -0.0 sunt egale la ==, dar au biți diferiți; NaN nu e egal cu el însuși, dar biții pot coincide
C
#include <stdbool.h>
#include <string.h>

struct produs {
    char cod;          /* urmat de 3 octeți de padding pe x86-64 */
    int stoc;
    const char *nume;
};

bool produs_egal(const struct produs *a, const struct produs *b) {
    return a->cod == b->cod &&
           a->stoc == b->stoc &&
           strcmp(a->nume, b->nume) == 0;
}

memcmp funcționează doar dacă ambele structuri au fost întâi puse pe zero cu memset sau inițializate cu {0}, nu conțin pointeri sau numere reale, iar padding-ul nu a fost atins de atribuiri ulterioare. E fragil și ușor de stricat la o modificare ulterioară.

Aceeași problemă de padding apare la hash-uirea unei structuri pe octeți sau la scrierea ei pe disc: octeții de umplutură pot conține date rămase din memorie.

Ce urmărește intervievatorul: Verifică înțelegerea padding-ului dintr-un unghi practic. Mulți candidați propun memcmp fără ezitare.

59 Junior

Ce sunt enum-urile în C, ce tip au valorile lor și ce limitări au față de alte limbaje?

Răspuns scurt: Un enum definește un set de constante întregi cu nume; constantele au tipul int, iar valorile pornesc de la 0 și cresc cu 1 dacă nu sunt date explicit. În C nu sunt type-safe: orice întreg poate fi atribuit unei variabile enum, fără eroare.

enum grupează constante întregi înrudite și le dă nume:

C
#include <stdio.h>

enum culoare { ROSU, VERDE, ALBASTRU, NR_CULORI };  /* 0, 1, 2, 3 */

enum eroare {
    ERR_OK = 0,
    ERR_IO = -1,
    ERR_MEM = -2,
    ERR_FORMAT = -10
};

static const char *nume_culori[NR_CULORI] = {
    [ROSU] = "rosu", [VERDE] = "verde", [ALBASTRU] = "albastru"
};

int main(void) {
    enum culoare c = VERDE;
    printf("%s %d\n", nume_culori[c], NR_CULORI);   /* verde 3 */
    return 0;
}

Elementul final NR_CULORI e un idiom frecvent: îți dă automat numărul de valori pentru dimensiunea tablourilor.

Detalii specifice C:

  • constantele (ROSU, VERDE) au tipul int până la C17; tipul variabilei enum culoare e ales de implementare (char, int sau unsigned), suficient pentru toate valorile
  • constantele sunt în spațiul de nume global al fișierului, deci două enum-uri nu pot avea amândouă o constantă OK; de aceea se folosesc prefixe (ERR_, COL_)
  • nu există verificare de tip: enum culoare c = 42; compilează, iar o funcție care primește enum culoare acceptă orice întreg
  • nu poți afla numele unei valori la rulare; ai nevoie de un tabel ca mai sus sau de X-macros

Față de #define, enum are avantajul că debuggerul afișează numele simbolic, iar -Wswitch te avertizează dacă un switch nu tratează toate valorile. În C23 poți fixa tipul de bază: enum culoare : uint8_t { ... };.

Ce urmărește intervievatorul: Verifică dacă știi diferențele față de enum-urile din C++ sau Java. Greșeala tipică e să crezi că compilatorul C refuză valori în afara listei.

Eroarea, în practică:redefinition of enumeratorconversion to different enumeration type

60 Junior

Scrie o listă simplu înlănțuită de întregi cu două funcții: inserare la început și eliberarea întregii liste.

Răspuns scurt: Fiecare nod conține valoarea și un pointer spre următorul. Inserarea la început alocă un nod, îl leagă de vechiul cap și actualizează capul printr-un pointer la pointer. Eliberarea parcurge lista salvând next înainte de fiecare free.

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

typedef struct nod {
    int val;
    struct nod *next;
} nod_t;

int push_front(nod_t **cap, int val) {
    nod_t *n = malloc(sizeof *n);
    if (n == NULL) return -1;
    n->val = val;
    n->next = *cap;
    *cap = n;
    return 0;
}

void free_list(nod_t **cap) {
    nod_t *cur = *cap;
    while (cur != NULL) {
        nod_t *urm = cur->next;   /* salvat înainte de free */
        free(cur);
        cur = urm;
    }
    *cap = NULL;
}

int main(void) {
    nod_t *lista = NULL;
    for (int i = 1; i <= 3; i++) push_front(&lista, i);
    for (nod_t *p = lista; p; p = p->next) printf("%d ", p->val);  /* 3 2 1 */
    putchar('\n');
    free_list(&lista);
    return 0;
}

Ce urmărește intervievatorul:

  • nod_t cap**: funcția trebuie să modifice pointerul de cap al apelantului; cu nod_t *cap, ar modifica doar copia locală și lista ar rămâne goală
  • în structură, câmpul next se declară cu struct nod *, pentru că nod_t nu există încă în acel punct
  • la eliberare, citirea lui cur->next după free(cur) ar fi use-after-free; de aceea se salvează întâi
  • verificarea lui malloc
  • lista goală e reprezentată de NULL, deci funcțiile funcționează fără caz special

Întrebări de continuare frecvente: inserare la final în O(1) (ții și un pointer la coadă), detectarea unui ciclu (doi pointeri, unul lent și unul rapid) și găsirea elementului din mijloc.

Ce urmărește intervievatorul: Verifică lucrul cu structuri recursive, alocare și pointer la pointer. Greșelile tipice: transmiterea capului prin valoare și free înainte de citirea lui next.

Eroarea, în practică:field has incomplete type 'struct ...'

61 Mid

Ce este un membru tablou flexibil (flexible array member) și cum aloci o structură care îl folosește?

Răspuns scurt: Este ultimul membru al unei structuri, declarat ca tablou fără dimensiune (char data[];, din C99). Aloci structura și datele într-un singur bloc: malloc(sizeof(struct s) + n). Obții o singură alocare, date contigue și o singură eliberare.

Când o structură are un antet fix și date de lungime variabilă (un mesaj de rețea, un șir cu lungime, un bloc de bytes), poți ține datele într-un pointer separat, cu două alocări. Membrul tablou flexibil permite un singur bloc:

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

typedef struct {
    size_t len;
    char data[];          /* trebuie să fie ultimul membru */
} sir_t;

sir_t *sir_nou(const char *s) {
    size_t n = strlen(s);
    sir_t *r = malloc(sizeof *r + n + 1);
    if (r == NULL) return NULL;
    r->len = n;
    memcpy(r->data, s, n + 1);
    return r;
}

int main(void) {
    sir_t *s = sir_nou("salut");
    if (s) {
        printf("%zu %s\n", s->len, s->data);
        free(s);          /* o singură eliberare */
    }
    return 0;
}

Avantaje față de un pointer separat: o singură alocare și o singură eliberare, nu poți uita să eliberezi datele, iar antetul și datele sunt alăturate în memorie, deci mai bune pentru cache.

Reguli:

  • structura trebuie să aibă cel puțin un alt membru, iar tabloul flexibil e ultimul
  • sizeof pe structură nu include tabloul (poate include padding la final)
  • structura nu poate fi element într-un tablou sau membru în altă structură
  • atribuirea *a = *b copiază doar partea fixă

Înainte de C99 se folosea „struct hack”-ul cu char data[1]; sau data[0] (extensie GCC). Accesul dincolo de primul element era tehnic comportament nedefinit, iar compilatoarele moderne, cu -fstrict-flex-arrays și sanitizerele de limite, îl semnalează.

Ce urmărește intervievatorul: Verifică cunoașterea unui idiom C99 folosit des în biblioteci și kernel. Candidații folosesc de obicei două alocări și uită uneori una dintre eliberări.

Eroarea, în practică:flexible array member is not at the end of struct

62 Mid

Poți scrie un membru al unui union și citi un altul? Care e diferența față de C++ și cum e mai sigur să reinterpretezi biții unui float?

Răspuns scurt: În C da: citirea altui membru decât cel scris reinterpretează reprezentarea în memorie (type punning), lucru documentat explicit din C99 TC3 și C11. În C++ e comportament nedefinit. Varianta portabilă în ambele limbaje e memcpy între obiecte de tipuri diferite.

Un union are toți membrii la aceeași adresă. Standardul C (nota din secțiunea despre accesul la membri, adăugată în C99 TC3 și păstrată în C11/C17) spune că, dacă citești alt membru decât ultimul scris, reprezentarea în octeți e reinterpretată ca noul tip. Rezultatul depinde de reprezentarea tipurilor pe platformă și poate fi o reprezentare invalidă (trap representation), dar nu încalcă regulile de aliasing.

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

int main(void) {
    union { float f; uint32_t u; } x = { .f = 1.0f };
    printf("0x%08X\n", (unsigned)x.u);    /* 0x3F800000 pe IEEE 754 */

    float g = -2.5f;
    uint32_t bits;
    memcpy(&bits, &g, sizeof bits);       /* portabil și în C++ */
    printf("0x%08X\n", (unsigned)bits);   /* 0xC0200000 */
    return 0;
}

În C++, accesarea unui membru inactiv e comportament nedefinit, chiar dacă GCC și Clang o tolerează în practică. De aceea, în headere folosite din ambele limbaje se preferă memcpy (iar în C++20 există std::bit_cast). Compilatoarele recunosc tiparul memcpy cu dimensiune fixă și îl transformă într-o simplă mutare de registru, deci nu costă nimic.

Ce nu e permis nici în C: castul de pointer *(uint32_t *)&g, care încalcă regula de strict aliasing.

Utilizări reale ale acestui tip de reinterpretare: extragerea exponentului unui float, serializarea, implementarea de funcții matematice rapide. Atenție că rezultatul depinde de endianness și de formatul real al tipului, deci codul trebuie documentat pentru platformele suportate.

Ce urmărește intervievatorul: Verifică precizia cunoștințelor despre o diferență reală dintre C și C++. Răspunsurile sunt adesea extreme: „e mereu UB” sau „e mereu sigur”.

63 Mid

Scrie o funcție care șterge dintr-o listă simplu înlănțuită primul nod cu o anumită valoare, fără caz special pentru capul listei.

Răspuns scurt: Parcurgi lista cu un pointer la pointer (nod_t **pp) care arată spre câmpul ce conține adresa nodului curent: la început &cap, apoi &nod->next. Când găsești valoarea, faci *pp = nod->next și eliberezi nodul. Capul se tratează la fel ca orice alt nod.

Varianta obișnuită ține un pointer prev și tratează separat cazul în care nodul de șters e primul, pentru că atunci trebuie modificat capul, nu prev->next. Cu un pointer la pointer, ambele cazuri devin unul singur: pp arată mereu spre „locul în care e memorată adresa nodului curent”.

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

typedef struct nod {
    int val;
    struct nod *next;
} nod_t;

bool sterge(nod_t **cap, int val) {
    for (nod_t **pp = cap; *pp != NULL; pp = &(*pp)->next) {
        nod_t *cur = *pp;
        if (cur->val == val) {
            *pp = cur->next;    /* actualizează fie capul, fie next-ul anterior */
            free(cur);
            return true;
        }
    }
    return false;
}

Pas cu pas: la început pp == cap, deci *pp e primul nod. Dacă el trebuie șters, *pp = cur->next modifică direct capul apelantului. Altfel, pp devine &cur->next, adresa câmpului next din nodul curent, iar o ștergere ulterioară modifică acel câmp.

Linus Torvalds a dat acest exemplu ca ilustrare a „bunului gust” în cod: eliminarea cazului special face funcția mai scurtă și mai greu de stricat.

Întrebări de continuare:

  • ștergerea tuturor aparițiilor: nu returnezi, iar după ștergere nu avansezi pp
  • complexitate O(n), memorie O(1)
  • lista dublu înlănțuită permite ștergerea în O(1) dacă ai deja pointerul la nod

Atenție la &(*pp)->next: precedența face din (*pp)->next membrul nodului, iar & îi ia adresa.

Ce urmărește intervievatorul: Verifică stăpânirea pointerilor la pointeri într-un context realist. Majoritatea candidaților scriu varianta cu prev și uită cazul în care se șterge capul.

64 Mid

Implementează un buffer circular (ring buffer) de dimensiune fixă pentru octeți, cu funcții de push și pop. Cum distingi bufferul plin de cel gol?

Răspuns scurt: Ții un tablou fix și doi indici, head pentru scriere și tail pentru citire, care avansează circular. Plin și gol se disting printr-o poziție mereu liberă, un contor sau indici care cresc liber, cu dimensiune putere a lui 2.

Bufferul circular e structura standard pentru cozi între producător și consumator: date primite pe UART, eșantioane audio, loguri. Nu alocă dinamic și are operații O(1).

Problema: dacă head == tail înseamnă „gol”, după ce umpli bufferul complet ajungi tot la head == tail. Soluția de mai jos folosește indici care cresc continuu (fără modulo) și o dimensiune putere a lui 2:

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

#define RB_SIZE 64u                 /* putere a lui 2 */
#define RB_MASK (RB_SIZE - 1u)

typedef struct {
    uint8_t buf[RB_SIZE];
    uint32_t head;                  /* total scrieri */
    uint32_t tail;                  /* total citiri */
} ring_t;

static inline uint32_t rb_count(const ring_t *r) { return r->head - r->tail; }

bool rb_push(ring_t *r, uint8_t b) {
    if (rb_count(r) == RB_SIZE) return false;   /* plin */
    r->buf[r->head & RB_MASK] = b;
    r->head++;
    return true;
}

bool rb_pop(ring_t *r, uint8_t *out) {
    if (r->head == r->tail) return false;       /* gol */
    *out = r->buf[r->tail & RB_MASK];
    r->tail++;
    return true;
}

De ce funcționează: head - tail e numărul de elemente, iar aritmetica pe uint32_t e definită modulo 2^32, deci rămâne corectă și după ce indicii trec de valoarea maximă. Masca & RB_MASK înlocuiește operatorul %, mai lent pe microcontrolere fără împărțire hardware.

Folosit între o întrerupere care face push și bucla principală care face pop, cu un singur producător și un singur consumator, structura funcționează fără blocare dacă indicii sunt accesați atomic și cu ordinea corectă a scrierilor (de exemplu cu stdatomic.h).

Ce urmărește intervievatorul: Verifică o structură de date folosită zilnic în embedded și în sisteme. Greșeala tipică e confuzia plin/gol sau folosirea % cu dimensiuni arbitrare.

65 Senior

Ce este un tip opac (opaque type) în C și cum îl folosești ca să ascunzi implementarea unei structuri?

Răspuns scurt: În header declari doar typedef struct stiva stiva_t; și funcțiile care primesc stiva_t *, iar definiția completă a structurii stă în fișierul .c. Utilizatorii nu pot accesa câmpurile sau crea obiectul pe stivă, deci poți schimba implementarea fără să le strici codul.

C nu are private, dar are tipuri incomplete: o structură declarată fără corp. Poți avea pointeri spre ea, dar nu poți accesa membri, nu poți face sizeof și nu poți declara variabile de acel tip. Pe asta se bazează încapsularea în C.

C
/* stiva.h */
#ifndef STIVA_H
#define STIVA_H
#include <stdbool.h>
#include <stddef.h>

typedef struct stiva stiva_t;          /* opac */

stiva_t *stiva_create(size_t cap);
void     stiva_destroy(stiva_t *s);
bool     stiva_push(stiva_t *s, int v);
bool     stiva_pop(stiva_t *s, int *out);
#endif
C
/* stiva.c */
#include <stdlib.h>
#include "stiva.h"

struct stiva {                         /* definiția, vizibilă doar aici */
    int *data;
    size_t len, cap;
};

stiva_t *stiva_create(size_t cap) {
    stiva_t *s = malloc(sizeof *s);
    if (!s) return NULL;
    s->data = malloc(cap * sizeof *s->data);
    if (!s->data) { free(s); return NULL; }
    s->len = 0;
    s->cap = cap;
    return s;
}
/* ... restul funcțiilor ... */

Exemple în biblioteca standard și în ecosistem: FILE (folosit doar prin FILE *), sqlite3, pthread_t în unele implementări.

Avantaje:

  • stabilitate ABI: poți adăuga sau schimba câmpuri fără să recompilezi aplicațiile care folosesc biblioteca dinamică
  • invarianții structurii pot fi garantați, pentru că nimeni din afară nu modifică câmpurile
  • headerul nu mai trebuie să includă dependențele implementării, deci compilarea e mai rapidă

Costuri: obiectul trebuie alocat de bibliotecă (de obicei pe heap), accesul la câmpuri trece prin funcții, deci nu pot fi inline în codul utilizatorului. În embedded, unde se evită malloc, biblioteca expune uneori o structură de dimensiune fixă cu câmpuri „rezervate” sau un pool static de obiecte.

Ce urmărește intervievatorul: Verifică dacă știi să proiectezi module C cu interfețe curate. E unul dintre semnele că un candidat a lucrat pe proiecte reale, nu doar pe exerciții.

Eroarea, în practică:incomplete definition of type 'struct ...'variable has incomplete type 'struct ...'

66 Senior

Ce face macro-ul offsetof și cum funcționează container_of din kernelul Linux?

Răspuns scurt: offsetof(tip, membru) din stddef.h dă distanța în octeți de la începutul structurii până la membru. container_of(ptr, tip, membru) scade această distanță din adresa unui membru ca să obțină adresa structurii care îl conține, tehnică folosită pentru liste intruzive.

offsetof ține cont de padding, deci e singura metodă corectă de a afla poziția unui câmp:

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

struct pachet {
    char tip;
    int lungime;
    double timp;
};

int main(void) {
    printf("%zu %zu\n", offsetof(struct pachet, lungime),
                        offsetof(struct pachet, timp));   /* de obicei 4 8 */
    return 0;
}

Listele intruzive inversează relația obișnuită: în loc ca nodul listei să conțină datele, datele conțin nodul listei. Un obiect poate fi în mai multe liste simultan (câte un nod pentru fiecare), iar codul de listă e scris o singură dată, generic.

C
struct list_head { struct list_head *next, *prev; };

struct task {
    int pid;
    struct list_head run_list;     /* nodul în coada de rulare */
};

#define container_of(ptr, type, member) \
    ((type *)((char *)(ptr) - offsetof(type, member)))

void proceseaza(struct list_head *pos) {
    struct task *t = container_of(pos, struct task, run_list);
    printf("%d\n", t->pid);
}

Castul la char * e esențial: aritmetica se face în octeți. Versiunea din kernel adaugă o verificare de tip la compilare, ca ptr să aibă chiar tipul membrului.

Unde vei vedea tehnica: kernelul Linux (list_head, rb_node), biblioteci de rețea, motoare de jocuri. Avantaje: nicio alocare suplimentară pentru noduri, localitate bună în memorie. Riscul: dacă greșești membrul sau tipul, obții un pointer greșit fără nicio eroare, deci macro-ul trebuie folosit doar prin funcții bine testate.

Ce urmărește intervievatorul: Verifică experiența cu cod de sistem și tehnici de bibliotecă avansate. Puțini candidați au văzut listele intruzive, deși sunt peste tot în kernel.

67 Senior

Trebuie să salvezi o structură într-un fișier binar sau să o trimiți prin rețea. De ce nu e o idee bună fwrite(&s, sizeof s, 1, f) și cum ai face serializarea corect?

Răspuns scurt: Layoutul structurii depinde de compilator și platformă: padding, endianness, dimensiunea tipurilor și pointerii, care nu au sens în alt proces. Corect e să definești formatul pe octeți și să scrii fiecare câmp explicit, cu lățime fixă și ordine de octeți stabilită.

fwrite(&s, sizeof s, 1, f) scrie imaginea din memorie a structurii. Funcționează cât timp același binar o citește pe aceeași mașină, dar se strică dacă:

  • padding-ul diferă între compilatoare, opțiuni (-fpack-struct, #pragma pack) sau arhitecturi; în plus, octeții de padding pot conține date rămase în memorie, adică o scurgere de informații
  • endianness-ul diferă: x86 și majoritatea ARM sunt little-endian, iar multe protocoale de rețea sunt big-endian
  • dimensiunile diferă: long are 8 octeți pe Linux 64 și 4 pe Windows
  • structura conține pointeri, care nu au sens în alt proces sau după repornire

Soluția: definești formatul extern explicit (de exemplu „4 octeți id big-endian, 2 octeți lungime, apoi N octeți nume”) și scrii funcții de codare:

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

static uint8_t *put_u32be(uint8_t *p, uint32_t v) {
    p[0] = (uint8_t)(v >> 24);
    p[1] = (uint8_t)(v >> 16);
    p[2] = (uint8_t)(v >> 8);
    p[3] = (uint8_t)v;
    return p + 4;
}

struct mesaj { uint32_t id; uint16_t len; const char *nume; };

size_t codeaza(const struct mesaj *m, uint8_t *out) {
    uint8_t *p = put_u32be(out, m->id);
    *p++ = (uint8_t)(m->len >> 8);
    *p++ = (uint8_t)m->len;
    for (uint16_t i = 0; i < m->len; i++) *p++ = (uint8_t)m->nume[i];
    return (size_t)(p - out);
}

Shiftările lucrează pe valori, deci codul e corect pe orice endianness. La decodare, verifici lungimile față de dimensiunea bufferului primit, înainte de a copia.

Pentru formate complexe sau care evoluează, alegi un format existent cu versiune: Protocol Buffers (cu nanopb pentru embedded), CBOR, MessagePack sau un header cu număr magic și versiune.

Ce urmărește intervievatorul: Verifică experiența cu date care ies din program, unde apar multe buguri subtile. Răspunsul slab e „folosesc #pragma pack” fără a menționa endianness-ul.

Preprocesor, compilare și linking

68 Junior

Care e diferența dintre #include <fisier.h> și #include "fisier.h"? Ce pui într-un header și ce nu?

Răspuns scurt: Cu < > preprocesorul caută în directoarele de sistem și cele date cu -I; cu ghilimele caută întâi lângă fișierul curent, apoi la fel ca la < >. În header pui declarații (prototipuri, tipuri, macro-uri, extern), nu definiții de variabile sau funcții ne-inline.

#include copiază textual conținutul fișierului în locul directivei. Ordinea de căutare e definită de implementare, dar convenția comună (GCC, Clang, MSVC) este:

  • #include "util.h": întâi directorul fișierului care face includerea, apoi directoarele -iquote și -I, apoi cele de sistem
  • #include <stdio.h>: doar directoarele -I și cele de sistem (de exemplu /usr/include)

Convenția: ghilimele pentru headerele proiectului, paranteze unghiulare pentru biblioteca standard și bibliotecile externe. Poți vedea lista exactă cu gcc -xc -E -v /dev/null.

Ce intră într-un header:

  • prototipuri de funcții publice
  • definiții de tipuri (struct, typedef, enum) necesare apelanților
  • macro-uri și constante
  • declarații extern pentru variabile globale partajate
  • funcții static inline mici
  • header guards

Ce nu intră:

  • definiții de variabile (int contor = 0;): fiecare .c care include headerul ar defini variabila, iar linkerul dă eroare de definiție multiplă
  • definiții de funcții obișnuite, din același motiv
  • #include-uri de care headerul nu are nevoie, care încetinesc compilarea și creează dependențe ascunse

O regulă bună: fiecare header trebuie să compileze singur. Ca să verifici, în modul.c incluzi modul.h primul; dacă îi lipsește o dependență, primești imediat eroare. Pentru tipuri folosite doar prin pointer, o declarație anticipată (struct conexiune;) e suficientă și evită includeri inutile.

Ce urmărește intervievatorul: Verifică organizarea de bază a unui proiect C. Greșeala clasică e definirea unei variabile globale direct în header.

Eroarea, în practică:expected "FILENAME" or <FILENAME>#pragma once in main file

69 Junior

Ce diferență este între #define N 10, const int N = 10; și enum { N = 10 }; în C? De ce int v[N]; cu const int N nu merge ca variabilă globală?

Răspuns scurt: #define e înlocuire textuală, fără tip și scope; const int e o variabilă read-only cu tip, dar în C nu e expresie constantă; enum dă o constantă întreagă reală. De aceea const int N nu poate da dimensiunea unui tablou global.

#define N 10: preprocesorul înlocuiește N cu 10 peste tot, înainte de compilare. Nu are tip, nu respectă scope-ul (e vizibil până la #undef sau finalul fișierului), nu apare în debugger și poate intra în conflict cu alte nume. Pe de altă parte, merge oriunde se cere o constantă: dimensiuni de tablou, case, #if.

const int N = 10;: o variabilă cu tip, scope și adresă, pe care nu o poți modifica. Diferența importantă față de C++: în C, un obiect const nu e o expresie constantă întreagă. De aceea:

C
const int N = 10;
int global[N];            /* eroare: dimensiune variabilă la nivel de fișier */

void f(void) {
    int local[N];         /* compilează, dar e un VLA, nu un tablou fix */
    switch (1) {
        case N: break;    /* eroare: etichetă case neconstantă */
    }
}

enum { N = 10 };: creează o constantă de tip int care e expresie constantă reală, cu scope normal și vizibilă în debugger. E varianta preferată pentru constante întregi în multe proiecte C.

Cum alegi:

  • constante întregi pentru dimensiuni și case: enum sau #define
  • constante de alte tipuri (double, șiruri): static const double PI = 3.14159; în header sau #define cu paranteze
  • valori folosite în #if sau date din linia de comandă (-DBUF=512): obligatoriu #define

C23 introduce constexpr pentru obiecte, care rezolvă problema: constexpr int N = 10; e o expresie constantă.

Ce urmărește intervievatorul: Verifică o diferență concretă între C și C++, des întâlnită de cei care vin din C++. Mulți cred că const int merge peste tot ca în C++.

Eroarea, în practică:initializer element is not a compile-time constantvariable-sized object may not be initialized

70 Junior

Cum funcționează compilarea condiționată cu #ifdef, #if defined(...) și NDEBUG? Ce face assert și când nu trebuie folosit?

Răspuns scurt: #if/#ifdef includ sau exclud cod înainte de compilare, după macro-uri definite în cod sau cu -D. assert(expr) oprește programul dacă expresia e falsă, dar dispare cu NDEBUG, deci nu pui în el efecte și nu validezi cu el intrări.

Compilarea condiționată se folosește pentru variante de platformă, opțiuni de build și cod de depanare:

C
#if defined(_WIN32)
    #include <windows.h>
#elif defined(__linux__)
    #include <unistd.h>
#else
    #error "Platformă nesuportată"
#endif

#ifdef DEBUG
    #define LOG(msg) fprintf(stderr, "%s\n", msg)
#else
    #define LOG(msg) ((void)0)
#endif

#if defined(A) && !defined(B) permite condiții compuse, ceea ce #ifdef nu poate. În #if, un identificator nedefinit e tratat ca 0, motiv pentru care -Wundef e util ca să prinzi greșelile de scriere.

assert din assert.h verifică o presupunere a programatorului. Dacă e falsă, afișează expresia, fișierul și linia, apoi apelează abort(). Când compilezi cu -DNDEBUG, cum fac multe configurații de release (de exemplu CMake în modul Release), macro-ul devine ((void)0).

Două consecințe:

C
assert(p = malloc(100));            /* bug: în release, malloc nu mai e apelat */
assert(fclose(f) == 0);             /* bug: în release, fișierul nu e închis */

void *p = malloc(100);
assert(p != NULL);                  /* nici așa nu e suficient pentru producție */

Regula: assert pentru invarianți interni („aici indexul e mereu în interval”), niciodată pentru erori care pot apărea legitim (lipsă de memorie, fișier inexistent, date invalide de la utilizator). Acelea se tratează cu cod normal, care rămâne și în release.

Pentru verificări la compilare există _Static_assert(sizeof(int) == 4, "int trebuie să aibă 4 octeți"); din C11, numit static_assert în C23.

Ce urmărește intervievatorul: Verifică diferența dintre verificările de depanare și tratarea erorilor. Bug-ul cu efecte în assert apare des în cod real.

Eroarea, în practică:Assertion `...' failedunterminated conditional directive

71 Junior

Ai o variabilă globală contor pe care vrei să o folosești în trei fișiere .c. Cum o declari corect? De ce codul care mergea cu GCC 9 dă eroare de „multiple definition” cu GCC 10?

Răspuns scurt: O definești într-un singur .c (int contor = 0;) și o declari în header cu extern int contor;, header inclus de toate fișierele. GCC 10 a trecut implicit la -fno-common, deci variabilele definite în mai multe fișiere fără inițializare nu mai sunt îmbinate de linker.

extern spune compilatorului că variabila există, dar e definită în altă parte; nu alocă memorie. Linkerul leagă apoi toate referințele de singura definiție.

C
/* contor.h */
#ifndef CONTOR_H
#define CONTOR_H
extern int contor;            /* declarație */
void incrementeaza(void);
#endif

/* contor.c */
#include "contor.h"
int contor = 0;               /* singura definiție */
void incrementeaza(void) { contor++; }

/* main.c */
#include <stdio.h>
#include "contor.h"
int main(void) {
    incrementeaza();
    printf("%d\n", contor);
    return 0;
}

Cazul GCC 10: mult cod vechi punea direct în header int contor; (fără extern și fără inițializare). Standardul numește asta definiție tentativă; în mai multe unități de compilare, rezultatul e comportament nedefinit. GCC folosea istoric „common symbols” (-fcommon), iar linkerul îmbina definițiile identice în tăcere. Din GCC 10, implicit e -fno-common, ca la Clang 11+, iar codul primește la link „multiple definition of contor”.

Repararea corectă e varianta cu extern de mai sus. Flag-ul -fcommon ascunde doar problema.

De ce merită evitată starea globală:

  • orice fișier o poate modifica, deci bugurile sunt greu de urmărit
  • funcțiile care o folosesc nu sunt reentrante și nu sunt sigure cu threaduri
  • testarea e mai grea

Dacă variabila e folosită doar într-un fișier, o declari static acolo. Dacă e folosită peste tot, o poți ascunde în spatele unor funcții de acces.

Ce urmărește intervievatorul: Verifică practica reală cu proiecte multi-fișier și cunoașterea unei schimbări de toolchain care a stricat mult cod. Mulți nu pot explica de ce codul vechi „mergea”.

Eroarea, în practică:undefined reference to `functie'

72 Junior

Ce sunt __FILE__, __LINE__, __func__ și __DATE__? Scrie un macro de logare care afișează automat fișierul, linia și funcția.

Răspuns scurt: Sunt identificatori predefiniți: __FILE__ și __LINE__ sunt macro-uri cu fișierul și linia curentă, __DATE__ și __TIME__ momentul compilării, iar __func__ (C99) e un șir cu numele funcției curente. Într-un macro de log se expandează la locul apelului, nu în definiția macro-ului.

Preprocesorul înlocuiește __FILE__ cu numele fișierului sursă ca literal șir și __LINE__ cu numărul liniei ca întreg. __func__ nu e macro, ci un identificator definit implicit în fiecare funcție, echivalent cu static const char __func__[] = "nume";. Pentru că un macro se expandează în locul în care e folosit, aceste valori arată exact unde a fost apelat logul.

C
#include <stdio.h>

#define LOG_ERR(fmt, ...) \
    fprintf(stderr, "[%s:%d %s] " fmt "\n", \
            __FILE__, __LINE__, __func__, __VA_ARGS__)

int deschide(const char *cale) {
    FILE *f = fopen(cale, "r");
    if (f == NULL) {
        LOG_ERR("nu pot deschide %s", cale);
        return -1;
    }
    fclose(f);
    return 0;
}

int main(void) {
    deschide("/nu/exista.txt");
    /* [main.c:9 deschide] nu pot deschide /nu/exista.txt */
    return 0;
}

__VA_ARGS__ (C99) preia argumentele variabile. Apelul LOG_ERR("mesaj fix"), fără alte argumente, lasă o virgulă în plus. Soluțiile sunt ##__VA_ARGS__ (extensie GCC/Clang) sau __VA_OPT__(,) din C23.

fmt e lipit direct de literalele din jur, deci trebuie să fie un literal șir, ceea ce împiedică și vulnerabilitatea format string.

Alte macro-uri utile: __STDC_VERSION__ (de exemplu 201710L pentru C17), __GNUC__, __x86_64__, __COUNTER__ (extensie).

Atenție la __DATE__ și __TIME__: fac build-ul nereproductibil, pentru că binarul diferă la fiecare compilare. Distribuțiile Linux folosesc variabila SOURCE_DATE_EPOCH ca să le fixeze, iar GCC avertizează cu -Wdate-time.

Ce urmărește intervievatorul: Verifică experiența practică cu depanarea și cu macro-uri variadice. Candidații încearcă uneori să scrie logarea ca funcție, unde __LINE__ ar arăta mereu aceeași linie.

73 Mid

De ce macro-urile cu mai multe instrucțiuni se scriu în do { ... } while (0)? Ce se strică în varianta de mai jos?

C
#define SWAP(a, b) int t = a; a = b; b = t;
if (x > y) SWAP(x, y);

Răspuns scurt: Fără protecție, doar prima instrucțiune intră sub if, iar restul se execută mereu. do { ... } while (0) transformă corpul într-o singură instrucțiune care cere ; la final și funcționează corect în if/else. În plus, acoladele dau variabilei temporare un scope propriu.

Un macro e înlocuire textuală. Codul de mai sus devine:

C
if (x > y) int t = x; x = y; y = t;;

O declarație nu poate fi corpul unui if, deci nu compilează. Chiar fără declarație (de exemplu cu t existent), doar t = x; ar fi condiționat, iar celelalte două atribuiri s-ar executa mereu.

Acoladele simple nu rezolvă complet:

C
#define SWAP(a, b) { int t = a; a = b; b = t; }
if (x > y) SWAP(x, y); else puts("ok");   /* eroare: else fără if */

; de după } încheie if-ul, iar else rămâne orfan. Varianta standard:

C
#define SWAP(a, b) do { \
    int swap_tmp_ = (a);  \
    (a) = (b);            \
    (b) = swap_tmp_;      \
} while (0)

if (x > y) SWAP(x, y); else puts("ok");   /* corect */

do { } while (0) e o singură instrucțiune care se termină cu ;, deci se comportă exact ca un apel de funcție. Bucla se execută o dată, iar compilatorul o elimină complet la optimizare.

Alte reguli pentru macro-uri sigure:

  • fiecare parametru între paranteze, (a), ca SWAP(v[i], v[j]) sau expresii să se expandeze corect
  • numele temporarelor cu prefix sau sufix neobișnuit, ca să nu se ciocnească de variabile ale apelantului (SWAP(t, u) cu temporara t ar fi un bug)
  • un macro care întoarce o valoare se pune între paranteze; dacă are nevoie de mai multe instrucțiuni, GCC oferă extensia ({ ... }) (statement expressions)

Ce urmărește intervievatorul: Verifică experiența cu macro-uri din cod real și înțelegerea expansiunii textuale. Mulți candidați propun doar acolade.

74 Mid

Ce fac operatorii # și ## în macro-uri? Ce sunt X-macros și ce problemă rezolvă?

Răspuns scurt: # transformă un argument de macro în literal șir (stringizing), iar ## lipește două tokenuri într-unul (token pasting). X-macros folosesc o singură listă de date expandată de mai multe ori cu definiții diferite, ca să generezi automat enum-uri, tabele de nume și cod sincronizat.

# transformă argumentul în șir, exact cum a fost scris:

C
#define AFIS(expr) printf(#expr " = %d\n", (expr))
AFIS(2 + 3 * 4);      /* printf("2 + 3 * 4" " = %d\n", (2 + 3 * 4)); */

## lipește tokenuri:

C
#define GETTER(camp) int get_##camp(const struct cfg *c) { return c->camp; }
GETTER(port)          /* int get_port(const struct cfg *c) { ... } */

Capcană: argumentele lui # și ## nu sunt expandate înainte. #define STR(x) #x aplicat pe STR(__LINE__) dă "__LINE__". Ai nevoie de un nivel intermediar:

C
#define STR_(x) #x
#define STR(x) STR_(x)    /* STR(__LINE__) devine "42" */

X-macros. O problemă clasică: un enum de coduri de eroare și un tablou cu mesajele lor, care trebuie ținute sincronizate manual. Cu X-macros, lista există o singură dată:

C
#include <stdio.h>

#define ERORI(X)                  \
    X(ERR_OK,     "succes")       \
    X(ERR_IO,     "eroare I/O")   \
    X(ERR_MEM,    "fără memorie")

#define CA_ENUM(nume, text) nume,
enum eroare { ERORI(CA_ENUM) ERR_COUNT };

#define CA_TEXT(nume, text) [nume] = text,
static const char *mesaje[] = { ERORI(CA_TEXT) };

int main(void) {
    printf("%s\n", mesaje[ERR_MEM]);   /* fără memorie */
    return 0;
}

Adaugi o eroare nouă într-un singur loc, iar enum-ul, tabelul de mesaje și orice alt cod generat (un switch, nume pentru loguri) se actualizează automat. Tehnica e folosită pentru tabele de comenzi, registre hardware și definiții de opțiuni.

Dezavantajul e lizibilitatea: codul generat nu se vede direct. Îl poți inspecta cu gcc -E fisier.c.

Ce urmărește intervievatorul: Verifică stăpânirea preprocesorului dincolo de constante simple. Puțini candidați știu de nivelul dublu de expandare necesar la stringizing.

Eroarea, în practică:'#' is not followed by a macro parameter

75 Mid

Ce este _Generic (C11)? Scrie un macro care afișează o valoare cu specificatorul printf potrivit tipului ei.

Răspuns scurt: _Generic alege la compilare o expresie în funcție de tipul unui argument, ca un switch pe tipuri. Permite macro-uri type-generic, cum sunt funcțiile din tgmath.h (sqrt care alege sqrtf, sqrt sau sqrtl).

Sintaxa e _Generic(expresie, tip1: rezultat1, tip2: rezultat2, default: rezultat). Expresia de control nu e evaluată; contează doar tipul ei, după conversiile de lvalue (de exemplu un tablou devine pointer, iar const de pe nivelul de sus dispare).

C
#include <stdio.h>

#define FMT(x) _Generic((x),           \
    int: "%d",                         \
    unsigned: "%u",                    \
    long: "%ld",                       \
    double: "%f",                      \
    char *: "%s",                      \
    const char *: "%s",                \
    default: "%p")

#define AFIS(x) (printf(FMT(x), (x)), putchar('\n'))

int main(void) {
    int n = 42;
    double d = 3.5;
    const char *s = "text";
    AFIS(n);      /* 42 */
    AFIS(d);      /* 3.500000 */
    AFIS(s);      /* text */
    AFIS(2u);     /* 2 */
    return 0;
}

Utilizări reale:

  • tgmath.h din biblioteca standard: sqrt(x) alege funcția corectă după tipul lui x
  • funcții „supraîncărcate” proprii: #define abs_g(x) _Generic((x), int: abs, long: labs, double: fabs)(x)
  • verificări de tip în macro-uri, de exemplu un container_of care refuză un pointer de tip greșit

Limitări:

  • char nu e același tip cu signed char sau unsigned char, iar literalele caracter ('a') au tipul int în C, deci ajung pe ramura int
  • un tip care nu apare în listă și nu are default dă eroare de compilare
  • tipurile typedef nu sunt tipuri noi: size_t și unsigned long pot fi același tip pe o platformă, iar două ramuri identice dau eroare
  • nu se pot genera funcții noi, doar alege între cele existente

Ce urmărește intervievatorul: Verifică familiaritatea cu C modern (C11+). Mulți candidați nu au auzit de _Generic sau cred că C nu are nicio formă de supraîncărcare.

76 Mid

Scrie un Makefile pentru un proiect C cu mai multe fișiere, care recompilează doar ce s-a schimbat, inclusiv când se modifică un header.

Răspuns scurt: Definești compilatorul și flag-urile, lista de fișiere obiect, o regulă de legare și o regulă de tip pattern %.o: %.c. Pentru headere, adaugi -MMD -MP ca GCC să genereze fișiere .d cu dependențe, pe care Makefile-ul le include.

make compară datele de modificare: o țintă se refac dacă e mai veche decât oricare dependență. Problema principală la C: un .o depinde și de headerele incluse, nu doar de .c. Dacă nu declari asta, modifici o structură într-un header, iar fișierele care îl folosesc nu se recompilează. Rezultatul e un binar cu layouturi diferite ale aceleiași structuri, cu buguri foarte greu de găsit.

MAKE
CC      := gcc
CFLAGS  := -std=c17 -Wall -Wextra -O2 -g
CPPFLAGS:= -Iinclude -MMD -MP
LDLIBS  := -lm

SRC := $(wildcard src/*.c)
OBJ := $(SRC:src/%.c=build/%.o)
DEP := $(OBJ:.o=.d)

app: $(OBJ)
	$(CC) $(LDFLAGS) $^ $(LDLIBS) -o $@

build/%.o: src/%.c | build
	$(CC) $(CPPFLAGS) $(CFLAGS) -c $< -o $@

build:
	mkdir -p $@

clean:
	rm -rf build app

.PHONY: clean
-include $(DEP)

Elementele cheie:

  • -MMD face ca GCC să scrie, la compilare, un fișier build/x.d cu toate headerele incluse de x.c (fără cele de sistem); -MP adaugă ținte goale pentru headere, ca ștergerea unui header să nu blocheze build-ul
  • -include $(DEP) le încarcă, iar - ignoră lipsa lor la primul build
  • $@ e ținta, $< prima dependență, $^ toate dependențele
  • | build e o dependență order-only: directorul trebuie să existe, dar data lui nu declanșează recompilări
  • LDLIBS vine după fișierele obiect, pentru că linkerul rezolvă simbolurile în ordine
  • liniile de comandă trebuie să înceapă cu TAB, nu cu spații

make -j$(nproc) compilează în paralel. Pentru proiecte mai mari sau multiplatformă, CMake generează aceste reguli automat.

Ce urmărește intervievatorul: Verifică dacă ai construit proiecte C reale, nu doar gcc main.c. Lipsa dependențelor de headere e o problemă clasică în Makefile-urile scrise de mână.

Eroarea, în practică:undefined reference to `functie'

77 Senior

Scrii o bibliotecă partajată în C. Cum controlezi ce simboluri sunt exportate și ce sunt simbolurile weak? Cum verifici rezultatul?

Răspuns scurt: Funcțiile interne le faci static sau compilezi cu -fvisibility=hidden și marchezi explicit API-ul public cu __attribute__((visibility("default"))). Un simbol weak poate fi înlocuit la link de o definiție normală (strong) cu același nume. Verifici cu nm -D sau objdump -T.

Implicit, pe Linux, toate funcțiile și variabilele globale non-static dintr-o bibliotecă .so sunt exportate. Asta are costuri: simbolurile interne devin parte din ABI (cineva ajunge să le folosească), pot intra în conflict cu simboluri din alte biblioteci, iar încărcarea e mai lentă, pentru că sunt mai multe relocări.

Controlul vizibilității:

C
/* api.h */
#if defined(_WIN32)
  #define MYLIB_API __declspec(dllexport)
#else
  #define MYLIB_API __attribute__((visibility("default")))
#endif

MYLIB_API int mylib_init(void);

/* intern.c, compilat cu -fvisibility=hidden */
int helper_intern(void) { return 1; }      /* nu e exportat */
MYLIB_API int mylib_init(void) { return helper_intern(); }
BASH
gcc -fPIC -fvisibility=hidden -shared intern.c -o libmylib.so
nm -D --defined-only libmylib.so    # apare doar mylib_init

Pe Windows logica e inversă: nimic nu e exportat fără __declspec(dllexport) sau un fișier .def. Pe Linux, un version script (-Wl,--version-script=lib.map) oferă control suplimentar și versionarea simbolurilor, cum face glibc.

Simboluri weak:

C
__attribute__((weak)) void on_error(int cod) { (void)cod; }  /* implementare implicită */

Dacă aplicația definește propria funcție on_error, linkerul o folosește pe aceea; altfel rămâne cea weak. Se folosește masiv în embedded: fișierele de startup definesc handlerele de întrerupere ca weak alias spre un handler implicit, iar tu le suprascrii doar pe cele de care ai nevoie. Și bibliotecile de test folosesc tehnica pentru a înlocui funcții.

Riscuri: o greșeală de scriere în numele funcției tale face ca versiunea implicită să fie folosită în tăcere, iar comportamentul weak diferă între linkerul static și cel dinamic.

Ce urmărește intervievatorul: Verifică experiența cu biblioteci reale și cu toolchain-ul, dincolo de compilarea simplă. E o întrebare care separă candidații care au livrat biblioteci de cei care doar le-au folosit.

Comportament nedefinit

78 Junior

Ce afișează programul de mai jos? Răspunsul „o valoare oarecare de pe stivă” e complet?

C
#include <stdio.h>
int main(void) {
    int x;
    if (x > 0) puts("pozitiv");
    if (x <= 0) puts("nepozitiv");
    return 0;
}

Răspuns scurt: Nu e complet: citirea unei variabile automatice neinițializate care nu și-a avut niciodată adresa luată e comportament nedefinit, iar optimizatorul poate trata x ca având valori diferite la fiecare citire. Programul poate afișa unul, ambele sau niciunul dintre mesaje.

Intuiția spune că x are „ce era înainte în memorie”, deci exact unul dintre mesaje apare. Standardul e mai strict. Valoarea unei variabile automatice neinițializate e nedeterminată, iar dacă variabila ar fi putut fi declarată register (adică nu i se ia adresa), citirea ei e comportament nedefinit (C11, 6.3.2.1p2).

În practică, compilatorul nu rezervă un registru sau o locație pentru o valoare care „nu există”. Clang, de exemplu, reprezintă valoarea ca undef, care poate fi tratată diferit la fiecare utilizare. Așa că ambele condiții pot fi evaluate ca adevărate sau ca false, iar la -O2 codul poate dispărea complet. Același program poate afișa altceva la -O0, la -O2 sau după o modificare fără legătură.

Variabilele locale neinițializate sunt cauza unora dintre cele mai frustrante buguri: programul merge în debug (unde stiva e adesea pe zero) și cade în release.

Cum previi:

  • inițializezi la declarare: int x = 0;, struct cfg c = {0};
  • compilezi cu -Wall -Wextra, care include -Wuninitialized și -Wmaybe-uninitialized (cele mai bune rezultate apar cu optimizare activă, -O2)
  • rulezi cu valgrind, care raportează „Conditional jump or move depends on uninitialised value(s)”, sau cu MemorySanitizer din Clang (-fsanitize=memory)
  • GCC 12+ și Clang au -ftrivial-auto-var-init=zero sau =pattern, folosit de kernelul Linux și de unele proiecte pentru întărire

Variabilele cu durată statică nu au această problemă: sunt inițializate implicit cu zero.

Ce urmărește intervievatorul: Verifică dacă înțelegi că UB nu înseamnă „o valoare aleatoare”, ci lipsa oricărei garanții. Majoritatea candidaților dau răspunsul intuitiv.

Eroarea, în practică:variable 'suma' is uninitialized when used hereuninitialized when used within its own init.

79 Junior

De ce codul de mai jos nu dă eroare la compilare și de multe ori nici la rulare? Ce se poate întâmpla?

C
int a[5] = {1, 2, 3, 4, 5};
int b = 100;
for (int i = 0; i <= 5; i++) a[i] = 0;

Răspuns scurt: C nu verifică limitele tablourilor: a[5] e doar o adresă calculată, iar scrierea acolo e comportament nedefinit. Poate suprascrie o altă variabilă (de exemplu b), date de control de pe stivă sau poate fi folosit de optimizator ca să transforme bucla într-una infinită.

a[i] înseamnă *(a + i), iar compilatorul generează pur și simplu o scriere la adresa calculată. Nu există verificare la rulare: ar costa la fiecare acces, iar filozofia C e să nu plătești pentru ce nu ceri. Condiția i <= 5 e un off-by-one clasic: tabloul are indici 0–4.

Ce se poate întâmpla la a[5] = 0:

  • dacă b e plasat imediat după a pe stivă, devine 0 fără nicio eroare
  • poate fi suprascris un canar de stivă, iar programul se oprește la ieșirea din funcție cu „stack smashing detected” (protecție activă cu -fstack-protector, implicit pe multe distribuții)
  • poate fi suprascrisă adresa de întoarcere, mecanismul exploatat în atacurile de tip buffer overflow
  • optimizatorul poate raționa că a[i] cu i == 5 nu se întâmplă niciodată, deci condiția i <= 5 e mereu adevărată în iterațiile valide; GCC a generat în cazuri similare bucle infinite

De aceea „merge la mine” nu înseamnă nimic pentru UB.

Unelte care prind bug-ul:

BASH
gcc -Wall -O2 prog.c                    # -Warray-bounds prinde cazurile evidente
gcc -g -fsanitize=address prog.c && ./a.out   # stack-buffer-overflow, cu linia

Valgrind nu prinde de obicei depășirile pe stivă, doar pe heap, de aceea AddressSanitizer e unealta potrivită aici.

Prevenire: bucle de forma i < n, cu n calculat ca sizeof a / sizeof a[0], funcții care primesc mereu dimensiunea bufferului alături de pointer și verificarea explicită a indicilor care vin din date externe.

Ce urmărește intervievatorul: Verifică înțelegerea consecințelor reale ale accesului în afara limitelor. Candidații spun adesea că „va da segmentation fault”, ceea ce de obicei nu se întâmplă.

Eroarea, în practică:array index 5 is past the end of the array*** stack smashing detected ***

80 Mid

Ce afișează codul de mai jos? E comportament nedefinit?

C
#include <stdio.h>
int f(void) { printf("f "); return 1; }
int g(void) { printf("g "); return 2; }
int main(void) {
    printf("%d\n", f() + g());
    return 0;
}

Răspuns scurt: Poate afișa f g 3 sau g f 3: ordinea de evaluare a operanzilor lui + (și a argumentelor unei funcții) e nespecificată, nu nedefinită. Programul e valid, dar rezultatul vizibil depinde de compilator, deci nu te bazezi pe o anumită ordine.

În C, ordinea în care sunt evaluați operanzii celor mai mulți operatori și argumentele unei funcții este nespecificată (unspecified): compilatorul poate alege orice ordine, chiar diferită de la un apel la altul, fără să o documenteze. Comportamentul rămâne definit: fiecare funcție se apelează exact o dată, iar suma e 3. Doar ordinea efectelor secundare, aici afișările, poate varia.

Diferența față de UB apare când două evaluări fără ordine modifică sau citesc același obiect:

C
int i = 0;
int x = f() + g();        /* nespecificat: ordinea apelurilor */
printf("%d %d", i, i++);  /* nedefinit: i citit și modificat fără secvențiere */
a[i] = i++;               /* nedefinit */

Există și operatori cu ordine garantată (puncte de secvență, din C11 „sequenced before”):

  • && și ||: stânga e evaluată complet înainte de dreapta
  • operatorul virgulă , (nu virgula dintre argumente)
  • ?:: condiția, apoi doar una dintre ramuri
  • finalul unei expresii complete (;) și momentul dinaintea apelului unei funcții, după evaluarea tuturor argumentelor

Cum scrii cod robust: dacă ordinea efectelor contează, le separi în instrucțiuni distincte:

C
int a = f();
int b = g();
printf("%d\n", a + b);    /* f g 3, garantat */

GCC pe x86-64 evaluează adesea argumentele de la dreapta la stânga, iar Clang de la stânga la dreapta, deci diferența se vede chiar între două compilatoare pe aceeași mașină. Avertismentul -Wsequence-point (inclus în -Wall) prinde cazurile care sunt UB.

Ce urmărește intervievatorul: Verifică dacă distingi comportamentul nespecificat de cel nedefinit pe un exemplu concret. Mulți candidați afirmă sigur că ordinea e de la stânga la dreapta.

Eroarea, în practică:unsequenced modification and access

81 Mid

Unde sunt erorile în apelurile printf de mai jos și de ce pot produce rezultate greșite sau crash-uri?

C
size_t n = sizeof(long);
long big = 5000000000L;
int *p = &x;
printf("%d %d %x\n", n, big, p);

Răspuns scurt: Toți trei specificatorii sunt greșiți: size_t cere %zu, long cere %ld, iar un pointer se afișează cu %p după conversie la void *. Un specificator care nu corespunde tipului e comportament nedefinit și poate decala citirea argumentelor următoare.

printf e variadică, deci nu cunoaște tipurile argumentelor. Citește din registre și de pe stivă exact ce îi spune șirul de format. Dacă tipurile nu corespund, comportamentul e nedefinit.

Pe x86-64 Linux, size_t și long au 8 octeți, iar %d citește doar 4. Valoarea 5000000000 afișată cu %d devine 705032704 (partea de jos a numărului). Pe platforme unde argumentele se pun pe stivă (x86 pe 32 de biți, cu long long), un specificator prea mic decalează toate argumentele de după el, iar %s ulterior poate citi o adresă aleatorie și opri programul.

Varianta corectă:

C
#include <stdio.h>

int main(void) {
    int x = 7;
    size_t n = sizeof(long);
    long big = 5000000000L;     /* necesită long pe 64 de biți */
    int *p = &x;
    printf("%zu %ld %p\n", n, big, (void *)p);
    return 0;
}

Tabelul de reținut:

  • size_t: %zu; ptrdiff_t: %td; long long: %lld; unsigned long: %lu
  • double și float (promovat): %f, %e, %g
  • char *: %s; pointeri: %p cu cast la void *, pentru că standardul cere void * explicit
  • int64_t și celelalte din stdint.h: macro-urile din inttypes.h, de exemplu PRId64

5000000000L nu încape într-un long de 32 de biți, deci pe Windows codul ar avea și o problemă de constantă. Acolo ai nevoie de long long și %lld.

Protecția practică e -Wall (care activează -Wformat): GCC și Clang verifică șirurile de format literale la compilare. Pentru funcțiile proprii de logare, atributul format(printf, ...) aduce aceeași verificare.

Ce urmărește intervievatorul: Verifică atenția la tipuri în I/O formatat, o sursă clasică de buguri de portabilitate. Candidații afișează adesea size_t cu %d și pointeri cu %x.

Eroarea, în practică:format specifies type 'int' but ... 'double'format specifies type 'char *' but ... 'char'

82 Senior

Primești un buffer de octeți de la rețea și vrei să citești un uint32_t de la offset-ul 3. De ce *(uint32_t *)(buf + 3) e o problemă și ce scrii în loc?

Răspuns scurt: Castul încalcă două reguli: adresa nu e aliniată pentru uint32_t (pe unele ARM sau în cod vectorizat asta dă excepție) și se accesează un obiect char printr-un tip incompatibil, adică strict aliasing. Folosești memcpy într-un uint32_t local sau asamblezi valoarea din octeți prin shiftări.

Alinierea. Fiecare tip are o cerință de aliniere: uint32_t trebuie de obicei să stea la o adresă multiplu de 4 (_Alignof(uint32_t)). Accesul la o adresă nealiniată e comportament nedefinit. Pe x86 merge de obicei, cu un cost mic de performanță. Pe ARMv5, pe Cortex-M0 și pe alte microcontrolere dă hard fault, iar pe x86, dacă compilatorul vectorizează codul cu instrucțiuni SSE care cer aliniere, poți primi segmentation fault chiar pe un procesor care altfel tolerează accesul nealiniat.

Aliasing-ul. Bufferul e un tablou de unsigned char (sau provine de la malloc și a fost scris ca octeți). Citirea lui printr-un uint32_t * încalcă regula care permite accesul la un obiect doar prin tipul lui sau prin tipuri caracter. Optimizatorul poate reordona citirea față de scrierile în buffer.

Variantele corecte:

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

uint32_t citeste_nativ(const unsigned char *p) {
    uint32_t v;
    memcpy(&v, p, sizeof v);     /* ordinea octeților a mașinii */
    return v;
}

uint32_t citeste_be(const unsigned char *p) {
    return (uint32_t)p[0] << 24 | (uint32_t)p[1] << 16 |
           (uint32_t)p[2] << 8  | (uint32_t)p[3];
}

Ambele sunt la fel de rapide ca un cast: GCC și Clang recunosc tiparele și generează o singură instrucțiune de încărcare (plus bswap pentru big-endian) acolo unde platforma permite acces nealiniat.

Pentru protocoale de rețea, varianta cu shiftări e preferabilă, pentru că face și conversia de endianness explicit și independent de platformă.

Ce urmărește intervievatorul: Verifică experiența cu cod de rețea și embedded pe arhitecturi diferite. Castul de pointer e răspunsul tipic și „funcționează” pe laptopul candidatului.

Intrare/ieșire și fișiere

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

Ce întoarce scanf și de ce se scrie scanf("%d", &n) cu &, dar scanf("%s", nume) fără?

Răspuns scurt: scanf întoarce numărul de câmpuri citite și atribuite cu succes, sau EOF dacă intrarea s-a terminat înainte de primul câmp. Are nevoie de adrese ca să scrie rezultatul; &n e adresa lui n, iar numele unui tablou char decade deja la pointer spre primul element.

scanf trebuie să modifice variabilele apelantului, iar în C asta se face doar prin pointeri. De aceea fiecare argument e o adresă: &n pentru un int, &x pentru un double. Un tablou char nume[32] folosit ca argument devine automat &nume[0], deci nu mai pui &. &nume ar avea tipul char (*)[32], aceeași adresă dar tip greșit pentru %s, ceea ce tehnic e nepotrivire de tip.

Uitarea lui & (scanf("%d", n)) transmite valoarea lui n ca adresă: scriere la o adresă aleatorie, de obicei crash. -Wall o prinde la compilare.

Valoarea de return trebuie verificată mereu:

C
#include <stdio.h>

int main(void) {
    int zi, luna;
    printf("Data (zi luna): ");
    int r = scanf("%d %d", &zi, &luna);
    if (r == EOF) {
        puts("intrare terminată");
    } else if (r != 2) {
        puts("format invalid");
    } else {
        printf("%02d.%02d\n", zi, luna);
    }
    return 0;
}

Dacă utilizatorul scrie 12 abc, r e 1: zi a fost citit, luna nu, iar valoarea lui luna rămâne neinițializată. Fără verificare, programul ar folosi o valoare oarecare.

Alte reguli:

  • %s citește până la primul spațiu și nu are limită; scrii mereu lățimea, %31s pentru un buffer de 32
  • %d, %f, %s sar peste spațiile albe dinainte, dar %c nu; pentru a sări peste ele scrii " %c", cu spațiu înainte
  • %lf pentru double, %f pentru float
  • scanf nu raportează overflow: 99999999999 cu %d e comportament nedefinit, motiv pentru care codul robust citește linii cu fgets și le convertește cu strtol

Ce urmărește intervievatorul: Verifică înțelegerea pointerilor aplicată pe I/O și obiceiul de a verifica rezultatele. Aproape niciun junior nu verifică valoarea întoarsă de scanf.

Eroarea, în practică:format specifies type 'int *' (scanf fără &)format 'float *' but argument has type 'double *'

84 Junior

Programul de mai jos intră în buclă infinită dacă utilizatorul scrie o literă în loc de număr. De ce și cum îl repari?

C
int n;
do {
    printf("Număr între 1 și 10: ");
    scanf("%d", &n);
} while (n < 1 || n > 10);

Răspuns scurt: Când scanf nu poate converti intrarea, întoarce 0 și lasă caracterele invalide în buffer, iar următorul apel le găsește din nou. n nu se schimbă, deci bucla nu se termină. Verifici valoarea întoarsă și golești linia, sau citești cu fgets și convertești cu strtol.

scanf("%d", &n) citește caractere cât timp formează un număr. La litera a, conversia eșuează: funcția întoarce 0, nu atribuie nimic lui n și pune caracterul înapoi în flux. La următoarea iterație, citirea începe tot de la a, eșuează din nou, iar programul afișează promptul la nesfârșit. Dacă n era neinițializat, bucla poate depinde și de o valoare nedeterminată. La EOF (Ctrl+D) apare tot o buclă infinită.

Reparația minimă cu scanf:

C
#include <stdio.h>

int citeste_1_10(void) {
    int n, r;
    for (;;) {
        printf("Număr între 1 și 10: ");
        r = scanf("%d", &n);
        if (r == EOF) return -1;
        if (r == 1 && n >= 1 && n <= 10) return n;
        int c;
        while ((c = getchar()) != '\n' && c != EOF)
            ;   /* aruncă restul liniei */
    }
}

Varianta mai robustă citește linia întreagă:

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

int citeste_1_10_v2(void) {
    char linie[64];
    while (printf("Număr între 1 și 10: "),
           fgets(linie, sizeof linie, stdin) != NULL) {
        char *end;
        long v = strtol(linie, &end, 10);
        if (end != linie && (*end == '\n' || *end == '\0') && v >= 1 && v <= 10)
            return (int)v;
    }
    return -1;
}

Avantajele variantei cu fgets: respinge și intrări ca 5abc (pe care scanf le acceptă ca 5), detectează overflow-ul și nu lasă resturi în buffer pentru următoarea citire.

Nu folosești fflush(stdin) pentru golire: standardul definește fflush doar pentru fluxuri de ieșire. Merge pe Windows cu MSVC, dar pe Linux e comportament nedefinit și de obicei nu face nimic.

Ce urmărește intervievatorul: Verifică dacă înțelegi cum funcționează bufferul de intrare. Soluția greșită tipică este fflush(stdin).

85 Junior

Cum deschizi corect un fișier text pentru citire și unul pentru scriere? Ce înseamnă modurile "r", "w", "a", "r+" și "b"?

Răspuns scurt: Apelezi fopen(cale, mod), verifici rezultatul (întoarce NULL la eșec, cu errno setat) și închizi cu fclose. "r" citește, "w" creează sau golește, "a" adaugă la final, "r+" citește și scrie fără să golească, iar "b" cere mod binar, relevant pe Windows.

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

int copiaza(const char *sursa, const char *dest) {
    FILE *in = fopen(sursa, "r");
    if (in == NULL) {
        fprintf(stderr, "%s: %s\n", sursa, strerror(errno));
        return -1;
    }
    FILE *out = fopen(dest, "w");
    if (out == NULL) {
        fprintf(stderr, "%s: %s\n", dest, strerror(errno));
        fclose(in);
        return -1;
    }
    char linie[256];
    while (fgets(linie, sizeof linie, in) != NULL)
        fputs(linie, out);

    int err = ferror(in);
    fclose(in);
    if (fclose(out) != 0 || err) return -1;   /* fclose poate eșua la scriere */
    return 0;
}

Modurile:

  • "r": citire; fișierul trebuie să existe
  • "w": scriere; creează fișierul sau îl golește dacă există
  • "a": adăugare; fiecare scriere merge la final, indiferent de fseek
  • "r+": citire și scriere, fișierul trebuie să existe, nu e golit
  • "w+", "a+": ca "w" și "a", plus citire
  • "x" (C11, combinat cu "w"): "wx" eșuează dacă fișierul există, util ca să nu suprascrii
  • "b": mod binar

Pe Windows, în modul text, \n se transformă în \r\n la scriere și invers la citire, iar Ctrl+Z poate fi tratat ca final de fișier. Pentru date binare (imagini, structuri) folosești mereu "rb"/"wb". Pe Linux și macOS cele două moduri sunt identice, dar "b" face codul portabil.

Cu "r+", între o citire și o scriere trebuie apelat fseek sau fflush, altfel comportamentul e nedefinit.

fclose merită verificat la fișierele scrise: datele stau în buffer, iar o eroare de disc plin poate apărea abia la închidere.

Ce urmărește intervievatorul: Verifică lucrul corect cu resurse și tratarea erorilor. Candidații uită de obicei să închidă primul fișier când al doilea fopen eșuează.

86 Junior

De ce bucla de mai jos procesează ultima linie de două ori?

C
char linie[128];
while (!feof(f)) {
    fgets(linie, sizeof linie, f);
    printf("%s", linie);
}

Răspuns scurt: feof devine adevărat abia după ce o citire a dat de final. După ultima linie bucla mai rulează o dată, fgets eșuează și lasă bufferul neschimbat, iar vechea linie e afișată din nou. Testezi direct rezultatul citirii.

feof(f) nu prezice viitorul. Întoarce adevărat doar dacă indicatorul de sfârșit de fișier a fost setat de o citire anterioară care a dat de final. Succesiunea pentru un fișier cu două linii:

  • iterația 1: feof e fals, fgets citește linia 1
  • iterația 2: feof e fals, fgets citește linia 2 (inclusiv \n), fără să încerce dincolo
  • iterația 3: feof e încă fals, fgets încearcă să citească, dă de final, întoarce NULL și setează indicatorul; linie rămâne cu linia 2, care e afișată din nou
  • abia acum feof e adevărat

Dacă fișierul nu se termină cu \n, a doua citire atinge deja finalul și dublura nu mai apare, deci bug-ul depinde de conținut. Mai rău, dacă fișierul e gol, linie e neinițializat și se afișează gunoi. La o eroare de citire (nu EOF), feof rămâne fals pentru totdeauna și bucla e infinită.

Forma corectă testează rezultatul fiecărei operații:

C
#include <stdio.h>

void afiseaza(FILE *f) {
    char linie[128];
    while (fgets(linie, sizeof linie, f) != NULL)
        fputs(linie, stdout);

    if (ferror(f))
        perror("citire");
}

Același tipar pentru celelalte funcții:

  • while ((c = fgetc(f)) != EOF), cu c de tip int
  • while (fscanf(f, "%d", &x) == 1)
  • while ((n = fread(buf, 1, sizeof buf, f)) > 0)

feof și ferror se folosesc după buclă, ca să afli de ce s-a oprit citirea: final normal sau eroare.

Ce urmărește intervievatorul: Verifică o greșeală clasică din manualele vechi și din codul juniorilor. Mulți candidați nu pot explica de ce apare dublura.

87 Mid

Un program afișează cu printf("Pas 3...") și apoi cade cu segmentation fault, dar mesajul nu apare în terminal. De ce? Ce înseamnă buffering pentru stdout și stderr?

Răspuns scurt: stdout e line-buffered când e legat la un terminal și complet bufferizat când e redirecționat; textul fără \n rămâne în buffer, iar la crash bufferul se pierde. stderr e nebufferizat. Pentru mesaje de diagnostic folosești stderr sau apelezi fflush(stdout).

Funcțiile din stdio.h nu apelează sistemul de operare la fiecare caracter, ci adună datele într-un buffer în memorie și le scriu în blocuri, cu un apel write. Standardul definește trei moduri, iar setvbuf permite alegerea lor:

  • nebufferizat (_IONBF): fiecare scriere ajunge imediat; implicit pentru stderr
  • line-buffered (_IOLBF): bufferul se golește la \n; implicit pentru stdout când e conectat la un terminal (în glibc)
  • complet bufferizat (_IOFBF): golire când bufferul (de obicei 4–8 KB) se umple; implicit pentru stdout redirecționat într-un fișier sau pipe

Bufferul se mai golește la fflush, la exit sau return din main și, în practică, înainte de citirea de la terminal.

În scenariul din întrebare, "Pas 3..." nu are \n, deci rămâne în buffer. La segmentation fault procesul e oprit de un semnal, exit nu mai rulează, iar bufferul se pierde. Concluzia greșită ar fi că programul a căzut înainte de pasul 3.

C
#include <stdio.h>

int main(void) {
    fprintf(stderr, "Pas 3...\n");     /* apare imediat */
    printf("Pas 3...");
    fflush(stdout);                     /* forțează scrierea */
    setvbuf(stdout, NULL, _IONBF, 0);   /* sau dezactivezi bufferul (înainte de orice scriere) */
    return 0;
}

Alte efecte ale buffering-ului:

  • ./prog > out.txt poate schimba ordinea dintre mesajele stdout și stderr față de terminal
  • după fork(), bufferul negolit e copiat în ambele procese și apare de două ori
  • fflush(stdin) nu e definit de standard

Pentru depanarea crash-urilor, un debugger sau un core dump e mai sigur decât afișările.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismului de I/O, important la depanare. Candidații trag des concluzii greșite despre locul crash-ului din cauza bufferului.

88 Mid

Scrie o funcție care citește un fișier binar întreg în memorie. Cum afli dimensiunea și ce întorc fread și fwrite?

Răspuns scurt: Deschizi cu "rb", mergi la final cu fseek(f, 0, SEEK_END), iei dimensiunea cu ftell, revii cu rewind sau fseek, aloci și citești cu fread. fread și fwrite întorc numărul de elemente complete transferate, nu de octeți, deci compari cu cât ai cerut.

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

unsigned char *citeste_tot(const char *cale, size_t *lungime) {
    FILE *f = fopen(cale, "rb");
    if (f == NULL) return NULL;

    unsigned char *buf = NULL;
    if (fseek(f, 0, SEEK_END) != 0) goto gata;
    long dim = ftell(f);
    if (dim < 0) goto gata;
    if (fseek(f, 0, SEEK_SET) != 0) goto gata;

    buf = malloc(dim > 0 ? (size_t)dim : 1);
    if (buf == NULL) goto gata;

    size_t citit = fread(buf, 1, (size_t)dim, f);
    if (citit != (size_t)dim) {        /* fișier trunchiat între timp sau eroare */
        free(buf);
        buf = NULL;
        goto gata;
    }
    *lungime = citit;
gata:
    fclose(f);
    return buf;
}

Detalii:

  • fread(ptr, size, count, f) întoarce numărul de elemente de size octeți citite complet. Cu size = 1 primești numărul de octeți, ușor de comparat. Cu fread(buf, 4, 10, f) pe un fișier de 15 octeți primești 3, iar ultimii 3 octeți citiți parțial nu sunt raportați
  • un rezultat mai mic decât cererea poate însemna final de fișier sau eroare; le distingi cu feof și ferror
  • fwrite întoarce tot numărul de elemente scrise; un rezultat mai mic e mereu eroare (disc plin, de exemplu)

Limitările acestei tehnici:

  • ftell întoarce long, care pe Windows are 32 de biți, deci fișierele de peste 2 GB necesită _ftelli64 sau, pe POSIX, ftello cu off_t
  • standardul C nu garantează că SEEK_END are sens pe fluxuri binare, iar pe pipe-uri și pe stdin fseek eșuează; o alternativă portabilă e citirea în blocuri cu un buffer care crește

Ce urmărește intervievatorul: Verifică lucrul cu fișiere binare și interpretarea corectă a valorilor întoarse. Greșeala tipică e să compari rezultatul lui fread cu numărul de octeți când size e mai mare decât 1.

89 Mid

Cum se tratează erorile în C, unde nu există excepții? Explică errno, perror, strerror și tiparul goto cleanup.

Răspuns scurt: Funcțiile semnalează eșecul prin valoarea întoarsă (-1, NULL, EOF), iar multe setează în plus errno cu cauza. perror și strerror transformă errno în text. Pentru funcții care alocă mai multe resurse, goto cleanup centralizează eliberarea într-un singur loc, în ordine inversă.

errno (din errno.h) e o valoare locală fiecărui thread, setată de funcțiile de bibliotecă la eșec cu un cod ca ENOENT (fișier inexistent), EACCES (permisiune refuzată) sau ENOMEM. Reguli importante:

  • îl citești doar după ce valoarea întoarsă a indicat eșec; funcțiile reușite pot lăsa errno neschimbat sau chiar îl pot modifica
  • îl salvezi imediat, pentru că orice alt apel de bibliotecă (inclusiv printf) îl poate suprascrie
  • pentru funcții ca strtol, care nu au o valoare de eroare distinctă, pui errno = 0 înainte

perror("fopen") afișează pe stderr „fopen: No such file or directory”, iar strerror(errno) întoarce textul ca să-l folosești în propriul mesaj.

goto cleanup e folosit pe scară largă în kernelul Linux și în proiecte C mari:

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

int proceseaza(const char *cale) {
    int rez = -1;
    char *buf = NULL;
    FILE *f = fopen(cale, "rb");
    if (f == NULL) { perror(cale); goto out; }

    buf = malloc(4096);
    if (buf == NULL) goto out_close;

    if (fread(buf, 1, 4096, f) == 0 && ferror(f)) goto out_free;

    rez = 0;                 /* succes */
out_free:
    free(buf);
out_close:
    fclose(f);
out:
    return rez;
}

Fiecare resursă are o etichetă, iar eliberarea are loc în ordine inversă alocării. Alternativa, cu if-uri imbricate sau eliberare duplicată în fiecare ramură de eroare, produce leak-uri când cineva adaugă o resursă nouă și uită o ramură.

Varianta cu o singură etichetă și pointeri inițializați cu NULL funcționează și ea, pentru că free(NULL) e sigur; pentru fclose adaugi if (f).

Ce urmărește intervievatorul: Verifică abordarea matură a erorilor în C, fără excepții. Candidații care consideră goto interzis mereu nu au lucrat de obicei pe cod C real.

Eroarea, în practică:ignoring return value ('warn_unused_result')

Depanare, embedded și situații

90 Junior

Cum folosești gdb ca să depanezi un program C? Care sunt comenzile de bază?

Răspuns scurt: Compilezi cu -g (și ideal -O0), pornești gdb ./prog, pui puncte de oprire cu break, rulezi cu run, avansezi cu next și step, inspectezi cu print și bt. După un crash, bt îți arată imediat lanțul de apeluri.

-g adaugă în executabil informațiile de depanare (DWARF): numele variabilelor, tipurile și legătura dintre instrucțiuni și liniile sursă. Fără el, gdb vede doar adrese. La -O2, variabilele pot fi „optimized out”, iar execuția sare între linii, de aceea pentru depanare se folosește -O0 sau -Og.

BASH
gcc -g -O0 -Wall prog.c -o prog
gdb --args ./prog input.txt

Comenzile de bază:

  • break main sau break prog.c:42: punct de oprire; break f if n == 0 îl face condiționat
  • run: pornește programul (cu argumentele date)
  • next (n): execută linia curentă fără să intre în funcții; step (s) intră în funcții
  • finish: rulează până la ieșirea din funcția curentă
  • continue (c): până la următorul punct de oprire
  • print x, print *p, print v[0]@10 (primele 10 elemente), print/x flags (în hexazecimal)
  • display x: afișează x după fiecare pas
  • bt (backtrace): stiva de apeluri; frame 2 te mută în cadrul respectiv, cu variabilele lui
  • watch contor: oprește execuția când variabila se modifică, foarte util când nu știi cine o strică
  • info locals, info args
  • layout src (TUI): sursa într-un panou separat

După un segmentation fault, run se oprește direct la instrucțiunea problematică, iar bt și print pe pointerii implicați arată de obicei cauza în câteva secunde.

Pentru crash-uri din afara debuggerului activezi core dump-urile (ulimit -c unlimited) și le deschizi cu gdb ./prog core. Pe macOS, echivalentul e lldb, cu comenzi asemănătoare (b, r, n, s, bt, p).

Ce urmărește intervievatorul: Verifică dacă știi să depanezi altfel decât cu printf. Mulți juniori n-au folosit niciodată watch sau bt.

Eroarea, în practică:Segmentation fault (core dumped)

91 Junior

Cum interpretezi raportul de mai jos de la valgrind și ce bug indică fiecare parte?

==123== Invalid write of size 4
==123==    at 0x109185: umple (prog.c:8)
==123==    by 0x1091B2: main (prog.c:14)
==123==  Address 0x4a8e068 is 0 bytes after a block of size 40 alloc'd
==123==    at 0x483B7F3: malloc (vg_replace_malloc.c:309)
==123==    by 0x1091A3: main (prog.c:13)
...
==123== 40 bytes in 1 blocks are definitely lost in loss record 1 of 1

Răspuns scurt: umple (linia 8) scrie un int imediat după un bloc de 40 de octeți alocat în main la linia 13: depășire cu un element a unui tablou de 10 int. Ultima linie arată un memory leak de 40 de octeți.

Valgrind (unealta implicită, Memcheck) rulează programul pe un procesor virtual și verifică fiecare acces la memorie. E de 20–50 de ori mai lent, dar nu cere recompilare (doar -g pentru numere de linie).

BASH
valgrind --leak-check=full --track-origins=yes ./prog

Citirea raportului:

  • „Invalid write of size 4”: o scriere de 4 octeți într-o zonă nealocată; „Invalid read” ar fi o citire
  • stiva de sub mesaj: unde s-a întâmplat (umple, prog.c:8, apelată din main, linia 14)
  • „0 bytes after a block of size 40”: adresa e chiar la finalul unui bloc de 40 de octeți, deci un off-by-one, tipic pentru i <= n în loc de i < n
  • „alloc'd at … main (prog.c:13)”: unde a fost alocat blocul
  • dacă ar fi scris „inside a block of size 40 free'd”, ar fi fost un use-after-free, cu încă o stivă care arată unde s-a făcut free

Categoriile de leak-uri de la final:

  • definitely lost: niciun pointer nu mai arată spre bloc, deci e un leak sigur
  • indirectly lost: blocul e accesibil doar dintr-un bloc pierdut (nodurile unei liste al cărei cap s-a pierdut); dispar când repari leak-ul principal
  • possibly lost: există doar pointeri spre interiorul blocului
  • still reachable: memorie încă referită la ieșire (de exemplu globale); de obicei nu e o problemă

Alte mesaje frecvente: „Conditional jump or move depends on uninitialised value(s)” (cu --track-origins=yes vezi de unde vine valoarea) și „Invalid free() / delete / delete[]”.

Regula de lucru: repari întotdeauna prima eroare raportată; următoarele sunt adesea consecințe ale ei.

Ce urmărește intervievatorul: Verifică experiența practică cu uneltele de memorie. Candidații spun că „folosesc valgrind”, dar nu știu să citească raportul.

92 Junior

Un coleg junior îți spune că nu înțelege pointerii. Cum i-ai explica, pe scurt și cu un exemplu?

Răspuns scurt: Pornesc de la memorie ca șir de căsuțe numerotate: variabila e o căsuță, adresa e numărul ei, iar pointerul e o variabilă care ține un astfel de număr. Apoi arăt ce fac & și * și de ce swap are nevoie de pointeri.

Un răspuns structurat are trei părți: modelul mental, exemplul concret și verificarea înțelegerii.

1. Modelul mental. Memoria e un șir lung de căsuțe de câte un octet, fiecare cu un număr (adresa). Când scrii int x = 7;, compilatorul rezervă 4 căsuțe și pune în ele valoarea 7. Un pointer e tot o variabilă, dar valoarea ei e o adresă, adică numărul unei căsuțe. Comparația cu adresa unei case funcționează bine: poți copia adresa pe mai multe bilețele (mai mulți pointeri), dar casa e una singură.

2. Exemplul. Scriu codul și desenez pe tablă căsuțele cu adrese inventate:

C
int x = 7;        /* căsuța 1000 conține 7 */
int *p = &x;      /* p (căsuța 2000) conține 1000 */
*p = 9;           /* „mergi la adresa din p și scrie 9” */
printf("%d\n", x);   /* 9 */

Explic că &x înseamnă „adresa lui x”, iar *p înseamnă „ce se află la adresa din p”. Apoi arăt swap fără și cu pointeri, ca să vadă de ce contează: funcția primește copii, iar adresa e singura cale de a modifica originalul.

3. Verificarea. Îi dau un exercițiu mic, de exemplu o funcție care împarte și întoarce câtul și restul prin doi pointeri, și îl las să-l scrie singur. Îi arăt în gdb cu print &x, print p și print *p că valorile sunt reale, nu abstracte.

Ce evit: să încep cu aritmetica pointerilor, pointeri la pointeri sau tablouri, înainte ca ideea de bază să fie clară.

Ce urmărește intervievatorul: Verifică abilitatea de a explica și de a mentora, nu doar cunoștințele. Un răspuns bun are model, exemplu și o verificare a înțelegerii.

93 Junior

Primești ca temă de acasă un mic program în C, de exemplu un parser care citește un fișier CSV și calculează statistici. Cum abordezi tema ca să faci o impresie bună?

Răspuns scurt: Clarific cerințele și cazurile limită, structurez codul în module mici cu funcții testabile, tratez explicit erorile de intrare, compilez fără avertismente cu -Wall -Wextra, verific memoria cu valgrind sau AddressSanitizer și livrez un Makefile, teste și un README scurt cu deciziile luate.

Evaluatorii nu se uită doar dacă programul dă rezultatul corect, ci și la cum arată codul pe care l-ai pune în producție. Un plan structurat:

1. Clarifici cerința. Notezi întrebările și presupunerile: ce separator, ce faci cu câmpurile goale, ghilimele, linii prea lungi, fișier gol, valori nenumerice. Dacă nu poți întreba, scrii presupunerile în README.

2. Structura. Separi citirea, parsarea și calculul:

  • csv.c/csv.h: parsarea unei linii în câmpuri
  • stats.c/stats.h: calculele, independente de I/O
  • main.c: argumentele din linia de comandă și afișarea

Funcțiile primesc dimensiunile bufferelor, întorc coduri de eroare și nu folosesc variabile globale.

3. Robustețea. Citești cu fgets sau getline, convertești cu strtod/strtol și verifici endptr, tratezi liniile invalide cu un mesaj care include numărul liniei, folosești coduri de ieșire diferite de zero la eșec.

4. Calitatea.

BASH
gcc -std=c17 -Wall -Wextra -Wpedantic -g -fsanitize=address,undefined *.c -o stats
valgrind --leak-check=full ./stats date.csv

Zero avertismente, zero leak-uri, cod formatat consecvent (de exemplu cu clang-format).

5. Teste. Câteva teste automate pentru parser (linie normală, câmpuri goale, numere invalide), chiar și cu un assert simplu sau un framework mic ca Unity, plus fișiere de test în repository.

6. Livrarea. Makefile cu ținte all, test, clean, un README cu instrucțiuni de build, presupunerile, limitările cunoscute și ce ai face cu mai mult timp. Istoricul Git cu commit-uri mici și mesaje clare arată și cum lucrezi.

Ce nu faci: optimizări premature, cod copiat fără să-l înțelegi sau funcționalități care nu au fost cerute.

Ce urmărește intervievatorul: Verifică dacă înțelegi ce înseamnă cod profesionist în C dincolo de „merge”. Temele respinse au de obicei leak-uri, avertismente și zero tratare a erorilor.

94 Mid

Cum scrii teste unitare pentru cod C? Cum testezi o funcție care citește dintr-un fișier sau apelează hardware-ul?

Răspuns scurt: Folosești un framework mic (Unity, CMocka, Check) sau macro-uri proprii de aserțiune, cu câte o funcție pe test. Dependențele externe le separi de logică și le înlocuiești în teste cu implementări false, prin pointeri la funcții sau la link.

C nu are un framework de testare standard, dar ecosistemul are opțiuni mature:

  • Unity (cu CMock pentru generarea de mock-uri): popular în embedded, un singur fișier .c
  • CMocka: mock-uri și verificări de memorie, folosit în proiecte ca libssh și Samba
  • Check: rulează fiecare test într-un proces separat, deci un crash nu oprește suita

Un test minimal, fără framework:

C
#include <stdio.h>
#include <string.h>
#include "parse.h"   /* int parse_port(const char *s, int *out); */

static int esecuri = 0;
#define CHECK(cond) do { if (!(cond)) { \
    fprintf(stderr, "%s:%d: %s\n", __FILE__, __LINE__, #cond); esecuri++; } } while (0)

static void test_port_valid(void) {
    int p;
    CHECK(parse_port("8080", &p) == 0 && p == 8080);
}
static void test_port_invalid(void) {
    int p;
    CHECK(parse_port("70000", &p) != 0);
    CHECK(parse_port("", &p) != 0);
}

int main(void) {
    test_port_valid();
    test_port_invalid();
    return esecuri ? 1 : 0;
}

Pentru dependențe externe, principiul e separarea logicii de efecte:

  • funcția de parsare primește un buffer sau un FILE *, nu o cale, deci în test îi dai fmemopen (POSIX) sau un șir
  • accesul la hardware trece printr-o interfață, adică o structură cu pointeri la funcții (read_reg, write_reg); în test o înlocuiești cu o implementare care înregistrează apelurile
  • link-time substitution: în build-ul de test legi uart_fake.c în loc de uart.c, cu aceleași funcții
  • funcțiile static se testează prin interfața publică sau, la nevoie, prin includerea fișierului .c în test

Testele le rulezi cu -fsanitize=address,undefined în CI, ca să prinzi și erorile de memorie, nu doar rezultatele greșite.

Ce urmărește intervievatorul: Verifică maturitatea inginerească. Mulți programatori C nu au scris teste automate și testează doar manual.

95 Mid

Pe un microcontroler fără unitate de virgulă mobilă (FPU), cum calculezi cu valori fracționare, de exemplu o temperatură cu două zecimale? Ce este aritmetica în virgulă fixă?

Răspuns scurt: Reprezinți valorile ca întregi scalați: temperatura în sutimi de grad (2537 = 25,37°C) sau în format Q, de exemplu Q16.16. Adunarea rămâne adunare de întregi, iar la înmulțire și împărțire ajustezi scala și folosești un tip intermediar mai lat.

Fără FPU, fiecare operație cu float e emulată software de bibliotecă și costă zeci sau sute de cicluri. Virgula fixă folosește întregi cu un factor de scală implicit.

Scalare zecimală (simplă, ușor de afișat):

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

typedef int32_t centigrade_t;      /* sutimi de grad */

centigrade_t medie(centigrade_t a, centigrade_t b) {
    return (a + b) / 2;
}

void afiseaza(centigrade_t t) {
    int32_t abs_t = t < 0 ? -t : t;
    printf("%s%ld.%02ld C\n", t < 0 ? "-" : "",
           (long)(abs_t / 100), (long)(abs_t % 100));
}

Format Q binar: în Q16.16, valoarea reală e x / 65536. Înmulțirea și împărțirea se fac prin shiftări, mai rapide decât împărțirea la 100:

C
typedef int32_t q16_t;
#define Q16(x) ((q16_t)((x) * 65536.0))         /* doar pentru constante */

static inline q16_t q16_mul(q16_t a, q16_t b) {
    return (q16_t)(((int64_t)a * b) >> 16);    /* produs intermediar pe 64 de biți */
}
static inline q16_t q16_div(q16_t a, q16_t b) {
    return (q16_t)(((int64_t)a << 16) / b);
}

Ce trebuie urmărit:

  • intervalul și precizia: Q16.16 acoperă aproximativ ±32768 cu pași de 1/65536; alegi formatul după datele reale (un senzor ADC pe 12 biți are alte nevoi)
  • overflow-ul: produsul a două valori pe 32 de biți are nevoie de 64 de biți
  • rotunjirea: shiftarea trunchiază; pentru rotunjire adaugi jumătate de unitate înainte (+ (1 << 15))
  • numerele negative: shiftarea la dreapta a unui negativ e implementation-defined, iar / trunchiază spre zero, deci verifici comportamentul compilatorului

Ce urmărește intervievatorul: Verifică experiența de embedded și stăpânirea aritmeticii pe întregi. Răspunsul slab e „folosesc float, compilatorul se descurcă”.

96 Mid

Un coleg trimite la code review o funcție care construiește o comandă de sistem cu sprintf și strcpy din date primite de la utilizator. Cum dai feedback și ce propui?

Răspuns scurt: Semnalez concret riscurile (buffer overflow și injecție de comenzi), cu un exemplu de intrare care strică funcția, propun alternative precise (snprintf cu verificarea trunchierii, validarea intrării, evitarea shell-ului cu execve) și păstrez un ton factual, legat de cod, nu de persoană.

Un răspuns bun separă partea tehnică de cea de comunicare.

Partea tehnică. Codul arată probabil așa:

C
char cmd[128];
sprintf(cmd, "convert %s out.png", nume_fisier);   /* nume de la utilizator */
system(cmd);

Probleme:

  • buffer overflow: un nume de 200 de caractere depășește cmd
  • injecție de comenzi: numele x.png; rm -rf ~ e executat de shell
  • system lansează un shell întreg, cu tot ce înseamnă interpretarea caracterelor speciale

Propunerea:

C
#include <unistd.h>
#include <sys/wait.h>

int converteste(const char *nume) {
    if (!nume_valid(nume)) return -1;           /* listă albă de caractere */
    pid_t pid = fork();
    if (pid == 0) {
        execlp("convert", "convert", "--", nume, "out.png", (char *)NULL);
        _exit(127);
    }
    int st;
    if (pid < 0 || waitpid(pid, &st, 0) < 0) return -1;
    return WIFEXITED(st) ? WEXITSTATUS(st) : -1;
}

Argumentele trec direct la program, fără shell, iar -- împiedică interpretarea unui nume ca opțiune. Dacă un șir trebuie construit, folosesc snprintf cu verificarea trunchierii.

Partea de comunicare.

  • comentariul e despre cod: „funcția asta permite injecție de comenzi dacă numele conține ;”, nu „ai scris cod nesigur”
  • dau un exemplu concret de intrare care o strică, ca problema să fie evidentă, nu o opinie
  • propun soluția sau un link spre ghidul intern (de exemplu SEI CERT C), nu doar „e greșit”
  • disting între blocant (securitate) și sugestii de stil
  • dacă tiparul apare des în proiect, propun o regulă automată: -Wformat-security, un linter ca clang-tidy sau interzicerea funcțiilor periculoase cu #pragma GCC poison

Dacă discuția se prelungește, o continui direct, nu prin zeci de comentarii.

Ce urmărește intervievatorul: Verifică atât cunoștințele de securitate, cât și felul în care colaborezi. Candidații fie ratează injecția, fie dau feedback acuzator.

97 Senior

Ce se întâmplă pe un microcontroler între apariția tensiunii de alimentare și apelul lui main()? Ce face codul de startup?

Răspuns scurt: Procesorul citește din tabela de vectori adresa stivei și a handlerului de reset, iar codul de startup copiază secțiunea .data din flash în RAM, pune .bss pe zero, configurează eventual ceasul și FPU-ul, apelează constructorii sau inițializările bibliotecii și abia apoi main().

Pe un Cortex-M, de exemplu, secvența la reset este:

  • hardware: procesorul citește primul cuvânt din tabela de vectori (de obicei la începutul flash-ului) ca valoare inițială a pointerului de stivă, iar al doilea cuvânt ca adresă a Reset_Handler, apoi sare acolo
  • SystemInit() (opțional, din fișierul de startup al producătorului): configurează ceasurile, PLL-ul, wait state-urile flash-ului și activează FPU-ul
  • copierea .data: valorile inițiale ale variabilelor sunt stocate în flash (LMA), dar codul le folosește din RAM (VMA), deci Reset_Handler le copiază
  • zero pe .bss: globalele neinițializate trebuie să fie 0, cum cere standardul
  • __libc_init_array(): rulează funcțiile de inițializare (constructori C++, __attribute__((constructor)))
  • main(): dacă se întoarce, startup-ul intră de obicei într-o buclă infinită

Adresele secțiunilor vin din scriptul de linker, prin simboluri:

C
extern uint32_t _sidata, _sdata, _edata, _sbss, _ebss;

void Reset_Handler(void) {
    uint32_t *src = &_sidata, *dst = &_sdata;
    while (dst < &_edata) *dst++ = *src++;      /* .data: flash -> RAM */
    for (dst = &_sbss; dst < &_ebss; ) *dst++ = 0;   /* .bss = 0 */
    SystemInit();
    main();
    for (;;) { }
}

De ce contează la interviu:

  • explică de ce o variabilă globală inițializată ocupă și flash, și RAM
  • un bug în scriptul de linker sau în startup produce globale cu valori greșite înainte ca main să ruleze
  • un watchdog activ implicit poate reseta placa în timpul inițializării unor tablouri .bss mari

Ce urmărește intervievatorul: Verifică înțelegerea profundă a modului în care rulează un program C pe hardware real. Candidații fără experiență embedded cred că main e primul cod executat.

98 Senior

Un dispozitiv embedded se resetează aleatoriu, iar suspectezi o depășire de stivă. Cum confirmi și cum previi?

Răspuns scurt: Confirmi cu „stack painting” (umpli stiva cu un tipar la pornire și verifici cât a rămas neatins), cu analiza statică -fstack-usage și cu protecția hardware (MPU sau verificarea stivei în RTOS). Previi eliminând recursivitatea și tablourile locale mari și dimensionând stiva cu o marjă măsurată.

Pe microcontrolere stiva are adesea doar câțiva KB și nu există o pagină de gardă ca pe Linux. Depășirea suprascrie în tăcere .bss, heap-ul sau stiva altui task, iar efectul apare mai târziu: variabile corupte, hard fault, resetări de watchdog.

Cum confirmi:

  • stack painting: în startup umpli zona de stivă cu un tipar (de exemplu 0xDEADBEEF); periodic sau la depanare verifici de la capătul de jos câte cuvinte au rămas neatinse. Valoarea minimă e „high water mark”-ul
  • RTOS: FreeRTOS oferă uxTaskGetStackHighWaterMark() și configCHECK_FOR_STACK_OVERFLOW, care apelează un hook la schimbarea de context dacă tiparul de la capăt a fost suprascris
  • MPU: configurezi o regiune fără acces chiar sub stivă; o depășire generează imediat o excepție cu adresa exactă. Cortex-M33 are registrele MSPLIM/PSPLIM pentru limita stivei
  • analiza fault-ului: în handlerul de hard fault salvezi registrele (PC, LR, SP) într-o zonă .noinit și le citești după reset

Analiza statică:

BASH
arm-none-eabi-gcc -fstack-usage -Wstack-usage=256 -c modul.c
# modul.su conține consumul de stivă al fiecărei funcții

Combinat cu graful de apeluri (unelte ca puncover sau analiza din IDE-urile producătorilor) obții adâncimea maximă pe cel mai lung lanț de apeluri, la care adaugi cadrele întreruperilor imbricate.

Prevenire:

  • fără recursivitate (o cer și MISRA C și ghidurile de siguranță)
  • fără tablouri locale mari sau VLA; bufferele mari devin static sau globale
  • stiva separată pentru întreruperi (MSP vs PSP pe Cortex-M)
  • dimensionezi stiva după măsurători, cu o marjă stabilită de echipă, și repeți măsurătoarea după fiecare schimbare majoră

Ce urmărește intervievatorul: Verifică experiența reală cu probleme embedded greu de reprodus. Un răspuns bun combină măsurarea la rulare cu analiza statică.

99 Senior

Un serviciu scris în C, care rulează pe server fără oprire, își mărește memoria cu câțiva MB pe zi până când e oprit de sistem. Cum investighezi?

Răspuns scurt: Confirm întâi că e leak, nu cache sau fragmentare, urmărind memoria în timp. Reproduc local sub sarcină cu LeakSanitizer, valgrind sau heaptrack, caut alocările care cresc odată cu cererile, apoi repar și adaug test și monitorizare.

Un răspuns structurat urmează pașii unei investigații reale.

1. Caracterizez problema. Urmăresc RSS-ul procesului în timp (ps, /proc/<pid>/status, metrici din monitorizare) și îl corelez cu traficul: crește cu numărul de cereri, cu timpul sau în salturi? O creștere care se oprește la un plafon e probabil un cache sau fragmentare, nu un leak. Verific și ce altceva crește: descriptori de fișiere (ls /proc/<pid>/fd | wc -l), threaduri, conexiuni.

2. Reproduc în afara producției. Pornesc serviciul local sau în staging, cu un generator de trafic care repetă tipurile de cereri din producție.

3. Folosesc uneltele potrivite.

  • LeakSanitizer (-fsanitize=address sau -fsanitize=leak): raportează la ieșire blocurile pierdute, cu stiva alocării; overhead mic, potrivit pentru teste de durată
  • valgrind --leak-check=full: foarte precis, dar lent, deci pentru scenarii scurte
  • heaptrack sau massif (valgrind --tool=massif): arată ce stivă de apeluri deține cea mai multă memorie în timp, util pentru memorie „still reachable” care crește, cum ar fi o listă la care doar se adaugă
  • dacă nu pot reproduce, folosesc unelte de producție cu overhead mic: profilerul de heap din jemalloc sau tcmalloc, ori eBPF (memleak din bcc)

4. Caut tiparele tipice. Ramuri de eroare care ies devreme fără free, realloc atribuit direct pointerului original, structuri cu membri alocați eliberate doar superficial, ownership neclar între module, bufferul alocat de o bibliotecă și neeliberat cu funcția ei.

5. Repar și previn. Corectez și adaug un test care rulează scenariul de multe ori sub LeakSanitizer în CI. Dacă problema venea din cod repetitiv de eliberare, introduc tiparul goto cleanup sau funcții _destroy clare.

Ce urmărește intervievatorul: Verifică metoda de investigație și cunoașterea uneltelor de producție, nu doar teoria. Răspunsul slab sare direct la „rulez valgrind în producție”.

100 Senior

Clientul raportează că aplicația ta C cade rar pe dispozitivul lui, iar tu nu poți reproduce bug-ul. Ai la dispoziție un core dump și binarul de release. Cum procedezi?

Răspuns scurt: Încarc core dump-ul în gdb cu binarul exact și cu simbolurile de depanare păstrate separat, citesc stiva de apeluri, registrele și variabilele, formulez ipoteze despre cauză, apoi încerc să reproduc condițiile cu sanitizere și teste țintite. Comunic clientului pașii și termenul estimat.

1. Mă asigur că am artefactele potrivite. Core dump-ul are sens doar cu binarul identic cu cel care a rulat. Practica bună e ca build-ul de release să păstreze simbolurile separat: compilezi cu -g, apoi objcopy --only-keep-debug app app.debug și strip, iar fișierul .debug se arhivează pentru fiecare versiune, identificat prin build-id (readelf -n app).

2. Analiza în gdb.

BASH
gdb ./app core.1234
(gdb) symbol-file app.debug
(gdb) bt full                 # stiva completă cu variabilele locale
(gdb) info registers
(gdb) frame 3
(gdb) print *req
(gdb) thread apply all bt     # pentru programe cu threaduri

3. Interpretarea. La -O2 unele variabile sunt „optimized out”, iar funcțiile inline apar comasate. Mă uit la instrucțiunea care a căzut (x/i $pc) și la registrele implicate: o adresă ca 0x10 sugerează accesul la un câmp printr-un pointer NULL, un model repetat ca 0xdeadbeef sugerează date corupte. Dacă stiva însăși pare coruptă, cauza e probabil un overflow pe stivă petrecut mai devreme.

4. Ipoteze și reproducere. Din context (ce cerere, ce date, ce versiune de firmware sau sistem) construiesc un scenariu. Rulez testele și scenariul cu -fsanitize=address,undefined și, dacă e o cursă între threaduri, cu -fsanitize=thread.

5. Livrarea și comunicarea. Îi spun clientului ce am găsit și ce urmează, nu promit o dată fără să cunosc cauza. Fix-ul vine cu un test de regresie. Dacă dispozitivele nu salvau core dump-uri, propun să se activeze colectarea automată a crash-urilor (de exemplu cu systemd-coredump sau un handler de semnal care scrie stiva).

Ce urmărește intervievatorul: Verifică experiența cu depanarea post-mortem, des întâlnită în produse livrate. Diferența dintre mid și senior e dacă știi să păstrezi simbolurile pentru build-urile de release.

Eroarea, în practică:Segmentation fault (core dumped)

Întrebări de interviu pe meserie

Alte tehnologii

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de Limbajul C, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață Limbajul C scriind cod, nu doar citind

Curs C: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.