সিদ্ধান্ত ও লুপ — if, switch আর range-for

১ · প্রোগ্রামের পথ — সোজা চলা, মোড় নেওয়া, ঘুরে আসা

এ পর্যন্ত আপনার প্রতিটি প্রোগ্রাম ওপর থেকে নিচে, একটির পর একটি লাইন চলেছে। কিন্তু বাস্তব কাজে এটুকু যথেষ্ট নয়। বিদ্যুৎ বিল কত হবে, তা নির্ভর করে কত ইউনিট খরচ হয়েছে তার ওপর। ক্লাসের ৬০ জন ছাত্রের নম্বর থেকে সর্বোচ্চ বের করতে একই কাজ ৬০ বার করতে হয়। প্রোগ্রাম কোন লাইন কখন, কতবার চালাবে — এই ক্রমকে বলে control flow.

ঢাকার একটি বাসের রুট ভাবুন। বাস বেশিরভাগ সময় সোজা চলে। কোনো মোড়ে এসে সিদ্ধান্ত নেয় — রাস্তা বন্ধ থাকলে বাঁয়ে, নইলে সোজা। আর দিনশেষে একই রুটে বারবার ঘুরে আসে, যতক্ষণ না শেষ ট্রিপের সময় হয়। প্রোগ্রামও ঠিক এই তিন রকম চলে:

এই পর্বে দুটি বড় অংশ — সিদ্ধান্ত আর লুপ। দুটিই C-এর মতো, তাই এখানে আমরা মূল ধারণা আর আধুনিক C++-এর নতুন সুবিধাগুলোয় জোর দেব। প্রতিটি খুঁটিনাটি নিয়ে আরও গভীরে যেতে চাইলে C কোর্সের সংশ্লিষ্ট পর্বের লিংক পাবেন।

২ · if, else if, else — শর্তের সিঁড়ি

সবচেয়ে সরল সিদ্ধান্ত: “শর্ত সত্য হলে এই কাজটি করো।” C++-এ লেখা হয় if (শর্ত) { ... }. বন্ধনীর ভেতরের শর্তটি একটি bool মান দেয় — true হলে block-টি চলে, false হলে লাফিয়ে পরের অংশে যায়। সাথে else দিলে “নইলে অন্যটা করো।” আর একাধিক বিকল্প থাকলে else if দিয়ে একটি সিঁড়ি বানানো হয়। পুরো কাঠামোকে বলে if-else.

বাস্তব উদাহরণ নিই — বিদ্যুৎ বিলের ধাপভিত্তিক দাম (slab). বাংলাদেশের বিতরণ কোম্পানিগুলো এমন ধাপে দাম ধরে: যত বেশি খরচ, ওপরের ধাপের প্রতি ইউনিটের দাম তত বেশি। আসল হার সময়ে সময়ে বদলায়, তাই এখানে সহজ একটি কাল্পনিক হার নিচ্ছি:

২৫০ ইউনিট খরচ হলে প্রোগ্রাম কোন পথে যায়, ধাপে ধাপে দেখুন। খেয়াল করুন কোন শর্তগুলো পরীক্ষা হয়, আর কোনগুলো একদমই হয় না:

1int units = 250, bill{};2if (units <= 75) {3    bill = units * 5;4} else if (units <= 200) {5    bill = 375 + (units - 75) * 7;6} else if (units <= 300) {7    bill = 1250 + (units - 200) * 8;8} else {9    bill = 2050 + (units - 300) * 10;10}

এবার একসাথে চারজন গ্রাহকের বিল হিসাব করে দেখুন। এখানে একটি range-for লুপও আছে, যা অংশ ৬-এ বিস্তারিত দেখবেন — আপাতত শুধু জানুন, এটি তালিকার প্রতিটি মান একবার করে units-এ বসায়:

#include <print>

int main() {
    constexpr int customers[] = {50, 150, 250, 400};   // units

    for (int units : customers) {
        int bill{};
        if (units <= 75) {
            bill = units * 5;
        } else if (units <= 200) {
            bill = 375 + (units - 75) * 7;
        } else if (units <= 300) {
            bill = 1250 + (units - 200) * 8;
        } else {
            bill = 2050 + (units - 300) * 10;
        }
        std::println("{:>4} units -> {:>5} taka", units, bill);
    }
}

তিনটি পুরোনো ফাঁদ

• if (x = 5): এটি তুলনা নয়, মান বসানো। x-এ 5 বসে, ফল 5 — যা সত্য, তাই শর্ত সবসময় সত্য। GCC -Wall-এ সতর্ক করে। তুলনা হলো == (পর্ব ০৬)।
• if (0 < x < 10): গণিতের মতো দেখালেও C++ এটিকে পড়ে (0 < x) < 10 — প্রথম অংশ true/false অর্থাৎ 1/0, যা সবসময় 10-এর কম। সঠিক রূপ 0 < x && x < 10.
• বন্ধনী ছাড়া if: {} না দিলে শুধু পরের একটি statement শর্তের অধীন। পরে কেউ দ্বিতীয় লাইন যোগ করলে সেটি সবসময় চলবে। নিরাপদ অভ্যাস — একটি লাইন হলেও {} দিন।

Nested শর্ত বনাম early return

শর্তের ভেতরে শর্ত, তার ভেতরে আরও শর্ত — কোড ডানে সরতে সরতে একটি পিরামিড হয়ে যায়। পড়তে গেলে মাথায় রাখতে হয় এখন কোন কোন শর্ত সত্য। বিকল্প হলো guard clause: অস্বাভাবিক বা ভুল অবস্থাগুলো শুরুতেই আলাদা করে বের করে দেওয়া, যাতে মূল কাজটি সোজা লাইনে থাকে। নিচে একই ফাংশন দুইভাবে (ফাংশন লেখার নিয়ম পর্ব ০৯-এ বিস্তারিত):

int bill_for(int units, bool connected) {
    if (connected) {
        if (units >= 0) {
            if (units <= 75) {
                return units * 5;
            } else {
                return 375 + (units - 75) * 7;   // সংক্ষেপে
            }
        } else {
            return -1;     // ভুল মিটার রিডিং
        }
    } else {
        return 0;          // সংযোগ নেই
    }
}

int bill_for(int units, bool connected) {
    if (!connected) return 0;      // সংযোগ নেই
    if (units < 0)  return -1;     // ভুল মিটার রিডিং

    if (units <= 75) return units * 5;
    return 375 + (units - 75) * 7; // সংক্ষেপে
}

দ্বিতীয়টিতে প্রতিটি লাইন একটি স্বাধীন কথা বলে: “সংযোগ না থাকলে শূন্য”, “রিডিং ঋণাত্মক হলে ভুল।” এর পরে পাঠক নিশ্চিত — সংযোগ আছে, রিডিং ঠিক। লুপের ভেতরে একই কাজ করে continue (অংশ ৭)।

৩ · C++17-এর উপহার — শর্তের সাথে ভ্যারিয়েবল বানানো

প্রায়ই এমন হয়: একটি মান বের করেন শুধু তা পরীক্ষা করার জন্য। যেমন একটি ইমেইল ঠিকানায় @ চিহ্ন কোথায় আছে খোঁজা। std::string-এর find অবস্থান ফেরত দেয়, আর না পেলে দেয় একটি বিশেষ মান std::string::npos. পুরোনো লেখায়:

auto pos = email.find('@');          // pos এখন পুরো ফাংশনে দৃশ্যমান
if (pos != std::string::npos) {
    std::println("user = {}", email.substr(0, pos));
}
// ... ৪০ লাইন পরে কেউ ভুল করে আবার pos ব্যবহার করলেন

সমস্যা হলো pos-এর জীবন। এর কাজ শেষ if-এর সাথেই, কিন্তু সে বেঁচে থাকে পুরো ফাংশন জুড়ে। পরে কেউ অন্য খোঁজের জন্য আবার pos নাম নিতে চাইলে সংঘর্ষ, বা পুরোনো মানটি ভুল করে ব্যবহার। C++17 থেকে if-এর ভেতরেই একটি init-statement লেখা যায়:

if (auto pos = email.find('@'); pos != std::string::npos) {
    std::println("user = {}", email.substr(0, pos));
} else {
    std::println("invalid email");   // pos এখানেও দেখা যায়
}
// এখানে pos আর নেই — compiler-ই আটকে দেবে

সেমিকোলনের আগের অংশ ভ্যারিয়েবল বানায়, পরের অংশ শর্ত। ভ্যারিয়েবলটির scope — অর্থাৎ কোডের যে অংশে নামটি চেনা যায় — if আর তার else পর্যন্তই। এটি for (int i = 0; ...)-এর মতোই, যেখানে i লুপের বাইরে থাকে না। একই সুবিধা switch-এও আছে: switch (auto c = read_choice(); c) { ... }.

if constexpr — একটি নাম শুধু চিনে রাখুন

C++17-এ আরেকটি রূপ এসেছে: if constexpr. সাধারণ if-এর শর্ত প্রোগ্রাম চলার সময় পরীক্ষা হয়। if constexpr-এর শর্ত পরীক্ষা হয় compile-এর সময়, আর মিথ্যা শাখাটি template-এর ক্ষেত্রে compile-ই হয় না। এর আসল কাজ template-এ — “টাইপ সংখ্যা হলে এভাবে, লেখা হলে ওভাবে।” পর্ব ৩৯-এ constexpr-এর সাথে এটি বিস্তারিত দেখবেন।

৪ · switch — একটি মান, অনেক দরজা

যখন একটি মাত্র পূর্ণসংখ্যা বা char-এর ভিন্ন ভিন্ন মানের জন্য ভিন্ন কাজ, তখন লম্বা else if-এর চেয়ে switch পরিষ্কার। ধরুন ১০০ নম্বরের পরীক্ষায় গ্রেড বের করবেন। marks / 10 (integer division) দিলে ৮৭ নম্বর হয় 8, ৯৪ হয় 9, ১০০ হয় 10:

switch (marks / 10) {
    case 10:
    case 9:
    case 8:  grade = 'A'; break;
    case 7:  grade = 'B'; break;
    case 6:  grade = 'C'; break;
    case 5:  grade = 'D'; break;
    default: grade = 'F'; break;   // বাকি সব মান
}

প্রতিটি case আসলে একটি দরজার নম্বর। মান যে দরজার সাথে মেলে, প্রোগ্রাম সেখান থেকে চলা শুরু করে — আর থামে break পেলে। কোনো দরজা না মিললে যায় default-এ। এখানে case 10:, case 9: খালি — তাই ১০ বা ৯ এলে সে নিচে গড়িয়ে case 8-এর কাজটিই করে। একে বলে fall-through.

Fall-through — সুবিধা, আর বিখ্যাত বাগ

খালি case-এর গড়িয়ে পড়া কাজের জিনিস। কিন্তু কাজসহ একটি case-এর শেষে break ভুলে গেলে সেটাও গড়িয়ে পরের case-এর কাজ করে ফেলে — নিঃশব্দে।

switch (level) {
    case 1:  discount = 5;            // break ভুলে গেছি!
    case 2:  discount = 10; break;    // level 1 হলেও discount হয় 10
    case 3:  bonus = 50;
             [[fallthrough]];         // ইচ্ছাকৃত: level 3-এ 4-এর সুবিধাও
    case 4:  discount = 20; break;
    default: discount = 0;  break;
}

কোনটা ভুল আর কোনটা ইচ্ছাকৃত, পাঠক বুঝবেন কীভাবে? C++17-এ এসেছে [[fallthrough]] — একটি attribute, যা compiler আর পাঠক দুজনকে বলে “এখানে break না থাকাটা আমার সিদ্ধান্ত।” GCC আর Clang-এ -Wimplicit-fallthrough (GCC-তে -Wextra-র অংশ) চালু থাকলে case 1-এর লাইনে সতর্কবার্তা আসবে, কিন্তু case 3-এ আসবে না। ফলে আসল বাগটি আলাদা হয়ে চোখে পড়ে।

switch-এর নিয়ম ও সীমা

• শুধু পূর্ণসংখ্যা-জাতীয় মান: int, char, enum. std::string বা double দিয়ে switch হয় না — সেখানে if/else if লাগবে।
• case-এর মান compile-এর সময় জানা ধ্রুবক: case 5: বা case MAX: (যদি MAX constexpr হয়)। case x: যেখানে x সাধারণ ভ্যারিয়েবল — চলবে না। case 1 ... 5-এর মতো পরিসরও standard C++-এ নেই।
• case-এর ভেতরে ভ্যারিয়েবল বানালে {} দিন: নইলে compiler বলে “jump to case label crosses initialization”, কারণ পরের case-এ লাফ দিলে ভ্যারিয়েবলটির initialization বাদ পড়ে যেত।
• সবসময় default: “এমন মান তো আসবেই না” — এই বিশ্বাসই সবচেয়ে বেশি বাগ আনে। অন্তত একটি বার্তা ছাপান বা error দিন।

enum-এর সাথে switch — compiler-কে পাহারায় বসানো

switch-এর সবচেয়ে শক্তিশালী ব্যবহার enum class-এর সাথে, যা পর্ব ১২-এ শিখবেন। ছোট একটি ঝলক:

enum class Payment { Cash, Card, Bkash, Nagad };

switch (method) {
    case Payment::Cash:  fee = 0;  break;
    case Payment::Card:  fee = 15; break;
    case Payment::Bkash: fee = 18; break;
    // Nagad ভুলে গেছি — g++ -Wall বলবে:
    // warning: enumeration value 'Nagad' not handled in switch
}

এখানে default না রাখাটা ইচ্ছাকৃত কৌশল। default থাকলে compiler ধরে নেয় বাকিগুলো আপনি সামলেছেন, আর নতুন একটি মান (যেমন পরে Rocket যোগ হলো) যোগ করলে কোনো সতর্কবার্তা আসে না। default না থাকলে -Wswitch প্রতিটি অসম্পূর্ণ switch দেখিয়ে দেয়। তাই নিয়মটা দাঁড়ায়: সাধারণ সংখ্যায় সবসময় default; নিজের enum-এ সব মান লিখুন, আর অজানা মান সামলান switch-এর পরে।

৫ · লুপ — while, do-while আর for

একই কাজ বারবার করার কাঠামোকে বলে loop, আর প্রতিবার একবার চালানোকে বলে একটি iteration. C++-এ মূল লুপ তিনটি, আর তিনটির পার্থক্য একটাই প্রশ্নে — শর্ত কখন পরীক্ষা হয়, আর গোনার হিসাব কোথায় লেখা থাকে।

for আসলে while-এরই গোছানো রূপ। for (শুরু; শর্ত; পরিবর্তন) { কাজ } — তিনটি অংশ এক লাইনে, যেন গোনার পুরো হিসাব এক জায়গায় দেখা যায়। ১ থেকে ৪ যোগ করার লুপটি ধাপে ধাপে চালিয়ে দেখুন। প্রতিটি ঘর নিজে আগে অনুমান করুন:

1int sum{};2for (int i = 1; i <= 4; ++i) {3    sum += i;4}5std::println("{}", sum);

do-while — অন্তত একবার: মেনু লুপ

একটি মোবাইল রিচার্জের মেনু ভাবুন। ব্যবহারকারী বের হতে চাইবেন কি না, তা জানতে হলে আগে অন্তত একবার মেনু দেখাতে হবে। এটিই do-while-এর স্বাভাবিক কাজ (এটি std::cin থেকে ইনপুট নেয়, তাই এখানে চালানোর বোতাম নেই):

int choice{};
do {
    std::println("1) Balance  2) Recharge  0) Exit");
    if (!(std::cin >> choice)) break;      // ইনপুট শেষ বা ভুল হলে বের হও
    switch (choice) {
        case 1:  std::println("Balance: 120 taka"); break;
        case 2:  std::println("Recharge done");     break;
        case 0:  std::println("Bye");               break;
        default: std::println("Wrong choice");      break;
    }
} while (choice != 0);

শেষের সেমিকোলনটি খেয়াল করুন — while (choice != 0);. do-while-এ এটি বাধ্যতামূলক। আর std::cin ব্যর্থ হলে (কেউ অক্ষর লিখলেন, বা ইনপুট শেষ) break না থাকলে এই লুপ চিরকাল ঘুরত, কারণ ব্যর্থ stream আর নতুন মান পড়ে না (পর্ব ০৭)।

অসীম লুপ — কখন বাগ, কখন নকশা

যে লুপের শর্ত কখনো মিথ্যা হয় না, তা infinite loop. ভুল করে হয় সাধারণত তিনভাবে: পরিবর্তনের অংশ ভুলে যাওয়া (while (i < n), কিন্তু ++i নেই), ভুল দিকে বদলানো (--i যেখানে ++i দরকার), বা এমন শর্ত যা কখনো মিথ্যা হয় না (অংশ ৭-এর unsigned ফাঁদ)। আবার ইচ্ছা করেও অসীম লুপ লেখা হয় — গেমের মূল লুপ, সার্ভার যা সারাদিন অনুরোধ শোনে, ATM-এর সফটওয়্যার। সেখানে লেখা হয় while (true) বা for (;;), আর ভেতরে স্পষ্ট একটি break বা return থাকে।

৬ · Range-based for — সূচক ছাড়া প্রতিটি উপাদান

ক্লাসের সব নম্বর একটি std::vector-এ আছে (পর্ব ১৩-এ বিস্তারিত)। প্রতিটি নম্বর একবার করে দেখতে হবে। পুরোনো পথে সূচক দিয়ে: for (std::size_t i = 0; i < marks.size(); ++i) — তিনটি জায়গায় ভুলের সুযোগ: শুরু, শর্ত আর বৃদ্ধি। C++11 থেকে লেখা যায় শুধু:

for (const auto& m : marks) {   // "marks-এর প্রতিটি m-এর জন্য"
    std::println("{}", m);
}

এটি array, std::vector, std::string (প্রতিটি অক্ষর) — যার শুরু আর শেষ আছে এমন সবকিছুর ওপর চলে। ভেতরে compiler এটিকে iterator দিয়ে লেখা একটি সাধারণ লুপে বদলে নেয় (পর্ব ৩২)। আপনার কাজ শুধু একটি সিদ্ধান্ত: লুপের ভ্যারিয়েবলটি কপি হবে, না আসল উপাদানের আরেক নাম?

কপি আর reference-এর পার্থক্যটাই সবচেয়ে বেশি ভুল করায়। ছাত্রদের নম্বরে ৫ নম্বর grace দিতে গিয়ে কী হয়, ধাপে ধাপে দেখুন:

1std::vector<int> v{40, 55, 70};2for (auto x : v)  x += 5;3// v এখন?4for (auto& x : v) x += 5;5// v এখন?

এবার সব একসাথে: range-for দিয়ে সর্বোচ্চ নম্বর খোঁজা, auto& দিয়ে grace দেওয়া, আর switch দিয়ে গ্রেড:

#include <print>
#include <vector>

int main() {
    std::vector<int> marks{72, 45, 88, 91, 67};
    int best = marks[0];
    for (const auto& m : marks) {
        if (m > best) best = m;
    }
    std::println("max = {}", best);

    for (auto& m : marks) m += 5;         // grace: vector bodlay
    for (const auto& m : marks) {
        char grade{};
        switch (m / 10) {
            case 10: case 9: case 8: grade = 'A'; break;
            case 7:  grade = 'B'; break;
            case 6:  grade = 'C'; break;
            default: grade = 'F'; break;
        }
        std::print("{}:{} ", m, grade);
    }
    std::println("");
}

Range-for-এ দুটি সাবধানতা, আর আধুনিক কিছু রূপ

• লুপের ভেতরে container-এর আকার বদলাবেন না। for (auto& x : v) v.push_back(x); — push_back মেমরি নতুন জায়গায় সরাতে পারে, তখন লুপের ভেতরের iterator পুরোনো ঠিকানা ধরে থাকে: undefined behavior (পর্ব ১৮)।
• সূচকও দরকার হলে: C++20 থেকে range-for-এও init-statement চলে — for (std::size_t i = 0; const auto& m : marks) { ...; ++i; }.
• সংখ্যার পরিসরের ওপর: C++20-এর std::views::iota দিয়ে for (int i : std::views::iota(1, 11)) লিখলে i চলে ১ থেকে ১০ পর্যন্ত (শেষ মানটি বাদ)। Ranges আর views-এর পুরো গল্প পর্ব ৩৫-এ।

৭ · break, continue আর off-by-one

লুপের মাঝখান থেকে পথ বদলানোর দুটি শব্দ আছে। break — “লুপ এখনই শেষ, বের হয়ে যাও।” continue — “এই iteration-এর বাকিটা বাদ, পরেরটায় যাও।” একটি বোলারের ওভারের রান যোগ করার কাল্পনিক নিয়ম দেখুন: ঋণাত্মক মান মানে ভুল এন্ট্রি (বাদ), আর 0 মানে ডেটার শেষ চিহ্ন (থামো):

1int runs[] = {5, -1, 3, 0, 7};  int sum{};2for (int r : runs) {3    if (r < 0)  continue;4    if (r == 0) break;5    sum += r;6}7std::println("{}", sum);

Off-by-one — একঘর বেশি, একঘর কম

লুপের সবচেয়ে প্রচলিত ভুলের নাম off-by-one: একবার বেশি বা একবার কম চলা। ১০০ মিটার রাস্তায় প্রতি ১০ মিটারে একটি খুঁটি বসাতে কয়টি খুঁটি লাগে? ১০ নয়, ১১ — এই “fencepost” প্রশ্নই off-by-one-এর মূল। কোডে এটি সাধারণত তিন জায়গায় লুকায়:

সবচেয়ে নিরাপদ অভ্যাস হলো C++-এর প্রচলিত half-open নিয়ম: শুরু ধরা, শেষ বাদ — [0, n), অর্থাৎ i = 0; i < n. এতে iteration সংখ্যা ঠিক n, খালি পরিসর মানে 0 < 0 মিথ্যা — লুপ নিজে থেকেই চলে না। Standard library-র প্রতিটি পরিসর (begin থেকে end) এই নিয়মে বানানো। আর container-এর ওপর হলে সবচেয়ে ভালো — সূচকই রাখবেন না, range-for নিন।

Signed-unsigned তুলনা — AI-এর প্রিয় সতর্কবার্তা

v.size() ফেরত দেয় std::size_t, একটি unsigned টাইপ। তাই for (int i = 0; i < v.size(); ++i) লিখলে g++ -Wall-এ বলে comparison of integer expressions of different signedness. ক্ষতিটা বাস্তব: ঋণাত্মক int unsigned-এ বদলে বিশাল সংখ্যা হয়ে যায়, ফলে -1 < v.size() মিথ্যা দাঁড়ায়। সমাধান তিনটি: সূচকের টাইপ std::size_t নিন, বা C++20-এর std::ssize(v) দিয়ে signed আকার নিন, বা সবচেয়ে ভালো — range-for.

Loop invariant — লুপ ঠিক কি না, প্রমাণের হাতিয়ার

অংশ ৫-এর trace table-এ একটি বাক্য প্রতিটি ধাপে সত্য ছিল: “sum হলো ১ থেকে i পর্যন্ত যোগফল।” লুপ লেখার সময় এমন একটি বাক্য খুঁজে নিন। সর্বোচ্চ খোঁজার লুপে invariant: “best হলো এ পর্যন্ত দেখা উপাদানগুলোর সর্বোচ্চ।” তিনটি প্রশ্ন করলেই লুপের সঠিকতা যাচাই হয় — শুরুতে কি এটি সত্য? প্রতিটি iteration কি একে সত্য রাখে? লুপ শেষে এটি কি ঠিক আপনার চাওয়া উত্তর দেয়? Off-by-one ভুল সাধারণত এই তিন প্রশ্নের প্রথম বা শেষটিতেই ধরা পড়ে।

৮ · লুপের ভেতরে লুপ — আর তার খরচ

লুপের ভেতরে আরেকটি লুপকে বলে nested loop. ছোটবেলার নামতার ছক এর সহজ উদাহরণ:

for (int row = 1; row <= 9; ++row) {
    for (int col = 1; col <= 9; ++col) {
        std::print("{:3}", row * col);
    }
    std::println("");
}

বাইরের লুপ ৯ বার, প্রতিবার ভেতরের লুপ ৯ বার — মোট ৮১টি গুণ। এখন ৯-এর বদলে যদি n হয়? কাজ হয় n × n. এই বৃদ্ধির হারকে বলে O(n²) — Big-O notation-এ।

ধরুন একটি মোবাইল ব্যাংকিং অ্যাপ ১০ লাখ লেনদেনের মধ্যে একই নম্বরের দুটি লেনদেন খুঁজছে। “প্রতিটির সাথে প্রতিটির তুলনা” — দুই স্তরের লুপ — ছোট পরীক্ষায় দিব্যি চলে, কিন্তু আসল ডেটায় ঘণ্টার পর ঘণ্টা লাগে। একই কাজ sort করে বা hash table দিয়ে (পর্ব ৩১, ৩৩) অনেক কম সময়ে হয়। তাই nested লুপ দেখলেই একবার জিজ্ঞেস করুন: n বড় হলে কী হবে? বিস্তারিত হিসাব শিখতে C কোর্সের Big-O ও সময়ের জটিলতা পর্বটি দেখুন।

৯ · AI-এর যুগে — লুপ AI লেখে, সীমানা পরীক্ষা আপনার

লুপ আর শর্ত AI টুল প্রায় নিখুঁতভাবে লেখে — দেখতে। কিন্তু লুপের বাগ থাকে সীমানায়: প্রথম উপাদান, শেষ উপাদান, খালি তালিকা, একটিমাত্র উপাদান। সাধারণ পরীক্ষায় এগুলো ধরা পড়ে না। AI-এর লেখা C++ লুপে বারবার যা দেখা যায়:

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

• প্রতিটি লুপের শেষ শর্ত হাতে মিলিয়েছি — < না <=? মোট কতবার চলবে বলতে পারি
• খালি container আর একটিমাত্র উপাদান দিয়ে কোডটি মনে মনে (বা আসলে) চালিয়েছি
• range-for-এ কপি, reference না const reference — প্রতিটির কারণ জানি
• int আর .size()-এর তুলনা নেই; unsigned সূচক উল্টো দিকে কমছে না
• প্রতিটি switch-এ break/[[fallthrough]] স্পষ্ট, আর default (বা enum-এর সব মান) আছে
• প্রতিটি লুপ শেষের দিকে এগোয়; nested লুপ থাকলে বড় n-এ সময় কত, আন্দাজ করেছি