تحويل الأنواع في C++‎: static_cast والتحويلات الضمنية والتحويلات

ما هو تحويل الأنواع

تحويل الأنواع يعني تحويل قيمة من نوع إلى آخر - تحويل double إلى int، أو char إلى رمزه العددي، أو مؤشّر إلى صنف أساس إلى مؤشّر إلى صنف مشتقّ. تؤدّي C++‎ بعض هذه التحويلات نيابةً عنك تلقائيًا، لكن تلك التي تؤدّيها بصمت هي بالضبط حيث تختبئ العلل.

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

التحويلات الضمنية

عندما تمزج أنواعًا عددية في تعبير، ترفع C++‎ النوع "الأصغر" إلى "الأكبر" كي يتطابق الطرفان. وهذا يفعل عادةً ما تريده.

#include <iostream>
using namespace std;

int main() {
    int apples = 3;
    double price = 1.5;

    double total = apples * price;   // int -> double تلقائيًا
    cout << total << endl;           // 4.5

    char c = 'A';
    int code = c;                    // char -> int (رمز ASCII)
    cout << code << endl;            // 65
    return 0;
}

تبدأ المتاعب عندما يسير التحويل في الاتجاه المعاكس - من نوع أوسع إلى نوع أضيق. هذا تحويل تضييق، وقد يفقد البيانات بصمت.

#include <iostream>
using namespace std;

int main() {
    double pi = 3.99;
    int rounded = pi;        // تضييق: يُسقَط الجزء الكسري، ولا يُقرَّب
    cout << rounded << endl; // 3

    int big = 300;
    char small = big;        // 300 لا تتّسع في char
    cout << static_cast<int>(small) << endl; // 44 (التفّت!)
    return 0;
}

التحويل من float إلى int يقطع نحو الصفر - فهو لا يقرّب، لذا تصبح 3.99 هي 3. وحشر 300 في char يسبّب فيضانًا. تنبّه مترجمات كثيرة هنا؛ وبعضها لا يفعل. وعندما تقصد التضييق فعلًا، صرّح به بوضوح عبر تحويل كي يعرف القارئ التالي أن ذلك كان مقصودًا.

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

السبب الأكثر شيوعًا للتحويل هو القسمة. عندما يكون المُعاملان عددين صحيحين، تؤدّي / قسمة صحيحة وتتخلّص من الباقي.

#include <iostream>
using namespace std;

int main() {
    int got = 7;
    int total = 10;

    double wrong = got / total;                       // 0  (القسمة الصحيحة أولًا!)
    double right = static_cast<double>(got) / total;  // 0.7

    cout << wrong << endl;
    cout << right << endl;
    return 0;
}

الإصلاح هو تطبيق static_cast<double> على أحد المُعاملين قبل القسمة. ومن الأخطاء الشائعة static_cast<double>(got / total) - وهو متأخّر جدًا، لأن got / total تساوي 0 بالفعل عند تنفيذ التحويل، فتحصل على 0.0. حوّل مُعاملًا، لا الناتج.

static_cast: تحويلك الافتراضي

تمنحك C++‎ أربعة تحويلات مسمّاة. والذي ستستخدمه في 95% من الأحيان هو static_cast<T>(value)، الذي يؤدّي تحويلات معرَّفة جيدًا بين أنواع مترابطة - تحويلات عددية، ومن enum إلى int، ومن void* رجوعًا إلى مؤشّر ذي نوع، والصعود/النزول في تسلسل أصناف عندما تعرف النوع مسبقًا.

#include <iostream>
using namespace std;

int main() {
    double balance = 19.95;
    int dollars = static_cast<int>(balance);   // 19، أُسقط الجزء الكسري

    int letter = 100;
    char ch = static_cast<char>(letter);       // 'd'

    cout << dollars << endl;   // 19
    cout << ch << endl;        // d
    return 0;
}

فضّل static_cast على التحويل القديم بأسلوب C ‏(int)balance. فالتحويل بأسلوب C سيجرّب أي تحويل كي يُترجَم الكود - بما في ذلك التحويلات الخطيرة أدناه - لذا قد يزيل const بصمت أو يعيد تفسير البايتات الخام. أما static_cast فلا يسمح إلا بالتحويلات التي يستطيع المترجم تبريرها فعلًا، كما أن static_cast<...> المطوَّل سهل البحث عنه في مراجعة الكود.

// تجنّب - تحويل بأسلوب C، بلا شبكة أمان:
int dollars = (int) balance;

// فضّل - صريح، مُتحقَّق منه، يسهل البحث عنه:
int dollars = static_cast<int>(balance);

التحويلات الثلاثة الأخرى (استخدمها بحذر)

التحويلات المتبقّية موجودة لمهام محدّدة وضيّقة. لا تلجأ إليها إلا حين يعجز static_cast فعلًا عن أداء المهمة.

const_cast يزيل const (أو يضيفه). واستخدامه المشروع الوحيد هو استدعاء واجهة برمجية بأسلوب C نسيت تعليم أحد المعاملات بـ const. أما تعديل كائن أُعلِن أصلًا بأنه const عبر const_cast فهو سلوك غير معرَّف.

void legacyApi(char* msg);   // واجهة قديمة، لا تأخذ const

const char* text = "hello";
legacyApi(const_cast<char*>(text));   // مقبول فقط إن لم تكتب legacyApi فيه

reinterpret_cast يعيد تفسير نمط البتّات الخام - مثلًا مؤشّر بوصفه عنوانًا عدديًا. وهو لا يؤدّي أي تحويل وغير آمن إلى حدّ كبير؛ وهو غالبًا علامة على أن عليك إعادة التفكير في التصميم.

dynamic_cast يحوّل بأمان مؤشّرًا أو مرجعًا إلى صنف أساس نحو نوع مشتقّ أثناء التشغيل، مستخدمًا النوع الفعلي للكائن. ويتطلّب أساسًا متعدّد الأشكال (صنفًا فيه دالة افتراضية virtual واحدة على الأقل) ويُعيد nullptr إذا لم ينطبق التحويل.

#include <iostream>
using namespace std;

struct Animal { virtual ~Animal() = default; };
struct Dog : Animal { void bark() { cout << "Woof!" << endl; } };

int main() {
    Animal* a = new Dog();

    if (Dog* d = dynamic_cast<Dog*>(a)) {  // ينجح: a هو فعلًا Dog
        d->bark();
    } else {
        cout << "not a Dog" << endl;
    }

    delete a;
    return 0;
}

لو كان a يشير إلى Animal آخر، لأعاد dynamic_cast<Dog*> القيمة nullptr وعمل فرع else - وهذا بالضبط سبب كونه أكثر أمانًا من استخدام static_cast على نحو أعمى للنزول في تسلسل.

أخطاء شائعة يجب تجنّبها

• تحويل الناتج بدلًا من مُعامل. ‏static_cast<double>(a / b) يُسقط جزءك الكسري أولًا. حوّل a أو b.
• افتراض أن التحويل من float إلى int يقرّب. بل يقطع: ‏static_cast<int>(2.99) هو 2. للتقريب استخدم std::round وstd::lround وغيرها.
• اللجوء إلى تحويل بأسلوب C. فهو يخفي أيّ تحويل يحدث. استخدم static_cast فتحصل على خطأ ترجمة حين يكون التحويل غير آمن، بدلًا من مفاجأة صامتة.
• التضييق إلى نوع أصغر مما يلزم. تحويل 300 إلى char أو long ضخم إلى int يلتفّ أو يفيض. اختر نوعًا هدفًا واسعًا بما يكفي للمدى.

التالي: If-Else

الآن وقد صرت قادرًا على تحويل القيم ومقارنتها بنظافة، فالخطوة التالية هي اتخاذ القرارات بها. تنفّذ تعليمة if-else كودًا مختلفًا تبعًا لما إذا كان الشرط true - أساس كل برنامج يتفرّع.