class ও object — নিজের টাইপ বানানো

১ · class কী — একটি ছাঁচ, অনেক জিনিস, আর একটি নিয়ম

পর্ব ২-এ (বস্তু দিয়ে ভাবা) আপনি কাগজে-কলমে একটি মোবাইল ওয়ালেটের নকশা করেছিলেন — কোন object কী জানে, কী করে, আর কোন নিয়ম কখনো ভাঙবে না। পর্ব ১২-এ (enum class, struct আর structured bindings) struct দিয়ে কয়েকটি তথ্যকে এক বাক্সে বেঁধেছিলেন। আজ এই দুটি ধারা এক জায়গায় মিলবে। মডিউল ৪ শুরু হলো, আর এর প্রথম প্রশ্ন: নিজের একটি টাইপ বানানো মানে আসলে কী?

C++-এর ভাষায়, একটি class একটি নতুন টাইপের সংজ্ঞা — ঠিক যেমন int বা std::string একটি টাইপ। class ঠিক করে দেয় দুটি জিনিস: এই টাইপের প্রতিটি জিনিস কোন ডেটা ধরে রাখবে, আর সেই ডেটার ওপর কোন কোন কাজ করা যাবে। আর সেই টাইপের একটি আসল, মেমরিতে জায়গা নেওয়া জিনিসকে বলে object, বা ওই class-এর একটি instance. int x; লিখলে x একটি int-এর object; BankAccount rahim; লিখলে rahim একটি BankAccount-এর object.

কিন্তু “কিছু ডেটা আর কিছু ফাংশন একসাথে” — এটুকু বললে class-এর আসল কারণটা বাদ পড়ে যায়। সেই কারণ বুঝতে একটি ব্যাংক হিসাব ভাবুন। এর ডেটা সরল: মালিকের নাম আর ব্যালান্স। কিন্তু এর সাথে একটি নিয়ম জড়িয়ে আছে, যা ব্যাংকের কাছে নামের চেয়েও জরুরি:

এমন নিয়ম, যা object-এর পুরো জীবনে প্রতিটি মুহূর্তে সত্য থাকতে হবে, তাকে বলে invariant. পর্ব ২-এ এই শব্দটি কাগজে দেখেছিলেন; এখন দেখবেন C++ কীভাবে এটিকে কোডে পাহারা দেয়। একটি class-এর কাজ তিনটি, আর তৃতীয়টিই সবচেয়ে গুরুত্বপূর্ণ:

২ · public আর private — দরজা খোলা রাখবেন, না পাহারাদার বসাবেন?

প্রথমে সবচেয়ে সরল পথে লিখে দেখা যাক — পর্ব ১২-এর মতো একটি struct, যার সব data member বাইরে থেকে খোলা:

struct Account {
    std::string owner;
    long long balance = 0;      // নিয়ম: কখনো ঋণাত্মক নয় — কিন্তু কে মানাবে?
};

Account acc{"Rahim", 5000};
acc.balance -= 9000;            // compile হয়। ব্যালান্স এখন -4000
acc.balance = 999999999;        // এটাও compile হয়। টাকা আকাশ থেকে এল

এখানে নিয়মটি শুধু একটি মন্তব্যে লেখা। প্রোগ্রামের যেকোনো জায়গা থেকে যে কেউ balance বদলাতে পারে, আর compiler কিছুই বলবে না। দশ হাজার লাইনের প্রোগ্রামে ব্যালান্স ঋণাত্মক হয়ে গেলে কে করল, খুঁজতে হবে প্রতিটি লাইনে — কারণ প্রতিটি লাইনই সন্দেহভাজন।

C++-এ সেই বন্ধ ভল্ট হলো private, আর ক্যাশিয়ার হলো member function. এই দুটি শব্দ — public আর private — কে কোন অংশ দেখতে পাবে তা ঠিক করে, তাই এদের বলে access specifier. private অংশ শুধু class-এর নিজের member function ব্যবহার করতে পারে; public অংশ সবার জন্য খোলা। ডেটা লুকিয়ে শুধু নিয়ম-মানা কাজের দরজা খোলা রাখার এই কৌশলের নাম encapsulation.

#include <print>

class BankAccount {
    long long balance_ = 0;                  // private: invariant balance_ >= 0
public:
    bool deposit(long long taka) {
        if (taka <= 0) return false;
        balance_ += taka; return true;
    }
    bool withdraw(long long taka) {
        if (taka <= 0 || taka > balance_) return false;   // niyom bhangar age thamo
        balance_ -= taka; return true;
    }
    long long balance() const { return balance_; }
};
int main() {
    BankAccount acc;
    acc.deposit(5000);
    std::println("withdraw 2000: {}", acc.withdraw(2000));
    std::println("withdraw 9000: {}", acc.withdraw(9000));
    std::println("balance = {}", acc.balance());
}

withdraw-এর ভেতরে ঠিক কী ঘটে, দুটি ডাক ধাপে ধাপে দেখুন — একটি অনুমোদিত, একটি প্রত্যাখ্যাত:

1acc.withdraw(2000);        // ব্যালান্স 50002bool withdraw(long long taka) {3    if (taka <= 0 || taka > balance_) return false;4    balance_ -= taka;5    return true;6acc.withdraw(9000);        // ব্যালান্স 30007acc.balance_ -= 9000;      // বাইরে থেকে সরাসরি?

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

পর্ব ১২-এ দেখেছেন, C++-এ struct আর class প্রায় হুবহু এক যন্ত্র। দুটিতেই ডেটা, member function, public/private, constructor — সব চলে। ভাষার নিয়মে পার্থক্য শুধু ডিফল্ট access-এ: struct-এ শুরু থেকে সব public, class-এ শুরু থেকে সব private (inheritance-এর ডিফল্টেও একই পার্থক্য, পর্ব ২৪-এ)। struct S { private: int x; }; আর class C { int x; }; একই জিনিস।

তাহলে কোনটি কখন? এখানে রীতিই আসল নিয়ম, আর C++ Core Guidelines সেটি স্পষ্ট বলে দেয়: যদি ডেটাগুলো স্বাধীনভাবে যেকোনো মান নিতে পারে — যেমন একটি বিন্দুর x আর y — তাহলে struct; যদি কোনো নিয়ম রক্ষা করতে হয়, তাহলে class, আর ডেটা private. পাঠক class শব্দটি দেখেই বোঝেন: “এখানে কোনো নিয়ম আছে, সাবধানে।”

৩ · এক নকশা, অনেক object — কার ডেটা কোথায়

এবার একই class থেকে কয়েকটি object বানালে মেমরিতে কী হয়? সবচেয়ে বড় ভুল ধারণাটি এখানেই ভাঙা দরকার: অনেকে ভাবেন প্রতিটি object-এর ভেতরে তার ফাংশনগুলোর একটি করে কপি থাকে। থাকে না। ধাপে ধাপে দেখুন:

stack (ডেটা)                       code (প্রোগ্রামের নির্দেশ)
  (খালি — এখনো কোনো object নেই)       BankAccount::deposit
                                     BankAccount::withdraw
                                     BankAccount::balance

stack (ডেটা)                       code
  rahim  [ balance_ = 0 ]             BankAccount::deposit
                                     BankAccount::withdraw
                                     BankAccount::balance

stack (ডেটা)                       code
  rahim  [ balance_ = 0 ]             BankAccount::deposit
  karim  [ balance_ = 0 ]             BankAccount::withdraw
  mitu   [ balance_ = 0 ]             BankAccount::balance
                                     (এখনো এই তিনটিই — কপি হয়নি)

stack (ডেটা)                       code
  rahim  [ balance_ = 5000 ]  ◄──┐       BankAccount::deposit ─┐
  karim  [ balance_ = 1200 ]  ◄──┼────────────────────────┘
  mitu   [ balance_ = 0 ]     (ছোঁয়া হয়নি)
                              একটিই deposit, দুবার দুই object-এর জন্য চলল

object-এর ভেতরে যা থাকে         object-এর ভেতরে যা থাকে না
  ✔ non-static data member          ✘ member function (code-এ একটিই কপি)
  ✔ দরকার হলে padding               ✘ static member (সবার জন্য একটি)
                                    ✘ public/private তথ্য (শুধু compile-এর সময়)
sizeof(BankAccount) = 8   ← একটি long long-এর সমান

এই শেষ ধাপটি C++-এর একটি মূল দর্শনের ছোট উদাহরণ — zero-overhead নীতি। BankAccount আর একটি খোলা long long মেমরিতে হুবহু এক জিনিস, আর deposit-এর মতো ছোট ফাংশন সাধারণত compiler সরাসরি ডাকার জায়গায় বসিয়ে দেয়। অর্থাৎ নিরাপত্তা পাচ্ছেন, কিন্তু গতি বা মেমরিতে কোনো দাম দিচ্ছেন না। ভাবনার প্রশ্ন ০২-এ এ নিয়ে আরও আছে।

৪ · this — ফাংশন জানে কোন object তাকে ডেকেছে

আগের ধাপের প্রশ্ন: code অংশে deposit মাত্র একটি। rahim.deposit(500) ডাকলে সে rahim-এর ব্যালান্স বাড়ায়, karim.deposit(200) ডাকলে karim-এর। ফাংশনটি কীভাবে জানে?

উত্তর: compiler প্রতিটি non-static member function-কে একটি লুকানো প্যারামিটার দেয় — যে object-এর ওপর ডাকা হলো, তার ঠিকানা। ফাংশনের ভেতরে এই ঠিকানার নাম this. ফাংশনের ভেতরে আপনি যখন শুধু balance_ লেখেন, compiler সেটিকে পড়ে this->balance_ হিসেবে। মানে, rahim.deposit(500) আসলে প্রায় এমন কিছু: “deposit চালাও, আর this হিসেবে দাও &rahim”. C-তে আপনি নিজে হাতে যা পাঠাতেন (account_deposit(&rahim, 500)), C++ সেটাই চুপচাপ করে দেয়।

1rahim.deposit(500);2bool deposit(long long taka) {3    balance_ += taka;   // আসলে: this->balance_ += taka;4karim.deposit(200);5    balance_ += taka;   // একই লাইন, অন্য this

this কখন নিজে লিখবেন

বেশিরভাগ সময় this লিখতে হয় না — compiler নিজেই বসিয়ে দেয়। তিনটি জায়গায় এটি কাজে আসে:

• নামের সংঘর্ষ। প্যারামিটার আর member-এর নাম একই হলে (void setLimit(long long limit) { this->limit = limit; }) প্যারামিটার member-কে ঢেকে দেয়। this->limit লিখে member বোঝাতে হয়। তবে ভালো সমাধান হলো নামেই পার্থক্য রাখা (limit_)।
• নিজেকে ফেরত দেওয়া। ফাংশন return *this; করলে ডাকার জায়গায় একই object ফিরে আসে, তাই একটির পর একটি ডাক জোড়া দেওয়া যায়: wallet.add(500).add(300);. একে বলে method chaining. std::cout << a << b ঠিক এভাবেই কাজ করে।
• নিজেকে অন্যের কাছে পাঠানো। যেমন একটি object নিজেকে কোনো তালিকায় নিবন্ধন করছে: registry.add(this);.

৫ · const member function — “আমি শুধু দেখব, বদলাব না”

BankAccount-এর balance() ফাংশনের নামের পরে একটি ছোট শব্দ ছিল: long long balance() const. এই const একটি প্রতিশ্রুতি — “এই ফাংশন object-এর কোনো ডেটা বদলাবে না।” এমন ফাংশনকে বলে const member function. পর্ব ১২-এ passed() const-এ এটি এক ঝলক দেখেছিলেন; এবার দেখুন এটি কেন অপরিহার্য।

পর্ব ১০ থেকে আপনি জানেন, বড় object ফাংশনে পাঠানোর সেরা উপায় const T& — কপি নেই, আর ফাংশন বদলাতে পারবে না। ধরুন একটি রিপোর্ট ফাংশন:

void printStatement(const BankAccount& acc) {
    std::println("Balance: {}", acc.balance());   // const ফাংশন — চলবে
    acc.deposit(100);                             // const নয় — compile error
}

এখানে acc একটি const object. compiler কীভাবে জানবে কোন ফাংশন ডাকা নিরাপদ? সে ফাংশনের ভেতরে ঢুকে দেখে না — শুধু ঘোষণা দেখে। নামের পরে const থাকলে ডাকা যাবে, না থাকলে যাবে না। ধাপে ধাপে দেখুন:

acc  ──>  [ balance_ = 3000 ]   const — এই পথ দিয়ে বদলানো নিষেধ

ফাংশনের ভেতরে this-এর টাইপ:
  সাধারণ member function    →  BankAccount*
  const member function     →  const BankAccount*

ঘোষণায় const আছে  →  this হবে const BankAccount*
const object-এর ঠিকানা const pointer-এ  →  মিলে গেল ✔
আউটপুট:  Balance: 3000

ঘোষণায় const নেই  →  this হবে BankAccount* (বদলাতে পারে)
const object-কে non-const pointer-এ?  →  মিলল না ✘

error: passing 'const BankAccount' as 'this' argument discards qualifiers

printStatement-এর ভেতরে acc.balance()  →  এটাও error ✘
ফাংশনটি কিছুই বদলায় না, কিন্তু compiler তা জানে না —
সে শুধু ঘোষণা দেখে। ঘোষণায় প্রতিশ্রুতি নেই, তাই অনুমতি নেই।
সমাধান: যে ফাংশন বদলায় না, তার নামের পরে const লিখুন।

এই অভ্যাসের নাম const-correctness: প্রোগ্রামের প্রতিটি জায়গায় স্পষ্ট বলে দেওয়া কোনটি বদলাতে পারে, কোনটি পারে না — আর compiler-কে সেটি যাচাই করতে দেওয়া। এর লাভ তিনটি। পাঠক ঘোষণা দেখেই বোঝেন কোন ফাংশন নিরাপদ। ভুল করে বদলানোর চেষ্টা compile-এর সময়েই ধরা পড়ে। আর const ফাংশন const ও non-const — দুই ধরনের object-এই ডাকা যায়, তাই সেটি বেশি জায়গায় কাজে লাগে।

৬ · class-এর বাইরে member লেখা — ClassName::func আর header/source ভাগ

এতক্ষণ সব ফাংশনের শরীর class-এর ভেতরেই লিখেছেন। ছোট ফাংশনের জন্য এটি ঠিক আছে, কিন্তু class বড় হলে ভেতরটা ভিড় হয়ে যায় — কোন কোন কাজ করা যায়, এক নজরে আর দেখা যায় না। তাই C++ ঘোষণা আর সংজ্ঞা আলাদা করতে দেয়: class-এর ভেতরে শুধু ফাংশনের মাথা (ঘোষণা), আর বাইরে শরীর। বাইরে লেখার সময় বলে দিতে হয় ফাংশনটি কোন class-এর — scope resolution operator :: দিয়ে:

// bank_account.h — বাকি প্রোগ্রাম এটুকুই দেখে
#pragma once
class BankAccount {
    long long balance_ = 0;
public:
    bool deposit(long long taka);
    bool withdraw(long long taka);
    long long balance() const { return balance_; }   // ছোট — ভেতরেই থাক
};

// bank_account.cpp — কীভাবে করা হয়
#include "bank_account.h"
bool BankAccount::withdraw(long long taka) {          // কোন class-এর withdraw?
    if (taka <= 0 || taka > balance_) return false;    // balance_ এখানেও সরাসরি
    balance_ -= taka;
    return true;
}

BankAccount::withdraw পড়ুন “BankAccount-এর withdraw”. এই নাম লেখার পর ফাংশনের ভেতরটা class-এর ভেতরের মতোই — balance_ সরাসরি দেখা যায়, this আছে, private-এ অনুমতি আছে। :: না লিখে শুধু bool withdraw(...) লিখলে সেটি হয়ে যায় একটি আলাদা সাধারণ ফাংশন, আর তখন balance_ চিনবে না। const ফাংশন বাইরে লিখলে const দুই জায়গাতেই লাগে: long long BankAccount::balance() const { ... }.

পর্ব ১১-এ (namespace আর header) দেখেছিলেন বড় প্রোগ্রাম কীভাবে header file আর source file-এ ভাগ হয়। class-এর ক্ষেত্রে প্রচলিত ভাগটি এমন:

একটি প্রশ্ন স্বাভাবিক: private ডেটা তো header-এ সবাই দেখতে পাচ্ছে, তাহলে লুকানো হলো কোথায়? উত্তর — private মানে “দেখা যাবে না” নয়, “ব্যবহার করা যাবে না”। compiler-কে object-এর আকার জানতে হয় (stack-এ কত জায়গা দেবে), তাই ডেটার তালিকা header-এ থাকতেই হয়। encapsulation এখানে নিরাপত্তার তালা নয়, ভুল থেকে বাঁচার বেড়া।

৭ · static member আর শুরুর মান — সবার জন্য একটি, প্রত্যেকের জন্য একটি

কখনো এমন তথ্য দরকার, যা কোনো একটি object-এর নয়, পুরো class-এর — যেমন “এ পর্যন্ত মোট কয়টি ওয়ালেট খোলা হয়েছে”। প্রতিটি object-এ এটি রাখলে সংখ্যাটি একশো জায়গায় একশো রকম হয়ে যেত। এর জন্য আছে static member: class-এর ভেতরে static লিখে ঘোষণা করা ডেটা বা ফাংশন, যার পুরো প্রোগ্রামে ঠিক একটি কপি — কোনো object-এর ভেতরে নয়। একটি মেস বাড়ির কথা ভাবুন: প্রত্যেকের নিজের খাট আর আলমারি আছে (সাধারণ member), কিন্তু দেয়ালের নোটিশবোর্ড সবার জন্য একটি (static member).

আর আরেকটি জিনিস আপনি ইতিমধ্যে ব্যবহার করছেন: long long balance_ = 0; — data member-এর ঘোষণাতেই শুরুর মান। একে বলে default member initializer (C++11 থেকে)। প্রতিটি নতুন object এই মান নিয়ে জন্মায়। নিচের bKash-ধাঁচের ওয়ালেটে দুটি ধারণা একসাথে দেখুন:

#include <print>

class Wallet {
    static inline int count_ = 0;          // shob Wallet mile ekti
    int id_ = ++count_;                    // proti object-er nijer, jonmer somoy
    long long balance_ = 0;
public:
    Wallet& add(long long taka) { if (taka > 0) balance_ += taka; return *this; }
    long long balance() const { return balance_; }
    int id() const { return id_; }
    static int count() { return count_; }  // kono object lage na
};

int main() {
    Wallet a, b;
    a.add(500).add(300);                   // *this ferot, tai chain
    const Wallet& view = b;                // shudhu const function chole
    std::println("a#{} = {}, b#{} = {}", a.id(), a.balance(), view.id(), view.balance());
    std::println("wallets = {}, sizeof = {}", Wallet::count(), sizeof(Wallet));
}

• static inline কেন? C++17-এর আগে static ডেটা class-এর ভেতরে শুধু ঘোষণা করা যেত; একটি .cpp ফাইলে আলাদা করে সংজ্ঞা দিতে হতো (int Wallet::count_ = 0;). C++17 থেকে inline লিখে class-এর ভেতরেই শুরুর মান দেওয়া যায়। ধ্রুবক হলে static constexpr int maxPin = 4; লিখুন।
• static ফাংশনে this নেই। তাই সে কোনো object-এর non-static ডেটা সরাসরি দেখতে পারে না — কার ডেটা দেখবে, জানেই না।
• সাবধান: একাধিক thread একসাথে Wallet বানালে এই সাধারণ int গোনা নিরাপদ নয় (পর্ব ৪৬-এর std::atomic লাগবে)। আর static ডেটা আসলে একটি global ভ্যারিয়েবলের মতোই — বেশি ব্যবহার করলে পর্ব ২-এর global-এর সমস্যাগুলো ফিরে আসে।

৮ · ভালো class-এর নকশা — চারটি প্রশ্ন

class লেখার নিয়ম শেখা সহজ; ভালো class নকশা করা কঠিন। একটি Student class দিয়ে দেখুন। প্রথম খসড়া, যা অনেকে (আর অনেক AI) প্রথমেই লেখেন:

class Student {                       // খসড়া — দেখতে “OOP”, আসলে খোলা struct
    std::string name;
    std::vector<double> gradePoints;
    double gpa;                           // জমা রাখা — gradePoints-এর সাথে মিলতেই হবে
public:
    void setGradePoints(std::vector<double> g) { gradePoints = g; }
    void setGpa(double g) { gpa = g; }    // যে কেউ ভুল GPA বসাতে পারে!
    double getGpa() { return gpa; }       // const-ও নেই
};

এখানে ডেটা private, ফাংশনও আছে — তবু encapsulation প্রায় শূন্য। setGpa(4.9) ডেকে যে কেউ এমন GPA বসাতে পারেন, যা গ্রেডের সাথে মেলে না, এমনকি ৪-এর বেশি। gpa আর gradePoints দুটি আলাদা জায়গায় একই সত্য রাখছে, আর দুটি মিলিয়ে রাখার দায়িত্ব পড়েছে বাইরের সবার ঘাড়ে। এবার চারটি প্রশ্ন দিয়ে নকশাটি ঠিক করুন:

class Student {
    std::string name_;
    std::vector<double> gradePoints_;            // invariant: প্রতিটি 0.0–4.0
public:
    bool addGrade(double gp) {                   // “বলে দিন” — যাচাই ভেতরে
        if (gp < 0.0 || gp > 4.0) return false;
        gradePoints_.push_back(gp);
        return true;
    }
    double gpa() const {                         // জমা নয় — প্রতিবার হিসাব
        if (gradePoints_.empty()) return 0.0;
        double sum = 0;
        for (double g : gradePoints_) sum += g;
        return sum / gradePoints_.size();
    }
};

এখন ভুল GPA বসানোর কোনো পথই নেই — কারণ GPA বসানোর ফাংশনই নেই। setGradePoints চলে গিয়ে এসেছে addGrade, যা একটি একটি করে যাচাই করে। আর gpa() const, তাই const Student-এও চলে। একটি তুলনা মনে রাখুন: পরীক্ষার মার্কশিটে মোট নম্বর হাতে লিখে রাখলে যোগে ভুল হতে পারে; কিন্তু সফটওয়্যারে যদি মোট সবসময় নম্বরগুলো থেকে হিসাব হয়, ভুল যোগফল তৈরিই হতে পারে না।

getter আর setter-এর ফাঁদ

প্রতিটি private ফিল্ডের জন্য একটি getter আর setter লেখা — getBalance(), setBalance() — এটি Java-র পুরোনো একটি রীতি থেকে আসা অভ্যাস। কিন্তু ভাবুন: setBalance(long long b) থাকলে balance_ private করে লাভ কী হলো? যে কেউ এখনো যেকোনো মান বসাতে পারে, শুধু একটু বেশি টাইপ করে। একে বলা যায় “পোশাক পরা public ডেটা”। setter-এর বদলে এমন কাজের নাম দিন যা বাস্তবে ঘটে — deposit, withdraw, addGrade, changePin(old, new) — আর প্রতিটির ভেতরে নিয়ম যাচাই করুন। getter-ও শুধু তখনই দিন, যখন বাইরের কারও সেই তথ্য সত্যিই দরকার।

আর সব ফাংশনকে member বানাতেও হবে না। যে কাজ public ফাংশন দিয়েই করা যায় — যেমন দুটি ওয়ালেটের মোট টাকা — সেটি একটি free function হিসেবে লিখুন: long long total(const Wallet& a, const Wallet& b) { return a.balance() + b.balance(); }. এতে private ডেটা ছুঁতে পারে এমন ফাংশনের সংখ্যা কম থাকে, আর invariant ভাঙলে খোঁজার জায়গাও কম (ভাবনার প্রশ্ন ০৫)।

class নকশার চেকলিস্ট

• invariant-গুলো এক-দুই বাক্যে লিখতে পারি; না পারলে হয়তো এটি struct
• নিয়ম-জড়িত সব ডেটা private, আর প্রতিটি public ফাংশন শেষে invariant সত্য রাখে
• যা অন্য ডেটা থেকে হিসাব করা যায় (GPA, মোট, বয়স), তা আলাদা ফিল্ডে জমা নেই
• অন্ধ setter নেই; ফাংশনের নাম বাস্তবের কাজ বলে (withdraw, addGrade)
• যে member function object বদলায় না, তার নামের পরে const
• private ডেটা না ছুঁয়েই যা করা যায়, তা member না হয়ে free function

৯ · AI-এর যুগে — AI-এর লেখা class যাচাই

“একটি BankAccount class লেখো” বললে AI টুল প্রায় সবসময় compile হয় এমন কোড দেয়। কিন্তু অনলাইনের লাখো উদাহরণ থেকে শেখা বলে সে প্রায়ই পুরোনো, যান্ত্রিক রীতি অনুসরণ করে — প্রতিটি ফিল্ডে getter-setter, যাচাইহীন ডেটা, আর const বাদ। এই কোড প্রথম দিনে চলে; সমস্যা আসে মাস তিনেক পরে, যখন কেউ setBalance(-500) ডেকে ফেলেন। যা প্রায়ই দেখবেন:

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

• class-এর invariant নিজের ভাষায় লিখেছি, আর প্রতিটি public ফাংশনের পর সেটি সত্য থাকে কি না মিলিয়েছি
• set দিয়ে শুরু প্রতিটি ফাংশন খুঁজেছি — কোনোটি কি যাচাই ছাড়াই নিয়ম-জড়িত ডেটা বদলায়?
• প্রতিটি getter আর শুধু-পড়ার ফাংশনে const আছে; একটি const reference দিয়ে ডেকে compile করে দেখেছি
• ভুল ইনপুট দিয়ে (ঋণাত্মক টাকা, ব্যালান্সের বেশি) ডেকে দেখেছি — object-এর অবস্থা বদলায়নি, আর ব্যর্থতা জানানো হয়েছে
• কোনো ফিল্ড অন্য ফিল্ড থেকে হিসাব করা যায় কি না দেখেছি; গেলে সেটি সরিয়ে const ফাংশন বানিয়েছি
• public ফাংশনের তালিকা পড়ে প্রশ্ন করেছি: এর প্রতিটি কি সত্যিই বাইরের কারও দরকার?