المؤشّرات الفارغة في لغة C: ما معنى NULL وكيف تفحصه

يحمل المؤشّر دائمًا قيمةً ما. وحين لا يكون لديه كائن يشير إليه بعد - قبل إسناده، أو بعد تحرير ما كان يشير إليه، أو حين لا يكون لدى دالة ما تُرجِعه - يحتاج إلى قيمة تعني بلا لبس "لا شيء هنا". تلك القيمة هي المؤشّر الفارغ، وNULL هو الاسم الذي تكتبه.

والانضباط المحيط به صغير ويسدّد ثمنه باستمرار: اضبط المؤشّرات على NULL حين لا هدف لها، وافحص NULL قبل المراجعة، وأرجِع NULL حين لا تملك نتيجة.

ما NULL فعليًا

NULL ماكرو معرَّف في <stddef.h> وتجلبه أيضًا <stdio.h> و<stdlib.h> و<string.h> وغيرها. وهو يتمدّد إلى ثابت مؤشّر فارغ - عادةً ((void*)0) أو 0 مجرّدًا.

ويضمن معيار C الخاصية التي تهمّ: المؤشّر الفارغ لا يساوي أي مؤشّر إلى كائن أو دالة فعلية. ومؤشّران فارغان من النوع نفسه يتساويان دائمًا.

#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 ? "yes" : "no");
    printf("none == NULL? %s\n", none == NULL ? "yes" : "no");

    return 0;
}

تطبع معظم الأنظمة (nil) أو 0x0 للمؤشّر الفارغ - أي العنوان صفر. وذلك تطبيق شائع لا قاعدة؛ فالمعيار لا يعد أبدًا بأن البتات أصفار. بل يعد بالمقارنة، فاكتب p == NULL ولا تكتب أبدًا ما يعتمد على التمثيل.

مراجعة NULL تنهار

هذا هو سبب كل فحص فراغ في الوجود:

int *p = NULL;
printf("%d\n", *p);   // undefined behavior - almost certainly a crash

على ويندوز وmacOS ولينكس تُترك الصفحة الأولى من فضاء العناوين غير مخطَّطة عن قصد، فيعترض المعالج الوصول ويقتل نظام التشغيل البرنامج. وسترى:

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

ذلك الانهيار الفوري ميزة. فهو يحوّل خطأً منطقيًا إلى فشل صاخب عند السطر الذي سبّبه بالضبط، بدلًا من إفساد صامت تكتشفه بعد ثلاثة أسابيع. انظر خطأ التجزئة لمعرفة كيف تقرأ الانهيار وتجد السطر.

ولهذا فإن "المؤشّر الفارغ" ليس استثناءً تلتقطه في C. فلا توجد آلية للتعافي؛ لا يوجد إلا الفحص المسبق.

افحص ما قد يفشل

تُشير الدوال التي قد تفشل إلى ذلك بإرجاع NULL. والفحص ليس تأدّبًا اختياريًا - فالانهيار هو البديل.

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

int main(void) {
    // 1. تُرجِع malloc القيمة NULL حين يفشل التخصيص
    int *numbers = malloc(5 * sizeof *numbers);
    if (numbers == NULL) {
        fprintf(stderr, "out of memory\n");
        return 1;
    }
    for (int i = 0; i < 5; i++) {
        numbers[i] = i * i;
    }
    printf("allocated ok: %d %d %d %d %d\n",
           numbers[0], numbers[1], numbers[2], numbers[3], numbers[4]);
    free(numbers);

    // 2. تُرجِع strchr القيمة NULL حين لا يُعثَر على المحرف
    const char *text = "hello world";
    const char *found = strchr(text, 'w');
    if (found != NULL) {
        printf("found 'w' at index %td\n", found - text);
    }

    const char *missing = strchr(text, 'z');
    printf("'z' found? %s\n", missing != NULL ? "yes" : "no");

    return 0;
}

المكتبة القياسية مليئة بهذه: malloc وcalloc وrealloc وfopen وstrchr وstrstr وgetenv وbsearch. وكل واحدة منها تجيب بـ "لا نتيجة" بـ NULL. انظر الذاكرة الديناميكية لقصة التخصيص كاملة.

واصطلاحان للفحص، وكلاهما شائع:

if (p == NULL) { /* handle */ }   // explicit - preferred for clarity
if (!p)        { /* handle */ }   // terse - relies on NULL being falsy

يُفحَص المؤشّر الفارغ على أنه خاطئ في شرط والمؤشّر الصالح على أنه صحيح، فكلاهما يعمل. والصيغة الصريحة أفضل قراءةً حين يمسح غريبٌ شيفرتَك بحثًا عن أخطاء.

NULL مقابل 0 مقابل غير المهيّأ

ثلاثة مواقف متمايزة يخلط المبتدئون بينها:

int *a = NULL;     "points at nothing" - testable, safe to check
int *b;            uninitialized - holds garbage, NOT testable
int *c = &x;       points at a real object

والخطير هو b. فبايتاته هي ما تُرك في خانة المكدّس تلك، وقد تكون أصفارًا (فتبدو سليمة) وقد تكون عنوانًا معقول المظهر من استدعاء سابق. ولا يوجد فحص يميّزه عن مؤشّر صالح، ويتغيّر السلوك بين بناء التنقيح وبناء الإصدار.

#include <stdio.h>

int main(void) {
    int *safe = NULL;      // لا شيء قطعًا

    if (safe == NULL) {
        printf("safe is null - we can test for this\n");
    }

    // لا يمكن فحص مؤشّر غير مهيّأ؛ والحلّ هو ألّا يكون لديك واحد
    int *fixed = NULL;
    int value = 7;

    if (fixed == NULL) {
        printf("fixed starts null\n");
        fixed = &value;
    }
    printf("fixed now points at %d\n", *fixed);

    return 0;
}

هيّئ كل مؤشّر. فإن لم يكن لديك عنوان بعد، فإن NULL هو العنوان. وترجم بـ -Wall -Wextra فينبّهك المترجم إلى كثير من الاستخدامات غير المهيّأة.

وعن 0: في سياق مؤشّر يكون الثابت الصحيح 0 هو ثابت المؤشّر الفارغ، فـ p = 0; شيفرة C صالحة. ومع ذلك فضّل NULL. فهو يشير إلى القصد، ويهمّ في الاستدعاءات متغيّرة الوسائط حيث لا يستطيع المترجم التحويل نيابةً عنك:

execl("/bin/ls", "ls", 0);       // risky - may pass an int where a pointer is expected
execl("/bin/ls", "ls", (char *)NULL);   // correct

وتضيف C23 الكلمة المفتاحية nullptr بنوعها الخاص الذي يتجنّب هذا الصنف من الالتباس كليًا؛ ويبقى NULL صحيحًا وقابلًا للنقل في كل مكان.

أنماط دفاعية

احرس في رأس كل دالة تأخذ مؤشّرات.

#include <stdio.h>

// تُرجِع 0 عند النجاح، وقيمة غير صفرية عند إدخال سيّئ
int average(const int *arr, int n, double *out) {
    if (arr == NULL || out == NULL || n <= 0) {
        return 1;                    // ارفض بدلًا من الانهيار
    }
    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("average = %.2f\n", result);
    }

    if (average(NULL, 4, &result) != 0) {
        printf("rejected a NULL array instead of crashing\n");
    }

    return 0;
}

اضبط على NULL بعد التحرير. لا تغيّر free مؤشّرك - بل تحرّر الذاكرة فقط. والمؤشّر القديم المتروك مؤشّر معلّق، واستخدامه سلوك غير معرَّف كثيرًا ما لا ينهار فورًا.

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

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

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

    free(p);
    p = NULL;          // صار الخطأ الآن انهيارًا صاخبًا لا صامتًا

    if (p == NULL) {
        printf("p is null - safe to test, safe to free again\n");
    }

    free(p);           // free(NULL) لا تفعل شيئًا صراحةً، وهي آمنة دائمًا
    return 0;
}

حقيقتان داخل ذلك المثال تستحقّان الحفظ. free(NULL) معرَّفة بألّا تفعل شيئًا، فلا تحتاج شيفرة التنظيف إلى حراستها أبدًا. وضبط p = NULL بعد free يحوّل الاستخدام بعد التحرير - الذي قد يفسد البيانات بصمت - إلى انهيار فوري قابل للتنقيح.

أرجِع NULL بمعنى "لا نتيجة"، وقُل ذلك.

// returns a pointer to the matching element, or NULL if there is none
int *find(int *arr, int n, int target);

وثّق ذلك في التعليق فوق الدالة. فالمستدعي الذي يعلم أن NULL محتمل يكتب الفحص؛ ومن لا يعلم لن يفعل.

قائمة تحقّق سريعة

• هيّئ كل مؤشّر، بعنوان حقيقي أو بـ NULL.
• افحص القيمة المُرجَعة من malloc وcalloc وrealloc وfopen قبل استخدامها.
• افحص وسائط المؤشّرات في رأس أي دالة قد تُستدعى بإدخال سيّئ.
• اضبط المؤشّرات على NULL فور free.
• اكتب NULL لا 0 كلما كان المقصود مؤشّرًا.
• ابنِ بـ -Wall -Wextra، وحين تستطيع شغّل تحت مُعقِّم: gcc -fsanitize=address,undefined يلتقط مراجعات الفراغ بتقرير دقيق.