অপারেটর — হিসাব, তুলনা আর যুক্তি

১ · মডিউল ২ শুরু — বাক্স থেকে হিসাবে

প্রথম মডিউলে আপনি শিখেছেন C++ কেন, প্রোগ্রাম কীভাবে compile হয়, আর ডেটা কোন টাইপের বাক্সে থাকে। এবার শুরু হলো মডিউল ২ — “ভাষার মূল যন্ত্রপাতি”. সাতটি পর্বে আপনি সেই যন্ত্রগুলো হাতে নেবেন, যা প্রায় প্রতিটি লাইনে লাগে: অপারেটর (এই পর্ব), ইনপুট-আউটপুট (পর্ব ০৭), সিদ্ধান্ত ও লুপ (পর্ব ০৮), ফাংশন (পর্ব ০৯), reference (পর্ব ১০), namespace ও header (পর্ব ১১), আর enum ও struct (পর্ব ১২)। মডিউল শেষে আপনি ছোট কিন্তু সত্যিকারের কাজের প্রোগ্রাম লিখতে পারবেন।

আগের পর্বে বাক্স বানিয়েছেন। কিন্তু বাক্সে মান রেখে বসে থাকলে কোনো কাজ হয় না। দোকানের বিল যোগ করতে হয়, নম্বর দেখে গ্রেড ঠিক করতে হয়, বছরটা অধিবর্ষ কি না যাচাই করতে হয়। এসব কাজের যন্ত্রই হলো operator — এমন চিহ্ন, যা এক বা একাধিক মান নিয়ে একটি নতুন মান তৈরি করে।

Operand কয়টি, সেই অনুযায়ী অপারেটর তিন রকম:

২ · গণিতের অপারেটর — যোগ, বিয়োগ, ভাগ আর ভাগশেষ

পাঁচটি arithmetic operator আছে: + (যোগ), - (বিয়োগ), * (গুণ), / (ভাগ) আর % (ভাগশেষ)। প্রথম তিনটি স্কুলের অঙ্কের মতোই কাজ করে — শুধু মনে রাখবেন, int-এর সীমা পার হলে overflow হয় (পর্ব ০৫)। আসল মজা আর আসল ফাঁদ শেষের দুটিতে।

ভাগ: int হলে দশমিক কাটা যায়

আগের পর্বে দেখেছেন, দুটি int ভাগ করলে ফলও int — একে বলে integer division. 17 / 5 = 3, 2 / 3 = 0. Rounding হয় না, সোজা কেটে ফেলা হয়। অন্তত একটি operand double হলে ভাগ দশমিকে হয়: 17.0 / 5 = 3.4.

কিন্তু integer division সবসময় শত্রু নয়, অনেক সময় এটাই আপনার দরকার। ধরুন একজন দোকানদার ১২৪০ টাকা ভাংতি দেবেন একশো টাকার নোটে। কয়টি নোট? 1240 / 100 = 12. বাকি কত থাকল? সেটা দেয় ভাগশেষের অপারেটর।

ভাগশেষ: %

% অপারেটর দুটি পূর্ণসংখ্যা ভাগ করে ভাগশেষ দেয়: 1240 % 100 = 40. এর ব্যবহার ভাবনার চেয়ে অনেক বেশি:

দুটি জিনিস মনে রাখুন। প্রথমত, % শুধু পূর্ণসংখ্যায় চলে — 7.5 % 2 লিখলে compile error; দশমিকের ভাগশেষ লাগলে <cmath>-এর std::fmod. দ্বিতীয়ত, শূন্য দিয়ে পূর্ণসংখ্যার ভাগ বা ভাগশেষ (x / 0, x % 0) undefined behavior — বেশিরভাগ কম্পিউটারে প্রোগ্রাম সাথে সাথে ভেঙে পড়ে। দশমিকে শূন্য দিয়ে ভাগ করলে IEEE 754 মেনে চলা সিস্টেমে বাস্তবে inf আসে, তবে C++ standard এটাকেও নিশ্চিত আচরণ বলে না। নিয়ম একটাই: ভাগের আগে ভাজক শূন্য কি না দেখে নিন — কীভাবে নিরাপদে দেখবেন, অংশ ৫-এ।

ঋণাত্মক সংখ্যার ভাগ — শূন্যের দিকে কাটা

-7 / 2 কত? গণিতে −৩.৫. পূর্ণসংখ্যায় দুটি উত্তর সম্ভব: −৩ (শূন্যের দিকে কাটা) বা −৪ (ছোটর দিকে নামানো, যাকে বলে floor). C++11 থেকে standard স্পষ্ট বলে: ভাগফল শূন্যের দিকে কাটা হবে, তাই -7 / 2 = -3. আর ভাগশেষ এমনভাবে ঠিক হয় যেন সবসময় এই সম্পর্কটি সত্য থাকে:

তাহলে -7 % 2 = −৭ − (−৩ × ২) = -1. ফলাফলে একটি সহজ নিয়ম বেরিয়ে আসে: ভাগশেষের চিহ্ন বাম পাশের সংখ্যার (ভাজ্যের) চিহ্নের মতো। 7 % -2 = 1, -7 % -2 = -1.

বাস্তব উদাহরণ: দোকানের বিল

একটি মুদি দোকানের বিল ভাবুন — ৩ কেজি চাল, ২ লিটার তেল, ১২টি ডিম। মোট ১০০০ টাকা বা বেশি হলে ১০% ছাড়, তারপর ছাড়ের পরের দামে ১৫% VAT. সব হিসাব পূর্ণসংখ্যায় রাখা হয়েছে, যাতে দশমিকের “প্রায়-সঠিক” ঝামেলা না থাকে:

#include <print>

int main() {
    constexpr int VAT_PERCENT = 15;

    int subtotal{};                          // taka
    subtotal += 3 * 120;                     // 3 kg chal
    subtotal += 2 * 350;                     // 2 litre tel
    subtotal += 12 * 15;                     // 12 ta dim

    int discount = (subtotal >= 1000) ? subtotal / 10 : 0;   // 10% chhar
    int afterDiscount = subtotal - discount;
    int vat = afterDiscount * VAT_PERCENT / 100;
    std::println("subtotal = {}, discount = {}", subtotal, discount);
    std::println("VAT = {}, total = {}", vat, afterDiscount + vat);

    std::println("1240 taka: {} notes of 100, {} left", 1240 / 100, 1240 % 100);
    std::println("-7 / 2 = {}, -7 % 2 = {}", -7 / 2, -7 % 2);
}

৩ · Assignment, += আর ++ — মান বদলানোর অপারেটর

= চিহ্নটি C++-এ “সমান” নয়, এর অর্থ “ডান পাশের মান বাম পাশের বাক্সে রাখো”। তাই count = count + 1; গণিতে অসম্ভব হলেও প্রোগ্রামে খুবই স্বাভাবিক: পুরোনো মানে ১ যোগ করে আবার একই বাক্সে রাখা। সমান কি না যাচাই করার অপারেটর আলাদা — == (অংশ ৪)।

একটি অদ্ভুত কিন্তু জরুরি তথ্য: assignment নিজেও একটি expression, এর একটি মান আছে — বাম পাশের ভ্যারিয়েবলটি। তাই a = b = 0; চলে: আগে b = 0, তারপর সেই ফল a-তে। অর্থাৎ = ডান থেকে বামে কাজ করে। এই সুবিধার একটি অন্ধকার দিকও আছে, যা অংশ ৪-এ দেখবেন।

সংক্ষিপ্ত রূপ — compound assignment

“নিজের সাথে কিছু করে আবার নিজেতেই রাখা” এত বেশি লাগে যে এর জন্য আলাদা লেখা আছে:

সংক্ষিপ্ত রূপ শুধু টাইপ করা কমায় না। scores[findIndex(roll)] += 5; লিখলে বাম পাশের অংশটি একবারই হিসাব হয়; লম্বা রূপে findIndex দুবার চলত। তবে একটি লুকোনো ফাঁদ আছে: int taka = 10; taka += 2.7; কোনো error ছাড়াই compile হয়, আর taka হয় 12 — ১২.৭-এর দশমিক নিঃশব্দে কেটে গেল। Compound assignment ফলকে বাম পাশের টাইপে বদলে নেয়, আর এখানে আগের পর্বের {} পাহারাদার নেই। GCC-তে -Wconversion দিলে সতর্কবার্তা পাবেন।

++ আর -- — এক বাড়ানো, এক কমানো

১ যোগ করা সবচেয়ে বেশি লাগে (গোনা, লুপ চালানো), তাই এর জন্য আছে increment ও decrement অপারেটর: ++ আর --. এরা দুই জায়গায় বসতে পারে, আর জায়গা অনুযায়ী ফল আলাদা:

• Prefix ++i: আগে বাড়াও, তারপর নতুন মানটি দাও।
• Postfix i++: পুরোনো মানটি দাও, আর ভ্যারিয়েবলটিকে বাড়িয়ে রাখো।

লাইন একা থাকলে (i++; বা ++i;) দুটির ফল একই — i এক বাড়ে। পার্থক্য দেখা যায় যখন মানটি অন্য কোথাও ব্যবহার হয়। ধাপে ধাপে দেখুন:

1int i = 5;2int a = i++;3int b = ++i;4int n = 0;5while (n < 3) std::print("{} ", n++);6int m = 0;7while (m < 3) std::print("{} ", ++m);8for (int k = 0; k < 3; ++k) { }

একই expression-এ মিশাবেন না

++ একটি মান দেয় এবং ভ্যারিয়েবল বদলায়। এই দ্বিতীয় কাজটিকে বলে side effect. একটি expression-এর ভেতরে একই ভ্যারিয়েবলে দুটি side effect, বা একটি side effect আর সেই ভ্যারিয়েবলের অন্য ব্যবহার থাকলে, প্রশ্ন ওঠে — কোনটা আগে? C++ সব ক্ষেত্রে এর উত্তর দেয় না। কোন হিসাব কোনটির আগে হতেই হবে, সেই নিয়মের নাম sequencing.

৪ · তুলনা — সমান, ছোট, বড়

ছয়টি comparison operator দুটি মান মিলিয়ে দেখে, আর ফল দেয় একটি bool — true বা false:

দেখতে সহজ, কিন্তু এখানে C++-এর সবচেয়ে বিখ্যাত তিনটি ফাঁদ লুকিয়ে আছে।

ফাঁদ ১ — = বনাম ==

if (balance = 0) — প্রোগ্রামার লিখতে চেয়েছিলেন “ব্যালান্স কি শূন্য?” কিন্তু একটি = কম পড়ায় এটা হয়ে গেল assignment: balance-এ 0 বসানো হলো, আর assignment-এর মান 0, যা শর্ত হিসেবে false. ফল দ্বিগুণ খারাপ — শর্ত কখনো সত্য হয় না, আর গ্রাহকের ব্যালান্স মুছে গেল! কোডটি বৈধ C++, তাই compile হয়। ভরসা compiler-এর সতর্কবার্তা: GCC-তে -Wall দিলে বলে suggest parentheses around assignment used as truth value. এজন্যই প্রতিটি প্রজেক্টে -Wall -Wextra চালু রাখুন (পর্ব ০৩)।

ফাঁদ ২ — 0 < x < 10 গণিতের মতো কাজ করে না

গণিতে লেখা যায় ০ < x < ১০. C++-এ 0 < x < 10 পড়া হয় (0 < x) < 10 — প্রথম তুলনার ফল true বা false, অর্থাৎ 1 বা 0, আর সেটা সবসময় 10-এর চেয়ে ছোট। ফলে শর্তটি সবসময় সত্য, x যা-ই হোক! সঠিক লেখা: 0 < x && x < 10. সুখবর: GCC আর Clang -Wall-এ এখানে সতর্ক করে।

ফাঁদ ৩ — signed আর unsigned মেশানো

পর্ব ০৫-এ unsigned টাইপ দেখেছেন। একটি signed আর একটি unsigned মান তুলনা করলে C++ signed মানটিকে unsigned-এ বদলে নেয়। −১-কে unsigned-এ বদলালে হয় সবচেয়ে বড় unsigned সংখ্যা (৩২ বিটে 4294967295). তাই -1 < 3u হয় false! বাস্তবে এটা সবচেয়ে বেশি ঘটে container-এর আকারের সাথে: v.size() unsigned, তাই int i = -1; i < v.size() মিথ্যা। এই signed-unsigned মেশানোয় GCC -Wall-এ -Wsign-compare সতর্কবার্তা দেয়। সমাধান তিনটি: দুই পাশ একই রকম টাইপে রাখা, C++20-এর std::ssize(v) দিয়ে signed আকার নেওয়া, বা C++20-এর <utility>-এর std::cmp_less(a, b) — যা গাণিতিকভাবে সঠিক তুলনা করে।

C++20-এর তিন-মুখী তুলনা — <=>

দুটি মান তুলনার আসল প্রশ্ন একটাই: প্রথমটি কি ছোট, সমান, না বড়? C++20 এই তিন উত্তর একবারে দেওয়ার জন্য একটি নতুন অপারেটর এনেছে — three-way comparison a <=> b, যাকে দেখতে মহাকাশযানের মতো বলে ডাকনাম “spaceship operator”. এর ফলকে 0-এর সাথে মেলাতে হয়: (a <=> b) < 0 মানে a ছোট, == 0 মানে সমান, > 0 মানে বড়।

#include <compare>

auto r = 3 <=> 5;          // std::strong_ordering::less
bool smaller = (r < 0);   // true

সংখ্যার জন্য এটা হয়তো বাড়াবাড়ি মনে হচ্ছে — < তো আছেই। এর আসল শক্তি নিজের টাইপে: একটি <=> লিখলে (বা compiler-কে বানিয়ে নিতে বললে) compiler সেখান থেকেই <, >, <=, >= চারটি বানিয়ে নেয়। আগে ছয়টি অপারেটর আলাদা আলাদা হাতে লিখতে হতো। নিজের টাইপে কীভাবে লিখবেন, তা পর্ব ২৩ ও পর্ব ৪২-এ।

৫ · যুক্তি — &&, ||, ! আর short-circuit

বাস্তবের শর্ত প্রায়ই একাধিক শর্ত জোড়া দিয়ে তৈরি: “নম্বর ৩৩ বা বেশি এবং উপস্থিতি ৭৫% বা বেশি হলে পাস।” এগুলো জোড়ার জন্য তিনটি logical operator:

শেষ কলামটি অনেককে অবাক করে: C++-এ and, or, not ভাষারই অংশ, কোনো header লাগে না। খুব কম কোডে দেখবেন, তবে পড়তে পারা উচিত।

বাস্তব উদাহরণ: অধিবর্ষ

গ্রেগরিয়ান ক্যালেন্ডারে কোনো বছর অধিবর্ষ, যদি তা ৪ দিয়ে বিভাজ্য হয় কিন্তু ১০০ দিয়ে নয় — অথবা ৪০০ দিয়ে বিভাজ্য হয়। তাই ২০২৪ অধিবর্ষ, ১৯০০ নয়, ২০০০ অধিবর্ষ। বাংলা বাক্যটি প্রায় হুবহু C++-এ বসে যায়:

Short-circuit — দরকার না হলে ডান পাশ চলে না

&&-এর বাম পাশ মিথ্যা হলে পুরো উত্তর তো মিথ্যাই — ডান পাশ দেখার দরকার কী? C++ ঠিক এটাই করে: ডান পাশ চালায়ই না. একইভাবে ||-এর বাম পাশ সত্য হলে ডান পাশ বাদ। একে বলে short-circuit evaluation, আর C++ নিশ্চয়তা দেয় যে বাম পাশ সবসময় আগে, পুরোপুরি শেষ হয়ে তারপর ডান পাশ (যদি দরকার হয়)। এটা শুধু গতি বাড়ানোর কৌশল নয় — এটা দিয়ে বিপজ্জনক কাজ আটকানো যায়:

1int count = 0, total = 500;2if (count != 03    && total / count > 50)4    std::println("high average");5else std::println("skipped");6if (total / count > 50 && count != 0)

একই কৌশল সবখানে: i < v.size() && v[i] == target — আগে সীমা যাচাই, তারপর পড়া; p != nullptr && p->balance > 0 — আগে দেখে নেওয়া যে ঠিকানা আছে (pointer, পর্ব ১৫)। আর ||-এ: isCached(id) || loadFromServer(id) — ক্যাশে থাকলে সার্ভারে যাওয়াই হয় না।

bool আর int — পুরোনো আত্মীয়তা

C++-এ bool নিজস্ব টাইপ, কিন্তু সংখ্যার সাথে এর সম্পর্ক ঘনিষ্ঠ — এটা C থেকে আসা উত্তরাধিকার। হিসাবে গেলে true হয় 1, false হয় 0 — তাই true + true = 2 (একটি int). উল্টো দিকে, শর্তের জায়গায় যেকোনো সংখ্যা বসানো যায়: শূন্য মানে মিথ্যা, শূন্য ছাড়া সব (−৫ সহ) মানে সত্য। এই নিঃশব্দ বদলটি এক ধরনের implicit conversion. তাই if (count) মানে if (count != 0).

সুবিধাজনক, কিন্তু স্পষ্ট নয়। নতুন কোডে if (count != 0) লেখাই ভালো — পাঠক বোঝেন আপনি সংখ্যা যাচাই করছেন, আর if (count = 0)-এর মতো ভুল চোখে পড়ে। আরেকটি ছোট তথ্য: std::println("{}", true) ছাপে true, কিন্তু std::cout << true ছাপে 1 (যদি না std::boolalpha দেন) — পরের পর্বে এ নিয়ে আরও।

এবার অধিবর্ষ, short-circuit আর নিরাপদ signed-unsigned তুলনা — তিনটি একসাথে চালিয়ে দেখুন:

#include <initializer_list>
#include <print>
#include <utility>

bool isLeap(int y) {
    return (y % 4 == 0 && y % 100 != 0) || y % 400 == 0;
}

int main() {
    for (int y : {1900, 2000, 2024, 2026})
        std::println("{}: {}", y, isLeap(y) ? "leap year" : "not leap");

    int count = 0, total = 500;
    if (count != 0 && total / count > 50) std::println("high average");
    else std::println("count is 0, division skipped");

    unsigned int size = 3;
    std::println("-1 < size? {}", std::cmp_less(-1, size));
}

৬ · Bitwise অপারেটর — প্রতিটি বিট আলাদা করে

এখন পর্যন্ত অপারেটরগুলো পুরো সংখ্যা নিয়ে কাজ করেছে। bitwise operator কাজ করে সংখ্যার ভেতরের প্রতিটি বিট নিয়ে, আলাদা আলাদা করে: & (দুটি বিটই 1 হলে 1), | (যেকোনো একটি 1 হলে 1), ^ (ঠিক একটি 1 হলে 1, XOR), ~ (সব বিট উল্টে দেওয়া), আর <<, >> (বিটগুলো বামে বা ডানে সরানো)।

বাস্তবে এর একটি সুন্দর ব্যবহার — অনেকগুলো হ্যাঁ/না তথ্য একটি ছোট সংখ্যায় রাখা। প্রতিটি বিট একটি “সুইচ”। এমন সংখ্যাকে বলে bitmask. Linux-এ ফাইলের read/write/execute অনুমতি ঠিক এভাবেই রাখা হয়। ধাপে ধাপে দেখুন:

READ  = 1 = 001
WRITE = 2 = 010
EXEC  = 4 = 100
একই কথা শিফট দিয়ে: 1u << 0, 1u << 1, 1u << 2

  001   (READ)
| 010   (WRITE)
  ---
  011   perm = 3

  011 & 010 = 010  -> not 0 -> WRITE allowed
  011 & 100 = 000  -> 0     -> EXEC denied

 ~010 = 101   (WRITE ছাড়া বাকি সব 1)
  011 & 101 = 001   perm = 1 (শুধু READ)

  001 ^ 100 = 101   EXEC চালু (perm = 5)
  101 ^ 100 = 001   আবার চালালে বন্ধ
Linux: chmod 754 = rwx r-x r-- (7 = 111, 5 = 101, 4 = 100)

Bitwise কাজে সবসময় unsigned টাইপ নিন — signed সংখ্যার চিহ্ন-বিট নিয়ে নানা সূক্ষ্মতা আছে। আর বিটের সংখ্যার সমান বা বেশি ঘর শিফট করা (যেমন ৩২-বিট int-এ x << 32) undefined behavior. বিট নিয়ে পুরো গভীর আলোচনা — মাস্ক, শিফট, বিট গোনা — C কোর্সের bitwise operation পর্বে আছে; নিয়মগুলো C++-এও একই। আধুনিক C++-এ std::bitset আর C++20-এর <bit> header-ও আছে (<bit>-এর পরিচয় পর্ব ৪১-এর লাইব্রেরি ভ্রমণে)।

৭ · Precedence আর associativity — কোনটা আগে

স্কুলে শিখেছেন “ভাগ-গুণ আগে, যোগ-বিয়োগ পরে”। C++-এও এমন নিয়ম আছে, শুধু অপারেটর অনেক বেশি। কোন অপারেটর আগে তার operand-গুলোকে “আঁকড়ে ধরে”, তার নাম precedence. আর একই স্তরের অপারেটর পাশাপাশি থাকলে বাম থেকে না ডান থেকে জোড়া হবে, তার নাম associativity. যেমন 10 - 4 - 3 = (10 - 4) - 3 = 3 (বাম থেকে), কিন্তু a = b = 0 = a = (b = 0) (ডান থেকে)।

পুরো টেবিল মুখস্থের দরকার নেই। তিনটি জিনিস মনে রাখলেই চলে: গণিত তুলনার আগে, তুলনা &&/||-এর আগে, আর assignment প্রায় সবার শেষে। এবার একটি মিশ্র expression ধাপে ধাপে ভাঙা যাক:

5 + 3 * 2 > 10 && 8 % 3 == 2
সবচেয়ে উঁচু স্তর: * আর %

5 + 6 > 10 && 2 == 2
এবার +

11 > 10 && 2 == 2
এবার > (ছোট-বড় তুলনা, == এর চেয়ে উঁচু)

true && 2 == 2
এবার ==

true && true
এবার &&

ok = true
পুরো কাঠামো: ((5 + (3 * 2)) > 10) && ((8 % 3) == 2)

যেখানে precedence ঠকায়

টেবিলের স্তর ৯ খেয়াল করুন: bitwise & তুলনা ==-এর নিচে. তাই জোড় যাচাইয়ের জন্য লেখা x & 1 == 0 আসলে পড়া হয় x & (1 == 0) = x & 0 = 0 — সবসময় মিথ্যা, x যা-ই হোক! এটা C থেকে আসা একটি ঐতিহাসিক দুর্ঘটনা (ভাবনার প্রশ্ন ১-এ গল্পটি আছে)। GCC -Wall-এ এখানে সতর্ক করে: suggest parentheses around comparison in operand of '&'.

আরেকটি: std::cout << a & b; — << (স্তর ৫) &-এর চেয়ে উঁচু, তাই এটা হয় (std::cout << a) & b, যা compile error. std::cout-এর << আসলে শিফটের অপারেটর, শুধু নতুন কাজ দেওয়া (অংশ ৮) — তাই শিফটের precedence-ই পায়।

৮ · Ternary, comma আর নিজের অপারেটর

Ternary ?: — এক লাইনের সিদ্ধান্ত

ternary operator লেখা হয় শর্ত ? মান১ : মান২ — শর্ত সত্য হলে প্রথম মান, মিথ্যা হলে দ্বিতীয়। এটি একটি expression, তাই এর ফল সরাসরি ভ্যারিয়েবলে রাখা যায়, এমনকি const ভ্যারিয়েবলেও: const int fee = isStudent ? 50 : 100;. if-else দিয়ে লিখলে fee-কে আগে খালি বানিয়ে পরে বদলাতে হতো, const করা যেত না।

Ternary ডান থেকে বামে জোড়া হয়, তাই কয়েকটি পরপর বসানো যায়। বাংলাদেশের SSC/HSC গ্রেড পদ্ধতির একটি অংশ:

const char* grade = (marks >= 80) ? "A+"
                  : (marks >= 70) ? "A"
                  : (marks >= 60) ? "A-"
                  : (marks >= 33) ? "pass"
                  :                 "F";

এভাবে সাজিয়ে লিখলে টেবিলের মতো পড়া যায়। কিন্তু এক লাইনে তিন-চারটি ternary গুঁজে দিলে কেউ পড়তে পারবে না — তখন if-else ভালো (পর্ব ০৮)। দুটি শাখার টাইপ একই রকম রাখুন; একটি int আর অন্যটি double হলে পুরো ফল double হয়ে যায়।

Comma অপারেটর — কম দেখবেন

comma operator a, b আগে a চালায়, তার ফল ফেলে দেয়, তারপর b চালিয়ে b-এর মান দেয়। প্রায় একমাত্র জায়গা যেখানে এটা স্বাভাবিক, তা হলো for লুপে দুটি ভ্যারিয়েবল একসাথে বদলানো: for (int i = 0, j = n - 1; i < j; ++i, --j) — এখানে ++i, --j comma অপারেটর। (int i = 0, j = n - 1-এর comma কিন্তু অপারেটর নয়, শুধু একাধিক ভ্যারিয়েবল ঘোষণার চিহ্ন।)

অন্য জায়গায় এটা মূলত বিভ্রান্তি তৈরি করে। int x = (1, 2); — x হয় 2. আর arr[i, j] লিখে অনেকে ভাবতেন দুই-মাত্রার array-র ঘর পড়ছেন, আসলে পড়তেন arr[j]. এই কারণে C++20 []-এর ভেতরে comma অপারেটর ব্যবহার deprecated করে, আর C++23 এই লেখাটিকে নতুন অর্থ দেয় — একাধিক সূচক নেওয়া operator[].

নিজের টাইপে অপারেটর — একটি ঝলক

একটি প্রশ্ন ভাবুন: std::string তো ভাষার মৌলিক টাইপ নয়, লাইব্রেরির একটি class. তাহলে "Dhaka"s + " Metro"-তে + কীভাবে কাজ করে? আর std::cout << x-এ শিফটের << কীভাবে ছাপার কাজ করে? উত্তর: C++-এ নিজের টাইপের জন্য অপারেটরের নতুন অর্থ দেওয়া যায় — একে বলে operator overloading. পর্ব ২৩-এ আপনি নিজের Money টাইপে + আর == লিখবেন। দুটি নিয়ম এখনই জেনে রাখুন: precedence বদলানো যায় না (নিজের <<-ও শিফটের স্তরেই থাকে), আর নিজের লেখা && বা || short-circuit করে না — তাই এ দুটি প্রায় কেউ overload করেন না।

৯ · AI-এর যুগে — অপারেটরের ভুল চোখে ধরা

অপারেটরের ভুলগুলো ছোট — এক অক্ষর, এক বন্ধনী। আর ঠিক এই কারণে বিপজ্জনক: কোড compile হয়, বেশিরভাগ ইনপুটে ঠিক চলে, শুধু একটি বিশেষ ক্ষেত্রে (ঋণাত্মক সংখ্যা, শূন্য, খালি তালিকা) ভুল ফল দেয়। AI টুল বিশাল পরিমাণ পুরোনো কোড থেকে শেখে, তাই সেই কোডের প্রচলিত ভুলগুলোও মাঝে মাঝে ফিরিয়ে আনে। AI-এর লেখা কোডে যা খুঁজবেন:

AI-এর কোডে অপারেটর যাচাইয়ের চেকলিস্ট

• প্রতিটি if/while-এর শর্তে = নয়, == আছে কি না দেখেছি
• প্রতিটি / আর %-এর জন্য জিজ্ঞেস করেছি: দুই পাশই কি int? ভাজক কি শূন্য হতে পারে? ঋণাত্মক হলে কী হবে?
• &&/||-এর বাম পাশে পাহারাদার শর্ত (শূন্য, সীমা, nullptr) আগে আছে
• bitwise অপারেটর তুলনার সাথে মিশলে বন্ধনী আছে
• .size()-এর সাথে signed সংখ্যার তুলনা বা বিয়োগ নেই
• -Wall -Wextra দিয়ে compile করে প্রতিটি warning পড়েছি — -Wparentheses আর -Wsign-compare এই ভুলগুলোর অনেকটাই ধরে