الثوابت في لغة C: ‏const و#define وenum

الثابت قيمة لها اسم ووعد بألّا تتغيّر. وتمنحك C ثلاث آليات لذلك، وهي أشياء مختلفة فعلًا في العمق - واحدة متغيّر، وواحدة استبدال نصّي، وواحدة نوع عددي صحيح.

لماذا نسمّي القيمة أصلًا

قارن هذين السطرين:

double area = 3.14159 * r * r;
double area = PI * r * r;

الثاني أفضل لثلاثة أسباب تظهر كلها لاحقًا. فهو يقول ما يعنيه العدد. ويظهر في مكان واحد بالضبط، فتغيير الدقّة تعديل واحد بدل بحث. وخطأ مطبعي في PI خطأ ترجمة، بينما خطأ مطبعي في 3.14195 جواب خاطئ.

وتُسمّى الأعداد غير المسمّاة المبعثرة في الشيفرة أرقامًا سحرية، وإزالتها من أرخص التحسينات التي يمكنك إدخالها على برنامج C.

const

تسم الكلمة المفتاحية const متغيّرًا بأنه للقراءة فقط:

#include <stdio.h>

int main(void) {
    const double PI = 3.14159265358979;
    const int MAX_USERS = 100;

    double r = 2.0;
    printf("Area of r=%.1f: %.4f\n", r, PI * r * r);
    printf("Capacity: %d users\n", MAX_USERS);

    /* PI = 3.0;  <- أزل التعليق عن هذا السطر فلن يُترجَم البرنامج */
    return 0;
}

أزل التعليق عن الإسناد فيرفض المترجم: assignment of read-only variable 'PI'. وذلك الخطأ وقت البناء هو المقصد كله.

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

ويجب تهيئة const عند نقطة التعريف - فلا فرصة ثانية:

const int limit;       /* خطأ (أو قيمة مهملة للأبد): لا شيء يستطيع الإسناد إليه لاحقًا */
const int limit = 50;  /* صحيح */

‏#define

البديل من المعالج الأولي هو الماكرو:

#include <stdio.h>

#define PI 3.14159265358979
#define MAX_USERS 100
#define GREETING "Welcome to the system"

int main(void) {
    double r = 2.0;
    printf("%s\n", GREETING);
    printf("Area of r=%.1f: %.4f\n", r, PI * r * r);
    printf("Capacity: %d users\n", MAX_USERS);
    return 0;
}

هذا ليس متغيّرًا. فقبل تشغيل المترجم، يستبدل المعالج الأولي كل ورود لـ PI في المصدر بالمحارف 3.14159265358979. ولا يرى المترجم الاسم إطلاقًا - وهذا بالضبط سبب كون #define بلا نوع وغير قابل للظهور في المنقّح.

لاحظ أنه لا فاصلة منقوطة ولا =. فالماكرو نصّ خام، لذا فإن هذا الخطأ الشائع:

#define MAX_USERS 100;        /* لاحظ الفاصلة المنقوطة */

int limit = MAX_USERS + 1;    /* يتوسّع إلى: int limit = 100; + 1;  -> خطأ */

يُنتج خطأً في سطر لا يشبه التعريف إطلاقًا. وعُرف تسمية الماكروات بأحرف كبيرة موجود تحديدًا ليعرف القرّاء أن ثمّة استبدالًا يجري.

وتُكتب الماكروات عُرفًا بـ UPPER_CASE؛ وتتبعه متغيّرات const عادةً كذلك حين تقوم مقام الفكرة نفسها.

ثوابت enum

الصيغة الثالثة تمنحك مجموعة من الأعداد الصحيحة المسمّاة:

#include <stdio.h>

enum { MAX_USERS = 100, BUFFER_SIZE = 256 };

enum Weekday { MON, TUE, WED, THU, FRI };

int main(void) {
    char buffer[BUFFER_SIZE];   /* ثابت حقيقي وقت الترجمة */

    printf("buffer holds %zu bytes\n", sizeof(buffer));
    printf("MAX_USERS = %d\n", MAX_USERS);

    enum Weekday today = WED;
    printf("MON=%d TUE=%d WED=%d, today=%d\n", MON, TUE, WED, today);
    return 0;
}

تبدأ القيم من 0 وتزيد بواحد ما لم تُسنِدها، فتكون MON صفرًا وFRI أربعة. وenum { ... } مجهولة الاسم صيغة شائعة لثوابت عددية صحيحة بسيطة.

ولثوابت enum ميزة حقيقية على البديلين: فهي ثوابت عددية صحيحة وقت الترجمة يفهمها المترجم، وهي مرئية للمنقّح. والقصة الكاملة في التعدادات في C.

أيّها تستخدم

والخيار الافتراضي ينبغي أن يكون const. والجأ إلى #define حين يجب أن توجد القيمة قبل الترجمة، وإلى enum حين تحتاج عددًا صحيحًا وقت الترجمة أو مجموعة مسمّاة.

والموضع الذي يؤلم فيه هذا فعلًا هو أحجام المصفوفات:

#include <stdio.h>

#define DEFINED_SIZE 5
enum { ENUM_SIZE = 5 };

int global_a[DEFINED_SIZE];   /* سليم */
int global_b[ENUM_SIZE];      /* سليم */

int main(void) {
    const int const_size = 5;
    int local[const_size];    /* مصفوفة متغيّرة الطول في C99 - تعمل هنا... */

    for (int i = 0; i < const_size; i++) local[i] = i * i;
    printf("local[4] = %d\n", local[4]);
    printf("globals: %zu %zu\n", sizeof(global_a), sizeof(global_b));
    return 0;
}

فـ const int في C هو متغيّر للقراءة فقط، لا تعبير ثابت وقت الترجمة. وداخل الدالة تقبل C99 صيغة int local[const_size] بجعلها مصفوفة متغيّرة الطول؛ أما على نطاق الملف أو داخل struct أو كعنوان case فتُرفض رفضًا تامًا. وenum و#define تعملان في كل مكان.

(وهذا أحد الفروق الحقيقية عن C++، حيث يكون const int تعبيرًا ثابتًا فعلًا. والشيفرات المتنقّلة بين اللغتين تتعثّر به.)

const مع المؤشّرات

تتّحد const والمؤشّرات بثلاث طرق، ومعانيها غير قابلة للتبادل. اقرأ التعريف من الاسم نحو الخارج:

const char *p;          /* p تشير إلى محارف يجب ألّا تُعدَّل */
char * const q;         /* q نفسها لا يمكن إعادة توجيهها؛ والمحارف قابلة للتغيير */
const char * const r;   /* لا المؤشّر ولا المحارف قابلة للتغيير */

#include <stdio.h>

int main(void) {
    char text[] = "hello";

    const char *p = text;
    /* *p = 'H';  <- خطأ: البيانات ثابتة عبر p */
    p = "world";  /* لكن إعادة توجيه p سليمة */
    printf("p now points at: %s\n", p);

    char * const q = text;
    q[0] = 'H';   /* تعديل البيانات عبر q سليم */
    /* q = "world";  <- خطأ: q نفسها ثابتة */
    printf("text is now: %s\n", text);
    return 0;
}

وصيغة const char * هي التي ستكتبها أكثر، لأنها النوع الصحيح لوسيط دالة يقرأ سلسلة نصية دون تغييرها:

#include <stdio.h>

/* تَعِد const المستدعي: هذه الدالة لن تعدّل سلسلتك النصية. */
size_t count_vowels(const char *s) {
    size_t n = 0;
    for (size_t i = 0; s[i] != '\0'; i++) {
        char c = s[i];
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') n++;
    }
    return n;
}

int main(void) {
    printf("vowels in \"programming\": %zu\n", count_vowels("programming"));
    return 0;
}

وإضافة const إلى وسيط للقراءة فقط لا تكلّف شيئًا وتوثّق العقد بطريقة يفرضها المترجم. وهي تستحقّ الفعل في كل مكان.

القيم النصية الحرفية ثابتة فعليًا

فخّ دقيق وُجدت const لالتقاطه:

char *s = "hello";   /* صياغة C سليمة، لكن s تشير إلى ذاكرة للقراءة فقط */
s[0] = 'H';          /* سلوك غير معرَّف - انهيار عادةً */

تعيش القيم النصية الحرفية في قسم للقراءة فقط من الملف التنفيذي. والكتابة عبر ذلك المؤشّر تُنتج خطأ تجزئة عادةً. وتعريف المؤشّر بـ const char *s = "hello"; يجعل المترجم يرفض الإسناد بدل أن يدعه ينهار أثناء التشغيل.

وإن احتجت سلسلة قابلة للتعديل، فانسخها إلى مصفوفة:

#include <stdio.h>

int main(void) {
    const char *literal = "hello";   /* للقراءة فقط، لا يمكن تعديلها */
    char copy[] = "hello";           /* مصفوفة: نسخة خاصة قابلة للتعديل */

    copy[0] = 'H';
    printf("literal: %s\n", literal);
    printf("copy:    %s\n", copy);
    return 0;
}