معاملات C++: الحسابية والمقارنة والمنطقية وغيرها

ما الذي تفعله المعاملات

المعامل رمز يُجري عملية على قيمة واحدة أو أكثر تُسمى المعاملات. لقد استخدمت بالفعل واحدًا منها: علامة = التي تربط قيمة بمتغير. تأتي C++ بمجموعة غنية من المعاملات للرياضيات والمقارنة والمنطق ومعالجة البتات - مع بعض الزوايا الحادة التي تُعثِر المبتدئين.

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

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

المعاملات الحسابية الخمسة هي + و - و * و / و % (باقي القسمة، أي ما يتبقى من عملية القسمة):

#include <iostream>
using namespace std;

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

    cout << "sum:       " << a + b << "\n";
    cout << "difference: " << a - b << "\n";
    cout << "product:    " << a * b << "\n";
    cout << "quotient:   " << a / b << "\n";
    cout << "remainder:  " << a % b << "\n";

    return 0;
}

المزلق الكبير يكمن في ذلك الناتج. فـ 17 / 5 تطبع 3 لا 3.4. عندما يكون كلا المعاملَين عددًا صحيحًا، تُجري / قسمة صحيحة وتُلقي بالجزء الكسري - فهي تقتطع باتجاه الصفر، ولا تُقرّب. وإذا أردت كسرًا حقيقيًا، فيجب أن يكون أحد المعاملَين على الأقل قيمة عشرية:

#include <iostream>
using namespace std;

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

    cout << a / b << "\n";          // 3  -> قسمة صحيحة
    cout << 17.0 / 5 << "\n";       // 3.4 -> القيمة 17.0 من النوع double
    cout << (double)a / b << "\n";  // 3.4 -> حوّل أحد المعاملَين أولًا

    return 0;
}

المعامل % يعمل مع الأعداد الصحيحة فقط. واستخدام % على قيمة double خطأ في الترجمة - استخدم std::fmod من <cmath> للحصول على باقي قسمة الأعداد العشرية.

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

علامة = المفردة تُسنِد؛ ولا تُقارن. تمنحك C++ صيغًا مركّبة تجمع بين عملية والإسناد كي لا تُكرّر اسم المتغير:

#include <iostream>
using namespace std;

int main() {
    int score = 10;

    score += 5;   // score = score + 5  -> 15
    score -= 3;   // 12
    score *= 2;   // 24
    score /= 4;   // 6
    score %= 4;   // 2

    cout << score << "\n";   // 2
    return 0;
}

من الأخطاء الكلاسيكية المؤلمة كتابة = بينما تقصد == داخل شرط. فـ if (x = 0) تُسنِد القيمة 0 إلى x ثم تختبر الناتج (وهو قيمة خاطئة)، بدلًا من المقارنة. وتُنبّهك المترجمات الحديثة إلى ذلك عند تفعيل التحذيرات - أبقِ -Wall مفعّلًا وتعامل مع التحذير بجدية.

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

تطرح معاملات المقارنة سؤالًا بنعم/لا وتُنتج قيمة bool (true أو false):

#include <iostream>
using namespace std;

int main() {
    int x = 7, y = 10;

    cout << (x == y) << "\n";  // 0  (false)
    cout << (x != y) << "\n";  // 1  (true)
    cout << (x <  y) << "\n";  // 1
    cout << (x >= 7) << "\n";  // 1

    cout << boolalpha;          // اطبع true/false بدلًا من 1/0
    cout << (x < y) << "\n";    // true
    return 0;
}

افتراضيًا تطبع cout قيمة bool على هيئة 1 أو 0. أدخِل boolalpha مرة واحدة فتتحوّل إلى الكلمتين true/false لبقية ذلك المجرى.

وهناك فخّ دقيق: لا تربط المقارنات على هذا النحو 1 < x < 10. فهذا يُحلَّل على أنه (1 < x) < 10 - تُنتج المقارنة الأولى قيمة bool (0 أو 1)، ثم تُقارَن بـ 10، فيكون الناتج الكامل دائمًا تقريبًا true. اكتب بدلًا من ذلك 1 < x && x < 10.

المعاملات المنطقية والتقييم القصير

تجمع && (و)، و || (أو)، و ! (نفي) بين التعبيرات المنطقية. والمعاملان الأولان يستخدمان التقييم القصير: يتوقف التقييم بمجرد معرفة الناتج.

#include <iostream>
using namespace std;

bool check(const char* label) {
    cout << "checked " << label << "\n";
    return true;
}

int main() {
    // يُتخطّى الطرف الثاني من && لأن الطرف الأول هو false:
    if (false && check("A")) {}

    // يُتخطّى الطرف الثاني من || لأن الطرف الأول هو true:
    if (true || check("B")) {}

    cout << "done\n";
    return 0;
}

لا تُنفَّذ check("A") ولا check("B") أبدًا - هذا هو التقييم القصير. وهو ليس مجرد تحسين؛ بل أداة. إذ يمكنك أن تكتب بأمان if (ptr != nullptr && ptr->ready) لأن الجزء ptr->ready لا يُبلَغ إلا عندما يكون ptr غير فارغ (non-null)، مما يتجنّب الوصول إلى مؤشر معلّق.

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

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

#include <iostream>
using namespace std;

int main() {
    int i = 5;
    cout << ++i << "\n";  // يزيد إلى 6 ثم يطبع 6 (سابقة)

    int j = 5;
    cout << j++ << "\n";  // يطبع 5 ثم يزيد إلى 6 (لاحقة)
    cout << j   << "\n";  // 6

    return 0;
}

عندما تريد الأثر الجانبي فقط (في حلقة for مثلًا)، فضّل ++i. فمع النوع int البسيط هما متطابقان، لكن مع الأنواع الأثقل مثل المُكرِّرات (iterators) تضطر الزيادة اللاحقة إلى نسخ القيمة القديمة أولًا، وهذا جهد مُهدَر.

تحذير أخير: لا تُعدّل المتغير نفسه مرتين داخل تعبير واحد، مثل i = i++ + 1; أو arr[i] = i++;. فترتيب هذه التحديثات غير محدّد والنتيجة سلوك غير معرَّف. اجعل لكل متغير تعديلًا واحدًا فقط في كل جملة.

المعاملات على مستوى البتات والأسبقية

للعمل منخفض المستوى توجد معاملات على مستوى البتات: & (و)، و | (أو)، و ^ (xor)، و ~ (نفي)، إضافة إلى معاملَي الإزاحة << و >>.

#include <iostream>
using namespace std;

int main() {
    unsigned int flags = 0b0101;   // قيمة ثنائية حرفية: 5

    cout << (flags & 0b0001) << "\n";  // 1  -> البت 0 مضبوط
    cout << (flags | 0b0010) << "\n";  // 7  -> اضبط البت 1
    cout << (flags ^ 0b0101) << "\n";  // 0  -> xor مع نفسه
    cout << (flags << 1)      << "\n"; // 10 -> إزاحة تضاعف القيمة

    return 0;
}

انتبه: << و >> هما أيضًا معاملا المجرى على cout. فداخل سطر cout تحتاج عادةً إلى أقواس حول إزاحة البتات، وإلا قرأها المترجم على أنها إدراج في المجرى.

وأخيرًا، تُحدّد الأسبقية ما الذي يرتبط أولًا عند مزج المعاملات. فـ * و / ترتبطان بقوة أكبر من + و -، تمامًا كما في الرياضيات، لذا فإن 2 + 3 * 4 يساوي 14. وترتبط المقارنة بقوة أقل من العمليات الحسابية، والمعاملان المنطقيان &&/|| بقوة أقل من ذلك. وعند الشك، لا تحفظ الجدول كاملًا - أضِف أقواسًا. فالصيغة (a + b) * c أوضح من الاعتماد على تذكّر القارئ للقواعد.

التالي: تحويل الأنواع

رأيت أعلاه أن (double)a / b أجبرت عددًا صحيحًا على الدخول في قسمة عشرية. هذا هو التحويل (cast) - تحويل قيمة عمدًا من نوع إلى آخر. في الصفحة التالية سنتناول أدوات التحويل في C++، من الترقيات الضمنية إلى static_cast، ومتى يكون كلٌّ منها آمنًا.