C++20/23 — modules, coroutines আর নতুন standard-এর যন্ত্রপাতি

১ · প্রতি তিন বছরে নতুন C++ — ট্রেনের মডেল

C++ কোনো একটি কোম্পানির পণ্য নয়। ভাষাটির নিয়ম লেখে ISO-র একটি কমিটি, যার আনুষ্ঠানিক নাম WG21. এতে আছেন compiler-নির্মাতা, বড় সফটওয়্যার কোম্পানির প্রকৌশলী, বিশ্ববিদ্যালয়ের গবেষক আর স্বেচ্ছাসেবীরা। তাঁরা প্রস্তাব (paper) লেখেন, বছরে কয়েকবার মিটিংয়ে বসে তর্ক করেন, ভোট দেন। ভোটে পাস হওয়া নিয়মগুলো মিলে তৈরি হয় একটি C++ standard — যেমন C++20 বা C++23. তারপর GCC, Clang আর MSVC-র দল সেই নিয়ম নিজেদের compiler-এ বাস্তবায়ন করে।

আগে এই কাজের কোনো নির্দিষ্ট সময়সূচি ছিল না। প্রথম standard এল ১৯৯৮ সালে (C++98), ২০০৩ সালে তার ভুল সংশোধন (C++03). তারপর কমিটি একটি বড় সংস্করণের কাজ শুরু করল, যার ডাকনাম ছিল “C++0x” — সবাই ধরে নিয়েছিল এটি ২০০০-এর দশকেই আসবে। কিন্তু একের পর এক বৈশিষ্ট্য যোগ হতে থাকল, আর একটি বৈশিষ্ট্য তৈরি না হলে পুরো standard আটকে থাকত। শেষে সেটি বের হলো ২০১১ সালে — C++11 নামে, প্রায় তেরো বছর পর।

এই নিয়মের ফল চোখে দেখা যায়: C++14, C++17, C++20, C++23 — চারটি standard ঠিক তিন বছর পরপর। বড় ও ঝুঁকির বৈশিষ্ট্যগুলো আগে আলাদা একটি পরীক্ষামূলক দলিলে যেত, যার নাম Technical Specification (TS). সেখানে compiler-নির্মাতারা বাস্তবায়ন করে দেখতেন, ব্যবহারকারীরা মতামত দিতেন, তারপর পরিণত হলে মূল standard-এ নেওয়া হতো। coroutines আর modules — দুটিই এই পথে এসেছে। ট্রেনগুলো ধাপে ধাপে দেখুন:

C++98: প্রথম আন্তর্জাতিক standard
  - class, template, exception, namespace
  - STL: vector, map, algorithm, iterator
C++03: মূলত ভুল সংশোধন, নতুন বৈশিষ্ট্য প্রায় নেই
এরপর দীর্ঘ বিরতি — পরের বড় সংস্করণের নাম "C++0x"

auto, range-for, lambda
move semantics, rvalue reference
unique_ptr, shared_ptr
std::thread, atomic, constexpr
override, final, nullptr, enum class
শিক্ষা: "সব তৈরি হলে ছাড়ব" = বারবার দেরি

C++14: ছোট পরিমার্জন
  - generic lambda, make_unique, return type deduction
C++17: মাঝারি সংস্করণ
  - optional, variant, any, string_view
  - filesystem, structured bindings, if constexpr

C++20 — বড় চার: concepts, ranges, modules, coroutines
  আরও: <=>, consteval, span, format, source_location
C++23 — গোছানো ও পূর্ণ করা:
  print, expected, generator, import std
  mdspan, flat_map, deducing this

static reflection — compile-এর সময় কোড নিজের গঠন দেখতে পারে
contracts — pre, post, contract_assert
std::execution — async কাজের সাধারণ কাঠামো
compiler-এ এগুলো আসছে ধাপে ধাপে

২ · যা আগেই শিখেছেন — C++20/23-এর পরিচিত মুখ

এই কোর্সে আপনি না জেনেই C++20/23-এর অনেকগুলো বৈশিষ্ট্য ব্যবহার করেছেন। কোর্সের শুরু থেকে আমরা std::println দিয়ে লিখেছি — সেটি C++23. নিচের তালিকায় প্রতিটির এক লাইনের মনে করিয়ে দেওয়া আর মূল পর্বের লিংক। এগুলো আবার শেখানো হবে না; এই পর্বের মনোযোগ নতুন জিনিসে।

বাকি থাকল C++20-এর “বড় চার”-এর দুটি — modules আর coroutines — আর ছোট ছোট কিছু সুবিধা। সেগুলোই এখন।

৩ · Modules — #include-এর পুরোনো সমস্যার উত্তর

পর্ব ১১-এ আপনি header ফাইল দিয়ে প্রোগ্রাম ভাগ করেছেন। কাজটি সহজ মনে হয়, কিন্তু #include-এর ভেতরের কৌশলটি ১৯৭০-এর দশকের C থেকে আসা, আর খুবই সরল: preprocessor header ফাইলের পুরো লেখা হুবহু কপি করে আপনার ফাইলে বসিয়ে দেয়। একে বলে textual inclusion. compiler তারপর সেই বিশাল, জোড়া-লাগানো ফাইলটিকে একটি translation unit হিসেবে পড়ে। এই সরলতার তিনটি দাম আছে।

C++ modules এই কৌশলটিই বদলে দেয়। একটি module-এর interface একবার compile হয়ে একটি বিশেষ বাইনারি ফাইলে যায় — একে বলে BMI (built module interface). GCC-তে এর এক্সটেনশন সাধারণত .gcm, Clang-এ .pcm, MSVC-তে .ifc. যে ফাইল import লেখে, compiler তার জন্য লেখা কপি করে না, সরাসরি সেই তৈরি BMI পড়ে নেয়। পার্থক্যটি ধাপে ধাপে দেখুন:

#include <vector>
#include "shop.h"

int main() { /* ১০ লাইনের কোড */ }

// ---- <vector> আর তার ভেতরের সব header-এর লেখা ----
// ... হাজার হাজার লাইন template, macro, helper ...
// ---- shop.h-এর লেখা ----
#define TAX 15          // এই macro এখন main.cpp-রও
int price_with_vat(int taka);
// ---- আপনার ১০ লাইন ----
int main() { ... }

a.cpp  → <vector> পড়ো, বোঝো, template তৈরি করো
b.cpp  → <vector> আবার পড়ো, আবার বোঝো
c.cpp  → আবার ...
... ২০০টি ফাইল = ২০০ বার একই header

export module shop;                  // module-এর নাম
export int price_with_vat(int taka); // যা বাইরে দেখা যাবে
#define TAX 15                       // module-এর ভেতরেই থাকবে

compiler: shop.cppm  ──►  shop.gcm (বাইনারি, একবারই তৈরি)

import shop;     // shop.gcm পড়ো — আবার parse করতে হয় না

main.cpp যা দেখে:  price_with_vat   (export করা নাম)
main.cpp যা দেখে না: TAX, অন্য helper, ভেতরের macro
import-এর ক্রম বদলালেও অর্থ বদলায় না

একটি ছোট module — interface আর implementation

একটি দোকানের দাম-হিসাবের module লিখে দেখা যাক। প্রথম ফাইলটি module interface unit — যা module-এর বাইরের চেহারা ঘোষণা করে। দ্বিতীয়টি module implementation unit — যেখানে ফাংশনের ভেতরের কাজ থাকে, বাইরে কিছু export করে না। header আর .cpp ফাইলের ভাগের মতোই, শুধু নিয়মগুলো ভাষার ভেতরে।

// shop.cppm — module interface unit (চালানোর জন্য নয়: এক ফাইলের অনলাইন compiler-এ চলবে না)
export module shop;                      // এই ফাইল module "shop"-এর মুখ
import std;                              // C++23: পুরো standard library এক লাইনে

export int price_with_vat(int taka);     // export: যারা import করবে, তারা দেখবে
int round_up(int x);                     // export নেই: module-এর ভেতরের কাজ

// shop_impl.cpp — module implementation unit
module shop;                             // "shop"-এর অংশ; নতুন কিছু export করে না
int round_up(int x) { return (x + 9) / 10 * 10; }
int price_with_vat(int taka) { return round_up(taka * 115 / 100); }

// main.cpp
import std;
import shop;
int main() { std::println("{}", price_with_vat(200)); }   // 230

লক্ষ করুন, round_up main.cpp থেকে ডাকা যাবে না — compiler বলবে নামটি দেখা যাচ্ছে না। header-এর জগতে এমন “গোপন” helper রাখতে static বা anonymous namespace লাগত; module-এ export না করাই যথেষ্ট। বড় module-কে টুকরো করা যায় partition দিয়ে (export module shop:cart;) — এটুকু শুধু নাম শুনে রাখুন। আর পুরোনো header-কেও module-এর মতো import করা যায়: import <vector>; — একে বলে header unit, যদিও এর সমর্থন modules-এর মধ্যেও সবচেয়ে অসম।

import std; — C++23-এর এক লাইনের লাইব্রেরি

C++20 module-এর ভাষাগত নিয়ম দিয়েছিল, কিন্তু standard library তখনো header-ই ছিল। C++23 যোগ করেছে import std; — এক লাইনে পুরো standard library, macro ছাড়া। মজার ব্যাপার হলো, সবকিছু একসাথে import করা প্রায়ই কয়েকটি বড় header include করার চেয়েও দ্রুত, কারণ BMI একবারই তৈরি হয়। (assert-এর মতো macro-গুলো module দিয়ে আসে না; সেগুলোর জন্য এখনো header লাগে। আর std.compat নামে আরেকটি module C-এর ::printf-এর মতো global নামগুলোও দেয়।)

# CMakeLists.txt — module-সহ একটি ছোট প্রজেক্ট (CMake 3.28+, Ninja generator)
cmake_minimum_required(VERSION 3.28)
project(shop CXX)
set(CMAKE_CXX_STANDARD 23)
add_executable(app main.cpp shop_impl.cpp)
target_sources(app PRIVATE FILE_SET CXX_MODULES FILES shop.cppm)
# import std; ব্যবহার করলে CMake-এ আলাদা সেটিং লাগে — আপনার সংস্করণের ডকুমেন্টেশন দেখুন

৪ · Coroutine — যে ফাংশন থেমে আবার চলতে পারে

এ পর্যন্ত আপনার সব ফাংশনের জীবন একই রকম: ডাকা হলো, শুরু থেকে শেষ পর্যন্ত চলল, একবার return করল, শেষ। তার local ভ্যারিয়েবলগুলো stack frame-এ ছিল, ফেরার সঙ্গে সঙ্গে মুছে গেল। পরের বার ডাকলে আবার একদম শুরু থেকে।

একটি coroutine এই নিয়ম ভাঙে। এটি মাঝপথে একটি মান দিয়ে থেমে যেতে পারে (suspend), আর পরে কেউ চাইলে ঠিক সেই জায়গা থেকে আবার চলতে পারে (resume) — local ভ্যারিয়েবলগুলো যেমন ছিল তেমনই রেখে।

C++-এ একটি ফাংশন coroutine হয়, যদি তার ভেতরে তিনটি নতুন keyword-এর অন্তত একটি থাকে:

coroutine-এ সাধারণ return লেখা যায় না, আর এর ফেরত-টাইপ হতে হয় বিশেষ ধরনের — যে টাইপ জানে কীভাবে থামা-চলা সামলাতে হয়। C++20 ভাষার যন্ত্রটি দিয়েছিল, কিন্তু কোনো তৈরি ফেরত-টাইপ দেয়নি। একটি সাধারণ generator লিখতেও নিজে একটি promise type, একটি std::coroutine_handle আর iterator মিলিয়ে কয়েক ডজন লাইন লিখতে হতো — তাই অনেকে coroutine দেখে ভয় পেতেন। C++23-এর std::generator সেই কাজ তৈরি করে দিয়েছে। এবার একটি চালানো যায় এমন উদাহরণ: দোকানের invoice নম্বর, একটি একটি করে, শুধু যখন দরকার।

#include <generator>
#include <print>

// A coroutine: pauses at each co_yield, resumes when the caller wants more
std::generator<int> invoice_numbers(int first) {
    for (int n = first; ; ++n) {             // an endless loop is fine here
        std::println("  [generator] making {}", n);
        co_yield n;                           // hand n to the caller, then pause
    }
}

int main() {
    int printed = 0;
    for (int inv : invoice_numbers(1001)) {   // each value is made on demand
        std::println("caller got INV-{}", inv);
        if (++printed == 3) break;            // stop: 1004 is never made
    }
}

দুই পক্ষের মধ্যে নিয়ন্ত্রণ কীভাবে হাত বদলায়, ধাপে ধাপে দেখুন। প্রতিটি ধাপে আগে অনুমান করুন, পরের আউটপুট লাইন কোনটি:

1generator<int> invoice_numbers(int first) {2    for (int n = first; ; ++n) {3        println("  [generator] making {}", n);4        co_yield n;5    }6}7for (int inv : invoice_numbers(1001)) {8    println("caller got INV-{}", inv);9    if (++printed == 3) break;10}

Coroutine frame — থামার সময় অবস্থা থাকে কোথায়?

সাধারণ ফাংশনের local ভ্যারিয়েবল থাকে stack frame-এ, যা ফেরার সময় মুছে যায়। কিন্তু coroutine থামার পর caller অন্য কাজ করে, অন্য ফাংশন ডাকে — stack-এর সেই জায়গা অন্যরা ব্যবহার করে ফেলে। তাই coroutine-এর অবস্থা রাখতে হয় এমন জায়গায়, যা থামার পরেও টিকে থাকে। একে বলে coroutine frame: এতে থাকে প্যারামিটারের কপি, যেসব local ভ্যারিয়েবল থামার পরেও লাগবে, আর “কোথায় থেমেছিলাম” তার চিহ্ন। frame সাধারণত heap-এ তৈরি হয়। তবে compiler যদি প্রমাণ করতে পারে যে coroutine-এর জীবন caller-এর ভেতরেই শেষ হবে, তাহলে সে এই heap বরাদ্দ বাদ দিতে পারে (HALO নামে পরিচিত অপ্টিমাইজেশন) — কিন্তু এর নিশ্চয়তা নেই।

কোথায় কাজে লাগে

এক, অলস সারি (lazy sequence) — যেমন উপরের invoice নম্বর, একটি বিশাল ফাইলের লাইন একটি একটি করে পড়া, বা একটি গাছের নোডগুলো ক্রমে ঘোরা। std::generator একটি range, তাই পর্ব ৩৫-এর view দিয়ে জুড়ে দেওয়া যায়: invoice_numbers(1001) | std::views::take(3).

দুই, async I/O — এখানেই coroutine-এর আসল শক্তি। নেটওয়ার্ক থেকে ডেটা আসতে সময় লাগে। পুরোনো পদ্ধতিতে হয় thread আটকে অপেক্ষা করতে হতো, নয়তো callback-এর ভেতরে callback লিখতে হতো। coroutine দিয়ে কোড দেখতে সোজা, ধাপে ধাপে — অথচ প্রতিটি co_await-এ thread ছাড়া পেয়ে অন্য কাজ করে:

// Asio লাইব্রেরি দিয়ে একটি echo server-এর অংশ — ধারণা দেখাতে, এখানে চালানোর জন্য নয়
asio::awaitable<void> echo(tcp::socket s) {
    char buf[1024];
    for (;;) {
        auto n = co_await s.async_read_some(asio::buffer(buf), asio::use_awaitable);
        co_await asio::async_write(s, asio::buffer(buf, n), asio::use_awaitable);
    }
}

এখানে co_await-এ coroutine থামে, আর ডেটা এলে Asio তাকে আবার জাগায়। একটি thread এভাবে হাজার হাজার সংযোগ সামলাতে পারে। standard library এখনো নিজে কোনো async I/O দেয় না; এজন্য Asio, cppcoro-র মতো লাইব্রেরি ব্যবহার হয়। আপনার কাজ coroutine লাইব্রেরি লেখা নয় — তৈরি লাইব্রেরি ঠিকভাবে ব্যবহার করা। thread আর async-এর মূল ধারণা পর্ব ৪৫-৪৬-এ আসবে।

৫ · ছোট কিন্তু প্রতিদিনের — C++20/23-এর সুবিধা

বড় বৈশিষ্ট্য নিয়ে আলোচনা বেশি হয়, কিন্তু রোজকার কোড সবচেয়ে বেশি বদলায় ছোট সুবিধাগুলো। প্রথমে দুটি একসাথে, একটি চালানো যায় এমন প্রোগ্রামে: পরীক্ষার নম্বরের একটি অংশ std::span দিয়ে পাঠানো, আর std::source_location দিয়ে এমন একটি log ফাংশন, যা নিজে থেকেই জানে কোন লাইন থেকে তাকে ডাকা হয়েছে।

#include <print>
#include <source_location>
#include <span>

void log(const char* msg, std::source_location at = std::source_location::current()) {
    std::println("[line {}] {}: {}", at.line(), at.function_name(), msg);
}

int average(std::span<const int> marks) {      // a view: no copy, knows its size
    log("averaging");
    int sum = 0;
    for (int m : marks) sum += m;
    return marks.empty() ? 0 : sum / static_cast<int>(marks.size());
}

int main() {
    int marks[] = {72, 85, 64, 90, 58, 77};
    std::span<const int> all{marks};
    std::println("first 3: {}", average(all.first(3)));
    std::println("last 2: {}", average(all.last(2)));
    log("done");
}

এবার আরও কিছু ছোট সুবিধা, এক জায়গায়। এগুলো GCC-র সাম্প্রতিক সংস্করণে যাচাই করা, তবে এখানে চালানোর জন্য নয়:

// C++20: using enum — switch-এ বারবার Color:: লিখতে হয় না
enum class Color { red, green, blue };
std::string_view name(Color c) {
    switch (c) {
        using enum Color;
        case red:   return "red";
        case green: return "green";
        case blue:  return "blue";
    }
    return "?";
}

// C++20: [[likely]] / [[unlikely]] — কোন শাখা বেশি ঘটে, compiler-কে ইঙ্গিত
if (payment_ok) [[likely]] { ship(); } else [[unlikely]] { alert(); }

// C++20: std::bit_cast — বিটগুলো হুবহু রেখে টাইপ বদল (memcpy-র নিরাপদ রূপ)
auto bits = std::bit_cast<std::uint32_t>(1.0f);     // 0x3f800000

// contains, starts_with, ends_with
stock.contains("rice");          // map/set: C++20
id.starts_with("INV-");          // string, string_view: C++20
id.ends_with("01");              // C++20
id.contains("10");               // string, string_view: C++23

// C++20: std::ssize — signed আকার, উল্টো লুপে নিরাপদ
for (auto i = std::ssize(v) - 1; i >= 0; --i) { /* ... */ }

• using enum (C++20): পর্ব ১২-এর enum class নিরাপদ, কিন্তু প্রতিবার Color::red লেখা ক্লান্তিকর। একটি scope-এর ভেতরে using enum Color; লিখলে সেখানে শুধু red লিখলেই চলে — নিরাপত্তা বজায় থাকে, কারণ এটি শুধু সেই ছোট scope-এ খাটে।
• [[likely]] / [[unlikely]] (C++20): পর্ব ৮-এর attribute-এর পরিবারে নতুন সদস্য। compiler এই ইঙ্গিতে কোড এমনভাবে সাজাতে পারে যাতে বেশি-ঘটা পথ দ্রুত হয়। এটি শুধু ইঙ্গিত, আদেশ নয় — আর ভুল ইঙ্গিত দিলে কোড ধীরও হতে পারে। মেপে না দেখে (পর্ব ৪৯) ছড়িয়ে দেবেন না।
• std::bit_cast (C++20): একটি float-এর বিটগুলো পূর্ণসংখ্যা হিসেবে দেখার পুরোনো কৌশল ছিল pointer cast বা union — যা C++-এ undefined behavior. এই কাজকে বলে type punning. bit_cast এটি বৈধভাবে করে, শর্ত হলো দুই টাইপের আকার সমান; আর এটি constexpr-ও।
• contains(), starts_with(), ends_with(): m.find(k) != m.end() বা s.rfind("INV-", 0) == 0-এর মতো ঘুরপথের বদলে সরাসরি প্রশ্ন। কোনটি কোন standard-এ, খেয়াল রাখুন — map-এর contains C++20, string-এর contains C++23.
• std::ssize (C++20): v.size() unsigned, তাই খালি vector-এ v.size() - 1 বিশাল একটি সংখ্যা হয়ে যায় (পর্ব ৬)। std::ssize(v) signed মান দেয়, তাই উল্টো লুপ নিরাপদ।
• designated initializer (C++20, পর্ব ১২-এ দেখেছেন): Order o{.id = 7, .qty = 2}; — কোন মান কোন ঘরে, নাম দেখেই বোঝা যায়। মনে রাখুন, C++-এ ঘরগুলো ঘোষণার ক্রমেই লিখতে হয়।

৬ · C++23-এর আরও কয়েকটি নতুন যন্ত্র

C++23-কে অনেকে “গোছানোর standard” বলেন, কিন্তু এতে কয়েকটি সত্যিকারের নতুন যন্ত্রও আছে। এগুলো এক ঝলকে চিনে রাখুন — কোনোটিই আপনাকে আজ ব্যবহার করতে হবে না, কিন্তু আধুনিক কোডে দেখলে চিনতে হবে।

// বহুমাত্রিক subscript: operator[] এখন একাধিক প্যারামিটার নিতে পারে
struct Grid {
    std::vector<int> d; int cols;
    int& operator[](int r, int c) { return d[r * cols + c]; }   // g[r, c]
};

// std::mdspan: পাশাপাশি থাকা ডেটার ওপর বহুমাত্রিক view (মালিক নয়)
std::vector<int> seats(3 * 4);
std::mdspan hall(seats.data(), 3, 4);     // ৩ সারি × ৪ আসন
hall[1, 2] = 1;                           // সারি 1, আসন 2

// std::flat_map: ভেতরে দুটি সাজানো vector — ছোট map-এ দ্রুত খোঁজা
std::flat_map<std::string, int> price{{"rice", 70}, {"dal", 120}};

// deducing this: object-কে স্পষ্ট প্যারামিটার হিসেবে নেওয়া
struct Account { int bal = 0; int get(this const Account& self) { return self.bal; } };

// auto(x): x-এর একটি নতুন কপি, টাইপ নিজে না লিখে
some_function(auto(v));                   // v নয়, v-এর একটি অস্থায়ী কপি পাঠাও

• multidimensional subscript: আগে m[i][j] লিখতে proxy object বানাতে হতো, বা m(i, j) দিয়ে কাজ চালাতে হতো। C++23 থেকে operator[] একাধিক প্যারামিটার নিতে পারে, তাই m[i, j] সরাসরি লেখা যায়। (C++20-এ এই লেখা একটি comma operator হিসেবে পড়া হতো, যা deprecated করে জায়গা খালি করা হয়েছিল।)
• std::mdspan: পর্ব ১৩-এ এর উল্লেখ দেখেছেন। একটি এক-লাইনের মেমরিকে ম্যাট্রিক্স বা ঘনকের মতো দেখার জানালা — বৈজ্ঞানিক হিসাব, ছবি প্রক্রিয়া, মেশিন লার্নিংয়ে কাজে লাগে।
• std::flat_map: পর্ব ৩১-এ উল্লেখ করা। গাছের বদলে সাজানো vector, তাই cache-বান্ধব আর খোঁজা দ্রুত; কিন্তু মাঝখানে ঢোকানো ধীর। একবার তৈরি করে বারবার পড়ার কাজে ভালো।
• deducing this: পর্ব ৩৪-এ lambda-র নিজেকে ডাকার কৌশলে দেখেছেন। এর বড় লাভ হলো const আর non-const সংস্করণের মতো দুইবার একই ফাংশন লেখার প্রয়োজন কমানো, আর পর্ব ২৫-এ উল্লেখ করা CRTP-এর অনেক ব্যবহার সরল করা।
• auto(x): “এর একটি নতুন কপি দাও” — টাইপের নাম না লিখে। template কোডে, যেখানে টাইপ লম্বা বা অজানা, সেখানে কাজে লাগে।

৭ · সামনে কী — C++26

C++26-এর বৈশিষ্ট্যের তালিকা ২০২৫ সালে বন্ধ হয়েছে, আর সেখানে তিনটি বড় জিনিস গৃহীত হয়েছে, যা নিয়ে কমিটি বহু বছর কাজ করেছে। compiler-এ এগুলো আসছে ধীরে ধীরে, তাই আজ নিজের কোডে ব্যবহারের আগে সমর্থন যাচাই করুন।

এর বাইরেও C++26-এ এসেছে #embed (একটি বাইনারি ফাইল সরাসরি array-তে বসানো), std::inplace_vector (নির্দিষ্ট সর্বোচ্চ আকারের, heap ছাড়া vector), আর নিরাপত্তার দিকে বড় পদক্ষেপ: অশুরু (uninitialized) ভ্যারিয়েবল পড়া এখন আর পুরোপুরি undefined behavior নয়, বরং “erroneous behavior” — যা পর্ব ৪৩-এর আলোচনার সঙ্গে সরাসরি যুক্ত। অন্যদিকে pattern matching (inspect/match) আর নিরাপত্তার “profiles” — এগুলো এখনো প্রস্তাবিত, C++26-এর অংশ নয়।

৮ · আপনার compiler কী পারে — যাচাইয়ের উপায়

standard-এ একটি বৈশিষ্ট্য থাকা আর আপনার compiler-এ সেটি থাকা — দুটি আলাদা কথা। C++20 প্রকাশিত হয় ২০২০ সালে, কিন্তু তার সব বৈশিষ্ট্য সব বড় compiler-এ আসতে কয়েক বছর লেগেছে, আর modules-এর বেলায় এখনো পুরো হয়নি। তাই দুটি অভ্যাস গড়ে তুলুন।

এক, compiler support table দেখা। cppreference-এর “C++ compiler support” পাতায় প্রতিটি বৈশিষ্ট্যের পাশে লেখা থাকে GCC, Clang আর MSVC-র কোন সংস্করণ থেকে সেটি আছে। একটি গুরুত্বপূর্ণ সূক্ষ্মতা: ভাষার বৈশিষ্ট্য (যেমন coroutine keyword) আসে compiler থেকে, আর লাইব্রেরির বৈশিষ্ট্য (যেমন std::generator) আসে standard library থেকে — GCC-র সঙ্গে libstdc++, Clang-এর সঙ্গে সাধারণত libc++ বা libstdc++. Clang compiler নতুন হলেও পুরোনো লাইব্রেরি থাকলে লাইব্রেরির বৈশিষ্ট্য না-ও পেতে পারেন।

দুই, feature-test macro ব্যবহার। প্রতিটি নতুন বৈশিষ্ট্যের একটি macro আছে, যা সমর্থন থাকলে define করা থাকে, আর তার মান একটি তারিখ (বছর ও মাস)। লাইব্রেরির macro-গুলো একসাথে পাওয়া যায় C++20-এর <version> header-এ। এভাবে কোড নিজেই ঠিক করতে পারে, কোন পথে যাবে:

#include <version>               // সব লাইব্রেরি macro এখানে

#if defined(__cpp_lib_generator) && __cpp_lib_generator >= 202207L
    #include <generator>
    // std::generator দিয়ে অলস সারি
#else
    // বিকল্প: একটি vector-এ আগে থেকে নম্বরগুলো বানানো
#endif

__cpp_lib_generator  =  202207L

=> শর্ত সত্য, প্রথম শাখা compile হয়
   #else-এর অংশ compiler দেখেই না

__cpp_lib_generator  ->  define করা নেই

=> #else শাখা compile হয়
   #include <generator> লাইনটি কখনো পড়াই হয় না,
   তাই "file not found" error-ও আসে না

__cpp_lib_ranges       202110L, 202202L, ... বৈশিষ্ট্য বাড়লে মান বাড়ে
__cpp_concepts         ভাষার বৈশিষ্ট্য: <version> ছাড়াই আছে
__cplusplus            শুধু standard-এর মোটা দাগ (যেমন 202302L)
                        — একটি নির্দিষ্ট বৈশিষ্ট্য আছে কি না, তা বলে না

বেশিরভাগ ক্ষেত্রে এত জটিলতার দরকার নেই — প্রজেক্টের জন্য একটি ন্যূনতম compiler সংস্করণ ঠিক করে নিলেই চলে। feature-test macro সবচেয়ে বেশি কাজে লাগে লাইব্রেরি-লেখকদের, যাঁদের কোড অনেক রকম compiler-এ চলতে হয়। আর দ্রুত পরীক্ষা করতে Compiler Explorer-এর মতো অনলাইন টুলে কয়েকটি compiler পাশাপাশি চালিয়ে দেখা সবচেয়ে সহজ।

৯ · AI-এর যুগে — “খুব নতুন” কোডের ফাঁদ

নতুন standard-এর বেলায় AI-এর ভুলগুলো একটু আলাদা ধরনের। পুরোনো বিষয়ে AI-এর কাছে লাখ লাখ উদাহরণ আছে; কিন্তু C++23-এর মতো নতুন বিষয়ে উদাহরণ কম, আর অনলাইনের অনেক লেখায় প্রস্তাব আর চূড়ান্ত নিয়ম মিশে আছে। তাই AI প্রায়ই এমন কোড দেয়, যা “কাগজে” ঠিক, কিন্তু আপনার compiler-এ চলে না — বা এমন বৈশিষ্ট্য দেখায়, যা আসলে এখনো কেবল প্রস্তাব। সাধারণ ভুলগুলো:

নতুন C++ কোড যাচাইয়ের চেকলিস্ট

• প্রতিটি নতুন বৈশিষ্ট্য কোন standard-এর, তা cppreference-এ মিলিয়ে দেখেছি (C++20, C++23, না শুধু প্রস্তাব)
• আমার আর দলের compiler ও standard library-র সংস্করণে সেটি আছে, compiler support table-এ দেখেছি
• কোডটি নিজের toolchain-এ -Wall -Wextra দিয়ে compile করে চালিয়েছি — AI-এর “চলবে” কথায় ভরসা করিনি
• সরল কাজে হাতে-লেখা coroutine কাঠামো নেই; তৈরি std::generator বা লাইব্রেরি ব্যবহার হয়েছে
• coroutine-এর প্যারামিটারে reference বা view থাকলে, তার lifetime coroutine-এর চেয়ে লম্বা কি না, যাচাই করেছি
• modules ব্যবহার করলে build system (যেমন CMake-এর সংস্করণ) সেটি সমর্থন করে কি না, আগে নিশ্চিত হয়েছি