العوامل في لغة C: الحسابية والمنطقية والأولوية

العوامل هي أفعال لغة C: تأخذ قيمًا وتنتج قيمًا جديدة. هناك نحو 40 عاملًا، لكن عشرة منها تغطّي معظم الشيفرة، واثنان منها لهما فخاخ حادّة بما يكفي لتستحق أقسامًا خاصة بها.

العوامل الحسابية

#include <stdio.h>

int main(void) {
    int a = 17, b = 5;

    printf("a + b  = %d\n", a + b);   /* 22 */
    printf("a - b  = %d\n", a - b);   /* 12 */
    printf("a * b  = %d\n", a * b);   /* 85 */
    printf("a / b  = %d\n", a / b);   /* 3  - قسمة صحيحة! */
    printf("a %% b  = %d\n", a % b);  /* 2  - الباقي */
    printf("-a     = %d\n", -a);      /* سالب أحادي */
    return 0;
}

(تطبع %% في سلسلة التنسيق علامة نسبة مئوية حرفية - أما % وحدها فتبدأ محدّد تنسيق.)

العوامل الحسابية الثنائية الخمسة هي + - * / %، إضافةً إلى - الأحادي للنفي و+ الذي لا يفعل شيئًا يُذكر.

فخّ القسمة الصحيحة

يؤدّي a / b بعددين صحيحين قسمة صحيحة ويرمي الباقي. ولا يوجد تقريب - بل تُقتطع النتيجة باتجاه الصفر.

#include <stdio.h>

int main(void) {
    int total = 7, count = 2;

    printf("7 / 2         = %d\n", total / count);          /* 3 */
    printf("7 / 2.0       = %f\n", total / 2.0);            /* 3.5 */
    printf("(double)7 / 2 = %f\n", (double)total / count);  /* 3.5 */

    double wrong = total / count;      /* القسمة تحدث أولًا، كأعداد صحيحة */
    printf("wrong average = %f\n", wrong);   /* 3.000000 */
    return 0;
}

الحالة الأخيرة هي الخطأ الذي يصمد حتى الإنتاج. فالإسناد إلى double لا يفيد: إذ تكون القسمة total / count قد تمّت سلفًا، وصارت int سلفًا، قبل وقوع الإسناد. والحلّ هو جعل أحد المعاملين ذا فاصلة عائمة داخل التعبير، عادةً بـتحويل نوع.

قاعدتان مرتبطتان: القسمة على صفر بأعداد صحيحة سلوك غير معرَّف وتُعطِّل البرنامج عادةً، وINT_MIN / -1 يفيض.

عامل باقي القسمة

يعطي % الباقي ويعمل على الأعداد الصحيحة فقط:

#include <stdio.h>

int main(void) {
    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            printf("%d is even\n", i);
        } else {
            printf("%d is odd\n", i);
        }
    }

    int seconds = 3725;
    printf("\n%d seconds = %dh %dm %ds\n",
           seconds, seconds / 3600, (seconds % 3600) / 60, seconds % 60);
    return 0;
}

فحص x % 2 == 0 للزوجية واستخدام % n لالتفاف فهرس حول مصفوفة هما الاستخدامان اليوميّان.

ومع الأعداد السالبة، يتبع % في C إشارة المقسوم:

#include <stdio.h>

int main(void) {
    printf(" 7 %% 3 = %d\n",  7 % 3);   /*  1 */
    printf("-7 %% 3 = %d\n", -7 % 3);   /* -1, not 2 */
    printf(" 7 %% -3 = %d\n", 7 % -3);  /*  1 */
    return 0;
}

لذا فإن x % 2 == 1 فحص معطوب للفردية حين يمكن أن تكون x سالبة - إذ إن -7 % 2 يساوي -1. استخدم x % 2 != 0 بدلًا منه.

أما بواقي الفاصلة العائمة فإن % معها خطأ ترجمة؛ استخدم fmod() من math.h.

الإسناد والإسناد المركّب

يخزّن = قيمة. أما الصيغ المركّبة فتجمع عملية مع التخزين:

#include <stdio.h>

int main(void) {
    int x = 10;

    x += 5;   printf("x += 5   -> %d\n", x);   /* 15 */
    x -= 3;   printf("x -= 3   -> %d\n", x);   /* 12 */
    x *= 2;   printf("x *= 2   -> %d\n", x);   /* 24 */
    x /= 4;   printf("x /= 4   -> %d\n", x);   /* 6  */
    x %= 4;   printf("x %%= 4   -> %d\n", x);  /* 2  */
    return 0;
}

يعني x += 5 ما يعنيه x = x + 5، لكنه يقيّم x مرة واحدة فقط - وهو ما يهمّ حين يكون الهدف شيئًا مثل arr[compute_index()].

والإسناد نفسه تعبير يعطي القيمة المسنَدة، ولهذا يعمل a = b = c = 0 (فهو يُسنِد من الطرف الأخير إلى الأول) ولهذا يُترجَم خطأ = مقابل == بصمت.

الزيادة والإنقاص

يضيف ++ واحدًا، ويطرح -- واحدًا. ولكلٍّ منهما صيغة سابقة وصيغة لاحقة:

#include <stdio.h>

int main(void) {
    int i = 5;
    int a = i++;    /* تأخذ a القيمة 5 (القديمة)، ثم تصبح i تساوي 6 */
    printf("postfix: a = %d, i = %d\n", a, i);

    int j = 5;
    int b = ++j;    /* تصبح j تساوي 6 أولًا، ثم تأخذ b القيمة 6 */
    printf("prefix:  b = %d, j = %d\n", b, j);

    int k = 5;
    k++;            /* كجملة مستقلة، مطابقة تمامًا لـ ++k */
    printf("statement: k = %d\n", k);
    return 0;
}

كجملة مستقلة يمكن تبادل الصيغتين، وi++ هو الخيار المتعارف عليه في ترويسة for لا لسبب أعمق من العادة.

وما يجب ألّا تفعله هو استخدام متغيّر أكثر من مرة في تعبير يُعدَّل فيه أيضًا:

int i = 5;
int x = i++ + i++;      /* سلوك غير معرَّف */
arr[i] = i++;           /* سلوك غير معرَّف */
printf("%d %d", i++, i);/* سلوك غير معرَّف */

لا تحدّد C ترتيب تقييم تلك التعبيرات الفرعية، فالنتيجة ليست غير محدّدة فحسب - بل سلوك البرنامج كله غير معرَّف. قسّم الجملة إلى اثنتين فيزول الالتباس.

عوامل المقارنة

ستة منها، وكلها تنتج قيمة int: 1 للصحيح و0 للخطأ.

#include <stdio.h>

int main(void) {
    int a = 5, b = 8;

    printf("a == b : %d\n", a == b);   /* 0 */
    printf("a != b : %d\n", a != b);   /* 1 */
    printf("a <  b : %d\n", a <  b);   /* 1 */
    printf("a >  b : %d\n", a >  b);   /* 0 */
    printf("a <= 5 : %d\n", a <= 5);   /* 1 */
    printf("a >= 9 : %d\n", a >= 9);   /* 0 */
    return 0;
}

كون النتيجة int عاديًا بدلًا من نوع منطقي مخصّص خاصية مميِّزة للغة C - انظر القيم المنطقية في C لما يترتّب على ذلك، بما في ذلك خطأ = مقابل ==.

وهناك خطآن في المقارنة خاصّان بـ C. فالتسلسل لا يعمل كما توحي الرياضيات: if (1 < x < 10) صحيح دائمًا، لأن 1 < x يُقيَّم إلى 0 أو 1 ثم يُقارَن ذلك بـ 10. اكتب if (x > 1 && x < 10). ومقارنة السلاسل النصية بـ == تقارن المؤشّرات لا النص - استخدم strcmp من string.h.

العوامل المنطقية

#include <stdio.h>

int main(void) {
    int age = 25;
    int has_license = 1;

    if (age >= 18 && has_license) {
        printf("May drive\n");
    }

    if (age < 13 || age > 65) {
        printf("Discounted ticket\n");
    } else {
        printf("Full price\n");
    }

    printf("!has_license = %d\n", !has_license);   /* 0 */
    printf("!0 = %d\n", !0);                       /* 1 */
    return 0;
}

&& عامل "و"، و|| عامل "أو"، و! عامل النفي. وتعامل الثلاثة أي قيمة غير صفرية على أنها صحيحة.

وهي تقصّر التقييم: يتوقّف && بمجرّد أن يكون أحد المعاملين خاطئًا، ويتوقّف || بمجرّد أن يكون أحدهما صحيحًا. ولا يُقيَّم الباقي إطلاقًا، وهذا ليس تحسينًا فحسب - بل ضمانة يمكنك الاعتماد عليها للأمان:

#include <stdio.h>

int is_safe(int *p) {
    /* إذا كانت p تساوي NULL فلن يُقيَّم *p إطلاقًا - إذ يتوقّف && أولًا. */
    return p != NULL && *p > 0;
}

int main(void) {
    int value = 7;
    printf("with a real pointer: %d\n", is_safe(&value));
    printf("with NULL:           %d\n", is_safe(NULL));
    return 0;
}

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

العامل الشرطي

عامل C الوحيد ذو المعاملات الثلاثة يختار بين قيمتين:

#include <stdio.h>

int main(void) {
    int a = 12, b = 30;

    int max = (a > b) ? a : b;
    printf("max = %d\n", max);

    printf("%d item%s\n", a, (a == 1) ? "" : "s");
    return 0;
}

condition ? value_if_true : value_if_false. إنه تعبير، فيصلح حيث لا تصلح جملة if - داخل وسيط لـ printf، أو في مهيّئ. أبقِه قصيرًا؛ فالعوامل الشرطية المتداخلة تصبح غير مقروءة بسرعة.

العوامل البتّية باختصار

تعمل هذه على البتات المفردة لعدد صحيح:

#include <stdio.h>

int main(void) {
    unsigned int a = 12;   /* 1100 بالثنائي */
    unsigned int b = 10;   /* 1010 */

    printf("a & b  = %u\n", a & b);    /* 8  - 1000, AND */
    printf("a | b  = %u\n", a | b);    /* 14 - 1110, OR  */
    printf("a ^ b  = %u\n", a ^ b);    /* 6  - 0110, XOR */
    printf("~a     = %u\n", ~a);       /* NOT - يقلب كل بت */
    printf("a << 2 = %u\n", a << 2);   /* 48 - إزاحة لأعلى، تضرب في 4 */
    printf("a >> 2 = %u\n", a >> 2);   /* 3  - إزاحة لأسفل، تقسم على 4 */
    return 0;
}

تُستخدم للرايات والأقنعة وسجلّات العتاد. وهناك تحذيران: & و| ليسا && و|| (فهما لا يقصّران التقييم ويعملان بتًّا بتًّا)، وإزاحة قيمة موقّعة أو الإزاحة بأكثر من عرض النوع سلوك غير معرَّف. استخدم الأنواع غير الموقّعة للعمل على البتات.

الأولوية

حين يخلو التعبير من الأقواس، يقرّر هذا الجدول ما يرتبط بماذا. الأعلى أولويةً أولًا:

النتائج العملية:

a + b * c       /* يعني a + (b * c) */
a < b == c < d  /* يعني (a < b) == (c < d) - نادرًا ما يكون هذا مقصودك */
x & 1 == 0      /* يعني x & (1 == 0)، أي x & 0 - خطأ كلاسيكي */
*p++            /* يعني *(p++) - راجِع p، ثم قدّمها */

السطر الثالث جدير بالحفظ: يرتبط == أوثق من &، لذا تحتاج فحوص أقنعة البتات إلى أقواس - (x & 1) == 0.

لا أحد يحفظ المستويات الخمسة عشر كلها، ولا أحد يحتاج إلى ذلك. تعلّم أن * يغلب +، وأن المقارنات تغلب && الذي يغلب ||، وأن كل ما عدا ذلك يأخذ أقواسًا:

if ((flags & MASK) != 0 && (count > 0 || force)) { ... }

هذا السطر يحمل أقواسًا زائدة عن الحاجة وهو أفضل بها.