লাইব্রেরি ভ্রমণ — chrono, random আর filesystem

১ · নিজে লেখার আগে বাক্সটা খুলুন

ধরুন আপনাকে একটি পরীক্ষার প্রস্তুতির অ্যাপ বানাতে বলা হলো। অ্যাপটি দেখাবে পরীক্ষার আর কত দিন বাকি, প্রতিদিন প্রশ্নগুলো এলোমেলো ক্রমে দেবে, একটি CSV ফাইল থেকে নম্বর পড়বে, আর মাপবে একজন পরীক্ষার্থী প্রতিটি প্রশ্নে কত সময় নিলেন। প্রথম চিন্তা হতে পারে: “দিন গোনার একটি ফাংশন লিখি, এলোমেলো করার জন্য rand() নিই, সংখ্যা পড়তে atoi ডাকি।” প্রতিটি কাজই ছোট মনে হয়। কিন্তু প্রতিটির ভেতরে লুকিয়ে আছে এমন ফাঁদ, যা বহু প্রোগ্রামার বছরের পর বছর ধরে খুঁজে পেয়েছেন — অধিবর্ষ (leap year), ৩১ দিনের মাস, ঘড়ি হঠাৎ পিছিয়ে যাওয়া, এলোমেলো সংখ্যার পক্ষপাত, “8x” লেখাকে 8 পড়ে ফেলা।

C++-এর standard library প্রতিটি compiler-এর সাথে আসে — GCC-র সাথে libstdc++, Clang-এর সাথে প্রায়ই libc++, Visual Studio-র সাথে MSVC STL. এর চারটি বড় গুণ আছে:

• পরীক্ষিত: কোটি কোটি প্রোগ্রাম এগুলো প্রতিদিন ব্যবহার করে। আপনার হাতে লেখা তারিখ-গণনায় যে বাগ আছে, তা এখানে বহু আগেই ধরা পড়ে ঠিক হয়েছে।
• সব জায়গায় চলে (portable): একই কোড Windows, Linux, macOS আর অনলাইন judge-এ একই অর্থ বহন করে। standard যা নিশ্চিত করে, তা সব বাস্তবায়নকে মানতে হয়।
• দ্রুত: লাইব্রেরি-লেখকেরা বছরের পর বছর এগুলো অপ্টিমাইজ করেন। std::from_chars বা std::sort-এর চেয়ে দ্রুত সংস্করণ হাতে লেখা সহজ নয়।
• সবাই চেনে: অন্য একজন C++ প্রোগ্রামার std::chrono::steady_clock দেখলেই বোঝেন আপনি কী করছেন। আপনার নিজের বানানো myTimer2 বুঝতে তাঁকে পুরো ফাংশন পড়তে হবে।

২ · লাইব্রেরির মানচিত্র — কোন header-এ কী

standard library শতাধিক header-এ ভাগ করা। এগুলোকে কয়েকটি পরিবারে সাজালে মনে রাখা সহজ হয়। নিচের টেবিলে প্রতিটি পরিবার, তার প্রধান header, আর এই কোর্সের কোথায় সেটি শেখানো হয়েছে বা হবে:

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

৩ · chrono-র duration — একক যেখানে টাইপের অংশ

পুরোনো অনেক API-তে সময় যেত একটি সাধারণ সংখ্যা হিসেবে: sleep(5). পাঁচ কী? সেকেন্ড, মিলিসেকেন্ড, নাকি মাইক্রোসেকেন্ড? উত্তর লুকিয়ে থাকে ডকুমেন্টেশনে, কোডে নয়। একজন ভাবলেন মিলিসেকেন্ড, আরেকজন সেকেন্ড — আর প্রোগ্রাম হাজার গুণ বেশি বা কম অপেক্ষা করল। compiler কিছুই বলবে না, কারণ তার চোখে দুটিই শুধু int.

std::chrono-র উত্তর হলো এককটিকে টাইপের ভেতরে ঢুকিয়ে দেওয়া। একটি duration হলো একটি সংখ্যা (count) আর একটি একক (period) — যেমন “১৫০০টি মিলিসেকেন্ড”। std::chrono::seconds, milliseconds, minutes, hours সবই আলাদা টাইপ, আর C++20 থেকে days, weeks, months, years-ও আছে। ভেতরে এরা শুধু একটি পূর্ণসংখ্যা — কোনো বাড়তি মেমরি বা গতির খরচ নেই, এককের সব হিসাব compile-এর সময়েই হয়।

C++14 থেকে লেখাও সহজ: literal দিয়ে 5s, 250ms, 2h, 30min. এগুলো ব্যবহার করতে using namespace std::chrono; (বা শুধু std::chrono_literals) লিখতে হয় — তবে একটি ফাংশনের ভেতরে, header ফাইলের global অংশে নয়।

void wait_for_otp(std::chrono::seconds timeout);  // একক স্বাক্ষরেই লেখা

using namespace std::chrono;
wait_for_otp(90s);          // ঠিক
wait_for_otp(2min);         // ঠিক: 2min নিজে থেকেই 120s হয়
// wait_for_otp(90);        // error: শুধু একটি int — কোন একক?
// wait_for_otp(1500ms);    // error: ms থেকে s-এ গেলে তথ্য হারাতে পারে

শেষ দুটি লাইনই এই নকশার মূল কথা। যে রূপান্তরে তথ্য হারায় না, তা নিজে থেকে হয় — মিনিট থেকে সেকেন্ড, সেকেন্ড থেকে মিলিসেকেন্ড। যে রূপান্তরে তথ্য হারাতে পারে, তা compiler আটকায় — ১৫০০ মিলিসেকেন্ডকে পূর্ণ সেকেন্ডে আনলে আধা সেকেন্ড কোথায় যাবে? সেটি আপনাকে স্পষ্ট করে বলতে হবে: duration_cast শূন্যের দিকে কেটে ফেলে (truncate), আর C++17-এর floor, ceil, round নিজেদের নাম অনুযায়ী কাজ করে। ধাপে ধাপে দেখুন — প্রতিটি ধাপে আগে নিজে অনুমান করুন:

1auto t = 1500ms;2milliseconds m = 2s;3seconds s = t;            // ?4auto a = duration_cast<seconds>(t);5auto b = round<seconds>(t);6auto c = 2h + 30min;

ভগ্নাংশ দরকার হলে দশমিক count-ওয়ালা duration নিন: duration<double> মানে দশমিক সেকেন্ড, তাই duration<double>(1500ms) প্রিন্ট করলে আসে 1.5s. আর কাঁচা সংখ্যাটি দরকার হলে (যেমন JSON-এ লিখতে) .count() ডাকুন — কিন্তু যত দেরিতে সম্ভব, যাতে একক যতক্ষণ সম্ভব টাইপের পাহারায় থাকে।

৪ · time_point আর clock — কোন ঘড়ি দিয়ে মাপবেন

duration হলো “কতক্ষণ”। আর time_point হলো “কখন” — একটি নির্দিষ্ট মুহূর্ত, যা প্রকাশ করা হয় একটি শুরুর বিন্দু (epoch) থেকে কত duration পেরিয়েছে তা দিয়ে। প্রতিটি time_point কোনো একটি ঘড়ির (clock) সাথে বাঁধা, আর দুটি time_point বিয়োগ করলে পাওয়া যায় একটি duration. দুটি ঘড়ি সবচেয়ে জরুরি:

তৃতীয় একটি নামও দেখবেন — high_resolution_clock. নামটি লোভনীয়, কিন্তু standard বলে এটি অন্য দুটির কোনো একটির ডাকনাম হতে পারে; কোনটি, তা লাইব্রেরিভেদে আলাদা। তাই এটি এড়িয়ে চলুন। নিয়মটা এক লাইনের: কতক্ষণ লাগল জানতে steady_clock, কখন ঘটল জানতে system_clock. কেন, তা নিচের ঘটনায় দেখুন:

1auto w0 = system_clock::now();2auto s0 = steady_clock::now();3work();                  // 1.5 s4// NTP: wall clock moved back 3 s5auto w = system_clock::now() - w0;6auto s = steady_clock::now() - s0;

একটি কাজ কতক্ষণ নিল, তা মাপার স্বাভাবিক কাঠামো এমন। এর আউটপুট প্রতিবার আলাদা, তাই এটি চালানোর উদাহরণ হিসেবে দেওয়া হয়নি:

#include <chrono>
#include <print>

void build_question_bank();                       // যে কাজ মাপব

void measure() {
    using clock = std::chrono::steady_clock;
    const auto start = clock::now();
    build_question_bank();
    const auto elapsed = clock::now() - start;    // একটি duration
    std::println("took {}",
        std::chrono::duration_cast<std::chrono::milliseconds>(elapsed));
}   // যেমন: took 37ms — প্রতিবার আলাদা

৫ · C++20 ক্যালেন্ডার আর time zone — তারিখের হিসাব

তারিখের হিসাব শুনতে সহজ: “আজ থেকে পরীক্ষার দিন পর্যন্ত কত দিন?” হাতে লিখতে গেলে শুরু হয় প্রশ্নের পর প্রশ্ন। কোন মাস ৩০ দিনের, কোনটি ৩১-এর? ফেব্রুয়ারি এ বছর ২৮ না ২৯? ২১০০ সাল কি অধিবর্ষ? (না — ১০০ দিয়ে বিভাজ্য, কিন্তু ৪০০ দিয়ে নয়।) AI আর নতুন প্রোগ্রামাররা প্রায়ই “এক মাস = ৩০ দিন” ধরে নেন, আর ফল কয়েক দিন এদিক-ওদিক হয়ে যায়।

C++20 chrono-তে পুরো ক্যালেন্ডার যোগ করেছে। মূল টাইপগুলো:

• year, month, day, weekday — আলাদা আলাদা অংশ। literal: 2026y, 17d; মাসের নাম ধ্রুবক হিসেবে: October, February.
• year_month_day — একটি পূর্ণ তারিখ, তিনটি ঘরে (field) রাখা। লেখা যায় / দিয়ে: 2026y/October/17 বা 2026y/10/17.
• sys_days — একই তারিখ, কিন্তু ১৯৭০-এর ১ জানুয়ারি থেকে কত দিন, সেই একটি সংখ্যা হিসেবে। এটি আসলে system_clock-এর একটি time_point, যার একক দিন।

দুটি রূপের দুই রকম কাজ। মানুষের মতো তারিখ পড়তে-লিখতে year_month_day; দিন গুনতে আর যোগ-বিয়োগ করতে sys_days. দুটির মধ্যে রূপান্তর এক লাইনে, আর ভেতরের অধিবর্ষ আর মাসের দৈর্ঘ্যের হিসাব লাইব্রেরি নিজে করে। আরেকটি জরুরি ফাংশন হলো ok() — তারিখটি বাস্তবে আছে কি না, তা জানায়। এবার ক্যালেন্ডারের হিসাবের ফাঁদগুলো ধাপে ধাপে দেখুন:

auto d = 2026y / January / 31;
d          => 2026-01-31
d.ok()     => true

auto n = d + months{1};
n          => 2026-02-31 is not a valid date
n.ok()     => false

year_month_day{ sys_days{n} }
           => 2026-03-03
(ফেব্রুয়ারি ২৮ + আরও ৩ দিন)

year_month_day{ 2026y / February / last }
           => 2026-02-28
(2028y / February / last  => 2028-02-29)

(2026y / February / 30).ok()  => false
(2028y / February / 29).ok()  => true    // অধিবর্ষ
(2100y / February / 29).ok()  => false   // ১০০-তে বিভাজ্য, ৪০০-তে নয়

এবার সব একসাথে একটি ছোট প্রোগ্রামে দেখুন। আগের অংশের duration-এর হিসাব, আর একটি পরীক্ষার দিন গোনা — ধরুন ঢাকায় একটি চাকরির পরীক্ষা ১০ ডিসেম্বর ২০২৬, আর আজকের তারিখ আমরা কোডেই স্থির করে দিয়েছি, যাতে আউটপুট সব জায়গায় এক থাকে:

#include <chrono>
#include <print>

int main() {
    using namespace std::chrono;
    auto t = 1500ms;
    std::println("{} -> cast {}, round {}", t, duration_cast<seconds>(t), round<seconds>(t));
    std::println("2h + 30min = {}", 2h + 30min);

    constexpr year_month_day today{2026y / October / 17};    // fixed for the demo
    constexpr year_month_day exam{2026y / December / 10};
    std::println("{} is a {}", today, weekday{sys_days{today}});
    std::println("days left: {}", sys_days{exam} - sys_days{today});

    auto feb = 2026y / February / 30;
    std::println("{} ok? {}", feb, feb.ok());
    auto next = 2026y / January / 31 + months{1};
    std::println("Jan 31 + 1 month ok? {}", next.ok());
}

আসল “আজ” — আর time zone-এর প্রশ্ন

বাস্তব অ্যাপে “আজ” আসবে ঘড়ি থেকে: floor<days>(system_clock::now()). কিন্তু এখানে একটি ফাঁদ আছে। system_clock চলে UTC-তে, আর ঢাকা UTC-র ৬ ঘণ্টা আগে। অর্থাৎ ঢাকায় রাত ১২টা থেকে সকাল ৬টার মধ্যে UTC-তে তখনো আগের দিন! রাত ২টায় কেউ অ্যাপ খুললে দেখবেন “৫৫ দিন বাকি”, অথচ ঢাকার ক্যালেন্ডারে ইতিমধ্যে নতুন দিন। সমাধান C++20-এর time zone সহায়তা:

using namespace std::chrono;
zoned_time dhaka{"Asia/Dhaka", system_clock::now()};    // IANA-র নাম
auto local_today = floor<days>(dhaka.get_local_time());
year_month_day ymd{local_today};                         // ঢাকার তারিখ
std::println("{:%d/%m/%Y %H:%M}", dhaka);                // যেমন 17/10/2026 21:05

"Asia/Dhaka" নামটি আসে IANA time zone database থেকে — বিশ্বের প্রায় সব অপারেটিং সিস্টেম যে তালিকা ব্যবহার করে, যেখানে প্রতিটি অঞ্চলের ইতিহাসসহ নিয়ম লেখা। “শুধু ৬ ঘণ্টা যোগ করি” কেন যথেষ্ট নয়? কারণ নিয়ম বদলায়: বাংলাদেশ নিজেই ২০০৯ সালে কয়েক মাসের জন্য ঘড়ি এক ঘণ্টা এগিয়ে রেখেছিল (daylight saving time), আর পুরোনো তারিখের হিসাবে সেটি ধরতে হয়। তবে একটি সতর্কতা: time zone অংশের সহায়তা লাইব্রেরিভেদে আলাদা. MSVC আর নতুন GCC-র libstdc++-এ এটি আছে, কিন্তু কিছু লাইব্রেরি আর পুরোনো compiler-এ এখনো অসম্পূর্ণ, আর অনলাইন compiler-এ time zone ডেটাবেস না-ও থাকতে পারে। ব্যবহারের আগে নিজের টুলচেইনে পরীক্ষা করুন।

৬ · <random> — rand() ছেড়ে engine আর distribution

C থেকে আসা সবচেয়ে পরিচিত এলোমেলো সংখ্যার কোড এমন: srand(time(nullptr)); তারপর rand() % 6 + 1. এতে কয়েকটি সমস্যা একসাথে:

• মান অনির্দিষ্ট: standard rand()-এর অ্যালগরিদম বলে দেয় না। কিছু বাস্তবায়নে RAND_MAX মাত্র 32767 (যেমন MSVC), আর পুরোনো কিছু বাস্তবায়নে নিচের bit-গুলোর ধারা খুব নিয়মিত ছিল।
• ভাগশেষের পক্ষপাত: RAND_MAX 32767 হলে মোট ৩২৭৬৮টি সম্ভাব্য মান। % 10 নিলে ০ থেকে ৭ আসে ৩২৭৭ বার করে, কিন্তু ৮ আর ৯ আসে ৩২৭৬ বার। পার্থক্য ছোট, কিন্তু সীমা যত বড়, পক্ষপাত তত বেশি। একে বলে modulo bias.
• লুকানো global অবস্থা: পুরো প্রোগ্রামে একটিই ধারা। একটি লাইব্রেরি গোপনে srand ডাকলে আপনার ধারা বদলে যায়, আর একাধিক thread থেকে ডাকলে নিরাপদ হওয়ার নিশ্চয়তা নেই।
• দুর্বল seed: time(nullptr) সেকেন্ডে বদলায়। একই সেকেন্ডে চালু হওয়া দুটি প্রোগ্রাম হুবহু একই “এলোমেলো” ধারা পায়।

C কোর্সের rand() অংশে এগুলো বিস্তারিত আছে। C++11-এর <random> কাজটিকে দুই ভাগে ভাগ করেছে:

engine-কে শুরুর অবস্থা দেয় একটি seed. আসল এলোমেলোতার জন্য seed নেওয়া হয় std::random_device থেকে, যা সাধারণত অপারেটিং সিস্টেমের এলোমেলোতার উৎস ব্যবহার করে। পুরো পাইপলাইনটি ধাপে ধাপে দেখুন:

std::mt19937 gen{2026};                    // টেস্ট: প্রতিবার একই ধারা
std::mt19937 gen{std::random_device{}()};  // আসল ব্যবহার: প্রতিবার আলাদা

state: ৬২৪টি ৩২-বিট সংখ্যা (প্রায় ২.৫ KB)
seed 2026 থেকে state ভরে নেওয়ার নিয়ম standard-এ লেখা
=> সব compiler-এ হুবহু একই state

প্রথম তিনটি:  942082305  3292560774  1773871898
সীমা: 0 থেকে 4294967295
GCC, Clang, MSVC — সবখানে এই একই তিনটি সংখ্যা

std::uniform_int_distribution die{1, 6};   // দুই প্রান্তসহ [1, 6]
int roll = die(gen);   // দরকার হলে gen() একাধিকবার ডাকে,
                       // যাতে ১ থেকে ৬ সমান সম্ভাবনায় আসে
অ্যালগরিদম: লাইব্রেরি নিজে বেছে নেয়

একই seed + একই লাইব্রেরি  => প্রতিবার একই দান
একই seed + অন্য লাইব্রেরি  => দান আলাদা হতে পারে
(engine একই, distribution-এর অ্যালগরিদম আলাদা)

এবার বাস্তবের একটি কাজ: প্রতিদিন কুইজের ২০টি প্রশ্ন এলোমেলো ক্রমে দেওয়া। একটি engine একবার বানিয়ে বারবার ব্যবহার করুন — প্রতিবার ডাকার সময় নতুন engine বানানো ধীর, আর ফলও খারাপ হয়:

#include <algorithm>
#include <numeric>
#include <random>
#include <vector>

std::vector<int> quiz_order(std::mt19937& gen) {   // engine বাইরে থেকে আসে
    std::vector<int> q(20);
    std::iota(q.begin(), q.end(), 1);              // 1, 2, ..., 20
    std::ranges::shuffle(q, gen);
    return q;
}

// টেস্টে:   std::mt19937 gen{2026};                    — প্রতিবার একই ক্রম
// আসল অ্যাপে: std::mt19937 gen{std::random_device{}()}; — প্রতিবার নতুন ক্রম

এখানেও একই সতর্কতা খাটে: shuffle-এর ভেতরের পদ্ধতিও লাইব্রেরি ঠিক করে, তাই একই seed-এ GCC আর MSVC ভিন্ন ক্রম দিতে পারে। একই লাইব্রেরিতে কিন্তু প্রতিবার একই ক্রম — বাগ খোঁজার জন্য সেটাই যথেষ্ট। আর একটি সূক্ষ্ম বিষয়: random_device{}() একটিমাত্র ৩২-বিট সংখ্যা দেয়, অথচ mt19937-এর অবস্থা প্রায় ২০,০০০ বিটের। তাই এভাবে seed দিলে সম্ভাব্য ধারা মাত্র প্রায় ৪৩০ কোটি। কুইজ বা গেমের জন্য যথেষ্ট; বৈজ্ঞানিক সিমুলেশনে সাধারণত std::seed_seq দিয়ে আরও বেশি seed-ডেটা দেওয়া হয়।

৭ · ছোট কিন্তু কাজের — format, numeric, bit আর utility

format আর print — একবার মনে করিয়ে দেওয়া

পর্ব ৭-এ আপনি std::format (C++20) আর std::println (C++23) দেখেছেন: {} জায়গায় মান বসে, টাইপ যাচাই হয় compile-এর সময়। chrono-র টাইপগুলোর জন্য এদের নিজস্ব ফরম্যাট-চিহ্ন আছে, যা C-এর strftime-এর মতো দেখতে:

using namespace std::chrono;
year_month_day d{2026y / October / 17};
std::println("{}", d);                 // 2026-10-17   (ISO ফরম্যাট, ডিফল্ট)
std::println("{:%d/%m/%Y}", d);        // 17/10/2026
std::println("{:%d %B %Y}", d);        // 17 October 2026
std::println("{}", hh_mm_ss{4537s});   // 01:15:37
std::println("{}", 3min + 15s);        // 195s

লগ বা ফাইলে তারিখ রাখার সময় ডিফল্ট ISO ফরম্যাট (2026-10-17) সবচেয়ে ভালো — অক্ষর অনুযায়ী সাজালেই তারিখ অনুযায়ী সাজানো হয়, আর কোনো দেশে এর অর্থ নিয়ে বিভ্রান্তি নেই। (10/11/2026 — ১০ নভেম্বর না ১১ অক্টোবর?) ব্যবহারকারীকে দেখানোর সময় তাঁর পরিচিত ফরম্যাট দিন।

<numeric>, <numbers> আর <cmath>

std::gcd(12, 18);                          // 6   (C++17, <numeric>)
std::lcm(4, 6);                            // 12
std::midpoint(2147483600, 2147483640);     // 2147483620 — overflow হয় না
std::numbers::pi;                          // 3.141592653589793 (C++20, <numbers>)
std::hypot(3.0, 4.0);                      // 5   (<cmath>)
std::lerp(10.0, 20.0, 0.25);               // 12.5 (C++20)

প্রতিটির পেছনে একটি গল্প আছে। std::gcd আর std::lcm — কনটেস্টে এখনো অনেকে নিজের Euclid লুপ লেখেন বা GCC-র অ-standard __gcd ব্যবহার করেন; C++17 থেকে এর দরকার নেই। std::midpoint — (a + b) / 2-এ দুটি বড় int যোগ করলেই overflow, আর signed overflow মানে undefined behavior. binary search-এ এই বাগ বছরের পর বছর বিখ্যাত লাইব্রেরিগুলোতে লুকিয়ে ছিল। std::numbers::pi — M_PI আসলে C++ standard-এর অংশ নয়, কিছু প্ল্যাটফর্মে বিশেষ macro ছাড়া পাওয়াই যায় না; C++20-এ pi, e, sqrt2 সহ ধ্রুবকগুলো এসেছে টাইপসহ।

<bit> — bit গোনা আর ২-এর ঘাত

C++20-এর <bit> header সেইসব কাজ দেয়, যা আগে compiler-এর বিশেষ ফাংশন (__builtin_popcount) বা হাতে লেখা কৌশলে করতে হতো। সবগুলো শুধু unsigned টাইপে কাজ করে:

std::popcount(13u);         // 3    — 1101-এ তিনটি 1
std::bit_ceil(100u);        // 128  — 100-এর সমান বা বড় সবচেয়ে ছোট ২-এর ঘাত
std::has_single_bit(64u);   // true — 64 কি ২-এর ঘাত?
std::countr_zero(40u);      // 3    — 101000-এর ডানে তিনটি 0

std::popcount কনটেস্টে bitmask DP-তে প্রতিদিনের যন্ত্র; bit_ceil লাগে hash table বা ring buffer-এর মাপ ২-এর ঘাতে আনতে। আধুনিক CPU-তে এগুলোর বেশিরভাগ একটিমাত্র মেশিন-নির্দেশে চলে, আর compiler সেটি নিজে বেছে নেয়। C++23-এ এসেছে std::byteswap, যা নেটওয়ার্ক বা ফাইল-ফরম্যাটের byte-ক্রম উল্টাতে কাজে লাগে।

utility-র টুকিটাকি

কয়েকটি ছোট যন্ত্র, যা আগের পর্বগুলোতে এসেছে, এক জায়গায়:

std::pair p{"Rahim", 87};              // দুটি মান একসাথে (পর্ব ১২)
std::tuple t{"Dhaka", 2026, 4.5};      // যতগুলো খুশি
auto [name, marks] = p;                // structured binding

std::swap(a, b);                       // দুটির মান অদলবদল
int old = std::exchange(x, 0);         // x = 0, আর পুরোনো মান ফেরত (পর্ব ২২)
int pct = std::clamp(score, 0, 100);   // 0-এর নিচে 0, 100-এর ওপরে 100
auto [lo, hi] = std::minmax({4, 9, 2}); // lo = 2, hi = 9

এদের প্রত্যেকটি এক লাইনের কাজ, কিন্তু নাম দিয়ে উদ্দেশ্য বলে দেয়। std::clamp লেখা থাকলে পাঠক এক নজরে বোঝেন “সীমার ভেতরে আনা হচ্ছে”; দুটি nested if দেখে সেটা বুঝতে সময় লাগে, আর < আর <=-এর ভুলও লুকিয়ে থাকতে পারে। ছোট যন্ত্র চেনার লাভ এটাই — কোড ছোট হয়, আর পড়া সহজ হয়।

৮ · লেখা থেকে সংখ্যা: from_chars — আর filesystem-এর এক ঝলক

ধরুন একটি CSV ফাইলের একটি লাইন 87,92,8x,75 — কেউ ভুল করে একটি নম্বরে একটি অক্ষর টাইপ করে ফেলেছেন। প্রচলিত উপায়গুলো এখানে কী করে?

C++17-এর std::from_chars (header <charconv>) চারটি জিনিস করে না: exception ছোড়ে না, মেমরি নেয় না, locale দেখে না, আর শুরুর ফাঁকা জায়গা বাদ দেয় না। বদলে ফেরত দেয় দুটি জিনিস — কোথায় থামল (ptr) আর কোনো ভুল হলো কি না (ec, একটি std::errc). locale না মানার গুরুত্ব বড়: strtod জার্মান locale-এ চললে 3.14-কে পড়ে শুধু 3, কারণ সেখানে দশমিক চিহ্ন কমা। একটি সার্ভার কোন দেশের সেটিংসে চলছে, তার ওপর ফাইল-পড়ার ফল নির্ভর করা উচিত নয়। উল্টো কাজের জন্য আছে std::to_chars, যা দশমিক সংখ্যাকে সবচেয়ে ছোট এমন লেখায় আনে, যা পড়ে আবার হুবহু একই সংখ্যা পাওয়া যায়।

এবার CSV লাইনটি নির্ভরযোগ্যভাবে পড়ুন, আর সাথে mt19937-এর সেই standard-নির্ধারিত সংখ্যাটি নিজের চোখে দেখুন:

#include <charconv>
#include <print>
#include <random>
#include <ranges>
#include <string_view>

int main() {
    std::mt19937 gen;                              // default seed 5489
    gen.discard(9999);                             // skip 9999 values
    std::println("10000th raw value: {}", gen());  // fixed by the standard

    std::string_view line = "87,92,8x,75";
    int sum = 0;
    for (auto part : line | std::views::split(',')) {
        std::string_view f(part.begin(), part.end());
        int v = 0;
        auto [end, ec] = std::from_chars(f.data(), f.data() + f.size(), v);
        if (ec == std::errc{} && end == f.data() + f.size()) sum += v;
        else std::println("skip bad field '{}'", f);
    }
    std::println("sum = {}", sum);
}

filesystem — এক ঝলক

C++17-এর std::filesystem ফাইল আর ফোল্ডারের পথ নিয়ে কাজ করে — সব অপারেটিং সিস্টেমে একই কোডে। এর কেন্দ্রে path টাইপ, যা Windows-এর \ আর Linux-এর / দুটিই সামলায়। শুধু স্বাদ নেওয়ার জন্য:

#include <filesystem>
namespace fs = std::filesystem;

fs::path p = "results/2026/marks.csv";
p.filename();      // "marks.csv"
p.extension();     // ".csv"
p.parent_path();   // "results/2026"

if (fs::exists(p)) { /* ফাইলটি আছে */ }
for (const auto& e : fs::directory_iterator{"results"})   // ফোল্ডারের তালিকা
    std::println("{}", e.path().string());

পথ জোড়া দেওয়া (dir / "file.txt"), ফাইল কপি ও মোছা, ফোল্ডার তৈরি, ভুল সামলানো, আর ফাইল stream দিয়ে ফাইল পড়া-লেখা — সব পর্ব ৪৪-এ বিস্তারিত। আজ শুধু মানচিত্রে জায়গাটা চিনে রাখুন: ফাইলের পথ নিয়ে string কাটাকাটি নয়, fs::path.

৯ · AI-এর যুগে — সময়, তারিখ আর random-এর কোডে AI-এর ভুল

সময় আর এলোমেলো সংখ্যার কোডে AI সবচেয়ে বেশি “পুরোনো অভ্যাস” দেখায়। কারণ ইন্টারনেটে বিশ বছরের পুরোনো উদাহরণে ভরা — srand(time(0)), clock() দিয়ে benchmark, হাতে লেখা দিন গোনা। এসব কোড compile হয়, ছোট পরীক্ষায় ঠিকঠাক চলে, আর ভুল ফল দেয় শুধু বিশেষ দিনে — অধিবর্ষে, মাসের ৩১ তারিখে, রাত ১২টার পরে, বা ঘড়ি মেলানোর মুহূর্তে। সাধারণ ভুলগুলো:

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

• কোডে rand, srand, time(, atoi, clock( খুঁজেছি — একটিও নেই, বা প্রতিটির পরিষ্কার কারণ আছে
• সময়কাল মাপা হয়েছে শুধু steady_clock দিয়ে; system_clock শুধু তারিখ-সময় দেখাতে বা লগে
• তারিখের যোগ-বিয়োগ sys_days-এ; মাস যোগের পর ok() বা মাসের শেষ দিনের নীতি ঠিক করা আছে
• engine একবারই তৈরি; টেস্টে স্থির seed, আর টেস্ট distribution-এর ফলকে “প্রত্যাশিত মান” হিসেবে ধরে না
• সংখ্যা পড়ায় from_chars-এর ec আর ptr দুটিই যাচাই হয়েছে; খালি ঘর আর "8x" দিয়ে নিজে চালিয়ে দেখেছি
• নিরাপত্তার কোনো কাজে (OTP, token, পাসওয়ার্ড) <random>-এর engine ব্যবহার হয়নি