মাঝপথের প্রজেক্ট — দোকানের হিসাবের একটি CLI টুল

১ · কেন একটি প্রজেক্ট — আর ইঞ্জিনিয়ার কীভাবে শুরু করেন

আঠারোটি পর্বে আপনি অনেক যন্ত্র হাতে নিয়েছেন: std::vector, std::string, struct, enum class, ফাংশন, reference, namespace, header, আর মেমরির মালিকানা ও lifetime. কিন্তু যন্ত্র চেনা আর মিলিয়ে কিছু বানানো দুটি আলাদা দক্ষতা — হাতুড়ি আর করাত চিনলেই কেউ আলমারি বানাতে পারেন না।

এই পর্বে আমরা একটি সত্যিকারের ছোট টুল বানাব। মোহাম্মদপুরের টাউন হল বাজারে শাহীন ভাইয়ের একটি মুদি দোকান। প্রতিদিন সকালে মাল আসে, সারাদিন বিক্রি হয়, আর রাতে তিনি জানতে চান — কোন মাল কতটা বাকি, আজ মোট কত টাকা বিক্রি হলো। খাতায় লিখতে লিখতে প্রায়ই হিসাব মেলে না: কখনো লেখা হয় ২০ কেজি চাল বিক্রি, অথচ দোকানে ছিল ১৫ কেজি!

আমাদের প্রোগ্রামটি হবে একটি CLI টুল — terminal-এ চলে, প্রতিটি লাইনে একটি কমান্ড পড়ে। শেষ পর্যন্ত এর সাথে কথোপকথন দেখতে হবে এমন:

> add rice 50 72.50
ok: rice +50
> sell rice 3
ok: rice -3
> sell rice 80
error: only 47 rice left
> report
ITEM      QTY      PRICE
rice       47      72.50
sales today: 217.50 Tk
> quit

অভিজ্ঞ ইঞ্জিনিয়ার সরাসরি int main() লিখতে বসেন না। পাঁচটি ধাপের প্রতিটিতে একটি লিখিত জিনিস তৈরি হয়, আর পরের ধাপ দাঁড়ায় আগেরটির ওপর। “পরে” চেপে দেখুন:

add  <item> <qty> <price>   মাল এল — স্টকে যোগ
sell <item> <qty>           বিক্রি — স্টক কমবে, বিক্রির মোট বাড়বে
report                     সব মালের স্টক আর আজকের মোট বিক্রি
quit                       বের হওয়া
নিয়ম: যতটা আছে তার বেশি বিক্রি করা যাবে না
এখন নয়: ফাইলে সংরক্ষণ, বাকির খাতা, মাসিক রিপোর্ট

struct Item {
    std::string name;          // "rice"
    int         qty{};         // স্টকে কতটা, কখনো ঋণাত্মক নয়
    long long   price_paisa{}; // 72.50 Tk = 7250
};
enum class Command { Add, Sell, Report, Quit, Unknown };
সিদ্ধান্ত: টাকা পয়সায় পূর্ণসংখ্যা, double নয়

namespace shop {
  Result add (Ledger& lg, const std::string& name,
              int qty, long long price_paisa);
  Result sell(Ledger& lg, const std::string& name, int qty);
}
// Result = Ok | BadInput | NotFound | NotEnough
নিয়ম: shop:: এর কোনো ফাংশন কিছু ছাপে না

[x] M1  লুপ ঘোরে, quit আর অজানা কমান্ড বোঝে
[x] M2  add আর report — প্রথম আসল কাজ
[ ] M3  sell আর সব ইনপুট যাচাই   ← এখানে MVP পূর্ণ
[ ] M4  ফাইলে ভাগ, std::format-এ সুন্দর রিপোর্ট
[ ] M5  ফাইলে save/load (পর্ব ৪৪-এর পরে)

T1  খালি দোকানে report          → sales today: 0.00 Tk   PASS
T2  sell rice abc                → usage বার্তা           PASS
T3  স্টকের বেশি বিক্রি           → only 47 rice left      PASS
T4  অজানা কমান্ড "dance"         → unknown command        PASS
T5  ইনপুট হঠাৎ শেষ (EOF)        → শান্তভাবে বের হয়       PASS

২ · চাহিদা — কমান্ডের ভাষা আর “কী বানাব না”

নতুনদের সবচেয়ে সাধারণ ভুল হলো সমস্যা না বুঝেই কোড লিখতে বসা। দর্জির কথা ভাবুন — মাপ না নিয়ে জামা সেলাই করলে যত সুন্দর সেলাই-ই হোক, গায়ে লাগবে না। সফটওয়্যারে “মাপ নেওয়া”-র নাম requirement বা চাহিদা লেখা। চাহিদা লেখার একটি জনপ্রিয় ছাঁচ হলো user story:

“কে” মনে করিয়ে দেয় প্রোগ্রামটি কার জন্য (শাহীন ভাই প্রোগ্রামার নন, তাই বার্তা হবে পরিষ্কার), আর “কেন” বলে আসল উদ্দেশ্য। প্রতিটি story-র সাথে লিখুন কিছু acceptance criteria — কখন বলবেন কাজটি “হয়েছে”। এগুলো যাচাই করা যায় এমন হতে হবে: “সহজে ব্যবহার করা যাবে” যাচাই করা যায় না; “স্টকের বেশি বিক্রি চাইলে কিছু না বদলে বাকি পরিমাণ জানাবে” যাচাই করা যায়।

লক্ষ করুন, এই টেবিলটিই একটি ছোট specification. এতে কীভাবে বানানো হবে তার একটি শব্দও নেই — vector না map, কোন ফাংশন — শুধু কী করবে। এই আলাদা রাখাটাই spec-এর শক্তি: পরে পুরো ভেতরটা বদলে গেলেও টেবিল একই থাকে, আর টেস্টগুলোও।

যা বানাব না — MVP-র সীমারেখা

শাহীন ভাই আরও চাইলেন: কোন ক্রেতার কত বাকি, মাসিক লাভ-ক্ষতি, স্টক কমলে মোবাইলে SMS! সবই যৌক্তিক, কিন্তু সব একসাথে বানাতে গেলে কয়েক সপ্তাহেও শেষ হবে না। তাই প্রথমে একটি MVP — সবচেয়ে ছোট সংস্করণ, যা তাঁর সবচেয়ে বড় কষ্টটি দূর করে: স্টকের বেশি বিক্রি লেখা আর রাতের যোগফলের গরমিল।

৩ · ডেটা মডেল — একটি মাল, একটি খাতা, একটি কমান্ড

শাহীন ভাইয়ের খাতার যেকোনো লাইন দেখুন: “চাল — ৪৭ কেজি — ৭২.৫০”. তিনটি তথ্য, একটি মাল। এটাই আমাদের data model-এর শুরু। পর্ব ১২-এর struct ঠিক এই কাজের জন্য, আর পর্ব ১৩-এর std::vector অনেকগুলো মাল পাশাপাশি রাখার জন্য:

struct Item {
    std::string name;                 // "rice" — std::string, তাই দৈর্ঘ্যের সীমা নেই
    int         qty{};                // স্টকে কতটা; নিয়ম: কখনো ঋণাত্মক নয়
    long long   price_paisa{};        // একক দাম পয়সায়: 72.50 Tk = 7250
};

struct Ledger {
    std::vector<Item> items;          // দোকানের সব মাল, যোগ করার ক্রমে
    long long sold_paisa{};           // আজকের মোট বিক্রি, পয়সায়
};

enum class Command { Add, Sell, Report, Quit, Unknown };
enum class Result  { Ok, BadInput, NotFound, NotEnough };

মাত্র কয়েকটি লাইন, কিন্তু প্রতিটির পেছনে একটি সিদ্ধান্ত আছে। একজন ইঞ্জিনিয়ার সিদ্ধান্তগুলো লিখে রাখেন — কী বেছে নিলাম, কেন, আর তার দাম কী — যাতে ছয় মাস পরে কেউ (বা নিজেই) “এটা এমন কেন?” প্রশ্নের উত্তর পান:

শেষ কথা qty-এর comment নিয়ে: “নিয়ম: কখনো ঋণাত্মক নয়।” এমন সবসময়-সত্য নিয়মকে বলে invariant. খেয়াল করুন, এখন এটা শুধু একটি comment — struct-এর সব member খোলা, তাই যেকোনো জায়গা থেকে কেউ lg.items[0].qty = -5; লিখলে কেউ আটকাবে না। এই দুর্বলতাটি মনে রাখুন; মডিউল ৪ ঠিক এর সমাধান দিয়ে শুরু হবে।

৪ · একটি লাইনের যাত্রা — পড়া, ভাগ, যাচাই, বদল, ছাপা

প্রতিটি CLI টুলের হৃদয় একটি লুপ: একটি লাইন পড়া → বুঝে নেওয়া → কাজ করা → ফল জানানো → আবার পড়া। লুপ থামে দুই পথে: ব্যবহারকারী quit লিখলেন, অথবা ইনপুটই শেষ (EOF — Linux-এ Ctrl+D, Windows-এ Ctrl+Z তারপর Enter). দ্বিতীয় পথটি ভুলে গেলে প্রোগ্রাম অসীম লুপে আটকে যেতে পারে।

কেন cin >> নয়, পুরো লাইন

পর্ব ০৭-এ std::cin >> x দিয়ে ইনপুট নিয়েছিলেন। কিন্তু কমান্ড-লাইনের জন্য এটা বিপজ্জনক। ধরুন কেউ লিখলেন sell rice — পরিমাণ দিতে ভুলে গেছেন। cin >> cmd >> name >> qty তখন পরের লাইনের প্রথম শব্দটিকেই (হয়তো report) পরিমাণ হিসেবে পড়তে চাইবে, ব্যর্থ হবে, আর stream ব্যর্থ অবস্থায় আটকে যাবে। এক লাইনের ভুল গড়িয়ে পরের লাইন নষ্ট করল।

সমাধান দুই ধাপের, যা প্রায় প্রতিটি পেশাদার CLI-তে দেখবেন। এক, std::getline দিয়ে পুরো একটি লাইন একটি std::string-এ পড়া — লাইনের সীমানা এখানেই চূড়ান্ত। দুই, সেই লাইন থেকে একটি std::istringstream বানানো — <sstream>-এর এই stream একটি string-কে ইনপুটের উৎস বানায়, ফলে ঠিক cin-এর মতো >> দিয়ে শব্দ আর সংখ্যা আলাদা করা যায়। এই লাইনের পড়া ব্যর্থ হলে শুধু এই ছোট stream-টাই নষ্ট হয়; পরের লাইনের জন্য নতুন একটি তৈরি হবে।

এবার দোকানের লুপের ভেতরে একটি লাইন — sell rice 3 — ঢুকলে ঠিক কী কী ঘটে, ধাপে ধাপে দেখুন। শুরুতে স্টকে আছে ১০ কেজি চাল, প্রতি কেজি ৭২ টাকা:

1for (std::string line; std::getline(std::cin, line); ) {2    std::istringstream in{line};3    in >> word;4    switch (parse(word)) { case Command::Sell:5    if (!(in >> name >> qty) || qty <= 0) usage();6    Item* it = find(stock, name);7    if (qty > it->qty) not_enough();8    it->qty -= qty; sold += qty * it->price_paisa;9    std::println("ok: {} -{}", name, qty);

৫ · এক ফাইলের MVP — চালিয়ে দেখুন

এবার পুরো MVP একটি ফাইলে। অনলাইনে চালানো সহজ করতে একটি ছোট ছাড় নেওয়া হয়েছে: দাম পূর্ণ টাকায় (72), আর ভেতরে পয়সায় রাখা হয় (7200). “72.50”-এর মতো দশমিক দাম পড়া পরের মাইলস্টোনের কাজ, সেটা অংশ ৮-এ টেস্টসহ দেখবেন। ইনপুট আগে থেকেই দেওয়া — একটি ছোট সেশন, যাতে ইচ্ছা করে কয়েকটি ভুলও রাখা আছে। “Run” চাপুন:

#include <iostream>
#include <print>
#include <sstream>
#include <string>
#include <vector>

enum class Command { Add, Sell, Report, Quit, Unknown };
struct Item { std::string name; int qty{}; long long price_paisa{}; };

Command parse(const std::string& w) {
    if (w == "add")    return Command::Add;
    if (w == "sell")   return Command::Sell;
    if (w == "report") return Command::Report;
    return w == "quit" ? Command::Quit : Command::Unknown;
}
Item* find(std::vector<Item>& stock, const std::string& name) {
    for (Item& it : stock) if (it.name == name) return &it;
    return nullptr;                                  // not in stock
}

int main() {
    std::vector<Item> stock;
    long long sold = 0;                              // today's sales, in paisa
    for (std::string line; std::getline(std::cin, line); ) {
        std::istringstream in{line};
        std::string word, name;
        int qty = 0, taka = 0;
        in >> word;
        switch (parse(word)) {
        case Command::Add:
            if (!(in >> name >> qty >> taka) || qty <= 0 || taka <= 0) {
                std::println("error: usage: add <item> <qty> <taka>"); break; }
            if (Item* it = find(stock, name)) it->qty += qty;
            else stock.push_back({name, qty, taka * 100LL});
            std::println("ok: {} +{}", name, qty); break;
        case Command::Sell: {
            if (!(in >> name >> qty) || qty <= 0) { std::println("error: usage: sell <item> <qty>"); break; }
            Item* it = find(stock, name);
            if (!it) { std::println("error: no item '{}'", name); break; }
            if (qty > it->qty) { std::println("error: only {} {} left", it->qty, name); break; }
            it->qty -= qty; sold += qty * it->price_paisa;
            std::println("ok: {} -{}", name, qty); break; }
        case Command::Report:
            for (const Item& it : stock) std::println("{:<6} qty {:>3}", it.name, it.qty);
            std::println("sales: {}.{:02} Tk", sold / 100, sold % 100); break;
        case Command::Quit: return 0;
        case Command::Unknown: std::println("error: unknown command '{}'", word);
        }
    }
}

৬ · ফাইলে ভাগ — namespace, header আর তিন স্তর

পঞ্চাশ লাইনের প্রোগ্রাম এক ফাইলে চলে, কিন্তু টুল বড় হলে সব main-এ রাখলে একটি জিনিস বদলাতে গিয়ে আরেকটি ভাঙবে। পর্ব ০২-এ শিখেছেন decomposition, আর পর্ব ১১-এ শিখেছেন namespace ও header file. এবার দুটিকে একসাথে প্রয়োগ করার পালা।

প্রোগ্রামটিকে তিনটি দায়িত্বে ভাগ করা হলো। এই নীতির নাম separation of concerns — আলাদা দায়িত্ব আলাদা জায়গায়। রেস্টুরেন্টের মতো: ওয়েটার অর্ডার নেন আর খাবার দেন, রাঁধুনি রান্না করেন, ভাঁড়ারে মাল থাকে। রাঁধুনি কখনো টেবিলে গিয়ে অর্ডার নেন না।

সবচেয়ে গুরুত্বপূর্ণ নিয়ম: shop:: namespace-এর কোনো ফাংশন std::cin পড়বে না, std::println করবে না। সে শুধু ডেটা নেয়, নিয়ম মেনে বদলায়, আর একটি Result ফেরত দেয়। কী বার্তা দেখানো হবে — ইংরেজিতে, বাংলায়, বা মোবাইল অ্যাপের পপ-আপে — সেই সিদ্ধান্ত ওপরের স্তরের। ফলে যুক্তির অংশ কীবোর্ড ছাড়াই টেস্ট করা যায়, আর ভবিষ্যতে একটি GUI বা ওয়েব সার্ভার এই একই ledger.cpp হুবহু ব্যবহার করতে পারে। নিচে চারটি ফাইল দেখুন (এগুলো একসাথে compile করতে হয়, তাই এখানে Run নেই):

#pragma once
#include <string>

namespace shop {
    struct Item {
        std::string name;
        int         qty{};            // invariant: qty >= 0 (এখনো শুধু কথায়)
        long long   price_paisa{};    // 72.50 Tk = 7250
    };
}

#pragma once
#include <string>
#include <vector>
#include "item.h"

namespace shop {
    enum class Result { Ok, BadInput, NotFound, NotEnough };

    struct Ledger {
        std::vector<Item> items;
        long long sold_paisa{};
    };

    // চুক্তি: কোনোটিই কিছু ছাপে না। ব্যর্থ হলে Ledger একটুও বদলায় না।
    [[nodiscard]] Result add (Ledger& lg, const std::string& name, int qty, long long price_paisa);
    [[nodiscard]] Result sell(Ledger& lg, const std::string& name, int qty);
    long long stock_value(const Ledger& lg);      // const&: শুধু পড়বে
}

#include "ledger.h"

namespace shop {
namespace {                                       // এই ফাইলের ভেতরের সাহায্যকারী
    Item* find(Ledger& lg, const std::string& name) {
        for (Item& it : lg.items) if (it.name == name) return ⁢
        return nullptr;
    }
}

Result add(Ledger& lg, const std::string& name, int qty, long long price_paisa) {
    if (name.empty() || qty <= 0 || price_paisa <= 0) return Result::BadInput;
    if (Item* it = find(lg, name)) it->qty += qty;
    else lg.items.push_back({name, qty, price_paisa});
    return Result::Ok;
}

Result sell(Ledger& lg, const std::string& name, int qty) {
    if (qty <= 0) return Result::BadInput;        // guard clause: আগে সব যাচাই
    Item* it = find(lg, name);
    if (it == nullptr) return Result::NotFound;
    if (qty > it->qty) return Result::NotEnough;
    it->qty -= qty;                               // তারপর একসাথে বদল
    lg.sold_paisa += qty * it->price_paisa;
    return Result::Ok;
}

long long stock_value(const Ledger& lg) {
    long long total = 0;
    for (const Item& it : lg.items) total += it.qty * it.price_paisa;
    return total;
}
}

#include <iostream>
#include <print>
#include <sstream>
#include "ledger.h"

enum class Command { Add, Sell, Report, Quit, Unknown };
Command parse_command(const std::string& w);     // সংজ্ঞা নিচে, এখানে বাদ
bool parse_money(const std::string& s, long long& paisa);   // অংশ ৮-এ টেস্টসহ
void print_report(const shop::Ledger& lg);       // std::format-এর টেবিল

const char* message(shop::Result r) {
    switch (r) {
        case shop::Result::Ok:        return "ok";
        case shop::Result::BadInput:  return "error: bad input";
        case shop::Result::NotFound:  return "error: no such item";
        case shop::Result::NotEnough: return "error: not enough stock";
    }
    return "error: ?";
}

int main() {
    shop::Ledger lg;                              // মালিক একজনই — RAII
    for (std::string line; std::getline(std::cin, line); ) {
        std::istringstream in{line};
        std::string word, name, price; int qty = 0;
        in >> word;
        switch (parse_command(word)) {
        case Command::Sell:
            in >> name >> qty;
            std::println("{}", message(shop::sell(lg, name, qty))); break;
        // ... Add, Report, Quit, Unknown — আগের মতোই
        }
    }
}

কয়েকটি বিষয় খেয়াল করুন, প্রতিটিই আগের কোনো পর্বের শিক্ষা। #pragma once header দুবার ঢোকা আটকায় (পর্ব ১১)। header-এ শুধু টাইপ আর ফাংশনের ঘোষণা, সংজ্ঞা .cpp-তে — তাই ODR ভাঙে না। find একটি anonymous namespace-এ, ফলে অন্য কোনো ফাইল একে দেখতেই পায় না — বাইরের দুনিয়ার কাছে প্রতিশ্রুতি শুধু ledger.h-এ যা লেখা। sell-এর শুরুর তিনটি guard clause “আগে যাচাই, পরে বদল” নিয়মটি কোডে লিখে দিয়েছে। আর [[nodiscard]] থাকায় কেউ shop::sell(lg, "rice", 3); লিখে ফলাফল ফেলে দিলে compiler সতর্ক করবে — ব্যর্থ বিক্রি নিঃশব্দে হারিয়ে যাবে না। তৈরি করার কমান্ড (পর্ব ০৩-এর মতো, প্রতিটি .cpp আলাদা translation unit, শেষে link):

# header কমান্ডে লাগে না — #include নিজেই টেনে আনে
g++ -std=c++23 -Wall -Wextra -g -fsanitize=address,undefined main.cpp ledger.cpp -o shop
./shop

৭ · মাইলস্টোন — প্রতিটি ধাপের শেষে প্রোগ্রাম চলে

নতুনরা প্রায়ই ৪০০ লাইন লিখে প্রথমবার compile করেন, আর পান অসংখ্য error. অভিজ্ঞরা প্রথমে ছোট কিছু বানান যা চলে, তারপর একটু একটু যোগ করেন, আর প্রতিটি যোগের পর প্রোগ্রাম আবার চলে। কিছু ভাঙলে দোষী শেষ যোগ করা অংশটুকুই।

দোকানের টুলের পাঁচটি মাইলস্টোন দেখুন — প্রতিটিতে নতুন কী কাজ করে, আর কোন টেস্টে তা প্রমাণিত:

> add rice 10 72
[add: coming soon]
> dance
error: unknown command 'dance'
> quit
টেস্ট: quit-এ বের হয় · অজানা কমান্ডে বার্তা · EOF-এ আটকে থাকে না

> report
sales: 0.00 Tk
> add rice 10 72
ok: rice +10
> add rice 5 72
ok: rice +15     ← আগের মাল, তাই পরিমাণ বাড়ল
টেস্ট: খালি report · একই মাল দুবার add · তিনটি মাল যোগ করে report মেলানো

> sell rice 3
ok: rice -3
> sell rice 99
error: only 12 rice left
> sell rice abc
error: usage: sell <item> <qty>
টেস্ট: অংশ ৮-এর পুরো টেস্ট প্ল্যান · হাতে হিসাবের সাথে sales মেলানো

> report
ITEM      QTY      PRICE
rice       12      72.50
egg        30      13.00
sales today: 217.50 Tk
std::println("{:<8}{:>5}{:>11}", name, qty, taka_text(price));
টেস্ট: M3-এর সব টেস্ট হুবহু আবার পাস (refactoring-এর প্রমাণ)

$ ./shop shop.txt
loaded 2 items from shop.txt
> sell egg 6
ok: egg -6
> quit
saved 2 items to shop.txt
std::ifstream / std::ofstream — নিজেই ফাইল বন্ধ করে (RAII)
টেস্ট: save → load → report আগের মতোই · ভাঙা ফাইলে crash নয়

৮ · টেস্ট — স্ক্রিপ্ট করা ইনপুট আর একটি বাগ শিকার

“চালিয়ে দেখেছি, চলছে” — এটি টেস্ট নয়; আপনি চালিয়েছেন শুধু নিজের মাথার ইনপুট দিয়ে। দোকানের কর্মচারী টাইপ করবেন এমন জিনিস, যা আপনি কল্পনাও করেননি। Test plan হলো আগে থেকে লিখে রাখা তালিকা: কোন পরিস্থিতি, কী ইনপুট, কী ফল আশা করছি। সবচেয়ে বেশি বাগ লুকিয়ে থাকে edge case-এ — সীমানায়, শূন্যে, খালি জায়গায়:

স্ক্রিপ্ট করা ইনপুট — হাতে টাইপ ছাড়া পুরো সেশন

CLI-এর একটি বড় সুবিধা: পুরো সেশন একটি টেক্সট ফাইলে লেখা যায়। পর্ব ০৭-এর redirection দিয়ে সেই ফাইল প্রোগ্রামের ইনপুট বানিয়ে, আউটপুট আরেক ফাইলে নিয়ে, আগে থেকে যাচাই করে রাখা “সঠিক” আউটপুটের সাথে মেলানো যায়। একে বলে golden-file test. অংশ ৫-এর “Run” বোতামও ঠিক এটাই করেছে — আগে লেখা ইনপুট দিয়ে প্রোগ্রাম চালানো:

# tests/t3_negative.txt-এ আছে: add oil -2 190 / sell rice 0 / report
./shop < tests/t3_negative.txt > got.txt
diff tests/t3_negative.expected got.txt && echo PASS    # এক অক্ষর আলাদা হলেও ধরা পড়ে

দশটি টেস্ট-ফাইল একটি ছোট script এক সেকেন্ডে চালিয়ে দেয় — প্রতিটি পরিবর্তনের পর চালান। এবার দেখুন, একটি টেস্ট কীভাবে একটি আসল বাগ ধরে। ধরুন M3 লেখার সময় তাড়াহুড়োয় sell-এ স্টকের পরীক্ষাটি বাদ পড়েছিল:

add egg 30 13
sell egg 40
report

  ok: egg +30
- error: only 30 egg left
+ ok: egg -40
- egg    qty  30
+ egg    qty -10
- sales: 0.00 Tk
+ sales: 520.00 Tk
FAIL — ৩টি লাইন আলাদা

Result sell(Ledger& lg, const std::string& name, int qty) {
    if (qty <= 0) return Result::BadInput;
    Item* it = find(lg, name);
    if (it == nullptr) return Result::NotFound;
    // স্টকের পরীক্ষা নেই!
    it->qty -= qty;                       // 30 - 40 = -10
    lg.sold_paisa += qty * it->price_paisa;   // 40 x 1300
    return Result::Ok;
}

shop::Ledger lg;
assert(shop::add(lg, "egg", 30, 1300) == shop::Result::Ok);
assert(shop::sell(lg, "egg", 40) == shop::Result::NotEnough);  // FAIL
assert(lg.items[0].qty == 30 && lg.sold_paisa == 0);

    if (it == nullptr) return Result::NotFound;
    if (qty > it->qty) return Result::NotEnough;
    it->qty -= qty;
t4_stock: PASS · test_ledger: PASS · বাকি সব: PASS

একটি ছোট ফাংশনের টেস্ট — দশমিক দাম পড়া

M4-এ দাম আসবে “72.50” রূপে, আর আমাদের দরকার 7250 পয়সা। std::stod("72.50") * 100 লেখা লোভনীয়, কিন্তু তাতে আবার floating point ঢুকে পড়ে — 0.29 * 100 হুবহু ২৯ হয় না, ২৮.৯৯৯৯… হয়, আর পূর্ণসংখ্যায় কাটলে ২৮! তাই লেখাটিকে অক্ষর ধরে ধরে নিজেই পড়া নিরাপদ। এমন ফাংশন লেখার সাথে সাথেই তার টেস্ট লিখুন। assert শর্ত মিথ্যা হলে লাইন নম্বরসহ প্রোগ্রাম থামায়; সব পাস করলে শেষ লাইনে PASS ছাপা হয়:

#include <cassert>
#include <print>
#include <string>

// "72.50" -> 7250 paisa; returns false for bad text
bool parse_money(const std::string& s, long long& paisa) {
    long long taka = 0; int frac = 0, decimals = 0;
    bool dot = false, digit = false;
    for (char c : s) {
        if (c == '.' && !dot) { dot = true; continue; }
        if (c < '0' || c > '9') return false;        // "12abc", "-5"
        digit = true;
        if (!dot) taka = taka * 10 + (c - '0');
        else if (++decimals > 2) return false;       // "1.234"
        else frac = frac * 10 + (c - '0');
    }
    if (!digit) return false;                        // "" or "."
    paisa = taka * 100 + (decimals == 1 ? frac * 10 : frac);
    return true;
}

int main() {
    long long p = 0;
    assert(parse_money("72.50", p) && p == 7250);
    assert(parse_money("72.5", p) && p == 7250);
    assert(parse_money("13", p) && p == 1300);
    assert(!parse_money("12abc", p) && !parse_money("1.234", p));
    assert(!parse_money("", p) && !parse_money(".", p));
    std::println("PASS: all parse_money tests");
}

৯ · AI-এর যুগে — AI আপনার pair-programmer, আপনি নকশাকার

এই পুরো প্রজেক্ট একটি প্রম্পটেই AI দিয়ে লেখানো যায় — কিন্তু এক প্রম্পটের ৩০০ লাইনে কোথায় টাকা double, কোথায় স্টকের পরীক্ষা নেই, খুঁজে পাওয়া কঠিন। পেশাদারেরা AI-কে ব্যবহার করেন pair programming-এর সঙ্গীর মতো: AI লেখে, আপনি দিক ঠিক করেন আর প্রতিটি লাইন যাচাই করেন। এর তিনটি নিয়ম:

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

• টাকা কোথাও float/double-এ নেই; std::stod দিয়ে দাম পড়া হয়নি (পর্ব ০৫)
• ইনপুট পড়া হয় getline + istringstream দিয়ে, আর প্রতিটি >>-এর সফলতা যাচাই হয় (পর্ব ০৭)
• বড় parameter const&, বদলানোর parameter & — অকারণ কপি নেই (পর্ব ১০)
• header-এ using namespace std; নেই, #pragma once আছে, সংজ্ঞা .cpp-তে (পর্ব ১১)
• enum class-এর ওপর switch-এ সব case আছে, অপ্রয়োজনীয় default নেই (পর্ব ১২)
• কোনো new/delete বা std::vector<Item*> নেই; মালিক vector নিজেই (পর্ব ১৬-১৭)
• vector-এর উপাদানের pointer/reference push_back-এর পরে ব্যবহার হয়নি (পর্ব ১৮)
• হিসাবের ফাংশন কিছু ছাপে না; প্রতিটি ব্যর্থতার পথের জন্য অন্তত একটি টেস্ট আছে, আর -Wall -Wextra-এ কোনো সতর্কবার্তা নেই

১০ · মডিউল ৩ শেষ — মেমরি, স্ট্রিং আর রিসোর্স এখন আপনার হাতে

এই পর্বের সাথে মডিউল ৩ “মেমরি, স্ট্রিং আর রিসোর্স” শেষ হলো। সাতটি পর্বে আপনি শিখেছেন ডেটা মেমরিতে কোথায় থাকে, কে তার মালিক, আর কতক্ষণ বাঁচে — আর আজ সব একসাথে একটি টুলে ব্যবহার করলেন। একবার ফিরে দেখুন:

মডিউল ৪ শুরু হবে ঠিক সেই দুর্বলতা থেকে, যা এই পর্বে বারবার চোখে পড়েছে: qty ≥ 0 নিয়মটি রক্ষা করছে শুধু comment আর ভদ্রলোকের চুক্তি। Ledger-এর ডেটা খোলা, তাই যে কেউ পাহারা পাশ কাটাতে পারে। পর্ব ২০-এ class দিয়ে ডেটা লুকানো হবে — items হবে private, আর বদলানো যাবে শুধু add()/sell() দিয়ে। এর নাম encapsulation.