Mit jelent a “ nullellenőrzés ” elvégzése C vagy C ++ nyelven?

A C és a C ++ nyelven a mutatók eleve nem biztonságosak, vagyis amikor egy mutatóra hivatkozunk, az ön felelőssége, hogy megbizonyosodjon arról, hogy valahol érvényes-e; ez a “kézi memóriakezelés” része (ellentétben az olyan nyelvű memóriakezelési sémákkal, mint a Java , PHP vagy .NET futtatókörnyezet, amely nem teszi lehetővé érvénytelen hivatkozások létrehozását jelentős erőfeszítések nélkül).

Gyakori megoldás, amely sok hibát elkap, az összes olyan mutató beállítása, amelyek nem mutatnak semmire. mint NULL (vagy helyesen C ++, 0), és ezt ellenőrizze, mielőtt a mutatóhoz hozzáférne. Konkrétan bevett gyakorlat az összes mutató inicializálása a NULL-ra (kivéve, ha már van mire mutatnia, amikor deklarálja őket), és NULL-ra állítja, amikor delete vagy free() őket (hacsak nem lépnek ki azonnal a hatálya alól). Példa (C-ben, de érvényes C ++ nyelven is):

void fill_foo(int* foo) { *foo = 23; // this will crash and burn if foo is NULL } 

Jobb verzió:

void fill_foo(int* foo) { if (!foo) { // this is the NULL check printf("This is wrong\n"); return; } *foo = 23; } 

Nullellenőrzés nélkül a NULL mutató átengedése ebbe a funkcióba segfaultot okoz, és semmit sem tehet – az operációs rendszer egyszerűen megöli a folyamatot, és esetleg core-dump vagy felbukkan egy összeomlási jelentés párbeszédpanel. A nullellenőrzéssel megfelelő hibakezelést hajthat végre, és kecsesen helyreállíthatja – maga kijavíthatja a problémát, megszakíthatja az aktuális műveletet, naplóbejegyzést írhat, értesítheti a felhasználót, ami megfelelő.

Megjegyzések

• @MrLister mire gondolsz, a null ellenőrzések nem működnek a C ++ nyelven?

A null mutató értéke pontosan definiált “sehol”; ez egy érvénytelen mutatóérték, amely garantáltan összehasonlítja az egyenlőtlenséget bármely más mutatóértékkel. A nullmutató eltérítésének megkísérlése meghatározatlan viselkedést eredményez, és általában futásidejű hibához vezet, ezért meg kell győződnie arról, hogy a mutató nem NULL, mielőtt megpróbálja levonni a figyelmét. Számos C és C ++ könyvtárfüggvény nullpontot ad vissza, jelezve a hiba állapotát. Például az malloc könyvtárfüggvény nullapontértéket ad vissza, ha nem tudja kiosztani a kért bájtok számát, és ha a memórián keresztül próbál meg elérni memóriát, akkor ez (általában) vezet futásidejű hibára:

int *p = malloc(sizeof *p * N); p[0] = ...; // this will (usually) blow up if malloc returned NULL 

Tehát meg kell győződnünk arról, hogy az malloc hívás sikeres volt-e a p a NULL ellen:

int *p = malloc(sizeof *p * N); if (p != NULL) // or just if (p) p[0] = ...; 

Most egy percig lógjon a zokniján, ez egy kicsit göröngyös.

Van null mutató érték és egy null mutató állandó , és a kettő nem feltétlenül azonos. A null mutató értéke az az érték, amelyet az alapul szolgáló architektúra a “sehol” kifejezésre használ. Ez az érték lehet 0x00000000, vagy 0xFFFFFFFF, vagy 0xDEADBEEF, vagy valami egészen más. Ne feltételezzük, hogy a null mutató értéke mindig 0.

A null mutató konstans , az OTOH mindig 0 értékű integrál kifejezés. Ami a forráskód ot illeti, a 0 (vagy bármely integrált kifejezés, amely 0-ra értékel) nullpontot jelent. A C és a C ++ is a NULL makrót definiálja null mutató konstansként. A kód összeállításakor a null mutató konstans helyére a megfelelő null mutató érték kerül a létrehozott gépi kódban.

Ne feledje továbbá, hogy a NULL csak egy a sok lehetséges érvénytelen mutató érték közül; ha deklarál egy automatikus mutató változót anélkül, hogy kifejezetten inicializálná, például

int *p; 

a változóban eredetileg tárolt érték határozatlan , és előfordulhat, hogy nem felel meg érvényes vagy hozzáférhető memóriacímnek. Sajnos nincs (hordozható) módja annak megállapítására, hogy egy nem NULL mutató értéke érvényes-e vagy sem, mielőtt megkísérelné használni. Tehát, ha a mutatókkal foglalkozik, akkor általában jó, ha kifejezetten inicializálja őket arra, hogy NULL, amikor kijelenti őket, és NULL értékre állítja őket, amikor nem mutatnak aktívan semmire.

Vegye figyelembe, hogy ez inkább a C, mint a C ++ probléma; az idiomatikus C ++ nem használhat annyi mutatót.

Van pár módszer, amelyek lényegében ugyanazt teszik dolog.

 int *foo = NULL; //sometimes set to 0x00 or 0 or 0L instead of NULL 

null ellenőrzés (ellenőrizze, hogy a mutató null-e), A verzió

 if( foo == NULL) 

null ellenőrzés, B verzió

 if( !foo ) //since NULL is defined as 0, !foo will return a value from a null pointer 

null ellenőrzés, C verzió

 if( foo == 0 ) 

A három közül inkább az első ellenőrzést használom, mivel ez kifejezetten megmondja a jövőbeli fejlesztőknek, hogy mit próbáltál ellenőrizni ÉS egyértelművé teszi, hogy a foo-ra számítottál, hogy mutató lesz.

Nem. Az egyetlen oka annak, hogy egy mutatót használjon a C ++ – ban, mert kifejezetten nullpontok jelenlétét szeretné elérni; máskülönben vehet egy referenciát, amely szemantikailag könnyebben használható és garantálja a nem null értéket.

Megjegyzések

• @James: ‘ new ‘ kernel módban?
• @James: A C ++ megvalósítása, amely a C ++ jelentős többségének képességeit képviseli a kódolók élvezik. Ez magában foglalja a összes C ++ 03 nyelvi jellemzőt (kivéve az export) és a C ++ 03 könyvtár összes funkcióját és TR1 és egy jó darab C ++ 11.
• Szeretném bárcsak az emberek nem mondanák

Ha nem ellenőrzi a NULL értéket, különösképpen, ha ez egy struktúra mutatója, akkor előfordulhat, hogy találkozott egy biztonsági réssel – NULL pointer dereference. A NULL pointer dereference további súlyos biztonsági résekhez vezethet, például puffertúlcsorduláshoz, versenyfeltétel … ez lehetővé teheti a támadók számára, hogy átvegyék az irányítást a számítógép felett.

Számos szoftvergyártó, például a Microsoft, az Oracle, az Adobe, az Apple … kiad egy szoftverjavítást a biztonsági rések kijavításához. ellenőrizze az egyes mutatók NULL értékét 🙂