En C, NULL és una constant simbòlica que sempre apunta a un punt inexistent de la memòria. Tot i que molts programadors ho consideren igual a 0, aquesta és una simplificació que us pot provocar més endavant. El millor és comprovar els vostres indicadors contra NULL directament i utilitzar 0 en altres contextos. D’aquesta manera, el vostre codi es mantindrà net i fàcil d’entendre, ja que sabreu que esteu treballant amb indicadors cada vegada que veieu NULL.
Passos
Part 1 de 2: Realització d'una comprovació nul·la
Pas 1. Utilitzeu el codi de comprovació nul·la estàndard
A continuació es mostra la forma més òbvia d’escriure un xec nul. Ho utilitzarem ptr en aquest article com a nom del punter que comproveu.
-
if (ptr == NULL)
{
// codi si el punter és NUL
} més {
// codi si no NULL
}
Pas 2. Comproveu si hi ha cap valor excepte NULL
De vegades és més convenient provar la desigualtat. No hi ha sorpreses aquí:
-
if (ptr! = NULL) {
// codi si no NULL
}
Pas 3. Escriviu primer el valor NULL per evitar errors (opcional)
El principal desavantatge del mètode PTR == NULL és la possibilitat que escriviu accidentalment ptr = NULL, assignant el valor NULL a aquest punter. Això pot causar un mal de cap important. Com que la prova de (in) igualtat tracta els operands de manera simètrica, podeu obtenir exactament el mateix resultat escrivint if (NULL == ptr) en canvi. Això és més resistent als errors tipogràfics, ja que un NULL = ptr accidental crea un simple error de compilació.
Això sembla una mica incòmode per a alguns programadors, però és perfectament vàlid. El mètode que utilitzeu només depèn de les preferències personals i de la qualitat del vostre compilador en detectar l'error if (ptr = NULL)
Pas 4. Comproveu si la variable és certa
Un simple si (ptr) prova si ptr és CERT. Tornarà FALS si ptr és NUL, o si ptr és 0. La distinció no importa en molts casos, però tingueu en compte que no són idèntiques en totes les arquitectures.
El revers d’això és si (! ptr), que retornarà TRUE si ptr és FALS.
Part 2 de 2: evitar errors
Pas 1. Establiu un punter abans de comprovar si hi ha NULL
Un error comú és suposar que un punter de nova creació té un valor NULL. Això no és cert. Un punter sense assignar encara apunta a una adreça de memòria, no només una que heu especificat. És pràctica habitual establir punteres de nova creació o alliberats a NULL per assegurar-vos que no utilitzeu aquesta adreça poc útil per accident.
-
Eviteu aquest error:
char * ptr;
if (ptr == NULL)
{
// Això tornarà FALS. Al punter se li ha assignat un valor vàlid.
}
-
En lloc d’això, escriviu:
char * ptr = NULL; // Això assigna el punter a NULL
if (ptr == NULL)
{
// Això retornarà TRUE si el punter no s'ha reassignat.
}
Pas 2. Presteu atenció a les funcions que podrien tornar NULL
Si una funció pot retornar NULL, penseu si aquesta és una possibilitat i si això causaria problemes més endavant al vostre codi. Aquí teniu un exemple de la funció malloc que utilitza la comprovació nul·la (si (ptr)) per assegurar-se que només gestiona els indicadors amb valors vàlids:
-
int * ptr = malloc (N * sizeof (int));
si (ptr) {
int i;
per a (i = 0; i <N; ++ i)
ptr = i;
}
Pas 3. Compreneu que NULL és 0, però sempre heu d'utilitzar NULL en lloc de 0 quan treballeu amb punteres per obtenir més claredat
Històricament, C representava NULL com el número 0 (és a dir, 0x00). Avui en dia es pot complicar una mica i varia segons el sistema operatiu. Normalment podeu cercar NULL mitjançant ptr == 0, però hi ha casos en els racons en què això pot causar un problema. Potser el que és més important, l’ús de NULL fa evident que esteu treballant amb indicadors per a altres persones que llegeixen el vostre codi.
