operator overloading — নিজের টাইপে +, == আর <<

১ · সমস্যাটা আগে — নিজের টাইপ কেন built-in-এর মতো হবে?

পর্ব ২০ থেকে ২২-এ আপনি নিজের class বানাতে শিখেছেন — constructor, destructor, copy আর move সহ। এখন ধরুন একটি চায়ের দোকানের হিসাবের সফটওয়্যার লিখছেন। টাকার হিসাব double-এ রাখা বিপজ্জনক, কারণ floating-point সংখ্যা 0.1-এর মতো দশমিক ঠিকঠাক ধরতে পারে না; লাখ লাখ লেনদেনে পয়সার গরমিল জমে যায়। তাই আপনি একটি Money class বানালেন, যা ভেতরে সব টাকা পয়সায়, পূর্ণসংখ্যা হিসেবে রাখে: ১৫ টাকা মানে 1500 পয়সা, ১২ টাকা ৫০ পয়সা মানে 1250.

class তো হলো, এবার ব্যবহার। দুই কাপ চা আর একটি শিঙাড়ার দাম যোগ করতে হলে, operator ছাড়া লিখতে হয় এরকম:

Money bill = add(add(tea, tea), samosa);          // ফাংশন দিয়ে
if (lessThan(bill, wallet)) pay(bill);

Money bill = tea + tea + samosa;                  // operator দিয়ে
if (bill < wallet) pay(bill);

দুটি একই কাজ করে, কিন্তু দ্বিতীয়টি পড়তে অনেক সহজ। প্রথমটিতে বন্ধনী গুনতে হয়, ভাবতে হয় add-এর প্রথম প্যারামিটার কোনটা। দ্বিতীয়টি দেখলেই স্কুলের অঙ্কের মতো বোঝা যায়। int বা double-এর সাথে আপনি এভাবেই লেখেন — তাহলে নিজের টাইপের সাথে কেন পারবেন না? C++-এর উত্তর: পারবেন। একই operator-কে নিজের টাইপের জন্য নতুন অর্থ দেওয়াকে বলে operator overloading.

কোথায় অর্থ স্পষ্ট? যেখানে আপনার টাইপটি আসলে একটি “মান” (value semantics) — সংখ্যার মতো, যার যোগ-বিয়োগ-তুলনার একটি সর্বজনীন মানে আছে। টাকা, ভগ্নাংশ, বড় সংখ্যা (BigInt), জটিল সংখ্যা, 2D বা 3D vector, matrix, তারিখ ও সময়ের ব্যবধান। আবার যেখানে টাইপটি একটি পাত্র (container), সেখানে [] দিয়ে ভেতরের উপাদান ধরা স্পষ্ট — আপনি পর্ব ১৩-এ std::vector-এ এভাবেই v[i] লিখেছেন, আর সেটিও একটি overload করা operator.

২ · operator আসলে একটি ফাংশন — বিশেষ নাম সহ

পুরো বিষয়টার রহস্য ভাঙার জন্য একটি বাক্যই যথেষ্ট: C++-এ overload করা প্রতিটি operator একটি সাধারণ ফাংশন, যার নাম operator শব্দের পরে চিহ্নটি। +-এর ফাংশনের নাম operator+, তুলনার operator==, ছাপার operator<<. এর parameter আছে, return type আছে, এটি function overloading-এর সব নিয়ম মানে (পর্ব ৯) — শুধু ডাকার ভঙ্গিটা আলাদা। আপনি নাম লিখে ডাকেন না, চিহ্ন বসান; compiler নিজেই নামে বদলে নেয়।

Money operator+(Money a, const Money& b);   // একটি সাধারণ ফাংশনের ঘোষণা

Money x = tea + samosa;              // আপনি যা লেখেন
Money y = operator+(tea, samosa);    // compiler যা বোঝে — এটাও বৈধ C++

দ্বিতীয় লাইনটি কেউ লেখে না, কিন্তু লিখলেও চলবে। এটা জানলে অনেক ভয় কেটে যায়: operator overloading শেখা মানে নতুন ভাষা শেখা নয়, আপনার জানা ফাংশনেরই আরেকটি রূপ। tea + samosa দেখে compiler ঠিক কী কী করে, ধাপে ধাপে দেখুন:

Money tea(15);          // ভেতরে 1500 পয়সা
Money samosa(12, 50);   // ভেতরে 1250 পয়সা
Money x = tea + samosa;

tea.operator+(samosa)      // ১. Money-র member? (নেই)
operator+(tea, samosa)     // ২. non-member? (আছে — Money-র friend)
int + int, double + double // ৩. built-in — Money-র সাথে মেলে না

Money operator+(Money, const Money&)   ✔ নিখুঁত মিল
(অন্য কোনো operator+ থাকলে এখানে তুলনা হতো;
 দুটি সমান ভালো হলে — ambiguous call error)

Money x = operator+(tea, samosa);
// a = tea-র কপি, b = samosa-র reference

tea    → 1500 পয়সা   (অপরিবর্তিত)
samosa → 1250 পয়সা   (অপরিবর্তিত)
x      → 2750 পয়সা   (নতুন object)

যা বদলানো যায়, আর যা যায় না

operator overload করলে আপনি শুধু অর্থ বদলান। ভাষার ব্যাকরণ একই থাকে। precedence (কে আগে হিসাব হবে), associativity (বাঁ থেকে না ডান থেকে), আর কতটি operand লাগবে — এগুলো পর্ব ৬-এর built-in নিয়মেই আটকে থাকে। তাই a + b * c সবসময় a + (b * c), আপনার টাইপ যা-ই হোক।

৩ · member না non-member? symmetry আর hidden friend

একটি operator দুইভাবে লেখা যায়। member function হিসেবে লিখলে বাঁ দিকের operand হয় *this (পর্ব ২০-এর this), আর প্যারামিটার থাকে একটি কম। non-member বা free function হিসেবে লিখলে দুটি operand-ই সাধারণ প্যারামিটার।

struct Vec2 {
    int x, y;
    Vec2 operator*(int k) const { return {x * k, y * k}; }   // member: v * 2 → v.operator*(2)
};
Vec2 operator*(int k, Vec2 v) { return v * k; }             // non-member: 2 * v → operator*(2, v)

একটি গেমের কথা ভাবুন। একটি চরিত্রের গতি speed, আর ২ সেকেন্ডে সে কতদূর যাবে — speed * 2. পদার্থবিজ্ঞানের বইয়ে লেখা থাকে 2 * speed. দুটির অর্থ এক, তাই দুটিই চলা উচিত। কিন্তু member দিয়ে শুধু প্রথমটি হয়: 2 * speed-এর বাঁ দিকে int, আর int-এর ভেতরে আপনি কোনো member যোগ করতে পারবেন না। বাঁ দিকের operand যখন আপনার টাইপ নয়, তখন non-member ছাড়া উপায় নেই। এই দুই দিকেই সমান আচরণের নাম symmetry.

একই সমস্যা আরও সূক্ষ্মভাবে আসে implicit conversion-এ। ধরুন একটি Fraction class-এ int থেকে রূপান্তর চলে (constructor explicit নয়)। member operator+ হলে half + 1 চলে (ডান দিকের 1 Fraction-এ রূপান্তরিত হয়), কিন্তু 1 + half চলে না — কারণ C++ member ডাকার জন্য বাঁ দিকের object-কে রূপান্তর করে না। non-member হলে দুটিই চলে। এমন অসম আচরণ ব্যবহারকারীকে বিভ্রান্ত করে।

Hidden friend — class-এর ভেতরে লেখা non-member

non-member ফাংশনের প্রায়ই class-এর private ডেটা লাগে — Money-র ভেতরের পয়সা তো private. পথ হলো friend: class নিজে ঘোষণা দেয়, “এই ফাংশনটি আমার private অংশ দেখতে পারবে।” আধুনিক C++-এ সবচেয়ে পছন্দের রূপ হলো ফাংশনটিকে class-এর ভেতরেই friend হিসেবে সংজ্ঞায়িত করা — একে বলে hidden friend:

class Money {
    long long poisha_;
public:
    friend Money operator+(Money a, const Money& b) {   // ভেতরে লেখা, তবু member নয়
        a.poisha_ += b.poisha_;
        return a;
    }
};

“hidden” কেন? কারণ এই ফাংশনটি সাধারণ নাম-খোঁজায় (name lookup) দেখা যায় না; compiler এটিকে খুঁজে পায় শুধু তখন, যখন অন্তত একটি আর্গুমেন্ট Money — ADL-এর মাধ্যমে। এর তিনটি সুবিধা: (১) প্রতিটি + লেখার সময় compiler-কে হাজারটা অপ্রাসঙ্গিক operator+ যাচাই করতে হয় না, তাই compile দ্রুত হয় আর error message ছোট হয়; (২) অপ্রত্যাশিত রূপান্তরে ভুল ফাংশন বাছাইয়ের ঝুঁকি কমে; (৩) operator-টি class-এর পাশেই থাকে, খুঁজতে হয় না। অনেক আধুনিক লাইব্রেরি, আর standard library-র নতুন কিছু অংশ, এই রীতি ব্যবহার করে।

এবার একটি পুরো ছোট উদাহরণ — গেমের 2D vector, যেখানে 2 * speed আর speed * 3 দুটিই চলে। চালিয়ে দেখুন:

#include <print>

struct Vec2 {                                  // 2D vector for a game
    int x = 0, y = 0;
    Vec2& operator+=(Vec2 o) { x += o.x; y += o.y; return *this; }
    friend Vec2 operator+(Vec2 a, Vec2 b) { a += b; return a; }
    friend Vec2 operator*(int k, Vec2 v) { return {k * v.x, k * v.y}; }
    friend Vec2 operator*(Vec2 v, int k) { return k * v; }   // symmetry
    bool operator==(const Vec2&) const = default;
};

int main() {
    Vec2 pos{10, 5}, speed{3, -2};
    pos += 2 * speed;                          // 2 seconds of movement
    Vec2 far = pos + speed * 3;
    std::println("pos = ({}, {})", pos.x, pos.y);
    std::println("far = ({}, {})", far.x, far.y);
    std::println("pos == (16, 1)? {}", pos == Vec2{16, 1});
}

৪ · গাণিতিক operator — আগে +=, তার ওপর +

built-in টাইপে a += b আর a = a + b একই ফল দেয়। আপনার টাইপেও তাই হওয়া উচিত — নইলে পাঠক বিভ্রান্ত হবেন। দুটিকে আলাদাভাবে লিখলে একদিন একটিতে ভুল ঠিক করবেন, অন্যটিতে ভুলে যাবেন, আর দুটি আলাদা ফল দেবে। তাই প্রচলিত রীতি: আসল হিসাব থাকবে compound assignment +=-এ, আর + হবে তার ওপর তিন লাইনের মোড়ক।

class Money {
    long long poisha_ = 0;
public:
    Money& operator+=(const Money& o) {          // member: নিজেকে বদলায়
        poisha_ += o.poisha_;
        return *this;                             // নিজের reference ফেরত
    }
    friend Money operator+(Money a, const Money& b) {   // a আগে থেকেই কপি
        a += b;
        return a;
    }
};

দুটি signature-ই ভেবেচিন্তে বানানো। += ফেরত দেয় Money& — নিজের reference, কপি নয়। কারণ built-in +=-ও তাই করে: (x += 2) *= 3 লিখলে দুটি কাজই x-এর ওপর হয়। আর +-এর প্রথম প্যারামিটার ইচ্ছা করে by value: কপি তো আমাদের লাগতই (নতুন ফল বানাতে), তাই সেটা প্যারামিটারেই নিয়ে নিলাম। ডাকার জায়গায় যদি একটি temporary object থাকে (যেমন tea + samosa + samosa-এর মাঝের ফল), তবে কোনো কপিই হয় না — C++17-এর নিয়মে সেই temporary সরাসরি প্যারামিটারেই তৈরি হয়। দ্বিতীয় প্যারামিটার শুধু পড়া হয়, তাই const reference.

একটি সূক্ষ্ম বিষয়: return a += b; এক লাইনে লেখা যেত, কিন্তু তখন ফেরত যায় একটি reference (a += b-এর ফল), আর compiler সেটিকে কপি করে — নিজে থেকে move করে না। আলাদা দুই লাইনে return a; লিখলে compiler জানে a একটি local প্যারামিটার, তাই ফেরত দেওয়ার সময় move করতে পারে। ছোট টাইপে পার্থক্য নেই, বড় টাইপে (BigInt, Matrix) আছে। পুরো প্রক্রিয়াটি ধাপে ধাপে দেখুন:

1Money& operator+=(const Money& o) {2    poisha_ += o.poisha_;3    return *this;4}5friend Money operator+(Money a, const Money& b) {6    a += b;7    return a;8}9Money bill = tea + samosa;

বিয়োগ, গুণ, ভাগ — সব একই ছাঁচে: -= থেকে -, *= থেকে *. তবে প্রতিটি operator-এর জন্য নিজেকে জিজ্ঞেস করুন: এর অর্থ কি সত্যিই স্পষ্ট? Money - Money স্পষ্ট (ফেরত টাকা)। Money * int স্পষ্ট (তিন কাপ চা)। কিন্তু Money * Money — টাকা গুণ টাকা মানে “বর্গটাকা”, যার কোনো বাস্তব অর্থ নেই। তাই সেটি লিখবেনই না; কেউ ভুল করে লিখলে compile error-ই হবে আপনার সুরক্ষা। যে operator অর্থহীন, তা না থাকাটাই একটি ফিচার। একইভাবে unary - (যেমন -refund) স্পষ্ট, তাই সেটি দেওয়া যায়।

৫ · তুলনা — C++20-এর spaceship operator <=>

C++20-এর আগে Money-কে পুরোপুরি তুলনাযোগ্য করতে ছয়টি ফাংশন লিখতে হতো: ==, !=, <, <=, >, >=. সাধারণত == আর < আসল কাজ করত, বাকি চারটি তাদের ডাকত। ছয়টি ফাংশন, প্রতিটিতে ভুলের সুযোগ — কেউ একটিতে <-এর বদলে <= লিখলেই std::sort বা std::map অদ্ভুত আচরণ করত। আর class-এ নতুন সদস্য যোগ করলে ছয়টিই হালনাগাদ করতে হতো।

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

#include <compare>

class Money {
    long long poisha_ = 0;
public:
    auto operator<=>(const Money&) const = default;   // এই এক লাইনেই ছয়টি তুলনা
};

= default মানে compiler সদস্যগুলোকে ঘোষণার ক্রমে একে একে তুলনা করবে — প্রথম যেখানে পার্থক্য, সেখানেই ফল ঠিক (অভিধানের মতো, lexicographic order). আর <=> default করলে compiler নিজে থেকে একটি defaulted operator==-ও ঘোষণা করে দেয়। এই এক লাইন থেকে ছয়টি তুলনা কীভাবে আসে, দেখুন:

auto operator<=>(const Money&) const = default;
// ফেরতের টাইপ: std::strong_ordering (long long সদস্যের জন্য)

bool operator==(const Money&) const = default;   // compiler নিজে যোগ করে
tea == samosa   →  1500 == 1250  →  false

tea != samosa   →  !(tea == samosa)  →  true

bill < paid   →  (bill <=> paid) < 0
             →  (4000 <=> 5000) হলো less  →  true

bill >= paid  →  (bill <=> paid) >= 0  →  false
x < y         →  মিল না পেলে 0 < (y <=> x) — উল্টো প্রার্থী

== != < <= > >=   সব চলে
std::sort, std::map<Money, ...>, std::ranges::max — সব চলে

strong, weak, partial — তিন রকম ক্রম

<=>-এর ফেরতের টাইপ তিন রকম হতে পারে, আর পার্থক্যটা গণিতের চেয়ে দৈনন্দিন উদাহরণে সহজে বোঝা যায়:

auto দিলে compiler সদস্যদের মধ্যে সবচেয়ে দুর্বল ক্রমটি বেছে নেয়। Money-তে double সদস্য রাখলে <=> হয়ে যেত partial — আরেকটি কারণ, টাকা কেন পূর্ণসংখ্যায় রাখবেন। আর নিজে হাতে <=> লিখতে হলে (যেমন শুধু কিছু সদস্য দিয়ে তুলনা), ফেরতের টাইপ স্পষ্ট করে লিখুন, যাতে পাঠক জানেন আপনি কোন প্রতিশ্রুতি দিচ্ছেন। spaceship নিয়ে আরও গভীর কথা পর্ব ৪২-এ।

৬ · ছাপা — operator<< আর std::formatter

নিজের টাইপ std::cout << bill দিয়ে ছাপতে চাইলে << overload করতে হয়, যাকে stream-এর প্রসঙ্গে বলে insertion operator. এর বাঁ দিকে থাকে std::ostream (cout-এর টাইপ), যা standard library-র class — আপনি তাতে member যোগ করতে পারবেন না। তাই এটি সবসময় non-member, সাধারণত hidden friend:

friend std::ostream& operator<<(std::ostream& os, const Money& m) {
    return os << "Tk " << m.poisha_ / 100 << '.' << m.poisha_ % 100;   // (শূন্য-প্যাডিং পরে ঠিক করব)
}

signature-টি মুখস্থ রাখার মতো: প্রথম প্যারামিটার আর ফেরতের টাইপ দুটিই std::ostream&. stream কপি করা যায় না, আর কপি করার কোনো মানেও নেই — আমরা একই cout-এ লিখতে চাই। আর ফেরত দিতে হয় সেই একই stream, কারণ তা না হলে std::cout << "bill = " << bill << '\n'-এর মতো চেইন ভেঙে যায়। চেইনটি কীভাবে কাজ করে, দেখুন:

std::cout   // টাইপ std::ostream, স্ক্রিনের সাথে যুক্ত

operator<<(std::cout, "bill = ")
// library-র ফাংশন; লিখে ফেরত দেয় std::cout-এর reference

operator<<( operator<<(std::cout, "bill = "), bill )
// ভেতরেরটির ফল = std::cout&, তাই os = cout; আমরা লিখি "Tk 40.00", ফেরত os

operator<<( operator<<( operator<<(std::cout, "bill = "), bill ), '\n' )
// স্ক্রিনে: bill = Tk 40.00

void operator<<(std::ostream& os, const Money& m);
std::cout << bill << '\n';
error: no match for 'operator<<' (operand types are 'void' and 'char')

এবার পুরো Money class একসাথে — যোগ, বিয়োগ, তুলনা আর ছাপা। শূন্য-প্যাডিং (12.05, 12.5 নয়) ঠিক করতে ভেতরে std::format-এর {:02} ব্যবহার করেছি। চালিয়ে দেখুন:

#include <format>
#include <iostream>
class Money {
    long long poisha_ = 0;                     // 1 taka = 100 poisha
public:
    explicit Money(long long taka, long long poisha = 0) : poisha_(taka * 100 + poisha) {}
    Money& operator+=(const Money& o) { poisha_ += o.poisha_; return *this; }
    Money& operator-=(const Money& o) { poisha_ -= o.poisha_; return *this; }
    friend Money operator+(Money a, const Money& b) { a += b; return a; }
    friend Money operator-(Money a, const Money& b) { a -= b; return a; }
    auto operator<=>(const Money&) const = default;
    friend std::ostream& operator<<(std::ostream& os, const Money& m) {
        return os << std::format("Tk {}.{:02}", m.poisha_ / 100, m.poisha_ % 100);
    }
};

int main() {
    Money tea(15), samosa(12, 50), paid(50);
    Money bill = tea + samosa + samosa;
    std::cout << "bill = " << bill << ", change = " << paid - bill << '\n';
    std::cout << std::boolalpha << (bill <= paid) << ' ' << (tea == samosa) << '\n';
}

std::println-এর জন্য — std::formatter

পর্ব ৭-এ দেখেছেন, আধুনিক C++-এ ছাপার পছন্দের উপায় std::println (C++23 থেকে)। কিন্তু std::println("{}", bill) লিখলে compile error — format লাইব্রেরি << ব্যবহার করে না। তাকে শেখাতে হয় std::formatter-এর একটি template specialization দিয়ে (template নিয়ে বিস্তারিত পর্ব ২৮-২৯-এ; এখানে ছাঁচটি দেখে রাখুন):

template <>
struct std::formatter<Vec2> : std::formatter<std::string> {     // string-এর নিয়ম ধার নিই
    auto format(Vec2 v, std::format_context& ctx) const {
        return std::formatter<std::string>::format(std::format("({}, {})", v.x, v.y), ctx);
    }
};

std::println("pos = {}", pos);        // pos = (16, 1)
std::println("[{:>10}]", pos);       // [   (16, 1)] — প্রস্থ, alignment-ও চলে

std::formatter<std::string> থেকে উত্তরাধিকার নেওয়ায় (inheritance, পরের পর্ব) {:>10}-এর মতো প্রস্থ ও alignment-এর নিয়ম বিনা পরিশ্রমে পাওয়া গেল। কোনটি লিখবেন? নতুন কোডে std::formatter — এটি type-safe, দ্রুত, আর std::format, std::print, std::println সবখানে চলে। পুরোনো কোড বা লাইব্রেরির সাথে মেলাতে operator<<. বড় প্রজেক্টে প্রায়ই দুটোই থাকে, আর একটি অন্যটিকে ডাকে, যাতে ছাপার নিয়ম এক জায়গায় থাকে।

৭ · সূচক, ডাকা আর গোনা — [], () আর ++

operator[] — দুই রূপে

একটি বাসের টিকিট-ব্যবস্থায় Bus class আসনগুলোর যাত্রীর নাম রাখে। bus[3] দিয়ে ৩ নম্বর আসনের যাত্রী দেখা বা বদলানো স্পষ্ট — ঠিক vector-এর মতো। subscript operator সাধারণত দুটি রূপে লেখা হয়:

class Bus {
    std::vector<std::string> seats_;
public:
    std::string&       operator[](std::size_t i)       { return seats_[i]; }   // বদলানো যায়
    const std::string& operator[](std::size_t i) const { return seats_[i]; }   // শুধু পড়া
};

bus[3] = "Rahim";               // non-const রূপ: reference ফেরত বলে মান বসানো যায়
void show(const Bus& b) { std::println("{}", b[3]); }   // const রূপ

কেন দুটি? non-const রূপ reference ফেরত দেয়, তাই bus[3] = "Rahim" সরাসরি ভেতরের string বদলায় — কপি ফেরত দিলে বদল হতো কপিতে, আসল আসনে নয়। আর const Bus& হাতে থাকলে শুধু const ফাংশন ডাকা যায় (পর্ব ২০), তাই দ্বিতীয় রূপটি না থাকলে show ফাংশনটি compile হতো না। দুটি রূপের মধ্যে compiler নিজেই বেছে নেয় object const কি না দেখে।

আরেকটি বিষয়: std::vector-এর মতো আপনার []-ও সীমা যাচাই না করলে ভুল সূচকে undefined behavior. চাইলে একটি আলাদা at() দিন, যা যাচাই করে exception ছোড়ে — standard library-র রীতি মেনে।

operator() — matrix আর functor

একটি matrix-এ সারি আর কলাম — দুটি সূচক লাগে। C++23-এর আগে [] শুধু একটি আর্গুমেন্ট নিত, তাই matrix লাইব্রেরিগুলো (যেমন Eigen) বহু বছর ধরে function call operator () ব্যবহার করে আসছে:

class Matrix {
    int rows_, cols_;
    std::vector<int> data_;                          // সব মান এক সারিতে (row-major)
public:
    Matrix(int r, int c) : rows_(r), cols_(c), data_(r * c) {}
    int& operator()(int r, int c)       { return data_[r * cols_ + c]; }
    int  operator()(int r, int c) const { return data_[r * cols_ + c]; }
};

Matrix m(3, 4);
m(1, 2) = 7;              // সারি 1, কলাম 2

ভেতরে ডেটা একটি একটানা vector-এ row-major ক্রমে, যা cache-এর জন্য ভালো (পর্ব ১৩)। C++23 থেকে operator[]-ও একাধিক আর্গুমেন্ট নিতে পারে, তাই m[1, 2] লেখাও সম্ভব — std::mdspan এভাবেই কাজ করে। তবে () এখনো সবখানে চলে, আর পুরোনো compiler-এও।

()-এর আরও বড় ব্যবহার হলো function object বা functor — এমন object, যাকে ফাংশনের মতো ডাকা যায়, কিন্তু যার নিজের অবস্থা (state) থাকতে পারে। ধরুন একটি দোকানে নির্দিষ্ট দামের বেশি পণ্য গুনতে হবে, আর সীমাটা চলার সময় ঠিক হয়:

struct PriceAbove {
    Money limit;
    bool operator()(const Item& it) const { return it.price > limit; }
};

auto n = std::ranges::count_if(items, PriceAbove{Money(500)});   // ৫০০ টাকার বেশি কয়টি?

PriceAbove{Money(500)} একটি object, যে নিজের ভেতরে সীমাটি মনে রাখে, আর count_if প্রতিটি পণ্যের জন্য তাকে ডাকে। STL algorithm-গুলো (পর্ব ৩৩) এমন functor দিয়েই কাস্টমাইজ করা হয়। আর পর্ব ৩৪-এর lambda আসলে এই একই জিনিসের সংক্ষিপ্ত রূপ — compiler প্রতিটি lambda থেকে গোপনে এমন একটি class বানায়, যার ভেতরে একটি operator(). আজ যা শিখলেন, তা-ই lambda-র ভিত্তি।

++ — prefix আর postfix

++ আর ---এর দুটি রূপ (পর্ব ৬-এর increment ও decrement): ++c (আগে বাড়াও, নতুন মান দাও) আর c++ (পুরোনো মান দাও, তারপর বাড়াও)। দুটির নামই operator++, তাই আলাদা করতে C++ একটি পুরোনো কৌশল ব্যবহার করে — postfix রূপে একটি অব্যবহৃত int প্যারামিটার:

class TicketCounter {
    int next_ = 1;
public:
    TicketCounter& operator++() { ++next_; return *this; }        // prefix: ++c
    TicketCounter operator++(int) {                                // postfix: c++
        TicketCounter old = *this;                                 // পুরোনো অবস্থার কপি
        ++*this;                                                   // prefix-কেই ডাকি
        return old;                                                // কপি ফেরত — by value
    }
};

এখানেও আগের নীতি: আসল কাজ এক জায়গায় (prefix), postfix তার ওপর মোড়ক — ঠিক += আর +-এর মতো। আর লক্ষ করুন, postfix রূপকে একটি কপি বানাতে হয়। তাই নিজের টাইপে (আর iterator-এ) ফল ব্যবহার না করলে ++c লেখার অভ্যাস করুন। int-এ compiler পার্থক্য মুছে দেয়, বড় object-এ সবসময় পারে না।

৮ · রূপান্তর, explicit operator bool আর যা overload করবেন না

Conversion operator — সাবধানে

একটি class অন্য টাইপে রূপান্তরিত হওয়ার নিয়মও দিতে পারে, conversion operator দিয়ে: operator long long() const. এর কোনো ফেরতের টাইপ লেখা হয় না — নামটিই টাইপ। কিন্তু এটি খুব বিপজ্জনক হাতিয়ার। Money-তে এমন একটি রূপান্তর দিলে ঘটে এসব:

class Money { /* ... */ public: operator long long() const { return poisha_; } };

Money price(100);
auto x = price + 5;      // compile হয়! ফল long long 10005 — ৫ টাকা, না ৫ পয়সা? কেউ জানে না
if (price == 10000) {}   // compile হয়, পয়সায় তুলনা — পাঠক ভাববেন টাকায়
int n = price;           // নিঃশব্দে পয়সায় রূপান্তর

অংশ ৬-এ explicit constructor দিয়ে যে সুরক্ষা বানিয়েছিলাম, এক লাইনের implicit রূপান্তর তা ভেঙে দিল। নিয়ম তাই সহজ: রূপান্তর লাগলে নামওয়ালা ফাংশন দিন (price.inPoisha()), বা অন্তত explicit লিখুন, যাতে রূপান্তর শুধু স্পষ্ট static_cast-এ ঘটে।

explicit operator bool — “ঠিক আছে কি না” প্রশ্নের উত্তর

একটি ব্যতিক্রম খুব প্রচলিত: bool-এ রূপান্তর, যাতে if (obj) লেখা যায়। আপনি ইতিমধ্যে এটি ব্যবহার করেছেন — if (ptr) (পর্ব ১৭-এর unique_ptr), if (file), while (std::cin >> x). এগুলো সব explicit operator bool:

class Connection {
    bool open_ = false;
public:
    explicit operator bool() const { return open_; }
};

Connection c;
if (c) { /* ... */ }      // চলে — if-এর শর্তে explicit হলেও রূপান্তর হয়
if (!c && ready) {}      // চলে — !, &&, ||, ?: — সবই “শর্ত”
int n = c + 1;            // compile error — এটাই চাই

explicit থাকলেও if, while, !, &&, || আর ?:-এর শর্তে রূপান্তর ঘটে — একে বলে contextual conversion. কিন্তু হিসাবে বা অন্য ভ্যারিয়েবলে বসাতে গেলে আটকায়। কেন এত সতর্কতা? explicit না হলে bool নিজে int-এ উন্নীত হয়, তখন std::cin << x (তীর ভুল দিকে!) bool-কে int বানিয়ে bit shift হিসেবে compile হয়ে যেত। C++98-এ এই ঝুঁকি এড়াতে stream-গুলো operator void* আর নানা জটিল “safe bool” কৌশল ব্যবহার করত; C++11-এ explicit conversion আসার পর সমস্যাটির পরিষ্কার সমাধান হয়।

যা overload করবেন না

কিছু operator-এর built-in আচরণে এমন বিশেষ নিশ্চয়তা আছে, যা overload করলে হারিয়ে যায়। ফলে কোড দেখতে একরকম, চলে আরেকরকম:

মজার ব্যাপার, standard library নিজেই কয়েকবার “অপ্রচলিত” অর্থ ব্যবহার করেছে, আর সেগুলো এখন প্রচলিত: << মূলত bit shift, কিন্তু stream-এ “পাঠাও”; std::filesystem::path-এ (C++17) / মানে ফোল্ডার জোড়া, যেমন dir / "report.txt"; আর C++20-এর ranges-এ | মানে পাইপলাইন (পর্ব ৩৫)। এগুলো টিকেছে কারণ চিহ্নের দৃশ্যমান অর্থটা স্বাভাবিক (তীর, ফোল্ডারের দাগ, Unix-এর pipe), আর পুরো লাইব্রেরিতে একইভাবে, সঙ্গতিপূর্ণভাবে ব্যবহৃত। আপনার নিজের কোডে এমন নতুন রীতি চালু করার আগে দুবার ভাবুন — standard library-র মতো লক্ষ পাঠক আর দশকের অভ্যাস আপনার পেছনে নেই।

৯ · AI-এর যুগে — operator কোডের ভুল ধরা

AI টুল operator overloading-এর কোড খুব তাড়াতাড়ি লিখে দেয়, আর সেটি প্রায়ই compile হয়ে চলে। সমস্যা হলো, অনলাইনে বিশাল পরিমাণ C++98-যুগের টিউটোরিয়াল আছে, যেখানে ছয়টি তুলনা হাতে লেখা, += কপি ফেরত দেয়, আর member ফাংশনে const নেই। আবার “দেখতে চতুর” কোডের লোভে AI কখনো কখনো অদ্ভুত অর্থে operator বসায়। এগুলো ধরার জন্য আজকের প্রতিটি নিয়ম কাজে লাগবে:

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

• প্রতিটি operator-এর অর্থ এক বাক্যে বলতে পারি, আর সেটি built-in অর্থের সাথে মেলে — বিস্ময়কর কিছু নেই
• +=, -=, prefix ++ ফেরত দেয় T&; +, -, postfix ++ ফেরত দেয় নতুন মান (by value)
• + নিজে হিসাব করে না, +=-কে ডাকে; postfix ডাকে prefix-কে
• তুলনা <=> (দরকারে ==) দিয়ে, আর = default হলে সব সদস্য সত্যিই “মান”-এর অংশ কি না যাচাই করেছি
• যে operator object বদলায় না, তা const; []-এর const আর non-const দুই রূপ আছে
• 2 * v আর v * 2, a == b আর b == a — দুই দিকেই চালিয়ে দেখেছি
• কোনো implicit conversion operator নেই; bool-এ রূপান্তর হলে explicit
• &&, ||, কমা, unary & overload করা হয়নি