vector ও array — পাশাপাশি সাজানো ডেটা

১ · মডিউল ৩ শুরু — কেন পাশাপাশি সাজানো ডেটা এত দ্রুত

মডিউল ২-এ আপনি ভাষার যন্ত্রপাতি হাতে নিয়েছেন — অপারেটর, লুপ, ফাংশন, reference, নিজের টাইপ। কিন্তু এতদিন প্রোগ্রাম কাজ করেছে একটি-দুটি মান নিয়ে। বাস্তবের ডেটা আসে তালিকায়: একটি দোকানের মাসের ৩০ দিনের বিক্রি, একটি ক্লাসের ষাট জনের নম্বর, একটি সিনেমা হলের শখানেক সিট। মডিউল ৩ “মেমরি, স্ট্রিং আর রিসোর্স” এই প্রশ্ন দিয়েই শুরু: অনেকগুলো মান মেমরিতে কোথায়, কীভাবে থাকে — আর কে সেই মেমরির দায়িত্ব নেয়?

এই পুরো মডিউলের কেন্দ্রে একটি সরল ধারণা: উপাদানগুলো মেমরিতে পাশাপাশি থাকলে কাজ দ্রুত হয়। একে বলে contiguous memory. ধরুন একটি int ৪ বাইটের, আর প্রথম উপাদানটি আছে ঠিকানা 1000-এ। তাহলে দ্বিতীয়টি 1004-এ, তৃতীয়টি 1008-এ — সূচক i-এর উপাদান ঠিক 1000 + 4 × i-এ। কোনো খোঁজাখুঁজি নেই, একটি গুণ আর একটি যোগ — তাই যেকোনো উপাদানে পৌঁছানো এক লাফে।

গতির আরেকটি, আরও বড় কারণ আছে — CPU-র cache. মূল মেমরি (RAM) CPU-র তুলনায় অনেক ধীর। তাই CPU মেমরি থেকে একটি একটি বাইট আনে না, একসাথে একটি ছোট টুকরো আনে (সাধারণ কম্পিউটারে ৬৪ বাইটের একটি cache line) আর কাছের দ্রুত cache-এ রাখে। পাশাপাশি সাজানো ১৬টি int একটি cache line-এই এঁটে যায়: প্রথমটি পড়তে গিয়ে বাকি ১৫টিও বিনা খরচে হাতে চলে এল। আর আপনি যদি সারি ধরে এগোতে থাকেন, CPU আগেভাগেই পরের টুকরো এনে রাখে। এই সুবিধার নাম cache locality. বাস্তব প্রোগ্রামে এটি প্রায়ই Big-O হিসাবের চেয়েও বেশি পার্থক্য গড়ে দেয় — ভাবনার প্রশ্ন ০১-এ এর একটি বিখ্যাত উদাহরণ দেখবেন।

২ · C-ধাঁচের array — তিনটি পুরোনো ফাঁদ

C থেকে C++ পেয়েছে C-style array: int sales[30];. মেমরিতে এটি নিখুঁত — ৩০টি int পাশাপাশি, কোনো বাড়তি খরচ নেই। সমস্যা মেমরিতে নয়, এর আচরণে। পুরোনো কোড পড়তে, আর AI-এর লেখা কোডে ভুল ধরতে, এই তিনটি ফাঁদ চিনে রাখা জরুরি।

ফাঁদ ১ — নিজের আকার জানে না

array-এর আকার শুধু সেই জায়গাতেই জানা যায় যেখানে এটি ঘোষণা হয়েছে। সেখানে sizeof(sales) / sizeof(sales[0]) লিখে বা C++17-এর std::size(sales) দিয়ে ৩০ পাওয়া যায়। কিন্তু array-কে কোথাও পাঠালেই এই তথ্য হারিয়ে যায়। তাই C-তে প্রায় প্রতিটি ফাংশন দুটি জিনিস নেয় — array আর তার আকার, যেমন average(sales, 30). কেউ ভুল সংখ্যা দিলে কেউ টের পায় না।

ফাঁদ ২ — ফাংশনে গেলে pointer হয়ে যায়

এটি সবচেয়ে বিভ্রান্তিকর। void f(int a[30]) লিখলে মনে হয় ফাংশনটি ৩০টি int-এর array নিচ্ছে। আসলে compiler এটিকে পড়ে void f(int* a) হিসেবে — শুধু প্রথম উপাদানের ঠিকানা। ৩০ সংখ্যাটি পুরো উপেক্ষিত। একে বলে array-to-pointer decay. ফলে ফাংশনের ভেতরে sizeof(a) দেয় একটি pointer-এর আকার (সাধারণ 64-bit সিস্টেমে ৮), ৩০ × ৪ = ১২০ নয়। GCC এতে সতর্ক করে -Wsizeof-array-argument দিয়ে, কিন্তু সতর্কবার্তা পড়েন কয়জন?

void report(int sales[30]) {               // আসলে: int* sales
    auto n = sizeof(sales) / sizeof(sales[0]);   // 8 / 4 = 2, 30 নয়!
}

আরও একটি ফল: C-array-কে = দিয়ে কপি করা যায় না (int b[30] = sales; error), ফাংশন থেকে ফেরতও দেওয়া যায় না, আর a == b লিখলে মান নয়, দুটি ঠিকানা তুলনা হয়। অর্থাৎ int-এর মতো সাধারণ মানের আচরণ সে করে না।

ফাঁদ ৩ — সীমা পাহারা দেয় না

৩০ ঘরের array-এ sales[30] বা sales[-1] লিখলে compiler সাধারণত কিছু বলে না, প্রোগ্রামও থামে না। সেই ঠিকানায় অন্য যা আছে — হয়তো আরেকটি ভ্যারিয়েবল — সেটাই পড়া বা লেখা হয়। এটা undefined behavior: প্রোগ্রাম ঠিক চলতে পারে, ভুল ফল দিতে পারে, crash করতে পারে, বা সপ্তাহখানেক পরে অন্য কোথাও অদ্ভুত আচরণ করতে পারে। ইতিহাসের বহু বড় নিরাপত্তা-ত্রুটি ঠিক এই “সীমার বাইরে লেখা” থেকে এসেছে। পর্ব ০৮-এর off-by-one ভুল (i <= n লেখা i < n-এর বদলে) এখানেই সবচেয়ে বেশি ক্ষতি করে।

৩ · std::array — নির্দিষ্ট আকার, কিন্তু নিজের আকার জানে

সপ্তাহে ৭ দিন, বছরে ১২ মাস, দাবার বোর্ডে ৬৪ ঘর — অনেক ডেটার আকার প্রোগ্রাম লেখার সময়েই জানা। এদের জন্য C++11 এনেছে <array> header-এর std::array. এটি আসলে একটি C-array-কে ঘিরে রাখা ছোট একটি struct — মেমরিতে হুবহু একই, এক বাইটও বাড়তি নয়, গতিও একই। কিন্তু আচরণে অনেক ভদ্র:

std::array<int, 7> week{};               // ৭টি int, সব 0
std::array<int, 7> copy = week;           // পুরো কপি — C-array-এ যা অসম্ভব
std::println("{}", week.size());          // 7 — নিজের আকার জানে
if (copy == week) { }                     // মান তুলনা, ঠিকানা নয়
auto days = std::to_array({"Sat", "Sun", "Mon"});   // C++20: আকার নিজেই গুনে নেয়

খেয়াল করুন, std::array একটি aggregate — পর্ব ১২-এর struct-এর মতোই {} দিয়ে মান সাজানো যায়, আর week{} লিখলে সব ঘর শূন্য হয়। কিন্তু std::array<int, 7> w; (কোনো {} নেই) লিখলে C-array-এর মতোই আবর্জনা মান থাকে — তাই {} লেখার অভ্যাস রাখুন। আর আকার বাড়ানো-কমানো যায় না: ৮ম দিন যোগ করার কোনো উপায় নেই। আকার যখন ডেটার ওপর নির্ভর করে, তখন দরকার vector.

৪ · std::vector — বাড়তে পারা array, নিজের মেমরির মালিক

একটি চায়ের দোকানের মালিক প্রতিদিনের বিক্রি লিখে রাখতে চান। মাস শেষ হওয়ার আগে জানেন না কয় দিন দোকান খোলা থাকবে — হরতাল বা ঈদের ছুটিতে কম, হয়তো। এখানে দরকার এমন একটি সারি, যা দরকারমতো বড় হয়। সেটাই <vector> header-এর std::vector.

std::vector<int> sales;            // খালি — size 0
sales.push_back(1250);              // শেষে একটি যোগ — size 1
sales.push_back(980);               // size 2
std::vector<int> marks{72, 85, 64}; // শুরুতেই তিনটি মান
std::vector<int> zeros(30);         // ৩০টি 0 — গোল বন্ধনী!
std::vector<int> one{30};           // একটিমাত্র উপাদান: 30 — ফাঁদ!

শেষ দুটি লাইন একটি পরিচিত ফাঁদ: (30) মানে “৩০টি উপাদান”, কিন্তু {30} মানে “একটি উপাদান, যার মান ৩০”। পর্ব ০৫-এ brace initialization-কে নিরাপদ বলেছিলেন; vector-এর ক্ষেত্রে {} আগে মানের তালিকা হিসেবে পড়া হয়, তাই আকার দিতে গোল বন্ধনী লাগে।

vector আসলে কী — তিনটি সংখ্যা আর একটি ব্লক

ভেতরে একটি vector খুবই সরল। এর নিজের শরীরে থাকে তিনটি জিনিস: heap-এ নেওয়া একটি মেমরি ব্লকের শুরুর ঠিকানা, কয়টি উপাদান আসলে আছে (size), আর ব্লকে মোট কয়টির জায়গা আছে (capacity). উপাদানগুলো নিজেরা থাকে সেই ব্লকে — পাশাপাশি, ঠিক array-এর মতো। আর vector সেই ব্লকের মালিক: vector-এর জীবন শেষ হলে (যেমন ফাংশন থেকে বেরোলে) সে নিজেই উপাদানগুলো ধ্বংস করে মেমরি ফেরত দেয়। আপনাকে কখনো delete লিখতে হয় না। এই “মালিক নিজেই পরিষ্কার করে” নীতির নাম RAII — পর্ব ১৭-এ এর পুরো রূপ দেখবেন।

vector ঠিক এভাবেই বাড়ে। push_back-এ জায়গা থাকলে নতুন উপাদান সোজা পরের খালি ঘরে বসে — খুব দ্রুত। জায়গা না থাকলে ঘটে reallocation: নতুন বড় ব্লক, সব উপাদান সেখানে সরানো, পুরোনো ব্লক ফেরত। নিচের stepper-এ পাঁচটি push_back ধাপে ধাপে দেখুন। সংখ্যাগুলো এমন একটি লাইব্রেরির, যা প্রতিবার capacity ২ গুণ করে (GCC আর Clang-এর লাইব্রেরি প্রচলিতভাবে এমনই করে); অন্য লাইব্রেরি বা সংস্করণে capacity-র সংখ্যা আলাদা হতে পারে, কিন্তু ছবিটা একই।

1std::vector<int> v;2v.push_back(10);3v.push_back(20);4v.push_back(30);5v.push_back(40);6v.push_back(50);

capacity প্রতিবার কত গুণ বাড়বে, C++ standard তা বলে দেয় না — এটি লাইব্রেরির সিদ্ধান্ত, যাকে বলে growth factor. GCC (libstdc++) আর Clang-এর libc++ সাধারণত ২ গুণ বাড়ায়, Microsoft-এর লাইব্রেরি ১.৫ গুণ। standard শুধু একটি শর্ত দেয়: শেষে উপাদান যোগ করার গড় খরচ ধ্রুবক হতে হবে — amortized O(1). গুণ করে বাড়ালে এটা সম্ভব (কেন, ভাবনার প্রশ্ন ০২-এ দেখবেন); প্রতিবার মাত্র ১টি বা ১০টি ঘর বাড়ালে সম্ভব হতো না।

reserve, emplace_back আর clear

উপাদান কয়টি হবে আগে থেকে জানলে (বা মোটামুটি আন্দাজ থাকলে) reserve(n) লিখুন। এটি size বদলায় না — vector এখনো খালি — শুধু অন্তত nটির ঘর নিয়ে রাখে। struct-এর vector-এ emplace_back কাজে লাগে: orders.emplace_back("Tea", 2) লিখলে নতুন উপাদানটি সরাসরি vector-এর ঘরেই তৈরি হয়, আগে একটি অস্থায়ী বস্তু বানিয়ে তারপর সরাতে হয় না। আর clear() সব উপাদান মুছে size 0 করে, কিন্তু ব্লকটি রেখে দেয় — capacity আগের মতোই। মেমরি সত্যিই ফেরত চাইলে shrink_to_fit() একটি অনুরোধ, যা লাইব্রেরি মানতে বাধ্য নয় (বাস্তবে GCC মানে)। নিচের প্রোগ্রামে দোকানের এক মাসের বিক্রি দেখুন:

#include <print>
#include <vector>

int main() {
    std::vector<int> sales;
    sales.reserve(30);                         // 30 diner jayga age theke
    const auto cap = sales.capacity();

    for (int day = 1; day <= 30; ++day)
        sales.push_back(1000 + day * 50);      // dainik bikri (taka)

    std::println("days = {}, empty = {}", sales.size(), sales.empty());
    std::println("capacity >= 30: {}, new block during month: {}",
                 cap >= 30, sales.capacity() != cap);
    std::println("day 1 = {}, day 30 = {}", sales.front(), sales.back());

    sales.clear();                             // mash shesh, hisab muche felun
    std::println("after clear: size = {}, capacity kept: {}",
                 sales.size(), sales.capacity() == cap);
}

৫ · উপাদান পড়া ও বদলানো — [] বনাম .at(), মাঝখানে ঢোকানো-মোছা

vector-এর উপাদান পড়ার দুটি উপায়: v[i] আর v.at(i). সূচক ঠিক থাকলে দুটোই একই মান দেয়। পার্থক্য দেখা যায় শুধু ভুলের সময় — আর ঠিক তখনই পার্থক্যটা সবচেয়ে জরুরি। [] কোনো যাচাই করে না, C-array-এর মতোই সোজা ঠিকানা হিসাব করে পড়ে। .at() আগে bounds checking করে: সূচক size()-এর সমান বা বেশি হলে একটি exception ছোড়ে, যার টাইপ std::out_of_range. ধাপে ধাপে দেখুন:

1std::vector<int> marks{72, 85, 64};2int a = marks[1];3int b = marks.at(2);4int c = marks[3];       // সীমার বাইরে!5int d = marks.at(3);    // সীমার বাইরে!6// g++ -D_GLIBCXX_ASSERTIONS দিয়ে আবার

তাহলে সবখানে .at() নয় কেন? কারণ বেশিরভাগ লুপে সূচক নিজেই প্রমাণিতভাবে সঠিক — for (std::size_t i = 0; i < v.size(); ++i)-এ i কখনো সীমা ছাড়ায় না, আর range-for-এ তো সূচকই নেই। সেখানে প্রতিবার যাচাই অপ্রয়োজনীয়। একটি ব্যবহারিক নিয়ম: সূচক যখন বাইরে থেকে আসে — ব্যবহারকারীর ইনপুট, ফাইল, নেটওয়ার্ক — তখন .at() বা নিজে যাচাই; যখন লুপের গঠনই সঠিকতা নিশ্চিত করে, তখন [] বা range-for. আর পর্ব ০৫-এর signed-unsigned ফাঁদ মনে রাখুন: v.size() unsigned, তাই int সূচকের সাথে তুলনায় সতর্কবার্তা আসে; C++20-এর std::ssize(v) একটি signed আকার দেয়।

মাঝখানে ঢোকানো আর মোছা — কেন দামি

শেষে যোগ (push_back) আর শেষ থেকে মোছা (pop_back) সস্তা। কিন্তু উপাদানগুলো ফাঁকহীন সারিতে থাকে, তাই মাঝখান থেকে একটি মুছলে ফাঁক রাখা যায় না — পরের সবাইকে এক ঘর বাঁয়ে সরতে হয়। মাঝখানে ঢোকালে উল্টো: পরের সবাইকে এক ঘর ডানে। nটি উপাদানের vector-এ এর খরচ O(n). ক্লাসের পরীক্ষার নম্বরের তালিকা থেকে দ্বিতীয়জনকে বাদ দিলে কী ঘটে দেখুন:

1std::vector<int> m{39, 58, 64, 72, 85};2m.erase(m.begin() + 1);   // 58 মুছুন3//  ভেতরে: m[1] = m[2]4//          m[2] = m[3]5//          m[3] = m[4]6//  শেষ ঘর ধ্বংস, size কমল

৬ · পুরোনো ঠিকানা ভেঙে যায় — iterator invalidation

বাসা বদলের গল্পে একটি প্রশ্ন বাকি রইল: পুরোনো বাসার ঠিকানা যাঁদের কাছে ছিল, তাঁদের কী হবে? বন্ধু পুরোনো ঠিকানায় চিঠি পাঠালে সেটা যাবে এমন বাড়িতে, যেখানে এখন অন্য কেউ থাকে — বা বাড়িটাই ভাঙা। vector-এর ক্ষেত্রেও ঠিক তাই। আপনি যদি একটি উপাদানের দিকে reference, pointer বা iterator রেখে দেন, আর তারপর push_back-এ reallocation ঘটে, তাহলে সেই reference এখন মৃত ব্লকের দিকে তাকিয়ে আছে। একে বলে iterator invalidation, আর এটি C++-এর সবচেয়ে ক্লাসিক বাগগুলোর একটি। একটি বাস কাউন্টারের সিট-তালিকা দিয়ে দেখুন:

1std::vector<int> seats{11, 12, 13};2int& first = seats[0];3int* p = &seats[1];4seats.push_back(14);    // জায়গা নেই!5first = 99;             // মৃত ঠিকানায় লেখা6std::size_t idx = 0; seats[idx] = 99;

কোন কাজে কী ভাঙে, তার একটি সরল মানচিত্র মনে রাখুন। reallocation ঘটলে (push_back, emplace_back, insert, বা capacity-র চেয়ে বেশি reserve) — সব pointer, reference আর iterator অকেজো। reallocation না ঘটলে push_back শুধু end() iterator ভাঙে, বাকি সব বৈধ থাকে। erase বা মাঝখানে insert সেই জায়গা আর তার পরের সবকিছু ভাঙে, আগেরগুলো ঠিক থাকে। clear() সব উপাদানের reference ভাঙে। সবচেয়ে কুখ্যাত রূপটি হলো range-for-এর ভেতরে একই vector-এ push_back:

for (int x : v)
    if (x % 2 == 0) v.push_back(x);   // UB: লুপের লুকানো iterator ভেঙে যেতে পারে

range-for ভেতরে ভেতরে begin() আর end() iterator ধরে রাখে (পর্ব ০৮)। push_back-এ reallocation হলে সেগুলো মৃত ব্লকের দিকে তাকায়। পর্ব ১৮-এ lifetime আর dangling নিয়ে পুরো একটি পর্ব আছে — আজকের বাগটি সেখানকার প্রথম উদাহরণগুলোর একটি।

৭ · দুই মাত্রার ডেটা — সিনেমা হলের সিট-ম্যাপ

একটি সিনেমা হলে ১০টি সারি (A থেকে J), প্রতি সারিতে ১২টি সিট। টিকিট বিক্রির সফটওয়্যারকে জানতে হবে কোন সিট বিক্রি হয়েছে। সবচেয়ে স্বাভাবিক লেখা “vector-এর vector”:

std::vector<std::vector<int>> hall(10, std::vector<int>(12, 0));  // ১০ সারি × ১২ সিট
hall[2][5] = 1;                       // C সারির ৬ নম্বর সিট বিক্রি

পড়তে সুন্দর, কিন্তু মেমরিতে এর ছবি একটি টেবিল নয়। বাইরের vector-এ থাকে ১০টি ছোট vector-এর শরীর (প্রতিটিতে তিনটি সংখ্যা), আর প্রতিটি সারির ১২টি সিট থাকে heap-এর আলাদা আলাদা ১০টি ব্লকে — হয়তো একটি থেকে আরেকটি অনেক দূরে। অর্থাৎ ১১ বার মেমরি চাওয়া, আর সারি থেকে সারিতে যেতে cache-এর সুবিধা হারানো। প্রতিটি সারির আকারও আলাদা হতে পারে, যা কখনো সুবিধা (ত্রিভুজাকার ডেটা), কখনো বাগের উৎস।

বিকল্প হলো একটিমাত্র “চ্যাপ্টা” vector, যেখানে সারিগুলো একটার পর একটা রাখা — আগে A সারির ১২টি, তারপর B সারির ১২টি। একে বলে row-major বিন্যাস, আর সারি r, সিট c-এর সূচক হিসাব করা হয় একটি সূত্রে:

সূচক = r × কলামের_সংখ্যা + c

hall[r][c]                  →   flat[r * 12 + c]
C সারি (r=2), ৬ নম্বর (c=5)  →   flat[2 * 12 + 5] = flat[29]

flat: [A0 A1 … A11][B0 B1 … B11][C0 C1 C2 C3 C4 C5 …] …
       0 ……… 11     12 …… 23     24          29

আকার যদি প্রোগ্রাম লেখার সময়েই জানা থাকে (ধরা যাক হলটি কখনো বদলাবে না), তাহলে std::array<std::array<int, 12>, 10>-ও একটি ভালো পছন্দ — এটি মেমরিতে পুরোপুরি পাশাপাশি, কোনো heap-ই লাগে না। আর C++23-এ এসেছে std::mdspan, যা চ্যাপ্টা vector-এর ওপর বসিয়ে m[r, c] লিখে পড়ার সুযোগ দেয় — সূত্রটা সে নিজেই হিসাব করে। (বহু সূচকের [r, c] লেখাও C++23 থেকে বৈধ।)

৮ · ফাংশনে vector, range-for, algorithm আর std::span

পাঠানো — const&; ফেরত — সরাসরি মান

পর্ব ১০-এ দেখেছেন, বড় জিনিস মান হিসেবে পাঠালে পুরো কপি হয়। vector-এর ক্ষেত্রে কপি মানে নতুন ব্লক নেওয়া আর প্রতিটি উপাদান কপি করা — দশ লক্ষ নম্বরের তালিকায় সেটা সত্যিই ধীর। তাই নিয়ম:

• শুধু পড়বে: double average(const std::vector<int>& marks) — const reference, কোনো কপি নেই।
• বদলাবে: void addBonus(std::vector<int>& marks) — সাধারণ reference.
• নতুন vector বানিয়ে দেবে: std::vector<int> passed(const std::vector<int>& all) — সরাসরি মান ফেরত দিন। ভয় নেই: compiler সাধারণত copy elision করে কপি পুরো বাদ দেয়, আর না পারলে move করে — শুধু তিনটি সংখ্যা হাতবদল, উপাদানগুলো যেখানে ছিল সেখানেই থাকে (পর্ব ৩৬)। পুরোনো দিনের মতো “ফলাফল রাখার vector reference দিয়ে পাঠাও” কৌশলের দরকার নেই।

হাঁটা আর তৈরি algorithm

সূচক যখন লাগে না, তখন range-for সবচেয়ে নিরাপদ: for (int m : marks) পড়ার জন্য, for (int& m : marks) m += 5; বদলানোর জন্য, আর struct-এর vector-এ for (const auto& s : students). সীমার বাইরে যাওয়ার কোনো সুযোগই নেই। অনেক সাধারণ কাজ — সাজানো, যোগ, খোঁজা, গোনা — হাতে লুপ না লিখে STL-এর তৈরি algorithm দিয়ে করা যায়। C++20-এর std::ranges::sort(v) পুরো vector সাজায়, আর <numeric>-এর std::accumulate সব যোগ করে। পর্ব ৩৩-এ এমন কয়েক ডজন algorithm দেখবেন; আজ শুধু স্বাদ।

std::span — মালিক নয়, শুধু দেখার জানালা

একটি সমস্যা থেকে যায়। average(const std::vector<int>&) শুধু vector নেয়। কারও কাছে যদি std::array<int, 7> থাকে, বা পুরোনো লাইব্রেরি থেকে আসা C-array, বা vector-এর শুধু শেষ তিনটি উপাদান — তখন? C-ধাঁচে লিখলে average(const int* p, std::size_t n), যেখানে আবার সেই পুরোনো ঝুঁকি: ভুল n. C++20-এর <span> header-এর std::span এই দুটি সংখ্যাকে — শুরুর ঠিকানা আর উপাদানের সংখ্যা — এক বস্তুতে বাঁধে। যেকোনো পাশাপাশি সাজানো ডেটা থেকে নিজে থেকেই বানানো যায়, আকার নিজেই নিয়ে নেয়। আর এটি non-owning view: ডেটার মালিক নয়, কপি করা প্রায় বিনা খরচে, কিছু ফেরত দেয় না। নম্বরের তালিকা দিয়ে সব একসাথে দেখুন:

#include <algorithm>
#include <numeric>
#include <print>
#include <span>
#include <vector>

double average(std::span<const int> marks) {    // vector, array, C-array - sob cholbe
    if (marks.empty()) return 0.0;
    const int sum = std::accumulate(marks.begin(), marks.end(), 0);
    return static_cast<double>(sum) / static_cast<double>(marks.size());
}

int main() {
    std::vector<int> marks{72, 85, 39, 91, 64, 58};
    std::ranges::sort(marks);                      // choto theke boro
    std::println("sorted: {}", marks);
    std::println("lowest = {}, highest = {}", marks.front(), marks.back());
    std::println("class average = {:.2f}", average(marks));
    std::println("top 3 average = {:.2f}", average(std::span(marks).last(3)));
}

৯ · AI-এর যুগে — raw array, যাচাইহীন সূচক আর হারানো reference

AI টুলগুলো কয়েক দশকের C আর পুরোনো C++ কোড পড়ে শিখেছে, আর কনটেস্ট-ধাঁচের সমাধানও তাদের প্রশিক্ষণে প্রচুর। তাই তাদের লেখায় প্রায়ই ফিরে আসে int arr[100005];, new int[n], আর যাচাইহীন সূচক। এসব কোড প্রায়ই পরীক্ষার ইনপুটে ঠিকঠাক চলে — বাগ লুকিয়ে থাকে ঠিক সেই ইনপুটে, যা কেউ পরীক্ষা করেনি। সবচেয়ে সাধারণ ভুলগুলো:

AI-এর লেখা vector/array কোড যাচাইয়ের চেকলিস্ট

• কোথাও new[]/delete[] বা অকারণ C-array নেই — vector বা std::array
• বাইরে থেকে আসা প্রতিটি সূচক যাচাই করা, আর খালি vector-এ front()/back()/[0] নেই
• push_back, insert বা erase-এর পরে আগের কোনো reference, pointer বা iterator ব্যবহার হয়নি
• range-for-এর ভেতরে একই vector-এ push_back বা erase নেই
• শুধু পড়ার parameter const& বা std::span; ফেরত দেওয়া vector সরাসরি মান হিসেবে
• -D_GLIBCXX_ASSERTIONS আর -fsanitize=address দিয়ে একবার চালিয়ে দেখা হয়েছে