I C är NULL en symbolisk konstant som alltid pekar på en obefintlig punkt i minnet. Även om många programmerare behandlar det som lika med 0, är detta en förenkling som kan få dig att stiga senare. Det är bäst att kontrollera dina tips mot NULL direkt och använda 0 i andra sammanhang. Detta håller din kod ren och lätt att förstå, eftersom du vet att du arbetar med pekare varje gång du ser NULL.
Steg
Del 1 av 2: Utföra en nollkontroll
Steg 1. Använd standardkoden för nollkontroll
Följande är det mest uppenbara sättet att skriva en nollcheck. Vi kommer att använda ptr i den här artikeln som namnet på pekaren du kontrollerar.
-
om (ptr == NULL)
{
// kod om pekaren är NULL
} annat {
// kod om inte NULL
}
Steg 2. Testa för valfritt värde men NULL
Ibland är det mer bekvämt att testa för ojämlikhet istället. Inga överraskningar här:
-
om (ptr! = NULL) {
// kod om inte NULL
}
Steg 3. Skriv NULL först för att undvika fel (valfritt)
Den största nackdelen med PTR == NULL -metoden är chansen att du av misstag skriver ptr = NULL istället och tilldelar pekaren NULL -värdet. Detta kan orsaka stor huvudvärk. Eftersom testning för (in) jämlikhet behandlar operanderna symmetriskt kan du få exakt samma resultat genom att skriva om (NULL == ptr) istället. Detta är mer stavfelbeständigt, eftersom ett oavsiktligt NULL = ptr skapar ett enkelt kompileringsfel.
Detta ser lite besvärligt ut för vissa programmerare, men det är helt giltigt. Vilket tillvägagångssätt du använder beror bara på personliga preferenser och hur bra din kompilator är på att upptäcka if (ptr = NULL) -felet
Steg 4. Testa om variabeln är sann
En enkel om (ptr) testar om ptr är SANT. Den returnerar FALSK om ptr är NULL, eller om ptr är 0. Skillnaden spelar ingen roll i många fall, men var medveten om att dessa inte är identiska i alla arkitekturer.
Motsatsen till detta är om (! ptr), som returnerar SANT om ptr är FALSE.
Del 2 av 2: Undvika misstag
Steg 1. Ställ in en pekare innan du söker efter NULL
Ett vanligt misstag är att anta att en nyskapad pekare har ett NULL -värde. Det är inte sant. En otilldelad pekare pekar fortfarande på en minnesadress, bara inte en som du har angett. Det är vanligt att ställa in nyskapade eller nyligen befriade pekare till NULL för att se till att du inte använder den här obehagliga adressen av misstag.
-
Undvik detta misstag:
char *ptr;
om (ptr == NULL)
{
// Detta returnerar FALSE. Pekaren har tilldelats ett giltigt värde.
}
-
Skriv istället:
char *ptr = NULL; // Detta tilldelar pekaren till NULL
om (ptr == NULL)
{
// Detta returnerar SANT om pekaren inte har tilldelats om.
}
Steg 2. Var uppmärksam på funktioner som kan returnera NULL
Om en funktion kan returnera NULL, fundera på om detta är en möjlighet, och om det skulle orsaka problem senare i din kod. Här är ett exempel på malloc -funktionen med nollkontrollen (om (ptr)) för att säkerställa att den endast hanterar pekare med giltiga värden:
-
int * ptr = malloc (N * sizeof (int));
om (ptr) {
int i;
för (i = 0; i <N; ++ i)
ptr = i;
}
Steg 3. Förstå att NULL är 0 men du bör alltid använda NULL istället för 0 när du arbetar med pekare för tydlighetens skull
Historiskt sett representerade C NULL som talet 0 (det vill säga 0x00). Numera kan det bli lite mer komplicerat och varierar beroende på operativsystem. Du kan vanligtvis söka efter NULL med ptr == 0, men det finns hörnfall där detta kan orsaka problem. Kanske ännu viktigare, att använda NULL gör det uppenbart att du arbetar med tips för andra som läser din kod.
