constructor ও destructor — object-এর জন্ম আর বিদায়

১ · জন্মের মুহূর্ত থেকেই বৈধ — constructor-এর আসল কাজ

আগের পর্বে আপনি class বানিয়েছেন: কিছু data member, কিছু member function, আর private দিয়ে ভেতরের ডেটা লুকানো। কিন্তু একটি প্রশ্ন বাকি থেকে গেছে। একটি Date class-এর ভেতরে দিন, মাস আর বছর আছে। object তৈরি হওয়ার ঠিক পরের মুহূর্তে এই তিনটি সংখ্যার মান কী? কেউ যদি ভুলে মান না বসায়, বা বসায় ৩১ ফেব্রুয়ারি?

পর্ব ২০-এ দেখেছেন, প্রতিটি ভালো class-এর একটি invariant থাকে — এমন নিয়ম, যা object-এর পুরো জীবনে সত্য থাকতে হবে। Date-এর invariant: “মাস ১ থেকে ১২, দিন সেই মাসের দিনসংখ্যার মধ্যে।” member function-গুলো এই নিয়ম রক্ষা করে। কিন্তু রক্ষা করার আগে নিয়মটা প্রতিষ্ঠা করতে হয় — আর সেটাই constructor-এর কাজ।

default আর parameterized constructor

constructor একটি বিশেষ member function: নাম ঠিক class-এর নামে, কোনো return type নেই (এমনকি void-ও নয়), আর object তৈরির সময় compiler নিজেই তাকে ডাকে। যে constructor কোনো argument ছাড়াই ডাকা যায়, সেটি default constructor. যে constructor argument নেয়, তাকে সাধারণভাবে বলে parameterized constructor. পর্ব ৯-এর function overloading-এর নিয়মে একটি class-এ একাধিক constructor থাকতে পারে:

class Date {
    int d, m, y;
public:
    Date() : d(1), m(1), y(2000) {}                       // default constructor
    Date(int day, int month, int year)                    // parameterized
        : d(day), m(month), y(year) { /* যাচাই — অংশ ৭-এ */ }
};

Date a;               // default constructor: 01/01/2000
Date b(16, 12, 1971); // parameterized: বিজয় দিবস
Date c{26, 3, 1971};  // একই, কিন্তু {} দিয়ে — অংশ ৬-এ কেন ভালো

একটি গুরুত্বপূর্ণ নিয়ম: আপনি যদি class-এ কোনো constructor না লেখেন, compiler নিজে একটি default constructor বানিয়ে দেয়। কিন্তু একটিও constructor লিখলে (যেমন শুধু তিন-argument-এরটি), compiler আর default constructor বানায় না। তখন Date a; লিখলে compile error. এটা ইচ্ছাকৃত: আপনি যদি বলেন “Date বানাতে দিন-মাস-বছর লাগবেই”, তাহলে compiler চুপচাপ একটি ফাঁকা Date বানানোর পথ খোলা রাখবে কেন?

constructor আর destructor হলো special member function-দের সদস্য — এমন ফাংশন, যা দরকার হলে compiler নিজে তৈরি করতে পারে। মোট ছয়টি: default constructor, destructor, copy constructor, copy assignment, move constructor আর move assignment. প্রথম দুটি এই পর্বে; বাকি চারটি পরের পর্বে, Rule of 0/3/5-এর সাথে।

২ · member initializer list — body-তে assignment নয়

উপরের কোডে constructor-এর মাথার পরে একটি : আর তারপর d(day), m(month), y(year) দেখেছেন। এর নাম member initializer list. নতুনরা (আর অনেক AI টুলও) প্রায়ই এভাবে লেখেন:

Date(int day, int month, int year) {
    d = day;      // এটা initialization নয় — assignment
    m = month;
    y = year;
}

সাধারণ int-এর ক্ষেত্রে ফলাফল একই মনে হয়, কিন্তু ভেতরের ঘটনা আলাদা। C++-এর নিয়ম হলো: constructor-এর body-র { শুরু হওয়ার আগেই সব member তৈরি হয়ে যায়। initializer list-এ যা বলা আছে, সেভাবে; যা বলা নেই, সেটি তার নিজের default উপায়ে (std::string হলে ফাঁকা string, int হলে অনির্ধারিত আবর্জনা মান)। body-তে = লেখা মানে তৈরি-হয়ে-যাওয়া একটি member-এর মান পরে বদলানো। এই পার্থক্য তিন জায়গায় বড় হয়ে ওঠে। ধাপে ধাপে দেখুন:

1class Student {2    const int roll;3    std::string name;4public:5    // A: body-তে assignment6    Student(int r, const std::string& n) {7        roll = r;8        name = n;9    }10    // B: initializer list11    Student(int r, const std::string& n)12        : roll(r), name(n)13    {}14};

default member initializer — ডিফল্ট মান class-এর ভেতরেই

পর্ব ১২-এ struct-এ দেখেছেন, member-এর পাশেই ডিফল্ট মান লেখা যায়: এর নাম default member initializer. class-এও একই জিনিস চলে, আর অনেক constructor থাকলে এটি দারুণ কাজে আসে:

class Account {
    std::string owner;
    long long balance = 0;      // ডিফল্ট: শূন্য টাকা
    bool locked{false};         // {} দিয়েও লেখা যায়
public:
    Account() = default;                                    // owner "", balance 0, locked false
    explicit Account(std::string o) : owner(std::move(o)) {} // balance আর locked ডিফল্ট মানে
    Account(std::string o, long long b) : owner(std::move(o)), balance(b) {} // balance-এর ডিফল্ট উপেক্ষিত
};

নিয়মটা সরল: কোনো constructor-এর initializer list যদি একটি member-এর কথা বলে, সেটাই চলে; না বললে default member initializer চলে; সেটিও না থাকলে member তার নিজের default উপায়ে তৈরি হয়। ফলে int বা pointer-এর মতো member-এর পাশে সবসময় একটি ডিফল্ট মান লিখে রাখা ভালো অভ্যাস — তাহলে কোনো constructor ভুলে গেলেও আবর্জনা মান থাকে না।

৩ · তৈরি আর ধ্বংসের ক্রম

একটি object-এর ভেতরে অন্য object থাকলে (পর্ব ২-এর composition), কে আগে জন্মায়, কে আগে বিদায় নেয়? এই ক্রম C++ standard ঠিক করে দেয়, আর এটা জানা থাকলে অনেক সূক্ষ্ম বাগ আগেই ধরতে পারবেন। একটি রিকশা বানানোর কারখানা কল্পনা করুন — রিকশার ভেতরে চাকা, সিট আর হুড। প্রতিটি অংশের constructor আর destructor একটি লাইন প্রিন্ট করে:

#include <print>
#include <string>

struct Part {
    std::string name;
    explicit Part(const char* n) : name(n) { std::println("  make  {}", name); }
    ~Part() { std::println("  break {}", name); }
};

class Rickshaw {
    Part wheel{"wheel"};     // default member initializer
    Part seat;
    Part hood;
public:
    Rickshaw() : seat("seat"), hood("hood") { std::println("Rickshaw ready"); }
    ~Rickshaw() { std::println("Rickshaw scrapped"); }
};

int main() {
    Rickshaw r;
    std::println("riding...");
}

এবার একটি ফাঁদ। ধরুন initializer list-এ ক্রম উল্টে লিখলেন: Rickshaw() : hood("hood"), seat("seat"). কোনটি আগে তৈরি হবে? নিজে অনুমান করে তারপর stepper চালান:

1class Rickshaw {2    Part wheel{"wheel"};3    Part seat;4    Part hood;5public:6    Rickshaw() : hood("hood"), seat("seat")   // ক্রম উল্টো!7    { std::println("Rickshaw ready"); }8    ~Rickshaw() { std::println("Rickshaw scrapped"); }9    // body শেষে member ধ্বংস: hood, seat, wheel10};11int main() {12    Rickshaw r;13    std::println("riding...");14}

একই “উল্টো ক্রম” নিয়ম object-দের ক্ষেত্রেও। একটি ফাংশনে a, তারপর b তৈরি হলে ধ্বংস হয় আগে b, তারপর a — পর্ব ১৭-এর লাইব্রেরির বইয়ের মতো। global আর static object-ও প্রোগ্রাম শেষে তাদের তৈরির উল্টো ক্রমে ধ্বংস হয়। পর্ব ২৪-এ inheritance এলে আরও একটি স্তর যোগ হবে: base class-এর অংশ তৈরি হয় সবার আগে, member-দেরও আগে, আর ধ্বংস হয় সবার শেষে।

৪ · delegating constructor, = default আর = delete

একটি constructor অন্যটিকে কাজ দেয়

একটি লগ ফাইলের class ভাবুন — একটি সার্ভার যেখানে প্রতিটি ঘটনা লিখে রাখে। কেউ শুধু ফাইলের নাম দেবে, কেউ নাম আর মোড (আগের লেখার পরে যোগ করা, নাকি মুছে নতুন শুরু), কেউ কিছুই দেবে না। তিনটি constructor-এ একই যাচাই আর ফাইল-খোলার কোড তিনবার লিখলে, একদিন একটিতে বদলাবেন আর বাকি দুটিতে ভুলে যাবেন। C++11 থেকে এর সমাধান delegating constructor: একটি constructor তার initializer list-এ অন্য একটি constructor ডাকে।

class LogFile {
    std::ofstream out;
    std::string path;
public:
    LogFile(const std::string& p, bool append)              // আসল কাজ এখানেই
        : out(p, append ? std::ios::app : std::ios::trunc), path(p)
    {
        if (!out) throw std::runtime_error("cannot open " + p);
        std::println("open {}", path);
    }
    explicit LogFile(const std::string& p) : LogFile(p, true) {}   // ডিফল্ট মোড: append
    LogFile() : LogFile("app.log") {}                              // ডিফল্ট ফাইল
    ~LogFile() { std::println("close {}", path); }                 // out নিজে ফাইল বন্ধ করে

    LogFile(const LogFile&) = delete;              // একই ফাইলের দুই মালিক নয়
    LogFile& operator=(const LogFile&) = delete;
};

এখানে LogFile() কাজ দেয় এক-argument-এর constructor-কে, আর সেটি দুই-argument-এর আসলটিকে। এই শৃঙ্খলে ঠিক কোনটি কখন চলে, দেখুন:

1LogFile() : LogFile("app.log")2{ std::println("default file"); }3explicit LogFile(const std::string& p) : LogFile(p, true)4{ std::println("default mode: append"); }5LogFile(const std::string& p, bool append)6    : out(p, append ? std::ios::app : std::ios::trunc), path(p)7{ std::println("open {}", path); }8~LogFile() { std::println("close {}", path); }910LogFile log;   // কোনো argument নেই

শৃঙ্খলে কখনো বৃত্ত বানাবেন না (A ডাকে B, B ডাকে A) — এটা ভুল প্রোগ্রাম, compiler সবসময় ধরতে পারে না। আর বেশিরভাগ ক্ষেত্রে default argument বা default member initializer দিয়েও একই ফল পাওয়া যায়; delegating constructor সবচেয়ে কাজের, যখন body-তে যাচাইয়ের মতো আসল কোড আছে।

= default — compiler-এর নিজের নিয়মে বানানো

অন্য constructor লিখলে compiler default constructor বানানো বন্ধ করে, মনে আছে? কিন্তু কখনো আপনি দুটোই চান — Account-এর মতো, যেখানে ফাঁকা Account-ও অর্থবহ, কারণ default member initializer আগেই ঠিক মান দিয়ে রেখেছে। তখন লিখুন Account() = default;. এটি একটি defaulted function: compiler-কে স্পষ্ট করে বলা, “নিজের নিয়মে এটা বানাও।” Account() {} লেখার চেয়ে এটা ভালো, কারণ compiler তখন class-টিকে আরও সরল (trivial) রাখতে পারে আর পাঠকও বোঝেন — এখানে বিশেষ কিছু নেই।

= delete — নিষেধ, compiler-এর মুখে

উপরের LogFile-এ copy constructor আর copy assignment-এর পরে = delete দেখেছেন। এটি একটি deleted function: ফাংশনটি আছে, কিন্তু ডাকলেই compile error. একই ফাইলের দুটি LogFile object থাকলে দুটিই একদিন ফাইল বন্ধ করত, তাই কপি নিষেধ — পর্ব ১৭-এর unique_ptr ঠিক এভাবেই কপি আটকায়। = delete যেকোনো ফাংশনে চলে। যেমন void setAge(int a);-এর পাশে void setAge(double) = delete; লিখলে setAge(25.7) আর চুপচাপ 25 হয়ে যায় না, error দেয়। (কপি আর move-এর পুরো নিয়ম পরের পর্বে।)

৫ · explicit — অজান্তে টাইপ বদল আটকানো

একটি argument নেওয়া constructor-এর একটি গোপন ক্ষমতা আছে: C++ তাকে implicit conversion-এর জন্য ব্যবহার করে। অর্থাৎ যেখানে Temperature দরকার, সেখানে একটি double দিলে compiler নিজে থেকেই Temperature(double) ডেকে রূপান্তর করে নেয়। এমন constructor-কে বলে converting constructor. কখনো এটা সুবিধাজনক (std::string s = "hi"; এভাবেই কাজ করে), কিন্তু নিজের টাইপে প্রায়ই বিপজ্জনক। একটি আবহাওয়া স্টেশনের কোডে কী হতে পারে, দেখুন:

1struct Temperature {2    double celsius;3    Temperature(double c) : celsius(c) {}      // explicit নেই4};5void checkHeat(Temperature t) { if (t.celsius > 40) alarm(); }6double h = sensor.humidity();   // 85 (শতাংশ)7checkHeat(h);                   // ভুল ভ্যারিয়েবল!8// ঠিক করা সংস্করণ:9explicit Temperature(double c) : celsius(c) {}10checkHeat(h);                   // এবার error11checkHeat(Temperature{36.5});   // উদ্দেশ্য চোখে দেখা যায়

৬ · brace initialization, most vexing parse আর aggregate

কেন {} — uniform initialization

C++11-এর আগে object বানানোর উপায় ছিল কয়েক রকম: =, (), আর array-র জন্য {}. প্রতিটির নিয়ম আলাদা। C++11 আনল brace initialization — প্রায় সব জায়গায় {} চলে, তাই একে “uniform initialization”-ও বলা হয়। পর্ব ৫-এ এর একটি সুবিধা দেখেছেন: {} narrowing conversion আটকায়। int marks{87.5}; compile error, অথচ int marks = 87.5; চুপচাপ 87 বানায়। constructor-এর বেলাতেও একই — Date d{16.5, 12, 1971} error দেয়।

most vexing parse — দেখতে object, আসলে ফাংশন

এবার একটি বিখ্যাত ফাঁদ। নিচের লাইনটি দেখে মনে হয় default constructor দিয়ে একটি Timer বানানো হচ্ছে:

Timer t();          // ফাঁদ: এটা object নয়! "t নামের ফাংশন, যে Timer ফেরত দেয়"
t.start();          // error: request for member 'start' in 't', which is of non-class type 'Timer()'

Timer t1;           // ঠিক: default constructor
Timer t2{};         // ঠিক: {} দিয়ে, সবচেয়ে স্পষ্ট

কারণটা C থেকে আসা একটি ব্যাকরণ-নিয়ম: যে লাইনকে ঘোষণা (declaration) হিসেবে পড়া সম্ভব, compiler তাকে ঘোষণাই ধরে। Timer t(); হুবহু একটি ফাংশন ঘোষণার মতো, যেমন int rand();. এই বিভ্রান্তির নাম most vexing parse. আরও জটিল রূপে দুটি টাইপের নাম একসাথে এলে (Widget w(Gadget());) অভিজ্ঞ প্রোগ্রামারও ধোঁকা খান। {} কখনো ফাংশন ঘোষণা হতে পারে না, তাই brace initialization এই সমস্যা পুরোপুরি দূর করে।

aggregate আর designated initializer

সব টাইপের constructor লাগে না। যে struct শুধু কিছু মান একসাথে বহন করে — কোনো invariant নেই, সব member public — তাকে C++ বলে aggregate, আর তাকে সরাসরি {} দিয়ে member-ক্রমে মান দেওয়া যায়: aggregate initialization. C++20 থেকে member-এর নাম লিখেও দেওয়া যায় — designated initializer:

struct Delivery {                 // aggregate: কোনো constructor নেই, সব public
    std::string area;
    int parcels = 1;              // default member initializer চলে
    bool cashOnDelivery = false;
};

Delivery a{"Mirpur", 3, true};                       // ক্রম অনুযায়ী
Delivery b{.area = "Uttara", .cashOnDelivery = true}; // C++20: নাম ধরে; parcels = 1
// Delivery c{.cashOnDelivery = true, .area = "Banani"}; // error: ঘোষণার ক্রম মানেনি

designated initializer পড়তে সহজ: true কোন member-এর মান, তা আর অনুমান করতে হয় না। দুটি নিয়ম: নামগুলো ঘোষণার ক্রমেই লিখতে হবে (মাঝে বাদ দেওয়া চলে), আর নাম-দেওয়া ও নাম-ছাড়া মান মেশানো যায় না। আর একটি সূক্ষ্ম কথা: C++20 থেকে কোনো struct-এ যেকোনো constructor ঘোষণা করলেই (এমনকি = default দিলেও) সেটি আর aggregate থাকে না। সিদ্ধান্তের নিয়ম: struct-এর member-দের মধ্যে কোনো নিয়ম রক্ষা করতে হলে (যেমন Date-এর বৈধ তারিখ), constructor-সহ class বানান; শুধু মান বহন করলে aggregate-ই যথেষ্ট।

৭ · যাচাই করা constructor — অবৈধ object জন্মাতেই দেবেন না

এবার অংশ ১-এর প্রতিশ্রুতি রাখার পালা: একটি Date, যা ৩১ ফেব্রুয়ারি নিতে অস্বীকার করে। constructor-এর কোনো return value নেই, তাই “ব্যর্থ হলাম” জানানোর একমাত্র পরিষ্কার উপায় একটি exception ছোড়া। exception বের হলে object আর তৈরিই হয় না — কোনো ভুল Date কারও হাতে পৌঁছায় না।

#include <print>
#include <stdexcept>
class Date {
    int d, m, y;
    static int daysIn(int month, int year) {
        static constexpr int days[] = {31,28,31,30,31,30,31,31,30,31,30,31};
        bool leap = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
        return (month == 2 && leap) ? 29 : days[month - 1];
    }
public:
    Date(int day, int month, int year) : d(day), m(month), y(year) {
        if (m < 1 || m > 12 || d < 1 || d > daysIn(m, y)) throw std::invalid_argument("invalid date");
    }
    void show() const { std::println("{:02}/{:02}/{}", d, m, y); }
};
int main() {
    Date a(29, 2, 2024);  a.show();
    try { Date b(31, 2, 2025);  b.show(); }
    catch (const std::invalid_argument& e) { std::println("rejected: {}", e.what()); }
}

একটি গুরুত্বপূর্ণ নিয়ম: constructor exception ছুড়লে সেই object-এর destructor চলে না — কারণ object তো কখনো সম্পূর্ণ হয়নি। তবে তার যে member-রা ততক্ষণে তৈরি হয়ে গেছে, তাদের destructor ঠিকই চলে (তৈরির উল্টো ক্রমে)। এজন্যই রিসোর্স রাখুন RAII member-এ (std::ofstream, std::vector, std::unique_ptr): constructor-এর মাঝপথে ব্যর্থ হলেও আগে নেওয়া রিসোর্স নিজে থেকে ফেরত যায়। constructor-এ খোলা new লিখে পরের লাইনে exception হলে সেই মেমরি leak হয়। exception-এর পুরো গল্প, আর exception ছাড়া ব্যর্থতা জানানোর বিকল্প (std::expected), পর্ব ৩৭-এ।

৮ · destructor — শেষ মুহূর্তের দায়িত্ব

destructor-এর নাম ~ আর class-এর নাম, কোনো parameter নেই, কোনো return type নেই, আর প্রতিটি class-এ ঠিক একটি। পর্ব ১৭-এ দেখেছেন এটি RAII-এর অর্ধেক: constructor রিসোর্স নেয়, destructor ফেরত দেয়। এখানে তিনটি নকশা-প্রশ্ন বাকি।

কখন destructor লিখবেন? প্রায় কখনোই না

উপরের LogFile-এর destructor শুধু একটি লাইন প্রিন্ট করে; ফাইল বন্ধ করে std::ofstream member-টি নিজেই, তার নিজের destructor-এ। Account, Date, Delivery — কারও destructor লাগেনি। এটাই Rule of Zero: রিসোর্স রাখুন RAII member-এ, তাহলে compiler-এর বানানো destructor-ই সব member-কে ঠিক ক্রমে ধ্বংস করবে। নিজে destructor লিখুন শুধু তখন, যখন class নিজেই একটি কাঁচা রিসোর্সের মালিক — যেমন C লাইব্রেরির একটি handle, যার জন্য কোনো RAII মোড়ক নেই।

destructor কখনো exception ছোড়ে না

C++11 থেকে প্রতিটি destructor ডিফল্টভাবে noexcept — অর্থাৎ “আমি exception ছুড়ব না” প্রতিশ্রুতি দেওয়া। কোনো destructor থেকে তবু exception বের হলে প্রোগ্রাম সঙ্গে সঙ্গে std::terminate দিয়ে বন্ধ হয়। কারণটা পর্ব ১৭-এর stack unwinding-এ: একটি exception উড়ছে, পথে destructor-রা চলছে — তাদের একজন আরেকটি exception ছুড়লে একসাথে দুটি exception, যা সামলানোর কোনো যুক্তিসঙ্গত উপায় নেই। তাই destructor-এ ব্যর্থ হতে পারে এমন কাজ (যেমন ফাইলের শেষ লেখা ডিস্কে পাঠানো) থাকলে, একটি আলাদা close() ফাংশন দিন, যা ব্যবহারকারী আগে ডেকে ভুল দেখতে পারেন; destructor শুধু “শেষ চেষ্টা” করবে, ভুল গিলে ফেলবে।

destructor নিজে ডাকবেন না

r.~Rickshaw(); লেখা ভাষায় বৈধ, কিন্তু সাধারণ কোডে এটা প্রায় সবসময় ভুল: scope শেষে compiler আবার ডাকবে, ফলে একই object দুবার ধ্বংস — undefined behavior. destructor ডাকা compiler-এর কাজ। আগেভাগে রিসোর্স ছাড়তে চাইলে object-কে একটি ছোট { } block-এ রাখুন, বা close()/reset()-এর মতো ফাংশন দিন।

৯ · AI-এর যুগে — constructor-এর ভুল ধরা

AI টুলের লেখা class প্রায়ই compile হয় আর চলে, কিন্তু constructor-এ পুরোনো দিনের অভ্যাস থেকে যায়। কারণ অনলাইনে প্রচুর পুরোনো টিউটোরিয়াল আছে, যেখানে body-তে assignment আর ফাঁকা destructor “স্বাভাবিক”। এই ভুলগুলো সাধারণত চোখে পড়ে না, তাই আপনাকে খুঁজতে জানতে হবে:

AI-এর লেখা constructor যাচাইয়ের চেকলিস্ট

• constructor-এর body-তে member = ... খুঁজেছি — থাকলে initializer list-এ সরিয়েছি
• initializer list-এর ক্রম class-এর ঘোষণার ক্রমের সাথে মিলিয়েছি, আর -Wall দিয়ে compile করে -Wreorder নেই দেখেছি
• প্রতিটি এক-argument constructor-এ explicit আছে, বা না থাকার যুক্তি বলতে পারি
• class-এর invariant এক বাক্যে লিখেছি, আর constructor সেটি যাচাই করে কি না দেখেছি
• ফাঁকা বা অপ্রয়োজনীয় destructor মুছে দিয়েছি; যে destructor আছে, সেটি exception ছোড়ে না
• constructor আর destructor-এ একটি করে প্রিন্ট বসিয়ে চালিয়ে দেখেছি — তৈরি আর ধ্বংসের ক্রম আমার অনুমানের সাথে মেলে