enum class, struct আর structured bindings — নিজের টাইপ বানানো

১ · নিজের টাইপ — কোড যখন সমস্যার ভাষায় কথা বলে

পর্ব ০৫-এ আপনি int, double, bool-এর মতো তৈরি বাক্স চিনেছেন। এগুলো দিয়ে সবই লেখা যায় — কিন্তু “লেখা যায়” আর “পড়ে বোঝা যায়” এক জিনিস নয়। একটি খাবার-ডেলিভারি অ্যাপের কোডের এই লাইনটি দেখুন:

if (order[2] == 3 && order[4] > 0) notify(order[0]);

এটি হয়তো ঠিকঠাক চলে। কিন্তু 3 মানে কী? order[2] কোন তথ্য? এক মাস পরে আপনি নিজেও মনে করতে পারবেন না। এবার একই কাজ নিজের টাইপ দিয়ে:

if (order.status == Status::Delivered && order.tip > 0) notify(order.customer);

কোনো comment লাগল না। লাইনটি নিজেই বলছে: “অর্ডার পৌঁছে গেলে আর বকশিশ থাকলে গ্রাহককে জানাও।” প্রোগ্রামারের হাতে বানানো এমন টাইপকে বলে user-defined type. এই পর্বে আপনি এর তিনটি সবচেয়ে সরল রূপ শিখবেন:

২ · পুরোনো enum — নাম ছড়িয়ে পড়ে, সংখ্যা হয়ে যায়

C থেকে C++ পেয়েছে enum (enumeration — “গুনে গুনে তালিকা”)। এটি কয়েকটি নামকে একটি টাইপে বাঁধে, আর প্রতিটি নামের পেছনে একটি পূর্ণসংখ্যা রাখে — প্রথমটি 0, পরেরটি 1, এভাবে। তালিকার প্রতিটি নামকে বলে enumerator.

enum OrderStatus { Pending, Delivered };   // Pending = 0, Delivered = 1

সংখ্যার চেয়ে এটি অনেক ভালো। কিন্তু এই পুরোনো রূপের, যাকে এখন বলে unscoped enum বা plain enum, দুটি বড় দুর্বলতা আছে। এক, এর নামগুলো চারপাশের scope-এ ছড়িয়ে পড়ে — যেন একটি বাড়ির সব জিনিস রাস্তায় রাখা। দুই, এটি চুপচাপ int-এ বদলে যায়, তাই অর্থহীন হিসাবও compile হয়ে যায়। একটি ডেলিভারি অ্যাপে অর্ডারের অবস্থা আর পেমেন্টের অবস্থা — দুটোতেই “Pending” থাকা খুব স্বাভাবিক। কী ঘটে, ধাপে ধাপে দেখুন:

1enum OrderStatus { Pending, Delivered };2enum PaymentStatus { Pending, Paid };3int total = Delivered + 100;4enum class Order { Pending, Delivered };5enum class Payment { Pending, Paid };6Order o = Order::Pending;7int n = Order::Delivered + 100;8int code = static_cast<int>(o);

খেয়াল করুন, দ্বিতীয় সমস্যাটি প্রথমটির চেয়েও বিপজ্জনক। নামের সংঘর্ষ অন্তত compile error দেয়। কিন্তু নিঃশব্দে int হয়ে যাওয়া কোনো শব্দ করে না — if (status == 1), status * 2, এমনকি দুটি ভিন্ন enum-এর তুলনা (orderStatus == paymentStatus), সবই compile হয়ে যায়; GCC বড়জোর সতর্কবার্তা দেয়। অনেক বছরের পুরোনো C++ কোডে এ ধরনের বাগ এখনো লুকিয়ে আছে।

৩ · enum class — নিজের ঘরে থাকা, কঠোর টাইপের নাম

C++11 থেকে আসা enum class (একে scoped enum-ও বলে; enum struct লিখলেও হুবহু একই জিনিস) দুটি সমস্যাই একসাথে সমাধান করে। আধুনিক C++-এ নতুন কোডে এটিই ডিফল্ট পছন্দ। খাবার-ডেলিভারি অ্যাপের অর্ডারের চারটি অবস্থা দিয়ে শুরু করা যাক:

enum class Status { Placed, Cooking, OnTheWay, Delivered };

Status s = Status::Cooking;     // ঠিক আছে
s = Status::OnTheWay;           // ঠিক আছে — অবস্থা বদলাল
s = 2;                          // error: int থেকে Status-এ নিজে থেকে যাওয়া যায় না
if (s == Status::Delivered) { } // একই enum-এর মধ্যে তুলনা চলে

Underlying type — enum মেমরিতে কত বড়

প্রতিটি enum-এর পেছনে আসলে একটি পূর্ণসংখ্যা থাকে, যাকে বলে underlying type. enum class-এ ডিফল্টভাবে এটি int (সাধারণত ৪ বাইট)। কিন্তু চারটি অবস্থা রাখতে ৪ বাইট লাগে না। লক্ষ লক্ষ অর্ডার মেমরিতে বা ফাইলে রাখলে, বা নেটওয়ার্কে পাঠালে, আপনি নিজে আকার বেছে নিতে পারেন:

enum class Status : std::uint8_t { Placed, Cooking, OnTheWay, Delivered };  // ১ বাইট
enum class HttpCode : int { Ok = 200, NotFound = 404, ServerError = 500 };  // নিজে মান দেওয়া

দ্বিতীয় লাইনটি দেখায়, enumerator-কে নিজে মানও দেওয়া যায় — বাইরের কোনো নিয়ম (যেমন HTTP-র 404) মেলাতে এটা কাজে লাগে। আরেকটি সুবিধা: underlying type জানা থাকলে enum-কে আগে থেকে ঘোষণা করে রাখা যায় (enum class Status : std::uint8_t;) — পুরো তালিকা না দিয়েই। পর্ব ১১-এর header ফাইলে এটা কাজে লাগে, কারণ তালিকা বদলালে সব ফাইল নতুন করে compile করতে হয় না।

Enum থেকে সংখ্যা — std::to_underlying

static_cast<int>(s) কাজ করে, কিন্তু একটি ঝুঁকি আছে: কেউ পরে underlying type বদলে std::int64_t করলে আপনার int cast চুপচাপ ভুল আকারে বদলাবে। C++23 থেকে <utility>-এর std::to_underlying(s) ঠিক underlying type-টিই ফেরত দেয় — আকার নিয়ে আর ভাবতে হয় না। নিচের প্রোগ্রামে অর্ডারের অবস্থা, তার লেবেল, কোড আর আকার একসাথে দেখুন:

#include <cstdint>
#include <print>
#include <string_view>
#include <utility>

enum class Status : std::uint8_t { Placed, Cooking, OnTheWay, Delivered };

std::string_view label(Status s) {
    switch (s) {
        case Status::Placed:    return "Order placed";
        case Status::Cooking:   return "Restaurant is cooking";
        case Status::OnTheWay:  return "Rider is on the way";
        case Status::Delivered: return "Delivered, enjoy!";
    }
    return "Unknown";                 // enum-e baje man thakle
}

int main() {
    for (Status s : {Status::Placed, Status::OnTheWay, Status::Delivered})
        std::println("[{}] {}", std::to_underlying(s), label(s));
    std::println("sizeof(Status) = {} byte", sizeof(Status));
}

switch আর ভুলে যাওয়া case — compiler-এর পাহারা

enum class আর switch একসাথে খুব শক্তিশালী, কারণ compiler জানে তালিকায় ঠিক কোন কোন মান আছে। ফলে কোনো case বাদ পড়লে সে মনে করিয়ে দিতে পারে। বাস্তব সফটওয়্যারে এটা কতটা জরুরি, নিচের গল্পে দেখুন:

enum class Status { Placed, Cooking, OnTheWay, Delivered };

switch (s) {
    case Status::Placed:    return "Order placed";
    case Status::Cooking:   return "Cooking";
    case Status::OnTheWay:  return "On the way";
    case Status::Delivered: return "Delivered";
}
g++ -Wall: কোনো সতর্কবার্তা নেই

enum class Status { Placed, Cooking, OnTheWay, Delivered, Cancelled };

switch (s) {   // আগের মতোই চারটি case
    ...
}
warning: enumeration value 'Cancelled' not handled in switch [-Wswitch]

switch (s) {
    case Status::Placed:    return "Order placed";
    ...
    default:                return "Unknown";
}
কোনো সতর্কবার্তা নেই — কিন্তু বাতিল অর্ডার দেখায় "Unknown"

switch (s) {
    case Status::Placed:    return "Order placed";
    ...
    case Status::Delivered: return "Delivered";
    case Status::Cancelled: return "Cancelled";
}
সতর্কবার্তা নেই, আর আচরণও সঠিক

switch (s) {
    using enum Status;
    case Placed:    return "Order placed";
    case Cooking:   return "Cooking";
    ...
}
শুধু এই switch-এর ভেতরে Status:: লিখতে হয় না

৪ · struct — কয়েকটি তথ্যকে এক বাক্সে বাঁধা

একজন ছাত্রের তথ্য রাখতে চান: নাম, রোল, নম্বর। struct ছাড়া লিখতে হতো তিনটি আলাদা ভ্যারিয়েবল — name1, roll1, marks1, তারপর name2, roll2… ফাংশনে পাঠাতে তিনটি parameter, ফেরত দিতে আরও ঝামেলা। আর কোন marks কোন name-এর, সেটা শুধু ভ্যারিয়েবলের নামের ভরসায়।

struct এই তিনটিকে এক বাক্সে বাঁধে। বাক্সের ভেতরের প্রতিটি ভ্যারিয়েবলকে বলে data member, আর পড়া হয় ডট (.) দিয়ে:

struct Student {
    std::string name;
    int roll{};
    int marks{};
};                                  // শেষের সেমিকোলন ভুলবেন না!

Student rafi{"Rafi", 7, 85};
std::println("{} got {}", rafi.name, rafi.marks);

তিন উপায়ে মান সাজানো

উপরের Student একটি aggregate — নিজের কোনো constructor নেই, সব member বাইরে থেকে দেখা যায়। এমন struct-কে {}-এর ভেতরে মান সাজিয়ে বানানো যায়, একে বলে aggregate initialization. C++20 থেকে আরেকটি উপায় এসেছে — designated initializer, যেখানে প্রতিটি মানের আগে member-এর নাম লেখা হয়। আর struct-এর ভেতরেই ডিফল্ট মান লিখে রাখা যায় — default member initializer. একটি খাবার-অর্ডারের struct দিয়ে সবগুলো দেখুন:

1struct Order {2    std::string item;3    int qty{1};4    double price{};5    bool paid{false};6};7Order a{};8Order b{"Biryani", 2, 250.0, true};9Order c{.item = "Fuchka", .price = 60.0};10Order d{.qty = 3, .item = "Tea"};11Order e{"Kacchi", .qty = 2};12Order f;

ছোট একটি ইতিহাস — aggregate-এর নিয়ম বদলেছে

C++11-এ struct-এর ভেতরে ডিফল্ট মান লেখার সুযোগ এলেও তখন একটি অদ্ভুত নিয়ম ছিল: ডিফল্ট মান দিলেই struct আর aggregate থাকত না, ফলে {"Rafi", 7, 85} লেখা যেত না! C++14 এই নিয়ম তুলে দেয়। তাই পুরোনো বই বা ফোরামে “ডিফল্ট মান দিলে brace দিয়ে বানানো যায় না” পড়লে বুঝবেন, সেটা C++11-এর কথা।

৫ · Member function — struct-এর নিজের কাজ, আর class-এর সাথে সম্পর্ক

ধরুন বারবার জানতে হয় একজন ছাত্র পাস করেছেন কি না (৪০ বা তার বেশি)। একটি আলাদা ফাংশন bool passed(const Student& s) লেখা যায়। কিন্তু এই প্রশ্নটি তো ছাত্রেরই — তাই C++ ফাংশনটিকে struct-এর ভেতরেই রাখতে দেয়। এমন ফাংশনকে বলে member function:

struct Student {
    std::string name;
    int marks{};

    bool passed() const { return marks >= 40; }      // নিজের marks সরাসরি দেখে
    char grade() const {
        if (marks >= 80) return 'A';
        if (marks >= 60) return 'B';
        return marks >= 40 ? 'C' : 'F';
    }
};

Student s{.name = "Mitu", .marks = 72};
if (s.passed()) std::println("{} passed with {}", s.name, s.grade());

লক্ষ করুন, ফাংশনের ভেতরে marks লিখতে s.marks লাগেনি — member function যে অবজেক্টের ওপর ডাকা হয় (s.passed()), তার member-গুলো সরাসরি দেখতে পায়। নামের পরের const একটি প্রতিশ্রুতি: “এই ফাংশন অবজেক্টের কিছু বদলাবে না।” এর বিস্তারিত পর্ব ২০-এ। একটি বিষয় জেনে রাখুন: member function যোগ করলেও Student aggregate-ই থাকে — designated initializer, structured binding সবই চলে, কারণ এগুলো শুধু data member দেখে।

struct আর class — পার্থক্য মাত্র একটি শব্দের

অনেক বইয়ে পড়বেন “struct-এ শুধু ডেটা থাকে, class-এ ফাংশনও থাকে।” C-তে এটা সত্যি, C++-এ নয়। C++-এ struct আর class প্রায় হুবহু এক যন্ত্র — দুটোতেই ডেটা, ফাংশন, constructor, inheritance সব চলে। পার্থক্য শুধু ডিফল্ট access specifier-এ:

শেষ সারিটি নিয়ম নয়, রীতি — কিন্তু খুব শক্ত রীতি। Student-এর নাম যেকোনো লেখা, নম্বর যেকোনো সংখ্যা হতে পারে; বাইরের কেউ বদলালেও কিছু ভাঙে না — তাই struct. কিন্তু একটি bKash ওয়ালেটের ব্যালান্স যদি যে কেউ সরাসরি wallet.balance = -500 লিখতে পারে, সর্বনাশ। সেখানে ডেটা private রেখে শুধু deposit(), withdraw() ফাংশন দিয়ে বদলাতে দিতে হয় — সেটাই class, পর্ব ২০-এর বিষয়।

৬ · std::pair আর std::tuple — নামহীন জোড়া

কখনো কখনো দুটি মান একসাথে ফেরত দিতে হয়, আর শুধু সেজন্য একটি struct বানাতে আলসেমি লাগে। Standard library-তে এর জন্য তৈরি টাইপ আছে। <utility>-এর std::pair যেকোনো দুটি মান রাখে, যাদের নাম সবসময় first আর second. <tuple>-এর std::tuple যেকোনো সংখ্যক মান রাখে, যাদের কোনো নামই নেই — পড়তে হয় ক্রমিক নম্বর দিয়ে:

std::pair<std::string, int> topper{"Mitu", 97};
std::println("{} {}", topper.first, topper.second);

std::tuple<std::string, int, double> rec{"Rafi", 7, 3.75};
std::println("{} {} {}", std::get<0>(rec), std::get<1>(rec), std::get<2>(rec));

std::pair p{10, 2.5};   // C++17: টাইপ লিখতে হয় না, compiler বুঝে নেয় pair<int, double>

এগুলো সত্যিই কাজের — বিশেষ করে generic কোডে (পর্ব ২৮-২৯-এর template), যেখানে আগে থেকে জানা নেই কী কী মান থাকবে। Standard library নিজেও এদের ব্যবহার করে: পর্ব ৩১-এ দেখবেন, std::map-এর প্রতিটি উপাদান আসলে একটি pair (key আর value). কিন্তু নিজের কোডে একটি প্রশ্ন জিজ্ঞেস করুন: পাঠক কি .first আর .second দেখে বুঝবেন কোনটা কী?

দুটি মান ফেরত দেওয়া — সবচেয়ে কম আর সবচেয়ে বেশি নম্বর

একটি ক্লাসের নম্বরের তালিকা থেকে সর্বনিম্ন আর সর্বোচ্চ — দুটোই একটি ফাংশন থেকে চাই। তিনটি উপায় তুলনা করুন:

মজার কথা, C++ standard কমিটিও একই সিদ্ধান্তে পৌঁছেছে। পুরোনো std::minmax_element ফল দেয় একটি pair-এ; কিন্তু C++20-এর নতুন std::ranges::minmax ফল দেয় একটি struct-এ, যার member-দের নাম min আর max. নতুন নকশায় কমিটি জেনেশুনেই নামহীন জোড়া থেকে সরে এসেছে।

৭ · Structured bindings — বাক্স খুলে প্রতিটি অংশকে নাম দেওয়া

struct বা pair ফেরত দিলে ডাকার জায়গায় লিখতে হয় auto r = findMinMax(v);, তারপর r.min, r.max. C++17 থেকে এক লাইনেই বাক্স খুলে ফেলা যায়:

auto [lo, hi] = findMinMax(marks);      // lo = r.min, hi = r.max

এর নাম structured binding. বন্ধনীর ভেতরের নামগুলো ক্রম অনুযায়ী struct-এর data member-দের সাথে (বা pair-এর first/second, tuple-এর উপাদান, এমনকি array-এর ঘরগুলোর সাথে) জোড়া লাগে। নাম আপনার ইচ্ছামতো — struct-এর member-এর নামের সাথে মিলতে হবে না, শুধু সংখ্যা মিলতে হবে। একটা জিনিস প্রায় সবাই প্রথমবার ভুল বোঝেন: এই নামগুলো কি আসল অবজেক্টকেই বোঝায়, নাকি কপি? ধাপে ধাপে দেখুন:

1Student rafi{.name = "Rafi", .marks = 85};2auto [name, marks] = rafi;3marks = 90;4auto& [n2, m2] = rafi;5m2 = 90;6std::pair<std::string, int> top{"Mitu", 97};7const auto& [who, score] = top;8auto [x, y, z] = rafi;

এবার পুরো ছবিটি একসাথে চালিয়ে দেখুন — একটি Student, designated initializer, structured binding, struct-এর তুলনা আর দুটি মান ফেরত দেওয়া ফাংশন:

#include <print>
#include <string>
#include <vector>

struct Student {
    std::string name;
    int marks{};
    bool operator==(const Student&) const = default;   // C++20
};
struct MinMax { int min; int max; };
MinMax findMinMax(const std::vector<int>& v) {
    MinMax r{v[0], v[0]};
    for (int x : v) { if (x < r.min) r.min = x; if (x > r.max) r.max = x; }
    return r;
}
int main() {
    Student rafi{.name = "Rafi", .marks = 85};
    auto [name, marks] = rafi;
    std::println("{} got {}, same as copy? {}", name, marks, rafi == Student{"Rafi", 85});
    auto [lo, hi] = findMinMax({72, 85, 39, 91, 64});
    std::println("lowest = {}, highest = {}", lo, hi);
}

পরে যেখানে বারবার দেখবেন — map-এর ওপর লুপ

Structured binding সবচেয়ে বেশি চোখে পড়বে container-এর ওপর লুপে। পর্ব ৩১-এ std::map শিখলে এমন লেখা প্রতিদিন দেখবেন — map-এর প্রতিটি উপাদান একটি pair, আর লুপের মাথাতেই সেটি খুলে নাম দেওয়া হচ্ছে:

std::map<std::string, int> results{{"Mitu", 97}, {"Rafi", 85}};
for (const auto& [name, marks] : results)
    std::println("{}: {}", name, marks);
// C++17-এর আগে: for (const auto& p : results) std::println("{}: {}", p.first, p.second);

৮ · struct তুলনা — C++20-এর = default

দুটি int-কে == দিয়ে তুলনা করা যায়। দুটি Student-কে? C++20-এর আগে, নিজে না লিখলে, না। a == b লিখলেই error: no match for 'operator=='. কারণ compiler নিজে থেকে ধরে নিতে চায় না “সমান” মানে কী — সব member মেলা? শুধু রোল মেলা? তাই প্রতিটি struct-এর জন্য প্রোগ্রামাররা হাতে লিখতেন:

// C++20-এর আগে — প্রতিটি member হাতে মেলানো (একটি ভুলে গেলেই বাগ)
bool operator==(const Student& a, const Student& b) {
    return a.name == b.name && a.marks == b.marks;
}

struct-এ নতুন member যোগ হলে এই ফাংশন বদলাতে ভুলে যাওয়া খুব সাধারণ বাগ। C++20 থেকে compiler-কে বলে দেওয়া যায়: “সব member ক্রম ধরে মিলিয়ে তুলনাটা নিজেই বানিয়ে নাও।” একে বলে defaulted comparison:

#include <compare>

struct Student {
    std::string name;
    int marks{};
    auto operator<=>(const Student&) const = default;  // ==, !=, <, >, <=, >= সব পাওয়া গেল
};

Student a{"Rafi", 85}, b{"Rafi", 90};
// a == b -> false,  a < b -> true (নাম সমান, তাই marks দেখা হলো: 85 < 90)

এখানে নতুন চিহ্ন <=> — দেখতে মহাকাশযানের মতো বলে ডাকনাম “spaceship operator”, আসল নাম three-way comparison. একবারেই জানায় একটি মান অন্যটির চেয়ে ছোট, সমান না বড়; সেখান থেকে compiler বাকি চারটি তুলনা নিজেই বানিয়ে নেয়। = default দিলে তুলনা হয় member-দের ঘোষণার ক্রমে — অভিধানের মতো: আগে name, সমান হলে marks. শুধু == দরকার হলে প্রথম কোডের মতো bool operator==(...) const = default; যথেষ্ট। নিজের মতো করে operator লেখা পর্ব ২৩-এ, আর <=>-এর পূর্ণ গল্প পর্ব ৪২-এ।

৯ · AI-এর যুগে — সংখ্যার কোড আর নামহীন জোড়া

AI টুলগুলো বিশাল পরিমাণ পুরোনো কোড পড়ে শিখেছে, তাই তাদের লেখায় প্রায়ই C আর পুরোনো C++-এর অভ্যাস ফিরে আসে। বিশেষ করে কনটেস্ট-ধাঁচের সমাধানে নিজের টাইপ প্রায় থাকেই না — সবকিছু int আর pair. কোড চলে, পরীক্ষাও পাস করে; সমস্যা ধরা পড়ে যখন অন্য কেউ (বা আপনি নিজে) সেটা পড়তে বা বদলাতে যান। সাধারণ ভুলগুলো:

AI-এর লেখা struct/enum কোড যাচাইয়ের চেকলিস্ট

• কোনো “অবস্থা” বা “ধরন” int/char কোডে নেই — সবই enum class
• প্রতিটি struct-এর সংখ্যা, bool আর pointer member-এর ডিফল্ট মান আছে
• .first/.second/std::get<2> দেখে প্রতিটির অর্থ বলতে পারছি — না পারলে struct চাই
• enum-এর ওপর switch-এ অপ্রয়োজনীয় default নেই, আর -Wall-এ কোনো -Wswitch সতর্কবার্তা নেই
• প্রতিটি structured binding-এ auto, auto& না const auto& — সঠিকটি বেছে নেওয়া হয়েছে
• designated initializer-এ member-দের ক্রম struct-এর ঘোষণার সাথে মেলে

১০ · মডিউল ২ শেষ — ভাষার মূল যন্ত্রপাতি এখন আপনার হাতে

এই পর্বের সাথে মডিউল ২ “ভাষার মূল যন্ত্রপাতি” শেষ হলো। সাতটি পর্বে আপনি ভাষার সেই অংশগুলো হাতে নিয়েছেন, যা প্রায় প্রতিটি C++ প্রোগ্রামের প্রতিটি পাতায় থাকে। একবার ফিরে দেখুন:

এতদিন আপনার প্রোগ্রাম একটি-দুটি মান নিয়ে কাজ করেছে। কিন্তু বাস্তবের ডেটা আসে তালিকায় — ক্লাসের ষাট জন ছাত্র, দিনের হাজার অর্ডার। মডিউল ৩ শুরু হবে ঠিক সেখান থেকে: এক সারিতে অনেক মান রাখা, লেখা নিয়ে কাজ, আর মেমরির ভেতরে আসলে কী ঘটে — pointer, মালিকানা আর lifetime. আজকের Student আর Order struct সেখানে বারবার ফিরে আসবে, এবার শত শতটি একসাথে।