أنواع البيانات في C++: int وdouble وchar وbool والمزيد

لماذا تهمّ الأنواع في C++

في صفحة المتغيرات أعلنت قيمًا بنوع صريح مثل int age = 30;. هذا النوع ليس مجرد لافتة - فهو يخبر المترجم بعدد البايتات التي يحجزها، وكيف يفسّر تلك البايتات، وأي العمليات مسموح بها. وإذا أخطأت في النوع فقد تفقد الدقّة بصمت، أو تتعرّض للفيض، أو تستدعي سلوكًا غير معرّف.

تجمّع C++ أنواعها المدمجة في عدة عائلات: الأعداد الصحيحة، وأعداد الفاصلة العائمة، ونوع المحرف، والنوع المنطقي. لننظر إلى كل واحد منها، ثم إلى القواعد التي يتعثّر فيها الناس.

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

إليك مثالًا واحدًا لكل نوع جوهري في برنامج واحد. لاحظ لواحق القيم الحرفية (L وf وu) وعلامتي الاقتباس المفردتين حول char:

#include <iostream>
using namespace std;

int main() {
    int    count = 42;          // عدد صحيح، عادةً 32 بت
    long long big = 9000000000LL; // عدد صحيح أعرض، اللاحقة LL
    double price = 19.99;       // عدد عشري بـ 64 بت (الافتراضي للأعداد العشرية)
    float  ratio = 0.5f;        // عدد عشري بـ 32 بت - لاحظ الـ f
    char   grade = 'A';         // محرف واحد، علامتا اقتباس مفردتان
    bool   passed = true;       // true أو false فقط

    cout << count << " " << big << "\n";
    cout << price << " " << ratio << "\n";
    cout << grade << " " << passed << "\n"; // يُطبع bool كـ 1 / 0
}

يُطبع bool افتراضيًا كـ 1 أو 0، وليس true/false. ويستخدم char علامتي اقتباس مفردتين - فـ 'A' محرف واحد، بينما "A" (علامتا اقتباس مزدوجتان) قيمة حرفية نصية، وهي نوع مختلف تمامًا. وهذان الخطآن شائعان للغاية في البداية.

الأحجام ليست ثابتة

هذه أكبر مفاجأة لمن يأتي من لغات مثل Java. لا يضمن معيار C++ سوى الأحجام الدنيا وترتيب نسبي (short ≤ int ≤ long ≤ long long). أما الحجم الفعلي فيعتمد على المترجم والمنصة لديك. تحقّق دائمًا بـ sizeof:

#include <iostream>
using namespace std;

int main() {
    cout << "char:      " << sizeof(char)      << " byte\n";  // دائمًا 1
    cout << "short:     " << sizeof(short)     << " bytes\n";
    cout << "int:       " << sizeof(int)       << " bytes\n";
    cout << "long:      " << sizeof(long)      << " bytes\n";
    cout << "long long: " << sizeof(long long) << " bytes\n";
    cout << "double:    " << sizeof(double)    << " bytes\n";
}

في بناء Linux نموذجي بـ 64 بت سترى int = 4 وlong = 8. أما على ويندوز بـ 64 بت فإن long يبلغ 4 بايتات فقط. هذه الفجوة في قابلية النقل هي بالضبط السبب الذي يجعلك لا تكتب شيفرة تفترض أن long بحجم 64 بت.

عندما تحتاج إلى عرض دقيق، الجأ إلى أنواع الأعداد الصحيحة ذات العرض الثابت في <cstdint>:

#include <iostream>
#include <cstdint>
using namespace std;

int main() {
    int8_t   a = -120;          // 8 بت بالضبط، signed
    uint16_t b = 65000;         // 16 بت بالضبط، unsigned
    int32_t  c = 2000000000;    // 32 بت بالضبط
    int64_t  d = 9000000000LL;  // 64 بت بالضبط، على كل منصة

    cout << (int)a << " " << b << " " << c << " " << d << "\n";
}

استخدم int32_t/int64_t لصيغ الملفات وبروتوكولات الشبكة أو أي شيء يجب أن يتصرّف بشكل متطابق عبر الأجهزة. لاحظ التحويل (int)a - فبثّ نوع بحجم 8 بت يطبعه كمحرف لا كرقم، لذا حوّله أولًا.

Signed مقابل unsigned

يأتي كل نوع صحيح في صنفين. يمكن للنوع signed أن يحمل قيمًا سالبة؛ أما النوع unsigned فلا يستطيع، مقايضًا المدى السالب بقيمة موجبة قصوى أعلى. والنوع int العادي signed افتراضيًا.

#include <iostream>
#include <climits>
using namespace std;

int main() {
    unsigned int u = 0;
    u = u - 1;          // لا يصبح -1
    cout << u << "\n";  // يلتفّ إلى 4294967295 (القيمة القصوى لـ unsigned int)

    cout << "int max:  " << INT_MAX << "\n";
    cout << "uint max: " << UINT_MAX << "\n";
}

الطرح من 0 غير المُوقَّع يلتفّ إلى عدد موجب هائل بدلًا من أن يصبح سالبًا. وهذا يوقع الناس باستمرار - وبخاصة مع size_t (وهو نوع unsigned) الذي تُعيده .size():

vector<int> v = {1, 2, 3};
// خطر: v.size() من نوع unsigned. إذا كانت v فارغة، فإن v.size() - 1 يلتفّ
// إلى عدد ضخم وتعمل الحلقة إلى ما لا نهاية تقريبًا.
for (size_t i = 0; i <= v.size() - 1; i++) { /* ... */ }

فضّل i < v.size() (لا تستخدم أبدًا <= size() - 1)، أو تجنّب المشكلة كلها عبر حلقة for قائمة على نطاق.

فيض الأعداد الصحيحة سلوك غير معرّف

على عكس التفاف الأنواع unsigned (وهو معرّف جيدًا)، فإن فيض الأعداد الصحيحة المُوقَّعة سلوك غير معرّف في C++. ويُسمح للمترجم بفعل أي شيء - إعادة قيمة عشوائية، أو حذف الفحص أثناء التحسين، أو الانهيار:

#include <iostream>
#include <climits>
using namespace std;

int main() {
    int maxInt = INT_MAX;            // 2147483647
    cout << maxInt << "\n";
    cout << maxInt + 1 << "\n";      // سلوك غير معرّف - غالبًا يلتفّ إلى قيمة سالبة

    long long safe = (long long)maxInt + 1; // ارفع النوع قبل الجمع
    cout << safe << "\n";            // 2147483648، صحيح
}

الحل هو نفسه فخّ الفيض في أي لغة: أجرِ العملية الحسابية في نوع أعرض. حوّل أحد المعاملين إلى long long قبل علامة +، حتى يجري الجمع بـ 64 بت. وتحويل الناتج بعد ذلك يأتي متأخرًا جدًا - فالفيض قد حدث بالفعل.

اختيار النوع المناسب

في معظم الشيفرات تفي القيم الافتراضية بالغرض: int للأعداد الصحيحة، وdouble للأعداد العشرية. والجأ إلى غيرها فقط عندما يكون لديك سبب.

النوع	الحجم المعتاد	استخدمه عند
int	32 بت	الافتراضي للأعداد الصحيحة
long long	64 بت	القيم التي تتجاوز ~2 مليار: الطوابع الزمنية، العدّادات الكبيرة
double	64 بت	الافتراضي للأعداد العشرية - دقة جيدة
float	32 بت	المصفوفات الضيقة بالذاكرة حيث يمكن التضحية بالدقة
bool	1 بايت	راية true/false
int32_t / int64_t	دقيق	الصيغ العابرة للمنصات، البروتوكولات، التلاعب بالبتات

بعض المزالق التي ينبغي تذكّرها. لا يملك float سوى نحو 7 أرقام عشرية معنوية، لذا فإن 0.1f + 0.2f ليس 0.3 بالضبط - ففضّل double ما لم تكن بحاجة فعلية إلى توفير الذاكرة. كما أن char قد يكون signed أو unsigned تبعًا للمنصة، لذا إذا أجريت عمليات حسابية على بايتات خام، فاكتب صراحةً signed char أو unsigned char.

التالي: الكلمة المفتاحية auto

كتابة النوع في كل مرة تصبح مملّة، وأحيانًا يكون النوع طويلًا أو صعب التسمية. تتيح C++ للمترجم استنتاجه نيابةً عنك عبر الكلمة المفتاحية auto - فـ auto x = 42; يجعل x من نوع int، وauto it = v.begin(); يوفّر عليك كتابة نوع مكرّر مُطوَّل. وتتناول الصفحة التالية متى يجعل auto الشيفرة أوضح ومتى يخفي أكثر من اللازم.