مؤشّرات الدوال في لغة C: الصياغة وردود النداء وqsort

تعيش الشيفرة المترجَمة في الذاكرة تمامًا كما تعيش البيانات، فللدالة عنوان. ومؤشّر الدالة متغيّر يخزّن واحدًا - وبمجرّد أن تستطيع تخزين دالة، تستطيع تمرير واحدة كوسيط، أو الاحتفاظ بجدول منها، أو الاختيار بينها أثناء التشغيل.

وتلك هي القدرة وراء الترتيب بترتيب مخصّص، ومعالجات الأحداث، وواجهات الإضافات، وآلات الحالة. وهي أيضًا قطعة صياغة C الأكثر احتمالًا لجعل القارئ يتوقّف ويحدّق، فنبدأ من هناك.

صياغة التعريف

خذ دالة عادية:

int add(int a, int b);

ولتعريف مؤشّر يستطيع حمل عنوانها، استبدل الاسم بـ (*name):

int (*op)(int, int);

اقرأها من الداخل: op مؤشّر، إلى دالة، تأخذ (int, int)، وتُعيد int.

والقوسان ليسا زينة. فبدونهما ترتبط * بنوع الإرجاع بدلًا من ذلك:

int (*f)(int);   // مؤشّر إلى دالة تأخذ int وتُعيد int
int *g(int);     // دالة تأخذ int وتُعيد int* - مختلفة تمامًا

وإليها وهي تعمل من البداية إلى النهاية:

#include <stdio.h>

int add(int a, int b)      { return a + b; }
int subtract(int a, int b) { return a - b; }
int multiply(int a, int b) { return a * b; }

int main(void) {
    int (*op)(int, int);        // تعريف

    op = add;                   // إسناد (بلا حاجة إلى &)
    printf("add:      %d\n", op(10, 3));

    op = subtract;              // وجّهه إلى مكان آخر
    printf("subtract: %d\n", op(10, 3));

    op = &multiply;             // العامل & مسموح لكنه زائد
    printf("multiply: %d\n", (*op)(10, 3));   // وكذلك صيغة الاستدعاء هذه

    printf("\nthe function itself lives at %p\n", (void *)(void (*)(void))add);
    return 0;
}

تعمل صيغتا الاستدعاء كلتاهما لأن مُعيِّن الدالة يتحوّل إلى مؤشّر تلقائيًا. اكتب op(10, 3)؛ أما تهجئة (*op)(10, 3) فبقية من الماضي.

وملاحظة على printf الأخيرة: %p تتوقّع مؤشّر كائن، ومؤشّرات الدوال عائلة منفصلة رسميًا، فطباعة واحد ليست محمولة بدقّة. والتحويل يُسكت المترجمات على المنصّات التي يعمل عليها أصلًا؛ ونادرًا ما ستحتاج إلى طباعة واحد.

typedef يجعلها مقروءة

تصبح صياغة التعريف قبيحة بسرعة، وtypedef هو العلاج القياسي:

#include <stdio.h>

typedef int (*BinaryOp)(int, int);   // BinaryOp = مؤشّر إلى int(int,int)

int add(int a, int b)      { return a + b; }
int multiply(int a, int b) { return a * b; }

// الآن دالة تأخذ دالة تُقرأ كأي تعريف آخر
int apply(BinaryOp op, int x, int y) {
    return op(x, y);
}

int main(void) {
    BinaryOp op = add;
    printf("apply(add, 4, 5)      = %d\n", apply(op, 4, 5));
    printf("apply(multiply, 4, 5) = %d\n", apply(multiply, 4, 5));
    return 0;
}

قارن int apply(BinaryOp op, int x, int y) بالصيغة الخام int apply(int (*op)(int, int), int x, int y). المعنى نفسه؛ وإحداهما تستطيع قراءتها بنظرة. انظر typedef للقواعد العامة.

ردود النداء: ترك السلوك للمستدعي

ردّ النداء دالة تسلّمها لدالة أخرى كي تستطيع مناداتك في اللحظة المناسبة. وهو يتيح لقطعة شيفرة أن تتولّى بنية المهمّة بينما يوفّر المستدعي القرار.

#include <stdio.h>

typedef int (*Predicate)(int);

int is_even(int n)     { return n % 2 == 0; }
int is_positive(int n) { return n > 0; }
int is_big(int n)      { return n > 100; }

// دالة واحدة، وأي اختبار
int count_if(const int *arr, int n, Predicate test) {
    int count = 0;
    for (int i = 0; i < n; i++) {
        if (test(arr[i])) {
            count++;
        }
    }
    return count;
}

int main(void) {
    int data[8] = {-4, 3, 120, 7, -9, 200, 0, 15};
    int n = 8;

    printf("even:     %d\n", count_if(data, n, is_even));
    printf("positive: %d\n", count_if(data, n, is_positive));
    printf("big:      %d\n", count_if(data, n, is_big));

    return 0;
}

بدون مؤشّرات الدوال كنت ستكتب count_even وcount_positive وcount_big - ثلاث نسخ من الحلقة نفسها. ومعها تُكتب الحلقة مرة واحدة ويكون الاختبار هو الوسيط.

المردود الحقيقي: qsort

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

void qsort(void *base, size_t nmemb, size_t size,
           int (*compar)(const void *, const void *));

يتلقّى المقارن const void * اثنين - عنواني عنصرين - ويُعيد عددًا سالبًا إن كان الأول يسبق الثاني في الترتيب، وصفرًا إن تعادلا، وموجبًا إن كان يليه.

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

int compare_ints(const void *a, const void *b) {
    int x = *(const int *)a;      // حوّل إلى النوع الحقيقي، ثم اقرأ
    int y = *(const int *)b;
    if (x < y) return -1;
    if (x > y) return  1;
    return 0;
}

int compare_desc(const void *a, const void *b) {
    return compare_ints(b, a);    // بادل الوسيطين لعكس الترتيب
}

int main(void) {
    int data[8] = {42, 7, 19, 3, 88, 1, 55, 23};
    int n = sizeof data / sizeof data[0];

    qsort(data, n, sizeof data[0], compare_ints);
    printf("ascending:  ");
    for (int i = 0; i < n; i++) printf("%d ", data[i]);

    qsort(data, n, sizeof data[0], compare_desc);
    printf("\ndescending: ");
    for (int i = 0; i < n; i++) printf("%d ", data[i]);
    printf("\n");

    return 0;
}

وعادتان تحملهما من ذلك المقارن. لا تكتب أبدًا return x - y; - فهي تبدو ذكية وتفيض مع القيم الكبيرة أو السالبة، فتُنتج إشارة خاطئة ومصفوفة مرتّبة خطأً. وحوّل قبل فكّ الإشارة، لا بعدها: *(const int *)a، لأن *a على void * لا شيء لديها لتقرأه.

والآلية نفسها ترتّب البنى بأي حقل تشاء:

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

typedef struct {
    char name[20];
    int  score;
} Player;

int by_score(const void *a, const void *b) {
    const Player *p = a, *q = b;
    return (q->score > p->score) - (q->score < p->score);   // الأعلى أولًا
}

int by_name(const void *a, const void *b) {
    const Player *p = a, *q = b;
    return strcmp(p->name, q->name);
}

int main(void) {
    Player players[4] = {
        {"Ada",   91},
        {"Grace", 78},
        {"Linus", 91},
        {"Ken",   85}
    };
    int n = 4;

    qsort(players, n, sizeof players[0], by_score);
    printf("by score:\n");
    for (int i = 0; i < n; i++) printf("  %-6s %d\n", players[i].name, players[i].score);

    qsort(players, n, sizeof players[0], by_name);
    printf("by name:\n");
    for (int i = 0; i < n; i++) printf("  %-6s %d\n", players[i].name, players[i].score);

    return 0;
}

صيغة (q->score > p->score) - (q->score < p->score) تُعيد ‎-1 أو 0 أو 1 بالضبط بلا طرح وبلا فيضان. وstrcmp لديها أصلًا عُرف الإرجاع الصحيح، فيكون مقارن السلاسل النصية سطرًا واحدًا.

جداول مؤشّرات الدوال

مصفوفة من مؤشّرات الدوال تحوّل سلسلة if/else إلى بحث. وهكذا توزّع المفسّرات رموز العمليات وتشغّل أنظمة القوائم أوامرها.

#include <stdio.h>

typedef double (*Operation)(double, double);

double op_add(double a, double b) { return a + b; }
double op_sub(double a, double b) { return a - b; }
double op_mul(double a, double b) { return a * b; }
double op_div(double a, double b) { return b == 0 ? 0.0 : a / b; }

typedef struct {
    char      symbol;
    Operation fn;
    const char *name;
} Entry;

int main(void) {
    Entry table[] = {
        {'+', op_add, "add"},
        {'-', op_sub, "subtract"},
        {'*', op_mul, "multiply"},
        {'/', op_div, "divide"}
    };
    int n = sizeof table / sizeof table[0];

    double x = 12.0, y = 4.0;

    for (int i = 0; i < n; i++) {
        printf("%.1f %c %.1f = %.2f   (%s)\n",
               x, table[i].symbol, y, table[i].fn(x, y), table[i].name);
    }

    // التوزيع بناءً على محرف، دون switch
    char wanted = '*';
    for (int i = 0; i < n; i++) {
        if (table[i].symbol == wanted) {
            printf("\ndispatched '%c' -> %.2f\n", wanted, table[i].fn(x, y));
            break;
        }
    }

    return 0;
}

فإضافة عملية صارت إضافة صفّ، لا تحرير switch. اقرن ذلك بـ البنى فتحصل على شكل الإضافات القياسي في C: بنية من مؤشّرات الدوال هي ما تعنيه "الواجهة" في هذه اللغة.

أمور تعضّ

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

ومؤشّر الدالة الفارغ يبقى مؤشّرًا فارغًا. هيّئ بـ NULL وافحص قبل الاستدعاء، تمامًا كما مع مؤشّرات البيانات:

if (handler != NULL) {
    handler(event);
}

انظر المؤشّرات الفارغة لمعرفة لماذا يستحقّ ذلك الفحص وجوده.

ومؤشّرات void تُفقد أمان الأنواع، وتصبح أنت نظام الأنواع. فداخل مقارن qsort لا شيء يمنعك من التحويل إلى النوع الخاطئ. وإن رتّبت مصفوفة double بـ compare_ints، فإنها تُترجَم بنظافة وتُنتج هراءً.

وصياغة المعرِّف تتداخل. فدالة تُعيد مؤشّر دالة هي int (*get_op(char c))(int, int);. وحين تجد نفسك تكتب ذلك، فالجأ إلى typedef:

typedef int (*BinaryOp)(int, int);
BinaryOp get_op(char c);           // الشيء نفسه، لكن مقروءًا