حساب المؤشّرات في لغة C: الجمع والطرح والمرور على الذاكرة

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

وذلك القرار التصميمي الواحد هو سبب كون المرور على مصفوفة بمؤشّر طبيعيًا في C كالمرور عليها بفهرس.

إضافة 1 تتحرّك بكائن واحد لا ببايت واحد

خُذ مؤشّرًا، وأضف 1، واطبع العنوانين:

#include <stdio.h>

int main(void) {
    int    i = 0;
    double d = 0.0;
    char   c = 0;

    int    *pi = &i;
    double *pd = &d;
    char   *pc = &c;

    printf("int    *: %p -> %p  (moved %td bytes)\n",
           (void *)pi, (void *)(pi + 1), (char *)(pi + 1) - (char *)pi);
    printf("double *: %p -> %p  (moved %td bytes)\n",
           (void *)pd, (void *)(pd + 1), (char *)(pd + 1) - (char *)pd);
    printf("char   *: %p -> %p  (moved %td bytes)\n",
           (void *)pc, (void *)(pc + 1), (char *)(pc + 1) - (char *)pc);

    return 0;
}

يقفز int * أربعة بايتات، ويقفز double * ثمانية، ويقفز char * واحدًا - ويهبط كلٌّ منها بالضبط حيث يبدأ الكائن التالي من نوعه. والقاعدة بسيطة:

ptr + n  ==  (address in ptr) + n * sizeof(*ptr)

وهذا بالضبط سبب أن يكون للمؤشّر نوع أصلًا. فالعنوان المجرّد بلا نوع مرفق لن يعرف كم يبعد "التالي".

المرور على مصفوفة بمؤشّر

والآن المكسب. تقع عناصر المصفوفة في ذاكرة متتالية، فخطو مؤشّر يزورها بالترتيب:

#include <stdio.h>

int main(void) {
    int scores[5] = {88, 92, 75, 60, 100};

    printf("index form:   ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", scores[i]);
    }

    printf("\npointer form: ");
    for (int *p = scores; p < scores + 5; p++) {
        printf("%d ", *p);
    }
    printf("\n");

    return 0;
}

تطبع الحلقتان الأعداد الخمسة نفسها. وفي الثانية، تتحوّل scores إلى مؤشّر إلى عنصرها الأول، وتتقدّم p++ بمقدار int واحد، وتقرأ *p العنصر الموجود هناك. وبتوزيعه في الذاكرة:

 scores[0] scores[1] scores[2] scores[3] scores[4]
+---------+---------+---------+---------+---------+
|   88    |   92    |   75    |   60    |   100   |
+---------+---------+---------+---------+---------+
 ^         ^                                       ^
 p         p+1                                     scores+5
 (start)   (4 bytes later)                         (one past the end)

والعلاقة بين الصيغتين دقيقة وتستحق الحفظ: فـ scores[i] معرَّفة بأنها *(scores + i). والمزيد عن ذلك في المؤشّرات والمصفوفات.

الزيادة والإنقاص وفخّ *p++

تعمل ++ و-- على المؤشّرات بالقياس نفسه.

#include <stdio.h>

int main(void) {
    int data[4] = {10, 20, 30, 40};
    int *p = data;

    printf("*p        = %d\n", *p);      // 10
    p++;
    printf("after p++ = %d\n", *p);      // 20
    p += 2;
    printf("after p+=2= %d\n", *p);      // 40
    p--;
    printf("after p-- = %d\n", *p);      // 30

    return 0;
}

والتعبير الذي يربك الجميع هو *p++. فعامل ++ اللاحق يرتبط أوثق من *، فيعني "خُذ p الحالية، وقدّم p، ثم راجِع القيمة القديمة":

#include <stdio.h>

int main(void) {
    int data[3] = {1, 2, 3};
    int *p = data;

    int a = *p++;      // تقرأ data[0]، ثم تنتقل p إلى data[1]
    printf("a = %d, *p is now %d\n", a, *p);

    int *q = data;
    (*q)++;            // الأقواس: زِد القيمة، لا المؤشّر
    printf("data[0] = %d, *q = %d\n", data[0], *q);

    int *r = data;
    int b = *++r;      // السابقة: تقدّم أولًا، ثم اقرأ
    printf("b = %d\n", b);

    return 0;
}

ثلاثة تعابير بثلاثة معانٍ مختلفة:

و*p++ أسلوب اصطلاحي في C - فهي كيف تُكتب نسخ السلاسل النصية والمخازن - لكن اكتب الأقواس حين تقصد أي شيء آخر.

طرح مؤشّرين

طرح مؤشّر من آخر يعطي عدد العناصر بينهما، لا عدد البايتات:

#include <stdio.h>

int main(void) {
    int arr[8] = {2, 4, 6, 8, 10, 12, 14, 16};

    int *start = arr;
    int *end   = arr + 8;      // موضع واحد بعد العنصر الأخير

    printf("length      = %td\n", end - start);

    // جِد أول عنصر أكبر من 9 وأبلغ عن فهرسه
    int *found = start;
    while (found < end && *found <= 9) {
        found++;
    }
    if (found != end) {
        printf("first > 9   = %d at index %td\n", *found, found - start);
    }

    return 0;
}

نوع النتيجة هو ptrdiff_t، وهو نوع صحيح موقّع من <stddef.h>، يُطبَع بـ %td. وطرح مؤشّرين إلى مصفوفتين مختلفتين ينتج نتيجة غير معرَّفة - فالمعيار لا يعرّف العملية إلا داخل كائن واحد.

ويمكنك أيضًا طرح عدد صحيح من مؤشّر (فـ p - 3 تتراجع ثلاثة عناصر)، لكنك لا تستطيع جمع مؤشّرين. فـ "مجموع عنوانين" لا يسمّي شيئًا.

مقارنة المؤشّرات

تعمل عوامل المقارنة على مؤشّرات داخل المصفوفة نفسها، وتعني بالضبط ما يوحي به توزيع الذاكرة: فـ p < q محقّقة حين تعنون p عنصرًا أسبق.

#include <stdio.h>

int main(void) {
    char text[] = "stressed";
    char *front = text;
    char *back  = text + 7;      // آخر محرف، قبل '\0'

    // اعكس السلسلة في مكانها بمشي مؤشّرين نحو بعضهما
    while (front < back) {
        char temp = *front;
        *front = *back;
        *back  = temp;
        front++;
        back--;
    }

    printf("%s\n", text);
    return 0;
}

front < back هي كل قصة إنهاء الحلقة، وهي صحيحة لأن كلا المؤشّرين يبقى داخل مصفوفة واحدة. و== و!= هما أيضًا الطريقة الطبيعية لفحص حلقة مقابل علامة نهايتها، وهو ما يقودنا إلى القاعدة التي تجعل كل هذا مشروعًا.

قاعدة الموضع التالي للنهاية

تسمح C صراحةً بتكوين مؤشّر إلى الموضع الذي يلي بموضع واحد آخرَ عنصر في مصفوفة. ويمكنك حسابه وتخزينه والمقارنة به. لكن لا يمكنك مراجعته.

int arr[4];

 arr[0]   arr[1]   arr[2]   arr[3]   (no element)
+------+ +------+ +------+ +------+  +- - - -+
|      | |      | |      | |      |  |       |
+------+ +------+ +------+ +------+  +- - - -+
 ^                                    ^
 arr                                  arr + 4
 legal to use                         legal to FORM and COMPARE
                                      never legal to dereference

وتلك القاعدة هي ما يجعل شكل الحلقة المعياري صالحًا:

for (int *p = arr; p != arr + n; p++) {
    /* ... */
}

ففي التكرار الأخير تصبح p مساوية لـ arr + n، فتفشل المقارنة وتخرج الحلقة - دون قراءة ذلك الموضع إطلاقًا.

ومع ذلك يبقى شيئان غير معرَّفين. تكوين مؤشّر يتجاوز النهاية بـموضعين، أو يسبق البداية بموضع واحد، سلوك غير معرَّف حتى لو لم تراجعه إطلاقًا:

int *bad1 = arr + n + 1;   // undefined - too far past
int *bad2 = arr - 1;       // undefined - before the beginning

والثاني يهمّ عمليًا: فالحلقة العكسية المكتوبة for (int *p = arr + n - 1; p >= arr; p--) تحسب arr - 1 عند إنقاصها الأخير. وهي تعمل على كل مترجم شائع وتبقى غير معرَّفة رسميًا. والحلقة العكسية النظيفة تتجنّب ذلك:

#include <stdio.h>

int main(void) {
    int arr[5] = {1, 2, 3, 4, 5};
    int n = 5;

    // تمشي للخلف دون أن تخطو قبل البداية إطلاقًا
    for (int *p = arr + n; p != arr; ) {
        p--;
        printf("%d ", *p);
    }
    printf("\n");

    return 0;
}

مؤشّرات void والحسابات التي لا تستطيع إجراءها

يحمل void * عنوانًا بلا نوع مرفق، وهو كيف تبقى malloc وqsort عامّتين. ولأنه لا يوجد حجم عنصر، فإن حساب المؤشّرات على void * غير مسموح به في المعيار - حوّل إلى نوع محدّد (أو إلى char * للعمل على مستوى البايت) أولًا.

void *v = buffer;
// v + 1;              // not standard C - no size to scale by
char *b = v;
b + 1;                 // fine - one byte forward

ويقبل GCC وClang حسابات void * كامتداد يعاملها كـ char *، فالشيفرة المعتمِدة عليها تُترجَم حتى اليوم الذي تُبنى فيه في بيئة أكثر صرامة. ترجم بـ -std=c17 -pedantic إن أردت أن يُقال لك.

ما الذي يشتريه لك هذا

حساب المؤشّرات ليس حيلة تحسين تلجأ إليها أحيانًا - بل هو الآلية تحت فهرسة المصفوفات ومعالجة السلاسل النصية وكل مرور على مخزن في المكتبة القياسية. فـ strlen مؤشّر متقدّم إلى '\0' المُنهي ومطروح منه البداية. وmemcpy مؤشّران يخطوان معًا بالتزامن.

تاليًا، انظر كيف يعمل التكافؤ بين المصفوفات والمؤشّرات فعليًا، بما في ذلك فخّ sizeof الذي يوقع بالجميع أول مرة يمرّرون فيها مصفوفة إلى دالة: المؤشّرات والمصفوفات.