লিখিত ও মৌখিক (ভাইভা) প্রশ্ন — C++ মডেল উত্তর ও কৌশল

সংজ্ঞা: C একটি procedural ভাষা; C++ C-এর ওপর গড়া একটি multi-paradigm ভাষা — procedural, object-oriented, generic আর functional ধাঁচ একসাথে। Bjarne Stroustrup ১৯৭৯ সালে Bell Labs-এ “C with Classes” নামে কাজ শুরু করেন; ১৯৮৩ সালে নাম হয় C++. প্রথম ISO standard আসে ১৯৯৮ সালে (C++98), তারপর C++11 থেকে প্রতি তিন বছরে নতুন সংস্করণ — C++23 প্রকাশিত, আর C++26 চূড়ান্ত হওয়ার শেষ পর্যায়ে।

C++ কি C-এর superset? প্রায়, কিন্তু পুরোপুরি নয়। যেমন C-তে int *p = malloc(8); বৈধ, C++-এ void* থেকে স্বয়ংক্রিয় রূপান্তর নেই বলে error. C-তে int new = 5; চলে, C++-এ new একটি keyword. sizeof('a') C-তে sizeof(int), C++-এ ১.

উপসংহার: C++ কেন — বড় সিস্টেমে ভুলের সুযোগ কমাতে (RAII, type safety) আর C-এর গতি বজায় রেখে উঁচু স্তরের abstraction দিতে। এর মূলনীতি zero-overhead: যা ব্যবহার করবেন না, তার দাম দিতে হবে না। তাই game engine, browser, database, trading system-এ C++ এখনো প্রধান ভাষা।

ঝালিয়ে নিন: পর্ব ০১ · C++ কেন?

Reference হলো একটি বিদ্যমান object-এর আরেকটি নাম; pointer হলো একটি ভ্যারিয়েবল, যার মান একটি ঠিকানা।

উদাহরণ: void addBonus(int& salary) { salary += 500; } — ডাকার জায়গায় মূল ভ্যারিয়েবল বদলায়, কোনো & বা * লিখতে হয় না। বড় object কপি ছাড়া পাঠাতে const std::string&.

উপসংহার: “অবশ্যই একটি object আছে” এমন ক্ষেত্রে reference; “হয়তো কিছু নেই” বা “পরে অন্য কিছুকে দেখাবে” হলে pointer (বা std::optional). সতর্কতা: function থেকে local ভ্যারিয়েবলের reference ফেরত দিলে dangling reference — undefined behavior.

ঝালিয়ে নিন: পর্ব ১০ · reference, পর্ব ১৫ · pointer

Const correctness মানে যেখানে কোনো কিছু বদলানোর কথা নয়, সেখানে const লিখে compiler-কে সেই প্রতিশ্রুতি পাহারা দিতে দেওয়া। ভুল করে বদলালে compile error — বাগ চলার আগেই ধরা পড়ে।

• ভ্যারিয়েবল: const int maxSeat = 40; — শুরুর পর বদলানো যায় না।
• Parameter: void print(const std::vector<int>& v) — কপি নেই, আর ফাংশন v বদলাবে না।
• Member function: int balance() const; — এই ফাংশন object-এর অবস্থা বদলাবে না; const object-এ শুধু এমন ফাংশনই ডাকা যায়।
• Pointer: const int* p — যা দেখায় তা বদলানো যাবে না (pointer to const); int* const p — pointer নিজে অন্য কোথাও যাবে না (const pointer). ডান থেকে বাঁয়ে পড়ুন।
• mutable: const ফাংশনের ভেতরেও বদলানো যায় এমন member — যেমন cache বা mutex.

const বনাম constexpr: const শুধু বলে “বদলাবে না” — মান চলার সময়ও ঠিক হতে পারে (const int n = readInput();). constexpr ভ্যারিয়েবলের মান compile-এর সময়ই জানা থাকতে হবে।

উপসংহার: const প্রথম দিন থেকে লিখুন; পরে যোগ করতে গেলে একটি ফাংশন থেকে আরেকটিতে ছড়িয়ে পড়ে। const object বা reference নিয়ে কাজ করা কোড thread-এর মধ্যে ভাগ করাও সহজ।

ঝালিয়ে নিন: পর্ব ০৫ · টাইপ, auto আর const, পর্ব ২০ · class ও object

Namespace হলো নামের একটি আলাদা ঘর, যাতে বিভিন্ন লাইব্রেরির একই নাম ধাক্কা না খায়। std::sort আর আপনার mylib::sort পাশাপাশি থাকতে পারে, কারণ পুরো নাম আলাদা। :: হলো scope resolution operator.

namespace bank {
    double interest(double amount) { return amount * 0.07; }
}
namespace loan {
    double interest(double amount) { return amount * 0.12; }
}
double a = bank::interest(1000);   // 70
double b = loan::interest(1000);   // 120

ধরন: nested namespace (namespace app::db { }, C++17), namespace alias (namespace fs = std::filesystem;), আর anonymous namespace — যার ভেতরের নাম শুধু সেই .cpp ফাইলে দেখা যায় (internal linkage).

Header-এ using namespace std; নয় কেন: header যে ফাইলই include করুক, তার ভেতরে std-এর শত শত নাম ঢুকে পড়ে। কারও নিজের count বা distance ফাংশন থাকলে হঠাৎ ambiguity বা ভুল ফাংশন ডাকা হতে পারে — আর কেন হলো, খুঁজে পাওয়া কঠিন। .cpp ফাইলের ভেতরে, ছোট scope-এ, বা নির্দিষ্ট নামের জন্য using std::cout; তুলনামূলক নিরাপদ।

ঝালিয়ে নিন: পর্ব ১১ · namespace আর header

Destructor হলো class-এর বিশেষ member function (~ClassName()), যা object-এর জীবন শেষ হলে আপনাআপনি চলে। এর কোনো parameter বা return type নেই, একটি class-এ একটিই থাকে, আর C++11 থেকে এটি ডিফল্টভাবে noexcept.

RAII (Resource Acquisition Is Initialization) মানে রিসোর্সের — মেমরি, ফাইল, lock, socket — জীবন একটি object-এর জীবনের সাথে বেঁধে দেওয়া: constructor-এ রিসোর্স নেওয়া, destructor-এ ছাড়া। object scope থেকে বের হলেই রিসোর্স মুক্ত — স্বাভাবিকভাবে বের হোক, return হোক বা exception-এর কারণে stack unwinding হোক।

#include <print>

struct Logger {
    const char* name;
    explicit Logger(const char* n) : name(n) { std::println("open  {}", name); }
    ~Logger() { std::println("close {}", name); }
};

int main() {
    Logger a("A");
    {
        Logger b("B");
        std::println("inside block");
    }                          // b-এর scope শেষ: এখানেই close B
    Logger c("C");
    std::println("end of main");
}                              // উল্টো ক্রমে: close C, তারপর close A

উপসংহার: standard library-র প্রায় সবকিছুই RAII — std::vector, std::string, std::fstream, std::lock_guard, std::unique_ptr. তাই আধুনিক C++-এ হাতে delete বা close() প্রায় লিখতেই হয় না। destructor থেকে exception ছোড়া উচিত নয় — বেরিয়ে গেলে std::terminate ডাকা হয়।

ঝালিয়ে নিন: পর্ব ১৭ · RAII ও smart pointer, পর্ব ২১ · constructor ও destructor

Smart pointer হলো এমন RAII object, যা heap-এর একটি object-এর মালিক হয় এবং মালিকানা শেষ হলে নিজেই delete করে। এতে memory leak, double delete আর অনেক dangling pointer-এর ঝুঁকি দূর হয়।

• std::unique_ptr — একক মালিক। কপি করা যায় না, শুধু std::move দিয়ে মালিকানা সরানো যায়। সাধারণত raw pointer-এর সমান মাপ, বাড়তি খরচ প্রায় নেই। ডিফল্ট পছন্দ।
• std::shared_ptr — যৌথ মালিকানা। একটি control block-এ মালিকের সংখ্যা (reference count) রাখে; শেষ মালিক চলে গেলে object ধ্বংস। count বাড়ানো-কমানো atomic, তাই খরচ আছে।
• std::weak_ptr — মালিক নয়, শুধু পর্যবেক্ষক। count বাড়ায় না; lock() দিয়ে ব্যবহারের আগে দেখে নেয় object এখনো আছে কি না। দুটি shared_ptr একে অপরকে ধরে রাখলে (reference cycle) কেউ মুক্ত হয় না — একদিকে weak_ptr দিলে সমস্যা মেটে।

#include <memory>
#include <print>
#include <utility>

struct Node {
    int id;
    explicit Node(int i) : id(i) {}
    ~Node() { std::println("Node {} destroyed", id); }
};

int main() {
    auto u = std::make_unique<Node>(1);
    auto u2 = std::move(u);                   // মালিকানা সরল
    std::println("u empty? {}", u == nullptr);

    auto s1 = std::make_shared<Node>(2);
    std::weak_ptr<Node> w = s1;
    {
        auto s2 = s1;                         // দুই মালিক
        std::println("use_count = {}", s1.use_count());
    }
    std::println("use_count = {}", s1.use_count());
    s1.reset();                               // শেষ মালিক চলে গেল
    std::println("expired? {}", w.expired());
}

উপসংহার: ডিফল্ট unique_ptr; সত্যিই যৌথ মালিকানা লাগলে shared_ptr; cycle ভাঙতে বা “থাকলে দেখব” ধরনের সম্পর্কে weak_ptr. তৈরি করুন std::make_unique / std::make_shared দিয়ে — raw new লিখতে হয় না, আর make_shared object ও control block একবারে বরাদ্দ করে। যেখানে মালিকানা নেই, শুধু ব্যবহার, সেখানে ফাংশনে সাধারণ reference বা raw pointer পাঠানোই ঠিক।

ঝালিয়ে নিন: পর্ব ১৭ · RAII ও smart pointer

Object-oriented programming হলো প্রোগ্রামকে object দিয়ে সাজানো — প্রতিটি object নিজের ডেটা আর সেই ডেটার ওপর কাজ একসাথে রাখে। এর চারটি স্তম্ভ:

• Encapsulation: ডেটা লুকিয়ে শুধু নিয়ন্ত্রিত উপায়ে বদলাতে দেওয়া। class Account { long balance_; public: void deposit(long t); }; — বাইরে থেকে কেউ সরাসরি balance ঋণাত্মক করতে পারে না; deposit নিয়ম যাচাই করে।
• Abstraction: ভেতরের জটিলতা লুকিয়ে সহজ interface দেওয়া। std::vector-এ push_back ডাকলেই হয় — মেমরি বাড়ানো, কপি করা নিয়ে ভাবতে হয় না।
• Inheritance: একটি class আরেকটির বৈশিষ্ট্য নিয়ে নতুন class বানানো — “is-a” সম্পর্ক। class SavingsAccount : public Account { };
• Polymorphism: একই ডাক, ভিন্ন কাজ। compile-time — function overloading ও template; run-time — virtual function: Payment& p = bkash; p.fee(500); চালায় Bkash-এর নিয়ম।

উপসংহার: চারটি স্তম্ভ উপায়, লক্ষ্য নয়। লক্ষ্য হলো পরিবর্তন সহজ করা — একটি জায়গায় বদলালে অন্য জায়গা না ভাঙা। C++ শুধু OOP-এর ভাষা নয়; STL মূলত generic programming দিয়ে বানানো। অনেক ক্ষেত্রে inheritance-এর চেয়ে composition ভালো।

ঝালিয়ে নিন: পর্ব ০২ · বস্তু দিয়ে ভাবা, পর্ব ২০, পর্ব ২৫

C++-এ class আর struct প্রায় একই জিনিস — দুটিতেই member function, constructor, inheritance, virtual, template সবই চলে। ভাষার নিয়মে পার্থক্য মাত্র দুটি:

উপসংহার: C-এর struct-এর সাথে গুলিয়ে ফেলবেন না — C-তে struct-এ ফাংশন বা access control নেই। প্রচলিত নির্দেশিকা: object-এর কোনো নিয়ম (invariant) রক্ষা করতে হলে class আর private ডেটা; শুধু কয়েকটি মান একসাথে রাখতে struct.

ঝালিয়ে নিন: পর্ব ১২ · struct, পর্ব ২০ · class ও object

Constructor হলো object তৈরির সময় আপনাআপনি চলা বিশেষ ফাংশন, যার নাম class-এর নামে আর কোনো return type নেই। এর কাজ object-কে প্রথম মুহূর্ত থেকেই বৈধ অবস্থায় আনা।

• Default: argument ছাড়া — Account a;
• Parameterized: Account b("Rahim", 5000);
• Copy: Account(const Account&) — আরেকটি object থেকে কপি।
• Move: Account(Account&&) noexcept — অস্থায়ী object-এর রিসোর্স সরিয়ে নেওয়া (C++11).
• Delegating: একটি constructor আরেকটিকে ডাকে (C++11).
• Converting: এক argument-এর constructor, যা স্বয়ংক্রিয় রূপান্তর ঘটাতে পারে — অনাকাঙ্ক্ষিত হলে explicit লিখুন।

#include <print>
#include <string>
#include <utility>

class Account {
    std::string owner_;
    long balance_;
public:
    Account() : Account("unknown", 0) {}              // default → delegating
    Account(std::string owner, long bal)              // parameterized
        : owner_(std::move(owner)), balance_(bal) {}  // initializer list
    Account(const Account& o)                         // copy
        : owner_(o.owner_ + "-copy"), balance_(o.balance_) {}
    void show() const { std::println("{}: {}", owner_, balance_); }
};

int main() {
    Account a;
    Account b("Rahim", 5000);
    Account c = b;              // copy constructor চলে, assignment নয়
    a.show();
    b.show();
    c.show();
}

Member initializer list (: owner_(...), balance_(...)) member-কে সরাসরি শুরুর মান দেয়; constructor-এর শরীরের ভেতরে = দিলে member আগে ডিফল্টভাবে তৈরি হয়, পরে আবার assign হয়। চারটি ক্ষেত্রে list বাধ্যতামূলক: const member, reference member, যে member-এর default constructor নেই, আর যে base class-এর default constructor নেই।

সতর্কতা: member-গুলো তৈরি হয় class-এ ঘোষণার ক্রমে, list-এ লেখার ক্রমে নয়। এক member দিয়ে আরেকটির মান দিলে ক্রম মিলিয়ে লিখুন — GCC -Wreorder দিয়ে সতর্ক করে।

ঝালিয়ে নিন: পর্ব ২১ · constructor ও destructor

Copy মানে উৎসের একটি স্বাধীন প্রতিলিপি বানানো — উৎস অপরিবর্তিত থাকে। Move মানে উৎসের রিসোর্স (যেমন heap buffer) নিজের কাছে সরিয়ে নেওয়া — উৎস থাকে বৈধ কিন্তু অনির্দিষ্ট অবস্থায় (moved-from state). এক লাখ উপাদানের vector কপি করতে এক লাখ উপাদান কপি করতে হয়; move করতে শুধু তিনটি pointer.

পাঁচটি special member function object-এর জীবনচক্র নিয়ন্ত্রণ করে: destructor, copy constructor, copy assignment, move constructor, move assignment.

কেন একসাথে: নিজে destructor লিখেছেন মানে class কোনো রিসোর্সের মালিক। তখন compiler-এর বানানো copy শুধু pointer কপি করবে — দুটি object একই মেমরি delete করবে। আর একটি গুরুত্বপূর্ণ নিয়ম: destructor বা কোনো copy অপারেশন নিজে ঘোষণা করলে compiler আর move অপারেশন নিজে বানায় না — তখন “move” আসলে চুপচাপ copy হয়ে যায়।

উপসংহার: move constructor ও move assignment-এ noexcept দিন — নইলে std::vector বড় হওয়ার সময় নিরাপত্তার জন্য move-এর বদলে copy করে। নিজের রিসোর্স সামলানো class খুব কম লিখুন; লিখলে পাঁচটিই ভেবে লিখুন, বা যেগুলো লাগবে না সেগুলো = delete করুন।

ঝালিয়ে নিন: পর্ব ২২ · copy, move আর Rule of 0/3/5, পর্ব ৩৬ · move semantics

Shallow copy শুধু member-গুলোর মান কপি করে — pointer member থাকলে ঠিকানাটি কপি হয়, ঠিকানার ডেটা নয়। Deep copy pointer যে ডেটা দেখায়, সেটির নতুন একটি কপি বানায়, যাতে দুটি object সম্পূর্ণ স্বাধীন হয়।

class Buffer {
    int* data_;
    std::size_t n_;
public:
    explicit Buffer(std::size_t n) : data_(new int[n]{}), n_(n) {}
    ~Buffer() { delete[] data_; }
    // compiler-এর বানানো copy = shallow: দুজনেরই data_ একই ঠিকানা
    Buffer(const Buffer& o) : data_(new int[o.n_]), n_(o.n_) {   // deep copy
        std::copy(o.data_, o.data_ + n_, data_);
    }
    Buffer& operator=(const Buffer&) = delete;   // এখানে সহজ রাখতে বন্ধ
};

চিত্র: shallow copy-র পর a.data_ → [0 0 0] ← b.data_; deep copy-র পর a.data_ → [0 0 0] আর b.data_ → [0 0 0] (আলাদা ব্লক)।

বিপদ: raw pointer-এর মালিক class-এ shallow copy হলে (১) একজন বদলালে অন্যজনও বদলায়, (২) দুজনের destructor একই মেমরি দুবার delete[] করে — double delete, undefined behavior, (৩) একজন ধ্বংস হলে অন্যজন dangling pointer নিয়ে বাঁচে।

উপসংহার: সেরা সমাধান সমস্যাটাই এড়ানো — int*-এর বদলে std::vector<int> রাখুন। vector নিজেই deep copy করে, তখন Rule of Zero মেনে কিছুই লিখতে হয় না। একই ডেটা ইচ্ছে করে ভাগ করতে চাইলে std::shared_ptr.

ঝালিয়ে নিন: পর্ব ২২ · copy, move আর Rule of 0/3/5

Static member class-এর অংশ, কিন্তু কোনো object-এর ভেতরে থাকে না — পুরো প্রোগ্রামে এর একটিই কপি, সব object ভাগ করে ব্যবহার করে।

class Ticket {
    inline static int issued_ = 0;     // C++17: class-এর ভেতরেই সংজ্ঞা
    int number_;
public:
    Ticket() : number_(++issued_) {}
    static int issued() { return issued_; }   // this নেই
};
Ticket t1, t2, t3;
int n = Ticket::issued();   // 3 — object ছাড়াই ডাকা যায়

নিয়ম: static member function-এ this থাকে না, তাই সে সরাসরি non-static member ছুঁতে পারে না; এটি virtual বা const হতে পারে না। C++17-এর আগে static data member-এর সংজ্ঞা আলাদা .cpp ফাইলে দিতে হতো (int Ticket::issued_ = 0;); এখন inline static লিখলেই চলে। sizeof(Ticket)-এ static member-এর জায়গা ধরা হয় না।

উপসংহার: ব্যবহার — object গোনা, সব object-এর ভাগের constant, factory function (Account::fromCsv(...)). সতর্কতা: একাধিক thread থেকে বদলানো static ডেটায় mutex বা std::atomic লাগে।

ঝালিয়ে নিন: পর্ব ২০ · class ও object

Operator overloading মানে নিজের টাইপের জন্য +, ==, << ইত্যাদি অপারেটরের অর্থ সংজ্ঞায়িত করা, যাতে নিজের টাইপও built-in টাইপের মতো স্বাভাবিকভাবে লেখা যায়। এটি আসলে operator+ নামের একটি ফাংশন।

#include <iostream>

struct Money {
    long taka = 0;
    Money& operator+=(const Money& o) { taka += o.taka; return *this; }
    friend Money operator+(Money a, const Money& b) { a += b; return a; }
    friend bool operator==(const Money&, const Money&) = default;  // C++20
    friend std::ostream& operator<<(std::ostream& os, const Money& m) {
        return os << m.taka << " taka";
    }
};

int main() {
    Money a{500}, b{250};
    Money c = a + b;
    c += Money{50};
    std::cout << c << '\n';
    std::cout << std::boolalpha << (a + b == Money{750}) << '\n';
}

নিয়ম ও সীমাবদ্ধতা:

• নতুন অপারেটর বানানো যায় না (যেমন **); precedence, associativity আর operand-এর সংখ্যা বদলানো যায় না (ব্যতিক্রম: () যেকোনো সংখ্যক argument নেয়, আর C++23 থেকে []-ও)।
• অন্তত একটি operand নিজের টাইপ হতে হবে — int + int-এর অর্থ বদলানো যায় না।
• overload করা যায় না: ::, ., .*, ?: (আর sizeof, typeid-এর মতো keyword-অপারেটর)।
• =, [], (), -> অবশ্যই member function হতে হবে।
• &&, || overload করলে short-circuit আচরণ হারায় — তাই প্রায় কখনো করা হয় না।

উপসংহার: অপারেটর এমন অর্থে দিন, যা পাঠক আশা করেন — + দিয়ে বিয়োগ নয়। C++20 থেকে operator== আর operator<=> = default করলে compiler সব তুলনা নিজেই বানায়।

ঝালিয়ে নিন: পর্ব ২৩ · operator overloading

Inheritance হলো একটি বিদ্যমান class (base) থেকে নতুন class (derived) বানানো, যাতে derived base-এর ডেটা ও কাজ পায় এবং নিজের কিছু যোগ করে। public inheritance বোঝায় “is-a” সম্পর্ক — SavingsAccount একটি Account.

private member derived object-এর ভেতরে থাকে, শুধু derived-এর কোড সরাসরি ছুঁতে পারে না। গঠনের দিক থেকে ধরন: single, multilevel (A → B → C), hierarchical (এক base, অনেক derived), multiple (একাধিক base). multiple inheritance-এ একই base দুই পথে এলে diamond problem — সমাধান virtual inheritance.

ক্রম: তৈরি হয় আগে base, তারপর derived-এর member, তারপর derived-এর constructor-এর শরীর; ধ্বংস হয় ঠিক উল্টো ক্রমে।

উপসংহার: প্রায় সবসময় public inheritance ব্যবহার হয়; private inheritance মানে আসলে “এর সাহায্যে বানানো” — সেখানে সাধারণত composition (member হিসেবে রাখা) পরিষ্কার। inheritance শুধু কোড পুনর্ব্যবহারের জন্য নয় — derived যেন সব জায়গায় base-এর জায়গা নিতে পারে (Liskov substitution).

ঝালিয়ে নিন: পর্ব ২৪ · inheritance

সংজ্ঞা, ব্যাখ্যা আর চিত্র অংশ ২-এর ডায়াগ্রামে ধাপে ধাপে দেখানো হয়েছে। এখানে একটি সম্পূর্ণ প্রোগ্রাম, যেখানে ভিন্ন টাইপের object একটি container-এ রেখে একই ডাকে ভিন্ন কাজ হয়:

#include <memory>
#include <print>
#include <vector>

struct Shape {
    virtual ~Shape() = default;                  // virtual destructor
    virtual double area() const = 0;             // pure virtual
    void info() const { std::println("area = {}", area()); }
};
struct Rect : Shape {
    double w, h;
    Rect(double a, double b) : w(a), h(b) {}
    double area() const override { return w * h; }
};
struct Square : Shape {
    double s;
    explicit Square(double x) : s(x) {}
    double area() const override { return s * s; }
    ~Square() override { std::println("~Square"); }
};

int main() {
    std::vector<std::unique_ptr<Shape>> shapes;
    shapes.push_back(std::make_unique<Rect>(2, 3));
    shapes.push_back(std::make_unique<Square>(4));
    for (const auto& s : shapes) s->info();     // একই ডাক, ভিন্ন area
}

Destructor virtual না হলে: base-এর pointer দিয়ে derived object delete করা undefined behavior. বাস্তবে সাধারণত শুধু base-এর destructor চলে — derived-এর রিসোর্স (string, vector, file) কখনো মুক্ত হয় না। নিয়ম: যে class-এ অন্তত একটি virtual ফাংশন আছে বা যাকে base হিসেবে polymorphic-ভাবে ব্যবহার করা হবে, তার destructor public virtual (অথবা protected non-virtual, যাতে base pointer দিয়ে delete-ই করা না যায়)।

উপসংহার: vtable প্রতি class-এ একটি, vptr প্রতি object-এ একটি — দুটিই প্রচলিত বাস্তবায়ন, standard-এর বাধ্যবাধকতা নয়। constructor virtual হতে পারে না; constructor-এর ভেতরে virtual ডাকলে derived-এর সংস্করণ চলে না।

ঝালিয়ে নিন: পর্ব ২৫ · polymorphism ও virtual ফাংশন

Abstract class হলো এমন class, যাতে অন্তত একটি pure virtual function (virtual void pay() = 0;) আছে। এর object বানানো যায় না, কিন্তু এর pointer বা reference রাখা যায়। derived class সব pure virtual override না করলে সে-ও abstract থাকে।

C++-এ interface নামে কোনো keyword নেই (Java বা C#-এর মতো)। প্রচলিতভাবে interface বলতে বোঝায় এমন abstract class, যাতে শুধু pure virtual ফাংশন আর একটি virtual destructor আছে — কোনো ডেটা নেই, কোনো বাস্তবায়ন নেই।

struct Notifier {                               // interface
    virtual ~Notifier() = default;
    virtual void send(const std::string& msg) = 0;
};
struct SmsNotifier : Notifier {
    void send(const std::string& msg) override { /* SMS gateway */ }
};
// Notifier n;    // error: abstract class-এর object হয় না

উপসংহার: একটি সূক্ষ্ম তথ্য: pure virtual ফাংশনেরও সংজ্ঞা দেওয়া যায় — আর pure virtual destructor হলে সংজ্ঞা দিতেই হবে, কারণ derived-এর destructor শেষে base-এর destructor ডাকে। compile-time-এ “interface” বোঝাতে C++20 থেকে concept-ও ব্যবহার করা যায়, তখন কোনো virtual খরচ থাকে না।

ঝালিয়ে নিন: পর্ব ২৬ · abstract class ও interface

উদাহরণ: int area(int s); আর double area(double w, double h); — overloading. struct Bkash : Payment { long fee(long) const override; }; — overriding.

উপসংহার — একটি ফাঁদ: derived-এ base-এর ফাংশনের নামে কিন্তু ভিন্ন parameter-এ একটি ফাংশন লিখলে সেটি overload নয়, override-ও নয় — base-এর একই নামের সব ফাংশন লুকিয়ে যায় (name hiding). সমাধান: derived-এ using Base::area;. আর override লিখলে signature-এর ভুল compiler নিজেই ধরে।

ঝালিয়ে নিন: পর্ব ০৯ · ফাংশন ও overloading, পর্ব ২৫

SOLID হলো object-oriented ডিজাইনের পাঁচটি নীতির সংক্ষিপ্ত নাম; উদ্দেশ্য এমন কোড, যা বদলানো, পরীক্ষা করা আর বাড়ানো সহজ।

• S — Single Responsibility: একটি class-এর বদলানোর কারণ একটিই। Invoice হিসাব করবে; PDF বানানো আর ইমেইল পাঠানো আলাদা class-এর কাজ।
• O — Open/Closed: নতুন আচরণ যোগে খোলা, পুরোনো কোড বদলানোয় বন্ধ। নতুন পেমেন্ট পদ্ধতি (Nagad) যোগ করতে নতুন Payment-derived class লিখুন, পুরোনো switch বদলাতে হবে না।
• L — Liskov Substitution: base-এর জায়গায় যেকোনো derived বসালে প্রোগ্রাম ঠিক থাকবে। ক্লাসিক উদাহরণ: Square-কে Rectangle থেকে derive করলে setWidth একা চালালে Square-এর নিয়ম ভাঙে।
• I — Interface Segregation: বড় এক interface-এর বদলে ছোট ছোট interface. প্রিন্টার Printer নেবে, Scanner নয় — যা লাগে না, তা বাস্তবায়ন করতে বাধ্য করা উচিত নয়।
• D — Dependency Inversion: উঁচু স্তরের কোড নির্ভর করবে abstraction-এর ওপর। OrderService নেবে Notifier&, সরাসরি SmsNotifier নয় — test-এ নকল notifier বসানো যায় (dependency injection).

উপসংহার: SOLID নিয়ম নয়, নির্দেশিকা। ছোট প্রোগ্রামে সব নীতি জোর করে প্রয়োগ করলে অকারণ জটিলতা আসে। C++-এ এগুলো শুধু virtual দিয়ে নয়, template আর concept দিয়েও (compile-time-এ) প্রয়োগ করা যায়।

ঝালিয়ে নিন: পর্ব ২৭ · ডিজাইন নীতি — composition ও SOLID

Template হলো টাইপকে parameter বানিয়ে লেখা কোডের নকশা; compiler প্রতিটি ব্যবহৃত টাইপের জন্য আসল কোড বানায় (instantiation). এতে একই যুক্তি int, double, std::string — সবার জন্য একবার লিখলেই হয়, আর টাইপ যাচাইও পুরোপুরি থাকে।

#include <print>
#include <string>

template <typename T>                       // function template
T biggest(T a, T b) { return (a < b) ? b : a; }

template <typename T>                       // class template
struct Box {
    T value;
    void show() const { std::println("Box holds {}", value); }
};

template <>                                 // full specialization
struct Box<bool> {
    bool value;
    void show() const { std::println("Box holds {}", value ? "yes" : "no"); }
};

int main() {
    std::println("{}", biggest(3, 7));
    std::println("{}", biggest(std::string("apple"), std::string("mango")));
    Box<int>{42}.show();
    Box<bool>{true}.show();
}

Specialization: full specialization — একটি নির্দিষ্ট টাইপের জন্য সম্পূর্ণ আলাদা বাস্তবায়ন (template <> struct Box<bool>). Partial specialization — টাইপের একটি পরিবারের জন্য, যেমন সব pointer: template <typename T> struct Box<T*>; এটি শুধু class (ও variable) template-এ চলে, function template-এ নয় — সেখানে overloading ব্যবহার করুন। standard library-র উদাহরণ: std::vector<bool>.

উপসংহার: template-এর পূর্ণ সংজ্ঞা সাধারণত header-এ রাখতে হয়, কারণ instantiation-এর সময় compiler-কে পুরো কোড দেখতে হয়। অসুবিধা: লম্বা error message, compile সময় বাড়া, আর বেশি টাইপে বাড়তি binary (code bloat). C++20-এর concept টাইপের শর্ত স্পষ্ট করে error সহজ করে।

ঝালিয়ে নিন: পর্ব ২৮ · function template, পর্ব ২৯ · class template

STL (Standard Template Library) হলো C++ standard library-র template-ভিত্তিক অংশ — তৈরি data structure আর algorithm. এর নকশা মূলত Alexander Stepanov-এর; ১৯৯৪ সালে এটি standard-এ গৃহীত হয়ে C++98-এর অংশ হয়।

• Container: ডেটা রাখে — sequence (vector, deque, list, array), associative (map, set), unordered (unordered_map), আর adaptor (stack, queue, priority_queue).
• Iterator: container-এর ভেতর দিয়ে হাঁটার সাধারণ উপায় — pointer-এর মতো *it, ++it.
• Algorithm: sort, find, count_if, transform — iterator জোড়ার ওপর কাজ করে, container-এর ওপর সরাসরি নয়।
• Function object ও lambda: algorithm-কে নিয়ম জানায় — কীভাবে তুলনা, কোনটি গুনবে।

মূল ভাবনা: iterator হলো সেতু। M টি container আর N টি algorithm থাকলে M × N টি সংস্করণ লিখতে হয় না — M + N টিই যথেষ্ট। std::sort(v.begin(), v.end()) vector, array, deque — যেকোনো random-access container-এ চলে।

উপসংহার: C++20 থেকে std::ranges::sort(v) লেখা যায় — পুরো container একবারে, আর concept দিয়ে ভুল টাইপ হলে পরিষ্কার error. নিজে loop লেখার আগে দেখুন STL-এ তৈরি algorithm আছে কি না।

ঝালিয়ে নিন: পর্ব ৩০, পর্ব ৩২, পর্ব ৩৩

উদাহরণ: ছাত্রদের নম্বরের তালিকা — vector; রিকশার সারির মতো দুই দিক থেকে ঢোকা-বের হওয়া — deque (std::queue-এর ডিফল্ট ভিত্তিও deque); মাঝখানে অনবরত যোগ-বাদ আর উপাদানের ঠিকানা স্থির থাকা দরকার — list.

উপসংহার: ডিফল্ট vector. বইয়ের হিসাবে list-এর মাঝে যোগ O(1) হলেও, সেই জায়গা খুঁজতেই O(n) হাঁটতে হয়, আর ছড়ানো node-এ cache miss বেশি — তাই বাস্তবে ছোট-মাঝারি আকারে vector প্রায়ই list-এর চেয়ে দ্রুত। সিদ্ধান্ত নিন মেপে।

ঝালিয়ে নিন: পর্ব ৩০ · sequence container, পর্ব ৪৯ · পারফরম্যান্স

দুটিই key-value জোড়া রাখে, প্রতিটি key একবার। পার্থক্য ভেতরের গঠনে:

উদাহরণ: রোল নম্বর অনুযায়ী সাজিয়ে ফল ছাপা — map; শুধু “এই ফোন নম্বরের মালিক কে” দ্রুত খোঁজা — unordered_map.

উপসংহার: দুটিতেই m[key] পড়তে গেলে key না থাকলে নতুন ডিফল্ট উপাদান ঢুকে যায় — শুধু খুঁজতে find বা C++20-এর contains ব্যবহার করুন। contest-এ বিশেষভাবে বানানো ইনপুট দিয়ে unordered_map-কে worst case-এ ঠেলে দেওয়া যায় (anti-hash test) — সেখানে custom hash বা map নিরাপদ।

ঝালিয়ে নিন: পর্ব ৩১ · map, set আর unordered_map

Iterator হলো একটি object, যা container-এর একটি উপাদানকে নির্দেশ করে এবং পরের উপাদানে যেতে পারে — pointer-এর সাধারণীকৃত রূপ। begin() প্রথম উপাদান, end() শেষের পরের জায়গা (half-open range). ক্ষমতা অনুযায়ী ধরন: input, output, forward, bidirectional (list, map), random-access (vector, deque), আর C++20-এ contiguous (vector, array).

Iterator invalidation মানে container বদলানোর পর আগের iterator (বা reference, pointer) আর বৈধ না থাকা। এমন iterator ব্যবহার করা undefined behavior.

std::vector<int> v{1, 2, 3};
auto it = v.begin();
v.push_back(4);          // capacity ভরা থাকলে নতুন মেমরিতে সরে যায়
// std::println("{}", *it);   // UB: it পুরোনো মেমরি দেখাচ্ছে

for (auto i = v.begin(); i != v.end(); ) {   // লুপে মুছতে নিরাপদ পথ
    if (*i % 2 == 0) i = v.erase(i);   // erase নতুন বৈধ iterator ফেরত দেয়
    else ++i;
}
std::erase_if(v, [](int x) { return x > 2; });   // C++20: আরও সহজ

নিয়মের সারাংশ: vector — reallocation হলে সব invalid; না হলে যোগের জায়গা থেকে পরেরগুলো। reserve দিয়ে আগে জায়গা নিলে push_back-এ reallocation হয় না। list ও map — যোগ করলে কিছুই invalid হয় না, মুছলে শুধু মুছে ফেলা উপাদানের iterator. unordered_map — rehash হলে সব iterator invalid, কিন্তু উপাদানের reference টিকে থাকে।

উপসংহার: range-for লুপের ভেতরে একই vector-এ push_back বা erase করা একটি ক্লাসিক বাগ। AddressSanitizer আর libstdc++-এর debug mode (-D_GLIBCXX_DEBUG) এমন ভুল ধরতে সাহায্য করে।

ঝালিয়ে নিন: পর্ব ৩২ · iterator, পর্ব ১৩ · vector ও array

Lambda হলো নামহীন ফাংশন, যা যেখানে দরকার সেখানেই লেখা যায় (C++11). গঠন: [capture](parameter) -> return_type { body }. compiler প্রতিটি lambda-র জন্য একটি নামহীন class বানায়, যার operator() আছে; lambda-টি সেই class-এর একটি object (closure).

#include <algorithm>
#include <print>
#include <vector>

int main() {
    std::vector<int> marks{72, 45, 88, 39, 91};
    int pass = 40;

    auto passed = std::count_if(marks.begin(), marks.end(),
                                [pass](int m) { return m >= pass; });  // by value

    int total = 0;
    std::ranges::for_each(marks, [&total](int m) { total += m; });     // by reference

    auto counter = [n = 0]() mutable { return ++n; };                  // init-capture
    counter();
    counter();

    std::println("passed={} total={} counter={}", passed, total, counter());
}

• [] — কিছুই ধরে না; [x] — কপি; [&x] — reference; [=] / [&] — ব্যবহৃত সব কিছু কপি / reference-এ (default capture).
• [this] — object-কে pointer দিয়ে; [*this] (C++17) — পুরো object-এর কপি। C++20 থেকে [=] দিয়ে this আপনাআপনি ধরা deprecated.
• [p = std::move(ptr)] — init-capture (C++14), move-only জিনিস ধরতে।

উপসংহার: সবচেয়ে বড় ঝুঁকি — [&] দিয়ে local ভ্যারিয়েবল ধরে lambda-টি পরে চালানো (thread, callback, ফেরত দেওয়া), যখন ভ্যারিয়েবলটি আর নেই: dangling reference. দীর্ঘজীবী lambda-তে কপি বা init-capture পছন্দ করুন, আর কী ধরছেন তা স্পষ্ট লিখুন।

ঝালিয়ে নিন: পর্ব ৩৪ · lambda ও function object

Move semantics (C++11) হলো এমন object থেকে রিসোর্স কপি না করে সরিয়ে নেওয়া, যার আর দরকার নেই — যেমন অস্থায়ী object বা যাকে আর ব্যবহার করা হবে না। এর ভিত্তি rvalue reference T&&, যা শুধু rvalue-র সাথে বাঁধে। ফলে compiler আলাদা করতে পারে: “এটি কপি করতে হবে” (lvalue) আর “এটি থেকে চুরি করা যায়” (rvalue).

#include <cstddef>
#include <print>
#include <utility>
#include <vector>

struct Buffer {
    std::vector<int> data;
    explicit Buffer(std::size_t n) : data(n) {}
    Buffer(const Buffer& o) : data(o.data) { std::println("copy"); }
    Buffer(Buffer&& o) noexcept : data(std::move(o.data)) { std::println("move"); }
};

int main() {
    Buffer a(1000);
    Buffer b = a;               // a একটি lvalue → copy
    Buffer c = std::move(a);    // xvalue → move
    Buffer d = Buffer(10);      // prvalue → C++17-এ নিশ্চিত elision, কিছুই ছাপে না
    std::println("b={} c={} d={}", b.data.size(), c.data.size(), d.data.size());
}

std::move কী করে: নিজে কিছুই সরায় না। এটি শুধু একটি cast — static_cast<T&&> — যা একটি lvalue-কে xvalue বানায়, যাতে move constructor বা move assignment বেছে নেওয়া হয়। আসল সরানোর কাজ করে move constructor. তাই const object-এ std::move দিলে সাধারণত copy-ই হয়, কারণ const T&& move constructor-এ বাঁধে না।

উপসংহার: move-এর পর object “বৈধ কিন্তু অনির্দিষ্ট” — নতুন মান বসানো বা ধ্বংস করা নিরাপদ, পড়ে কিছু আশা করা নয়। return local;-এ std::move লিখবেন না — এতে NRVO বন্ধ হয়ে যেতে পারে (pessimizing move). template-এ T&& আসলে forwarding reference, সেখানে std::forward.

ঝালিয়ে নিন: পর্ব ৩৬ · move semantics, পর্ব ২২

Exception হলো ভুল জানানোর এমন উপায়, যেখানে ভুলের জায়গা থেকে throw করা হয় আর যে জায়গা ভুল সামলাতে জানে সেখানে catch করা হয়। মাঝের ফাংশনগুলোকে প্রতিটি ধাপে return code যাচাই করতে হয় না।

double withdraw(double balance, double amount) {
    if (amount > balance) throw std::runtime_error("insufficient balance");
    return balance - amount;
}
try {
    withdraw(500, 1000);
} catch (const std::exception& e) {          // const reference দিয়ে ধরুন
    std::println("error: {}", e.what());
}

কীভাবে কাজ করে: throw-এর পর প্রোগ্রাম ফাংশনের পর ফাংশন পেছনে যায়, প্রতিটি scope-এর local object-এর destructor চালায় (stack unwinding), যতক্ষণ না মেলে এমন catch পায়। কোনো catch না পেলে std::terminate. তাই RAII আর exception একসাথে কাজ করে — ফাইল, lock, মেমরি আপনাআপনি মুক্ত হয়। by value না ধরে const& দিয়ে ধরা হয়, যাতে কপি না হয় আর derived exception slicing-এ না কাটে।

উপসংহার: exception রাখুন সত্যিকারের ব্যতিক্রমী অবস্থার জন্য; প্রত্যাশিত ব্যর্থতায় (যেমন ব্যবহারকারীর ভুল ইনপুট) C++23-এর std::expected বা std::optional প্রায়ই পরিষ্কার। destructor থেকে exception বের হতে দেবেন না।

ঝালিয়ে নিন: পর্ব ৩৭ · exception আর std::expected, পর্ব ৩৮

constexpr (C++11, C++14-এ অনেক শিথিল) মানে “compile-এর সময় হিসাব করা যায়”। constexpr ভ্যারিয়েবলের মান compile-এর সময়ই ঠিক হতে হবে; constexpr ফাংশন compile-এর সময়ের মান দরকার এমন জায়গায় (যেমন static_assert বা constexpr ভ্যারিয়েবল) compile-এর সময় হিসাব হয়, আর সাধারণ argument পেলে চলার সময় চলে।

#include <array>
#include <print>

constexpr long long fact(int n) { return n <= 1 ? 1 : n * fact(n - 1); }

constexpr std::array<int, 6> make_squares() {
    std::array<int, 6> a{};
    for (int i = 0; i < 6; ++i) a[i] = i * i;
    return a;
}

int main() {
    static_assert(fact(5) == 120);          // compile-এর সময় যাচাই
    constexpr auto sq = make_squares();     // টেবিল compile-এর সময় তৈরি
    static_assert(sq[5] == 25);
    int n = 10;                             // চলার সময়ের মান
    std::println("fact(20)={} sq[4]={} fact(n)={}", fact(20), sq[4], fact(n));
}

উপসংহার: লাভ — চলার সময়ের হিসাব কমে, lookup table আগে থেকে তৈরি, আর compile-এর সময়ের হিসাবে ভাষার স্তরের undefined behavior (যেমন signed overflow) থাকলে compiler সেটিকে error হিসেবে ধরে। খরচ — compile সময় বাড়ে।

ঝালিয়ে নিন: পর্ব ৩৯ · constexpr

Concept (C++20) হলো template parameter-এর ওপর একটি নামযুক্ত শর্ত — compile-এর সময় যাচাই হওয়া একটি bool predicate. এটি বলে দেয় একটি টাইপের কী কী করতে পারা চাই।

#include <concepts>

template <std::integral T>                  // শুধু পূর্ণসংখ্যা টাইপ
T gcd(T a, T b) { return b == 0 ? a : gcd(b, a % b); }

template <typename T>
concept Printable = requires(const T& x) { x.print(); };   // নিজের concept

void show(const Printable auto& x) { x.print(); }

// gcd(4.5, 1.5);   // error: double, std::integral শর্ত পূরণ করে না

কেন দরকার: (১) পরিষ্কার error: concept ছাড়া ভুল টাইপ দিলে template-এর গভীর থেকে শত লাইনের error আসে; concept-এ এক লাইনে বলে “শর্ত পূরণ হয়নি”। (২) নকশার দলিল: ঘোষণা দেখেই বোঝা যায় কী টাইপ চলবে। (৩) overload বাছাই: শর্ত অনুযায়ী আলাদা সংস্করণ — বেশি নির্দিষ্ট শর্তওয়ালাটি প্রাধান্য পায় (subsumption). এর আগে এই কাজ std::enable_if আর SFINAE দিয়ে কঠিনভাবে করতে হতো।

উপসংহার: concept শুধু syntax যাচাই করে — x.print() লেখা যায় কি না; ফাংশনটি ঠিক কাজ করে কি না, সেটি যাচাই করে না। virtual interface-এর মতো চুক্তি, কিন্তু compile-time-এ এবং কোনো রানটাইম খরচ ছাড়া।

ঝালিয়ে নিন: পর্ব ৪০ · concepts

Undefined behavior (UB) হলো এমন কাজ, যার ফল সম্পর্কে C++ standard কোনো শর্ত দেয় না। প্রোগ্রাম ঠিক চলতে পারে, ভুল ফল দিতে পারে, crash করতে পারে, বা optimization চালু করলে আচরণ বদলে যেতে পারে। এটি implementation-defined (compiler নিজে ঠিক করে আর নথিতে লেখে, যেমন sizeof(int)) আর unspecified (কয়েকটি সম্ভাবনার যেকোনোটি, যেমন function argument-এর মূল্যায়নের ক্রম) থেকে আলাদা।

1. Signed integer overflow: int x = INT_MAX; x + 1; (unsigned-এ overflow সংজ্ঞায়িত — মান ঘুরে যায়)।
2. সীমার বাইরে প্রবেশ: v[10] যখন v.size() == 3 (v.at(10) হলে exception).
3. Dangling: শেষ হয়ে যাওয়া object-এর reference, pointer বা string_view ব্যবহার; delete-এর পর ব্যবহার (use-after-free).
4. শুরুর মান ছাড়া পড়া: int n; std::println("{}", n);
5. Data race: দুই thread একই ভ্যারিয়েবলে synchronization ছাড়া, অন্তত একটি লিখছে।
6. অন্যান্য: nullptr dereference, virtual destructor ছাড়া base pointer দিয়ে derived delete, new[]-কে delete দিয়ে মুক্ত করা, string literal বদলানো।

কেন বিপজ্জনক: compiler ধরে নেয় সঠিক প্রোগ্রামে UB নেই, আর সেই অনুমানে কোড বদলায়। যেমন if (x + 1 < x) দিয়ে overflow যাচাই — compiler ধরে নেয় signed overflow হয় না, তাই পুরো শর্তটাই মুছে দিতে পারে। ফলে “আমার মেশিনে চলে” প্রমাণ নয়।

উপসংহার: ধরার উপায় — -Wall -Wextra, -fsanitize=address,undefined, -fsanitize=thread, static analysis (clang-tidy), আর constexpr-এ পরীক্ষা। ভাইভায় “এর আউটপুট কী?” প্রশ্নের উত্তর যদি UB হয়, “undefined behavior” বলাটাই সঠিক উত্তর।

ঝালিয়ে নিন: পর্ব ৪৩ · Undefined Behavior ও নিরাপদ C++, পর্ব ১৮ · lifetime

Thread হলো একই process-এর ভেতরে স্বাধীনভাবে চলা একটি কাজের ধারা; সব thread একই মেমরি ভাগ করে। C++11 থেকে standard-এ std::thread, C++20-এ std::jthread.

• Race condition: ফল নির্ভর করে কোন thread আগে চলল তার ওপর। ++counter আসলে তিন ধাপ — পড়া, যোগ, লেখা; দুই thread মাঝপথে ঢুকে পড়লে একটি যোগ হারায়। synchronization ছাড়া একই ভ্যারিয়েবলে এমন লেখা data race — undefined behavior.
• Mutex: একসাথে শুধু একটি thread একটি critical section-এ ঢুকতে পারে। হাতে lock()/unlock() না করে RAII — std::lock_guard বা std::scoped_lock.
• Deadlock: দুই বা ততোধিক thread একে অপরের ধরে রাখা lock-এর জন্য চিরকাল অপেক্ষা করে। T1 ধরেছে A, চায় B; T2 ধরেছে B, চায় A.

#include <mutex>
#include <print>
#include <thread>
#include <vector>

int main() {
    long counter = 0;
    std::mutex m;
    auto work = [&] {
        for (int i = 0; i < 100000; ++i) {
            std::lock_guard<std::mutex> lock(m);   // এই লাইন মুছলে data race (UB)
            ++counter;
        }
    };
    std::vector<std::jthread> pool;
    for (int t = 0; t < 4; ++t) pool.emplace_back(work);
    pool.clear();                                 // jthread destructor-এ join করে
    std::println("counter = {}", counter);
}

Deadlock-এর চার শর্ত (সবগুলো একসাথে থাকলে তবেই হয়): mutual exclusion, hold and wait, no preemption, circular wait. এড়ানোর উপায়: (১) সব জায়গায় একই ক্রমে lock নেওয়া (lock ordering); (২) একাধিক mutex একসাথে std::scoped_lock lk(a, b); — এটি deadlock এড়ানোর কৌশল নিজেই প্রয়োগ করে; (৩) lock ধরে রেখে অজানা ফাংশন বা callback না ডাকা; (৪) lock-এর ভেতরে কাজ যত সম্ভব ছোট রাখা।

উপসংহার: মুদ্রণ করে বা debugger দিয়ে race ধরা কঠিন, কারণ সময় বদলালে বাগ লুকিয়ে যায় — -fsanitize=thread (ThreadSanitizer) ব্যবহার করুন। সবচেয়ে ভালো সমাধান প্রায়ই ভাগ করা ডেটা কমানো।

ঝালিয়ে নিন: পর্ব ৪৫ · মাল্টিথ্রেডিং, পর্ব ৪৬ · async, future আর atomics

Bjarne Stroustrup, Bell Labs-এ, ১৯৭৯ সালে কাজ শুরু করেন — নাম ছিল “C with Classes”. ১৯৮৩ সালে নাম হয় C++; ++ মানে “C-এর এক ধাপ পরের”। পর্ব ০১

প্রায়, পুরোপুরি নয়। void* থেকে স্বয়ংক্রিয় রূপান্তর C++-এ নেই (তাই int* p = malloc(8); error), আর new, class-এর মতো শব্দ C++-এ keyword. পর্ব ০১

Compile প্রতিটি .cpp ফাইলকে আলাদাভাবে object file বানায়; link সব object file আর library জুড়ে একটি executable বানায়। “undefined reference” হলো linker error — ঘোষণা আছে, সংজ্ঞা পাওয়া যায়নি। পর্ব ০৩

দুটিই নতুন লাইন দেয়, কিন্তু std::endl সাথে stream flush-ও করে। লুপে বারবার flush ধীর, তাই সাধারণত '\n'. পর্ব ০৭

initializer থেকে টাইপ বের করে (type deduction). শীর্ষ স্তরের const আর reference বাদ পড়ে, তাই a হলো int — একটি কপি। reference চাইলে auto& বা const auto&. পর্ব ০৫

Compile error — brace initialization-এ narrowing conversion নিষিদ্ধ। int x = 3.5; চলে, মান হয় 3 — এই নীরব ক্ষতি ঠেকাতেই {} পছন্দ করা হয়। পর্ব ০৫

Standard শুধু বলে অন্তত 16 bit; সাধারণ 64-bit Linux ও Windows-এ ৪ বাইট। নির্দিষ্ট মাপ লাগলে std::int32_t, std::int64_t. ভাইভায় অনুমানটি বলুন। পর্ব ০৫

3 আর 1. দুটিই int, তাই integer division — ভাগফল শূন্যের দিকে কাটা হয় (C++11 থেকে নিশ্চিত)। 7 / -3 = -2, তাই ভাগশেষ 7 − 6 = 1; ভাগশেষের চিহ্ন বাঁ দিকের সংখ্যার মতো। পর্ব ০৬

Fall-through — পরের case-এর কোডও চলতে থাকে। ইচ্ছে করে করলে C++17-এর [[fallthrough]]; লিখুন — compiler-এর সতর্কতা থামে, পাঠকও বোঝেন। পর্ব ০৮

auto — প্রতিটি উপাদানের কপি (ছোট টাইপে ঠিক আছে); auto& — উপাদান বদলাতে; const auto& — বড় object শুধু পড়তে, কপি ছাড়া। পর্ব ০৮

না — compile error. Overload বাছাই হয় শুধু argument দেখে; ডাকার জায়গায় return type দেখে বোঝার উপায় নেই। parameter-এর সংখ্যা বা টাইপ আলাদা হতে হবে। পর্ব ০৯

ফাংশন শেষ হলেই ভ্যারিয়েবলটির জীবন শেষ, তাই reference-টি dangling — ব্যবহার করা undefined behavior. GCC প্রায়ই সতর্ক করে (-Wreturn-local-addr); আর ফেরত টাইপ int&-এর মতো non-const reference হলে C++23-এ return x; সরাসরি compile error. মান ফেরত দিন; বাড়তি কপির ভয় নেই, RVO আর move আছে। পর্ব ১৮

না। int& r = x; r = y; মানে r-কে y-তে সরানো নয়, x-এ y-এর মান কপি করা। reference শুরুর সময়েই চিরকালের জন্য বাঁধা। পর্ব ১০

বৈধ উপায়ে না। int& r = *p; যখন p null — এখানেই null dereference, undefined behavior. তাই “কিছু নাও থাকতে পারে” বোঝাতে pointer বা std::optional. পর্ব ১০

দুটিই একই header দুবার ঢোকা ঠেকায়। Include guard (#ifndef … #define … #endif) standard; #pragma once standard নয়, কিন্তু GCC, Clang, MSVC সবাই সমর্থন করে আর লেখা সহজ। পর্ব ১১

নাম নিজের scope-এ থাকে (Color::Red), আপনাআপনি int-এ রূপান্তর হয় না, আর underlying type ঠিক করে দেওয়া যায়। ভুল তুলনা compile-এর সময়ই ধরা পড়ে। পর্ব ১২

C++17-এর বৈশিষ্ট্য — একটি pair, tuple বা struct-এর অংশগুলো একবারে আলাদা নামে নেওয়া: for (const auto& [name, marks] : result). map-এর লুপে সবচেয়ে কাজে লাগে। পর্ব ১২

size — এখন কয়টি উপাদান আছে; capacity — নতুন মেমরি না নিয়ে কয়টি ধরবে। আগে জানা থাকলে reserve(n) দিয়ে বারবার reallocation এড়ানো যায়। পর্ব ১৩

at সীমা যাচাই করে, বাইরে গেলে std::out_of_range ছোড়ে। [] যাচাই করে না — সীমার বাইরে গেলে undefined behavior, কিন্তু দ্রুত। পর্ব ১৩

এটি লেখার মালিক নয়, শুধু দেখে। অস্থায়ী string থেকে বানিয়ে রেখে দিলে — যেমন std::string_view sv = getName(); — string ধ্বংস হলেই sv dangling. পর্ব ১৪

nullptr-এর নিজস্ব টাইপ std::nullptr_t, যা শুধু pointer-এ রূপান্তর হয়। f(int) আর f(char*) থাকলে f(nullptr) নিশ্চিতভাবে pointer সংস্করণ ডাকে; f(0) ডাকে int সংস্করণ। পর্ব ১৫

new মেমরি নিয়ে constructor চালায় আর সঠিক টাইপের pointer দেয়; ব্যর্থ হলে std::bad_alloc. malloc শুধু কাঁচা বাইট দেয়, ব্যর্থ হলে NULL. delete destructor চালায়, free চালায় না। একটি দিয়ে নিয়ে অন্যটি দিয়ে ছাড়া undefined behavior. পর্ব ১৬

Undefined behavior — new[]-এর জোড়া delete[]. আধুনিক সমাধান: হাতে কোনোটিই নয়, std::vector<int> বা std::make_unique<int[]>(10). পর্ব ১৬

না — এটি move-only; copy constructor = delete. মালিকানা দিতে std::move(p); ফাংশন মালিকানা নিলে parameter std::unique_ptr<T> by value. শুধু ব্যবহার করলে T& বা T*. পর্ব ১৭

Class হলো নকশা — কী ডেটা, কী কাজ; object হলো সেই নকশায় তৈরি বাস্তব নমুনা, যার নিজের মেমরি আছে। বাড়ির নকশা একটি, বাড়ি অনেক। পর্ব ২০

Non-static member function-এর ভেতরে, যে object-এর ওপর ফাংশনটি ডাকা হয়েছে তার pointer (this pointer). static member function-এ this নেই। পর্ব ২০

সেই member-কে mutable ঘোষণা করুন — যেমন cache, গণনার counter বা mutex, যা object-এর বাইরের দৃশ্যমান অবস্থার অংশ নয়। অন্য কিছু হলে ফাংশনটি আসলে const হওয়ার কথাই নয়। পর্ব ২০

যখন আপনি কোনো constructor-ই লেখেননি। একটি parameterized constructor লিখলেই আর বানায় না — তখন দরকার হলে Account() = default; লিখুন। পর্ব ২১

এক argument-এর constructor দিয়ে অনাকাঙ্ক্ষিত স্বয়ংক্রিয় রূপান্তর ঠেকাতে। explicit Meters(double) থাকলে Meters m = 5.0; বা f(5.0) চলবে না, লিখতে হবে Meters{5.0}. পর্ব ২১

আগে base class, তারপর member-গুলো class-এ ঘোষণার ক্রমে — initializer list-এ যে ক্রমেই লিখুন। ধ্বংস হয় উল্টো ক্রমে। পর্ব ২১

by value হলে parameter বানাতেই একটি কপি লাগত — অর্থাৎ আবার copy constructor ডাকা, তার জন্য আবার… অসীম। তাই ভাষার নিয়মেই by-value copy constructor নিষিদ্ধ; লেখা হয় const T&. পর্ব ২২

প্রথমটি নতুন object তৈরি — copy constructor. দ্বিতীয়টি আগে থেকে থাকা object-এ নতুন মান — copy assignment (operator=). পর্ব ২২

হাতে লেখা operator= আগে নিজের পুরোনো রিসোর্স delete করে তারপর উৎস থেকে কপি করলে, উৎস আর গন্তব্য একই বলে কপির ডেটা আগেই মুছে গেছে। সমাধান: if (this == &o) যাচাই, বা copy-and-swap. পর্ব ২২

একটি ফাংশন ইচ্ছে করে নিষিদ্ধ করা (deleted function) — যেমন copy বন্ধ করে class-কে move-only বানানো, বা void f(double) = delete; দিয়ে অনাকাঙ্ক্ষিত রূপান্তরের ডাক আটকানো। ব্যবহার করলে compile error. পর্ব ২২

::, ., .* আর ?:; এছাড়া sizeof, typeid, alignof-এর মতো keyword-অপারেটর। পর্ব ২৩

Postfix-এ একটি নকল int parameter থাকে: T operator++(int), যা পুরোনো মানের কপি ফেরত দেয়। Prefix T& operator++() নিজেকেই ফেরত দেয় — কপি নেই বলে প্রায়ই দ্রুত। পর্ব ২৩

Derived object-কে base টাইপের মান হিসেবে কপি করলে derived অংশ কেটে বাদ পড়ে — Payment p = bkash;. এরপর virtual ডাকেও base-এর সংস্করণ চলে। এড়াতে reference বা pointer ব্যবহার করুন। পর্ব ২৪

B আর C দুটিই A থেকে derived, আর D দুটি থেকেই — তখন D-র ভেতরে A-র দুটি কপি থাকে, A-র member ধরলে ambiguity. সমাধান: B আর C-তে class B : virtual public A — তখন A-র একটিই কপি থাকে। পর্ব ২৪

Base-এর এমন ফাংশন, যা derived override করতে পারে, আর base-এর pointer বা reference দিয়ে ডাকলে object-এর আসল টাইপের সংস্করণ চলার সময় বাছাই হয়। পর্ব ২৫

প্রচলিত বাস্তবায়নে প্রতিটি polymorphic class-এর একটি vtable, প্রোগ্রামের স্থির ডেটা অংশে — heap বা stack-এ নয়। প্রতিটি object-এ শুধু একটি vptr (64-bit-এ সাধারণত ৮ বাইট)। এগুলো standard-এর নিয়ম নয়, compiler-এর কৌশল। পর্ব ২৫

Base-এর সংস্করণ। তখনো derived অংশ তৈরি হয়নি, তাই object-এর dynamic type ধরা হয় যে class-এর constructor চলছে সেটি। destructor-এর ভেতরেও একই নিয়ম। ফাংশনটি pure virtual হলে undefined behavior. পর্ব ২৫

না। object তৈরির সময় টাইপ আপনি নিজেই লিখে দেন, আর vptr বসানোই constructor-এর কাজ — তার আগে বাছাইয়ের কিছু নেই। “virtual constructor”-এর দরকার মেটায় virtual clone() ফাংশন বা factory function. পর্ব ২৫

override — base-এ মেলানো virtual ফাংশন না থাকলে compile error, তাই নামের বা signature-এর ভুল ধরা পড়ে। final — এই ফাংশন আর override করা যাবে না, বা এই class থেকে আর derive করা যাবে না। পর্ব ২৫

Object বানানো যায় না — compile error. কিন্তু তার pointer বা reference রাখা যায়, আর সেটিই polymorphism-এর মূল ব্যবহার: std::unique_ptr<Shape> s = std::make_unique<Square>(4); পর্ব ২৬

Composition (“has-a”) দুটি class-কে কম শক্তভাবে বাঁধে — ভেতরের অংশ বদলানো বা চলার সময় অন্যটি বসানো সহজ, base-এর ভেতরের পরিবর্তনে derived ভাঙে না। inheritance রাখুন সত্যিকারের “is-a” সম্পর্কের জন্য, যেখানে derived সব জায়গায় base-এর জায়গা নিতে পারে। পর্ব ২৭

Instantiation-এর সময় compiler-কে পুরো সংজ্ঞা দেখতে হয় — শুধু ঘোষণা দেখে Box<int>-এর কোড বানাতে পারে না। বিকল্প: .cpp-তে নির্দিষ্ট টাইপের জন্য explicit instantiation. পর্ব ২৮

Macro preprocessor-এর লেখা বদল — টাইপ যাচাই নেই, scope মানে না, argument একাধিকবার মূল্যায়ন হতে পারে। Template compiler-এর অংশ — টাইপ যাচাই হয়, namespace মানে, debug করা যায়। পর্ব ২৮

Class template argument deduction (C++17) — constructor-এর argument দেখে class template-এর টাইপ বের করা। std::vector v{1, 2, 3}; লিখলেই std::vector<int>, std::pair p{1, 2.5}; হয় pair<int, double>. পর্ব ২৯

Amortized O(1). মাঝে মাঝে জায়গা ফুরালে সব উপাদান নতুন মেমরিতে সরাতে হয় (O(n)), কিন্তু capacity গুণিতক হারে বাড়ে (libstdc++-এ দ্বিগুণ), তাই গড়ে প্রতি push_back-এ ধ্রুবক খরচ। পর্ব ৩০

push_back একটি তৈরি object কপি বা move করে ঢোকায়; emplace_back constructor-এর argument নিয়ে উপাদানটি vector-এর ভেতরেই তৈরি করে — v.emplace_back("Rahim", 5000);. আগে থেকে তৈরি object-এ দুটির পার্থক্য প্রায় নেই। পর্ব ৩০

না — std::sort-এর random-access iterator লাগে, list-এর iterator শুধু bidirectional. তাই list-এর নিজের member function আছে: lst.sort(); পর্ব ৩২

key না থাকলে operator[] নতুন একটি ডিফল্ট উপাদান ঢুকিয়ে দেয় — map অকারণে বড় হয়, আর const map-এ এটি compile-ই হয় না। খুঁজতে find বা C++20-এর contains. পর্ব ৩১

যখন অনেক key একই bucket-এ পড়ে (hash collision) — তখন খোঁজা O(n). খারাপ hash function বা ইচ্ছে করে বানানো ইনপুটে এমন হয়। পর্ব ৩১

std::remove_if আসলে কিছু মোছে না — রাখার উপাদানগুলো সামনে সরিয়ে নতুন “শেষ” ফেরত দেয়; তারপর v.erase(that, v.end()) বাকিটা মোছে। C++20 থেকে এক লাইনে: std::erase_if(v, pred); পর্ব ৩৩

Compiler একটি নামহীন class বানায়, যার operator()-ই lambda-র শরীর, আর capture করা ভ্যারিয়েবলগুলো সেই class-এর member. lambda-টি সেই class-এর একটি object — একটি function object. পর্ব ৩৪

যখন যেকোনো ধরনের callable (lambda, ফাংশন, function object) একই টাইপে রাখতে হয় — যেমন callback-এর তালিকা। খরচ: ভেতরে type erasure, বড় capture-এ heap allocation হতে পারে, আর ডাক সাধারণত inline হয় না। template বা auto parameter-এ এই খরচ নেই। পর্ব ৩৪

v | std::views::filter(...) | std::views::transform(...) কোনো নতুন container বানায় না; উপাদান চাওয়ার মুহূর্তেই হিসাব হয় (lazy evaluation). view মূল ডেটার মালিক নয় — মূল container ধ্বংস হলে view dangling. পর্ব ৩৫

না। std::move শুধু একটি cast — lvalue-কে rvalue reference (xvalue) বানায়, যাতে move constructor বা move assignment বাছাই হয়। আসল সরানোর কাজ করে সেই ফাংশনগুলো। পর্ব ৩৬

Standard library-র object থাকে “বৈধ কিন্তু অনির্দিষ্ট” অবস্থায় — ধ্বংস করা বা নতুন মান বসানো নিরাপদ, কিন্তু পড়ে কোনো নির্দিষ্ট মান আশা করা নয়। std::string বাস্তবে সাধারণত খালি হয়, তবু তার ওপর নির্ভর করবেন না। পর্ব ৩৬

vector বড় হওয়ার সময় strong guarantee রাখতে চায়। move মাঝপথে exception ছুড়লে পুরোনো অবস্থা ফেরানো যায় না, তাই move constructor noexcept না হলে (আর copy সম্ভব হলে) vector move-এর বদলে copy করে — ধীর। পর্ব ৩৬

মোটা দাগে: lvalue-এর পরিচয় আছে — নাম, ঠিকানা নেওয়া যায় (x, v[0]); rvalue অস্থায়ী মান (x + 1, std::string("hi")). C++11 থেকে আরও সূক্ষ্ম ভাগ: lvalue, prvalue, xvalue. পর্ব ৩৬

C++11 থেকে destructor ডিফল্টভাবে noexcept, তাই exception বের হলেই std::terminate — প্রোগ্রাম বন্ধ। destructor-এর ভেতরে ভুল হলে সেখানেই সামলান বা লগ করুন। পর্ব ৩৭

যেকোনো exception ধরে (catch-all). সাধারণত সবার শেষে, প্রোগ্রামের সীমানায় — লগ করে throw; দিয়ে আবার ছুড়তে বা নিরাপদে বন্ধ করতে। এতে exception-এর ধরন জানা যায় না। পর্ব ৩৭

optional<T> — একটি মান থাকতেও পারে, না-ও পারে (C++17); variant<A, B> — কয়েকটি টাইপের ঠিক একটি (C++17); expected<T, E> — হয় মান, নয় ভুলের কারণ (C++23). পর্ব ৩৮

Compile-এর সময় একটি শর্ত যাচাই — মিথ্যা হলে compile error. যেমন static_assert(sizeof(void*) == 8); নিশ্চিত করে কোডটি 64-bit-এর জন্য compile হচ্ছে। পর্ব ৩৯

Concepts, ranges, coroutines আর modules — প্রচলিতভাবে “বড় চার”। সাথে তিন-মুখী তুলনা <=>, std::span, std::format, consteval. পর্ব ৪২

Signed overflow undefined behavior; unsigned overflow সংজ্ঞায়িত — মান 2ⁿ দিয়ে ভাগশেষে ঘুরে যায় (UINT_MAX + 1u == 0). পর্ব ৪৩

joinable অবস্থায় destructor চললে std::terminate. হয় join(), নয় detach() করতে হয়। C++20-এর std::jthread destructor-এ নিজেই join করে, আর stop token দিয়ে থামার অনুরোধও পাঠাতে পারে। পর্ব ৪৫

না। Data race নির্দিষ্ট — synchronization ছাড়া একই মেমরিতে দুই thread, অন্তত একটি লিখছে; C++-এ UB. Race condition বড় ধারণা — ফল thread-এর সময়ের ওপর নির্ভর করা; প্রতিটি অপারেশনে mutex থাকলেও যুক্তির ভুলে race condition থাকতে পারে (যেমন “যাচাই, তারপর কাজ” আলাদা দুই lock-এ)। পর্ব ৪৫

সব জায়গায় একই ক্রমে lock নিন, অথবা একাধিক mutex একসাথে std::scoped_lock দিয়ে নিন — এটি নিজেই deadlock এড়ানোর কৌশল প্রয়োগ করে। পর্ব ৪৫

std::atomic একটি ভ্যারিয়েবলের একক অপারেশন (যোগ, পড়া, compare-exchange) lock ছাড়াই নিরাপদ করে — সাধারণত একটি hardware instruction. কয়েকটি ভ্যারিয়েবল একসাথে সামঞ্জস্য রেখে বদলাতে হলে mutex. পর্ব ৪৬

না। C++-এ volatile শুধু বলে প্রতিটি পড়া-লেখা সত্যিই মেমরিতে হবে (hardware register-এর জন্য); এটি atomicity বা thread-এর মধ্যে ক্রম দেয় না। thread-এর জন্য std::atomic বা mutex. পর্ব ৪৬

একটি build system generator — CMakeLists.txt-এর বর্ণনা থেকে Makefile, Ninja বা Visual Studio project বানায়। একই প্রজেক্ট Linux, Windows, macOS-এ build করা যায়। পর্ব ৪৭

Debug: সাধারণত -O0 -g — optimization নেই, debugger-এর তথ্য আছে। Release: -O2 বা -O3, প্রায়ই -DNDEBUG — তাতে assert বন্ধ হয়ে যায়। কিছু UB-জনিত বাগ শুধু release build-এ দেখা দেয়। পর্ব ৪৭

-g দিয়ে compile করে gdb-তে চালান; crash-এর পর bt (backtrace) দেখায় কোন লাইনে থেমেছে। সাথে -fsanitize=address দিয়ে চালালে ভুল পড়া-লেখার সঠিক জায়গা ও কারণ জানা যায়। পর্ব ৪৮

Unit test একটি ছোট অংশ — সাধারণত একটি ফাংশন বা class — জানা ইনপুটে প্রত্যাশিত ফল দেয় কি না স্বয়ংক্রিয়ভাবে যাচাই করে। জনপ্রিয় framework: GoogleTest, Catch2, doctest. edge case অবশ্যই রাখুন। পর্ব ৪৮

এটি C-এর stdio-র সাথে iostream-এর সমন্বয় বন্ধ করে, আর std::cin.tie(nullptr) প্রতিটি ইনপুটের আগে cout flush বন্ধ করে — বড় ইনপুটে cin/cout অনেক দ্রুত হয়। এরপর একই stream-এ printf/scanf আর cin/cout মেশাবেন না। পর্ব ৫০