Bune practici și erori frecvente în C

Responsabili:

• Dorinel Filip (2020)
• Darius Neațu (2020)

În această ghid facem o trecere în revistă a câtorva bune practice și erori frecvente de codare în limbajul C.

Alocarea de memorie este un subiect care pune probleme multora atunci când fac primii pași în utilizarea limbajului C.

În această secțiune, atragem atenția asupra unor elemente importante referitoare la alocarea de memorie și lucrul cu fișiere.

Memory leak-urile reprezintă o eroare de programare, în ceea ce privește alocarea dinamică de memorie, reprezentată de situația în care memoria nefolosită rămâne alocată.

Prin utilizarea utilitarului Valgrind checker-ul folosit la notarea automată a temelor poate descoperi execuțiile care lasă memorie nedealocată, iar acest lucru va fi depunctat, conform enunțului temei repective.

O problemă foarte similară Memory Leak-urilor o reprezintă neînchiderea fișierelor.

O altă problemă frecventă referitoare la alocarea de memorie o reprezintă utilizarea tipului nepotrivit de alocare de memorie.

În continuare vom exemplifica doar câteva astfel de erori:

Folosirea alocării dinamice pentru situații în care cantitatea de memorie ce urmează să fie alocată este cunoscută anterior și se dealocă în același context.

#define VECTOR_SIZE 9
 
void asa_nu() { // Exemplu de utilizare nerecomandata
	int *v = malloc(VECTOR_SIZE * sizeof(int));
 
	// lucru cu vectorul v[]
	...
 
	free(v);
}
 
void asa_da() {
	int v[VECTOR_SIZE];
 
	// lucru cu vectorul v
        ...
 
}

O excepție de la această regulă se face atunci când dorim să alocăm cantități mari de mamorie, deoarece alocarea dinamică permite tratarea situației de OOM (Out of Memory) și în multe cazuri permite alocarea unor zone mult mai mari de memorie.

Utilizarea Variable Length Arrays pentru alocarea de vectori mari sau cu dimensiune provenită din calcule fără limită superioară sau din input-ul utilizatorului

În cele mai recente versiuni, limbajul C permite alocarea de vectori folosind ca dimensiune variabile de tip întreg. Deși acest lucru permite utilizarea eficientă a spațiului de memorie de pe stivă funcției, utilizarea necorespunzătoare a acestei opțiuni poate duce la apariția unor erori la execuție (segmentation fault sau stack smashed) ce nu pot fi tratate.

O eroare comună o reprezintă utilizarea input-ului (neverificat) al utilizatorului ca dimensiune de alocare:

void asa_nu() { // Exemplu de utilizare nerecomandata
	int n;
	scanf("%d", &n);
 
	int v[n]; // dacă utilizatorul introduce un număr foarte mare sau negativ putem avea eroare la execuție
 
	...	
}

În continuare, vom prezenta 2 variante de tratare corectă a acestei situații:

1. Validarea faptului că avem un număr pozitiv și limitarea dimensiunii alocabile;
2. Folosirea alocării dinamice.

#define MAX_SIZE 10000
 
void asa_da_1() {
	int n;
	scanf("%d", &n);
 
	while(n <= 0 || n > MAX_SIZE) {
		printf("Numarul este prea mare, te rog introdu un nr. din (0, %d]\n", MAX_SIZE);
		scanf("%d", &n);
	}
 
	// Prelucrare vector v
	...
 
}
 
 
void asa_da_2() {
	int n;
	int *v;
 
	scanf("%d", &n);
 
	while(n <= 0) {
		printf("n trebuie sa fie un numar pozitiv. Reincearca!\n");
		scanf("%d", &n);
	}
 
	v = malloc(n * sizeof(int));
	if(v == NULL) {
		fprintf(stderr, "Nu am putut aloca memorie.\n");
		exit(-1);
	}
 
	// Prelucrare vector v
	...
 
	// Dealocare memorie pentru v
	free(v);
}

Pentru soluția 1 se observă că pune în responsabilitatea programatorului determinarea lui 'MAX_SIZE', care poate interveni ca o limitare nejustificată a funcționalității programului.

Un cititor al soluției 2 poate reclama contradicție cu recomandarea de a folosi memorie alocată static dacă dealocarea se va face în același context și dimensiunea alocată nu este mare. Totuși, codul nu garantează că n este un număr mic.