أنواع البيانات في لغة C: ‏int وfloat وchar وdouble وغيرها

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

وقائمة أنواع C قصيرة. والتعقيد في المُعدِّلات.

الأنواع الأساسية الأربعة

#include <stdio.h>

int main(void) {
    char  initial = 'K';        /* محرف واحد / بايت واحد */
    int   count   = 42;         /* عدد صحيح */
    float ratio   = 3.14f;      /* عدد عشري، دقّة مفردة */
    double precise = 3.141592653589793;  /* عدد عشري، دقّة مزدوجة */

    printf("char:   %c\n", initial);
    printf("int:    %d\n", count);
    printf("float:  %f\n", ratio);
    printf("double: %.15f\n", precise);
    return 0;
}

• char يحمل بايتًا واحدًا. ويُستخدم للمحارف المفردة ('A')، ولبايتات السلسلة النصية، وأحيانًا كعدد صحيح صغير جدًا.
• int هو حصان العمل للأعداد الصحيحة. عدّادات الحلقات والأحجام والمعرّفات.
• float و**double** يحملان الأعداد الحقيقية. وdouble ذو دقّة تقارب الضعف.
• void هو النوع الرابع بمعنى ما، لكنه يعني "لا قيمة" - فلا يمكنك تعريف متغيّر void، بل استخدامه فقط كنوع إرجاع دالة أو قائمة وسائط فارغة أو مؤشّر بلا نوع.

لاحظ اللاحقة f في 3.14f. فبدونها تكون القيمة الحرفية من نوع double، وإسنادها إلى float يفقد الدقّة بصمت. وبعض المترجمات تحذّر من ذلك.

المُعدِّلات: ‏short وlong وunsigned

تأتي الأنواع الصحيحة الأساسية مع مُعدِّلات تغيّر الحجم أو الإشارة.

#include <stdio.h>

int main(void) {
    short small = 32000;
    int normal = 2000000;
    long big = 2000000000L;
    long long huge = 9000000000000000000LL;

    unsigned int positive_only = 4000000000U;

    printf("short:        %hd\n", small);
    printf("int:          %d\n", normal);
    printf("long:         %ld\n", big);
    printf("long long:    %lld\n", huge);
    printf("unsigned int: %u\n", positive_only);
    return 0;
}

لكل نوع صحيح محدّد تنسيق خاص به: %hd لـ short، و%d لـ int، و%ld لـ long، و%lld لـ long long، و%u لغير الموقّع. واستخدام الخاطئ منها سلوك غير معرَّف، لا خطأ تقريب.

unsigned تزيل بتّ الإشارة وتضاعف المدى الموجب. فـ unsigned int يحمل من 0 إلى نحو 4.3 مليار بدل -2.1 إلى +2.1 مليار. وهو الخيار الصحيح لما لا يمكن أن يكون سالبًا فعلًا - الأحجام، وعدد البايتات، وأنماط البتّات - وفخّ لأي شيء قد يُطرح إلى ما دون الصفر.

وsigned هي الافتراض لـ int وshort وlong وlong long، فلا تكتبها تقريبًا أبدًا. والموضع الوحيد الذي تهمّ فيه هو char: فكون char المجرّد موقّعًا أو غير موقّع يحدّده التطبيق، لذا اكتب signed char أو unsigned char حين تهمّ الإشارة.

الأحجام: ما تحصل عليه فعلًا

يحدّد معيار C حدودًا دنيا، لا أحجامًا مضبوطة. وعلى أي جهاز حديث بـ 64 بتًا يعمل بلينكس أو ماك أو ويندوز سترى هذا:

وصفّ long هو الذي يوقع الناس: فهو 8 بايتات على لينكس وماك، و4 بايتات على ويندوز بـ 64 بتًا. والشيفرة التي تفترض أن long يمكنه حمل قيمة بـ 64 بتًا ليست محمولة. استخدم long long، أو الأنواع مضبوطة العرض من stdint.h (‏int32_t وuint64_t) حين يكون الحجم جزءًا من المتطلّب.

sizeof: اسأل المترجم

لا تخمّن حجمًا أبدًا - قِسْه:

#include <stdio.h>

int main(void) {
    printf("char:        %zu byte(s)\n", sizeof(char));
    printf("short:       %zu bytes\n", sizeof(short));
    printf("int:         %zu bytes\n", sizeof(int));
    printf("long:        %zu bytes\n", sizeof(long));
    printf("long long:   %zu bytes\n", sizeof(long long));
    printf("float:       %zu bytes\n", sizeof(float));
    printf("double:      %zu bytes\n", sizeof(double));
    printf("a pointer:   %zu bytes\n", sizeof(int *));
    return 0;
}

sizeof عامل لا دالة، ويُقيَّم وقت الترجمة. ويُنتج قيمة من نوع size_t، تُطبع بـ %zu.

وsizeof(char) مضمون أن يساوي 1 بالضبط - فذلك هو تعريف البايت في C. وكل ما عداه يُقاس نسبةً إليه.

limits.h وfloat.h

المدَيات المضبوطة لمترجمك متاحة كثوابت مسمّاة:

#include <stdio.h>
#include <limits.h>
#include <float.h>

int main(void) {
    printf("INT_MIN      = %d\n", INT_MIN);
    printf("INT_MAX      = %d\n", INT_MAX);
    printf("UINT_MAX     = %u\n", UINT_MAX);
    printf("LONG_MAX     = %ld\n", LONG_MAX);
    printf("CHAR_BIT     = %d bits per byte\n", CHAR_BIT);
    printf("FLT_DIG      = %d decimal digits\n", FLT_DIG);
    printf("DBL_DIG      = %d decimal digits\n", DBL_DIG);
    return 0;
}

هذه هي القيم التي تقارن بها حين تحتاج أن تعرف هل ستفيض عملية ما. وفحص if (a > INT_MAX - b) قبل حساب a + b هو كيف تكتشف الفيضان قبل وقوعه - وهو أمر مهمّ، لأنك لا تستطيع اكتشاف فيضان القيم الموقّعة بعده.

فيضان الأعداد الصحيحة

ما يحدث حين تتجاوز قيمة مدى نوعها يعتمد كليًا على الإشارة.

فيضان غير الموقّع معرَّف: تلتفّ القيمة بمقياس 2^N.

#include <stdio.h>
#include <limits.h>

int main(void) {
    unsigned int u = UINT_MAX;
    printf("UINT_MAX     = %u\n", u);
    printf("UINT_MAX + 1 = %u\n", u + 1);   /* مضمون أن يكون 0 */

    unsigned int zero = 0;
    printf("0 - 1        = %u\n", zero - 1); /* يلتفّ إلى UINT_MAX */
    return 0;
}

والحالة الثانية مصدر حقيقي للعلل. فحلقة مثل for (unsigned i = n - 1; i >= 0; i--) لا تنتهي أبدًا، لأن القيمة غير الموقّعة دائمًا >= 0.

وفيضان الموقّع سلوك غير معرَّف. ليس "يلتفّ" - بل غير معرَّف. ويُسمَح للمترجم بافتراض أنه لا يحدث أبدًا والتحسين على ذلك الأساس، ما يعني أن فحص فيضان مكتوبًا بعد وقوعه يمكن حذفه:

int sum = a + b;
if (sum < a) { /* قد يحذف المترجم هذا كليًا */ }

افحص قبلًا، باستخدام الحدود:

if (b > 0 && a > INT_MAX - b) {
    /* a + b ستفيض - عالج ذلك */
}

دقّة الفاصلة العائمة

يخزّن float وdouble الأعداد ثنائيًا، ومعظم الكسور العشرية ليس لها صيغة ثنائية مضبوطة - تمامًا كما أن 1/3 ليس له صيغة عشرية مضبوطة.

#include <stdio.h>

int main(void) {
    double a = 0.1;
    double b = 0.2;
    double sum = a + b;

    printf("0.1 + 0.2 = %.20f\n", sum);
    printf("Is it 0.3? %s\n", (sum == 0.3) ? "yes" : "no");

    /* الطريقة الصحيحة: قارن ضمن هامش تسامح. */
    double diff = sum - 0.3;
    if (diff < 0) diff = -diff;
    printf("Close enough? %s\n", (diff < 1e-9) ? "yes" : "no");
    return 0;
}

والقاعدة المترتّبة: لا تقارن أبدًا قيم الفاصلة العائمة بـ ==. قارن الفرق المطلق بهامش تسامح صغير بدلًا من ذلك.

ولا تستخدم الفاصلة العائمة للنقود أبدًا. خزّن السنتات كعدد صحيح؛ فـ long long من السنتات مضبوط حيث لا يكون double من الدولارات كذلك.

اختيار النوع

قائمة قرار قصيرة تغطّي معظم الشيفرات:

• الأعداد الصحيحة: int ما لم يكن لديك سبب. فهو النوع الذي يعالجه المعالج بأعلى كفاءة، والنوع الذي بُنيت حوله كل قواعد الحساب.
• أي شيء أكبر من ملياري وحدة: long long، أو int64_t من stdint.h.
• الأحجام والأطوال وفهارس المصفوفات من sizeof أو strlen: size_t. فهو غير موقّع ومضمون أن يتّسع لأي كائن.
• الأعداد العشرية: double. واستخدم float فقط لتنصيف الذاكرة في المصفوفات الكبيرة أو على عتاد مضمّن بلا وحدة دقّة مزدوجة.
• المحارف المفردة والبايتات الخام: char للنصّ، وunsigned char للبيانات الثنائية.
• صحيح/خطأ: bool من stdbool.h - انظر القيم المنطقية في C.
• عروض بتّات مضبوطة (صيغ الملفات، بروتوكولات الشبكة، مسجّلات العتاد): stdint.h - uint8_t وint16_t وuint32_t وهكذا.

#include <stdio.h>
#include <stdint.h>

int main(void) {
    uint8_t  flags = 0xFF;          /* 8 بتّات بالضبط، غير موقّع */
    int32_t  offset = -100000;      /* 32 بتًا بالضبط، موقّع */
    uint64_t file_size = 5000000000ULL;

    printf("flags:     %u\n", flags);
    printf("offset:    %d\n", offset);
    printf("file_size: %llu bytes\n", (unsigned long long)file_size);
    return 0;
}

خلط الأنواع

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

#include <stdio.h>

int main(void) {
    int a = 7, b = 2;

    printf("7 / 2  as ints   = %d\n", a / b);        /* 3، لا 3.5 */
    printf("7 / 2  with 2.0  = %f\n", a / 2.0);      /* 3.5 */

    int  small = -1;
    unsigned int big = 1;
    printf("-1 < 1u ? %s\n", (small < big) ? "yes" : "no");  /* مفاجئ */
    return 0;
}

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

وتلك القواعد التحويلية، وكيفية السيطرة عليها بتحويلات صريحة، هي موضوع تحويل الأنواع في C.