C'de NULL Göstericiler: NULL Ne Demektir ve Nasıl Kontrol Edilir

Bir gösterici her zaman bir değer tutar. Gösterecek bir nesnesi olmadığında - atanmadan önce, gösterdiği şey serbest bırakıldıktan sonra ya da bir fonksiyonun döndürecek bir şeyi olmadığında - açıkça "burada bir şey yok" demek için bir değere ihtiyacı vardır. O değer boş göstericidir ve NULL, yazdığınız isimdir.

Etrafındaki disiplin küçüktür ve sürekli kendini öder: hedefleri olmadığında göstericileri NULL yapın, dereferans etmeden önce NULL kontrolü yapın ve sonucunuz yoksa NULL döndürün.

NULL Aslında Nedir

NULL, <stddef.h> içinde tanımlanan ve ayrıca <stdio.h>, <stdlib.h>, <string.h> ve diğerleri tarafından getirilen bir makrodur. Bir boş gösterici sabitine genişler - tipik olarak ((void*)0) ya da düz 0.

C standardı önemli olan özelliği garanti eder: bir boş gösterici, gerçek herhangi bir nesneye ya da fonksiyona giden bir göstericiye eşitsiz karşılaştırılır. Aynı tipteki iki boş gösterici her zaman birbirine eşit karşılaştırılır.

#include <stdio.h>

int main(void) {
    int value = 42;
    int *good = &value;
    int *none = NULL;

    printf("good = %p\n", (void *)good);
    printf("none = %p\n", (void *)none);

    printf("\ngood == NULL? %s\n", good == NULL ? "evet" : "hayir");
    printf("none == NULL? %s\n", none == NULL ? "evet" : "hayir");

    return 0;
}

Çoğu sistem boş gösterici için (nil) ya da 0x0 yazdırır - sıfır adresi. Bu yaygın bir gerçekleştirimdir, bir kural değil; standart bitlerin sıfır olduğunu asla vaat etmez. Vaat ettiği şey karşılaştırmadır, dolayısıyla p == NULL yazın, gösterime bağlı hiçbir şey yazmayın.

NULL'u Dereferans Etmek Çökertir

Var olan her null denetiminin sebebi:

int *p = NULL;
printf("%d\n", *p);   // tanımsız davranış - neredeyse kesinlikle bir çökme

Windows, macOS ve Linux'ta adres uzayının ilk sayfası bilerek eşlenmemiş bırakılır, dolayısıyla CPU erişimi yakalar ve işletim sistemi programı öldürür. Şunu göreceksiniz:

Segmentation fault (core dumped)          # Linux
zsh: segmentation fault  ./program        # macOS

O anlık çökme bir özelliktir. Bir mantık hatasını, üç hafta sonra bulacağınız sessiz bir bozulma yerine ona yol açan tam satırda yüksek sesli bir başarısızlığa dönüştürür. Çökmeyi nasıl okuyup satırı nasıl bulacağınız için bkz. segmentation fault.

"Boş gösterici"nin C'de yakalayabileceğiniz bir istisna olmamasının sebebi budur. Kurtulma mekanizması yoktur; yalnızca önceden kontrol etme vardır.

Başarısız Olabilecekleri Kontrol Edin

Başarısız olabilen fonksiyonlar bunu NULL döndürerek bildirir. Kontrol etmek isteğe bağlı bir nezaket değildir - alternatifi çökmedir.

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

int main(void) {
    // 1. tahsis basarisiz oldugunda malloc NULL dondurur
    int *numbers = malloc(5 * sizeof *numbers);
    if (numbers == NULL) {
        fprintf(stderr, "bellek yetersiz\n");
        return 1;
    }
    for (int i = 0; i < 5; i++) {
        numbers[i] = i * i;
    }
    printf("tahsis basarili: %d %d %d %d %d\n",
           numbers[0], numbers[1], numbers[2], numbers[3], numbers[4]);
    free(numbers);

    // 2. karakter bulunamadiginda strchr NULL dondurur
    const char *text = "hello world";
    const char *found = strchr(text, 'w');
    if (found != NULL) {
        printf("'w' bulundu, indeks %td\n", found - text);
    }

    const char *missing = strchr(text, 'z');
    printf("'z' bulundu mu? %s\n", missing != NULL ? "evet" : "hayir");

    return 0;
}

Standart kütüphane bunlarla doludur: malloc, calloc, realloc, fopen, strchr, strstr, getenv, bsearch. Her biri "sonuç yok"u NULL ile yanıtlar. Tahsisin tüm hikâyesi için bkz. dinamik bellek.

Denetim için ikisi de yaygın iki deyim:

if (p == NULL) { /* ele al */ }   // açık - anlaşılırlık için tercih edilir
if (!p)        { /* ele al */ }   // kısa - NULL'un yanlış olmasına dayanır

Boş bir gösterici bir koşulda yanlış, geçerli bir gösterici doğru test edilir, dolayısıyla ikisi de çalışır. Açık biçim, bir yabancı kodunuzu hata için tararken daha iyi okunur.

NULL, 0 ve İlk Değersiz

Yeni başlayanların birbirine karıştırdığı üç ayrı durum:

int *a = NULL;     "hicbir seyi gostermiyor" - test edilebilir, kontrolu guvenli
int *b;            ilk degersiz - cop tutar, test EDILEMEZ
int *c = &x;       gercek bir nesneyi gosteriyor

Tehlikeli olan b'dir. Baytları o yığın yuvasında ne kaldıysa odur; sıfır olabilir (ve iyi görünebilir) ya da daha önceki bir çağrıdan kalma akla yatkın görünen bir adres olabilir. Hiçbir denetim onu geçerli bir göstericiden ayırt edemez ve davranış hata ayıklama ile yayın derlemeleri arasında değişir.

#include <stdio.h>

int main(void) {
    int *safe = NULL;      // kesinlikle hicbir sey

    if (safe == NULL) {
        printf("safe null - bunu test edebiliriz\n");
    }

    // ilk degersiz bir gosterici test edilemez; cozum bir tane bulundurmamaktir
    int *fixed = NULL;
    int value = 7;

    if (fixed == NULL) {
        printf("fixed null basliyor\n");
        fixed = &value;
    }
    printf("fixed simdi %d degerini gosteriyor\n", *fixed);

    return 0;
}

Her göstericiye ilk değer verin. Henüz bir adresiniz yoksa NULL o adrestir. -Wall -Wextra ile derleyin, derleyici sizin için pek çok ilk değersiz kullanımı işaretleyecektir.

0 hakkında: bir gösterici bağlamında tam sayı sabiti 0, boş gösterici sabitidir, dolayısıyla p = 0; geçerli C'dir. Yine de NULL'u tercih edin. Niyeti işaret eder ve derleyicinin sizin için dönüşüm yapamadığı değişken argümanlı çağrılarda önemlidir:

execl("/bin/ls", "ls", 0);              // riskli - gösterici beklenen yere int geçebilir
execl("/bin/ls", "ls", (char *)NULL);   // doğru

C23, bu belirsizlik sınıfından tamamen kaçınan kendi türüne sahip bir anahtar kelime olan nullptr'ı ekliyor; NULL her yerde doğru ve taşınabilir kalıyor.

Savunmacı Kalıplar

Gösterici alan bir fonksiyonun tepesinde koruma koyun.

#include <stdio.h>

// basarida 0, kotu girdide sifirdan farkli doner
int average(const int *arr, int n, double *out) {
    if (arr == NULL || out == NULL || n <= 0) {
        return 1;                    // cokmek yerine reddet
    }
    long total = 0;
    for (int i = 0; i < n; i++) {
        total += arr[i];
    }
    *out = (double)total / n;
    return 0;
}

int main(void) {
    int data[4] = {10, 20, 30, 41};
    double result;

    if (average(data, 4, &result) == 0) {
        printf("ortalama = %.2f\n", result);
    }

    if (average(NULL, 4, &result) != 0) {
        printf("cokmek yerine NULL diziyi reddetti\n");
    }

    return 0;
}

Serbest bıraktıktan sonra NULL yapın. free göstericinizi değiştirmez - yalnızca belleği serbest bırakır. Geride kalan bayat gösterici sarkan bir göstericidir ve onu kullanmak, çoğu zaman hemen çökmeyen tanımsız davranıştır.

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

int main(void) {
    int *p = malloc(sizeof *p);
    if (p == NULL) return 1;

    *p = 99;
    printf("deger = %d\n", *p);

    free(p);
    p = NULL;          // artik hata sessiz degil, yuksek sesli bir cokme

    if (p == NULL) {
        printf("p null - test etmesi guvenli, tekrar free etmesi guvenli\n");
    }

    free(p);           // free(NULL) acikca bir islemsizliktir, her zaman guvenli
    return 0;
}

O örnekteki iki olgu akılda tutmaya değer. free(NULL)'ın hiçbir şey yapmadığı tanımlıdır, dolayısıyla temizlik kodunun onu korumasına hiç gerek yoktur. Ve free'den sonra p = NULL yapmak, veriyi sessizce bozabilecek bir serbest-bırakma-sonrası-kullanımı anlık ve hata ayıklanabilir bir çökmeye dönüştürür.

"Sonuç yok" demek için NULL döndürün ve bunu söyleyin.

// eşleşen elemana bir gösterici döndürür, yoksa NULL
int *find(int *arr, int n, int target);

Bunu fonksiyonun üstündeki yorumda belgeleyin. Bir NULL'un mümkün olduğunu bilen bir çağıran denetimi yazar; bilmeyen yazmaz.

Hızlı Bir Kontrol Listesi

• Her göstericiye gerçek bir adres ya da NULL ile ilk değer verin.
• malloc, calloc, realloc ve fopen'ın dönüşünü kullanmadan önce kontrol edin.
• Kötü girdiyle çağrılabilecek her fonksiyonun tepesinde gösterici parametrelerini kontrol edin.
• free'den hemen sonra göstericileri NULL yapın.
• Bir gösterici kastedildiğinde 0 değil NULL yazın.
• -Wall -Wextra ile derleyin ve yapabildiğinizde bir denetleyici altında çalıştırın: gcc -fsanitize=address,undefined null dereferansları kesin bir raporla yakalar.