namespace আর header — বড় প্রোগ্রাম সাজানো

১ · বড় প্রোগ্রামের দুই সমস্যা — নাম আর ফাইল

রাকিব একটি মুদি দোকানের বিলিং সফটওয়্যার বানাচ্ছেন। প্রথম সপ্তাহে সব কোড ছিল এক ফাইলে, ২০০ লাইন। তিন মাস পরে কোড ৮,০০০ লাইন, দলে আরও দুজন। তখন দুটি সমস্যা একসাথে দেখা দিল:

• নামের সংঘাত: রাকিব টাকার হিসাবে total() লিখেছেন, সহকর্মী নাদিয়া ঝুড়ির হিসাবেও লিখেছেন total(). দুটো একসাথে জোড়া লাগাতেই error.
• ফাইলের বিশৃঙ্খলা: ৮,০০০ লাইনের এক ফাইলে একটি অক্ষর বদলালেও পুরোটা নতুন করে compile হয়। দুজন একই ফাইলে কাজ করলে একে অন্যের পরিবর্তন মুছে যায়। কোন অংশ কার, বোঝাই যায় না।

দুটি সমস্যা আলাদা, তাই সমাধানও দুটি। প্রথমটির উত্তর namespace — নামকে পরিবারে ভাগ করা। দ্বিতীয়টির উত্তর header আর source file-এ ভাগ করা — কাজকে ফাইলে ভাগ করা। ভালো C++ প্রজেক্টে এই দুই ভাগ সাধারণত একে অপরের সাথে মেলে: money.h আর money.cpp-এর সব কিছু থাকে money namespace-এ।

পর্ব ০৪-এ আপনি std:: আর দুটি ছোট namespace দেখেছেন, আর পর্ব ০৩-এ দেখেছেন দুই ফাইলের প্রজেক্ট কীভাবে আলাদা compile হয়ে link হয়। এই পর্বে সেই দুই ধারণাকে পেশাদার মাত্রায় নিয়ে যাব।

২ · নিজের namespace — nested, alias আর using-এর পরিধি

একটি namespace বানানো খুব সহজ: namespace shop { … }. ভেতরে যা ঘোষণা করবেন — ফাংশন, ভ্যারিয়েবল, struct, class — সবার পুরো নামের শুরুতে বসবে shop::. বাইরে থেকে ডাকতে scope resolution অপারেটর :: লাগে। কয়েকটি গুরুত্বপূর্ণ বৈশিষ্ট্য:

• Namespace খোলা থাকে। একই নামের namespace একাধিকবার, এমনকি আলাদা ফাইলে খোলা যায় — সবকিছু মিলে একটাই namespace হয়। money.h আর money.cpp দুটোতেই namespace shop::money { … } লেখা এভাবেই সম্ভব। (class-এর ক্ষেত্রে এমন হয় না — class একবারেই সম্পূর্ণ লিখতে হয়।)
• Namespace-এর ভেতরে namespace. একে বলে nested namespace. আগে লিখতে হতো namespace shop { namespace billing { … } }; C++17 থেকে এক লাইনেই লেখা যায় namespace shop::billing { … }.
• লম্বা নামের ডাকনাম। Namespace alias: namespace fs = std::filesystem; — এরপর fs::path লিখলেই চলে। নতুন কিছু তৈরি হয় না, শুধু একটি ছোট নাম।
• Global namespace. কোনো namespace-এর বাইরে লেখা সব নাম থাকে নামহীন সবার-বাইরের ঘরে। সেখানকার নাম স্পষ্টভাবে বোঝাতে সামনে শুধু :: লিখুন, যেমন ::limit.

Compiler নাম খোঁজে কীভাবে — ভেতর থেকে বাইরে

কোডে একটি নাম, ধরুন limit, দেখলে compiler-কে ঠিক করতে হয় সেটি কোন limit. এই কাজকে বলে name lookup. নিয়মটি সহজ: সবচেয়ে কাছের ঘর থেকে শুরু করে বাইরের দিকে যাও, আর প্রথম যেখানে নামটা পাবে, সেখানেই থামো. নিচের ডায়াগ্রামে compiler-এর সাথে খুঁজে দেখুন:

1int limit = 1000;            // global2namespace shop {3    int limit = 500;4    namespace billing {5        int fee = 20;6        bool allowed(int amount) {7            return amount + fee <= limit;8        }9    }10}11// main-এ: shop::billing::allowed(480)

using-এর দুই রূপ — আর তাদের পরিধি

পর্ব ০৪-এ using-এর দুই রূপ দেখেছেন। এবার আসল প্রশ্ন — এদের প্রভাব কতদূর ছড়ায়। উত্তর: যে scope-এ লিখবেন, সেই scope শেষ হওয়া পর্যন্ত।

এবার উপরের ডায়াগ্রামের কোডটাই চালিয়ে দেখুন। সাথে C++17-এর এক-লাইনের nested namespace, একটি alias আর ফাংশনের ভেতরে একটি using declaration যোগ করা হয়েছে:

#include <iostream>

int limit = 1000;                         // global namespace
namespace shop {
    int limit = 500;
    namespace billing {
        int fee = 20;
        bool allowed(int amount) { return amount + fee <= limit; }
    }
}
namespace shop::billing {                 // C++17: একই namespace-এ আরও যোগ
    int with_vat(int taka) { return taka + taka * 15 / 100; }
}
namespace bill = shop::billing;           // alias: শুধু ছোট নাম

int main() {
    std::cout << std::boolalpha << bill::allowed(490) << ' ' << bill::allowed(480) << '\n';
    using shop::billing::with_vat;        // শুধু একটি নাম, শুধু main-এর ভেতরে
    std::cout << with_vat(200) << ' ' << ::limit << '\n';
}

৩ · ফাইলের গোপন সহকারী — anonymous namespace, static আর ADL

বড় প্রজেক্টে প্রতিটি .cpp ফাইলে কিছু ছোট সহকারী ফাংশন থাকে, যা শুধু সেই ফাইলের কাজে লাগে — যেমন money.cpp-এ শতাংশ বের করার একটি percent_of. সমস্যা হলো, সাধারণভাবে লেখা ফাংশনের নাম পুরো প্রোগ্রামে দৃশ্যমান: cart.cpp-তেও কেউ যদি নিজের জন্য percent_of লেখেন (একই parameter-সহ), link-এর সময় দুটো ধাক্কা খাবে।

সমাধান হলো সহকারীকে নামহীন একটি namespace-এ রাখা — anonymous namespace:

// money.cpp
namespace {                          // নামহীন: শুধু এই ফাইলের জন্য
    long percent_of(long value, int pct) { return value * pct / 100; }
}
// এই ফাইলের বাকি অংশ percent_of সরাসরি ডাকতে পারে;
// অন্য কোনো .cpp ফাইল এটাকে দেখবেই না।

Compiler প্রতিটি ফাইলের anonymous namespace-কে একটি গোপন, অনন্য নাম দেয়, আর তার ভেতরের সব কিছু পায় internal linkage — অর্থাৎ নামটি linker-এর সাধারণ তালিকায় যায় না, শুধু ওই translation unit-এর ভেতরে থাকে। বিপরীতটি external linkage: সাধারণ ফাংশনের নাম, যা অন্য ফাইল থেকে ডাকা যায়।

C-র static দিয়েও তো হয়?

হয়। static long percent_of(…) লিখলেও ফাংশনটি internal linkage পায় — C-তে এটাই একমাত্র পথ। তাহলে পার্থক্য কোথায়?

Standard দুটোকেই বৈধ রাখে। কোন পথ ভালো, তা নিয়ে বড় প্রজেক্টের নিয়মও আলাদা: Google-এর স্টাইল গাইড .cc ফাইলের ভেতরের জিনিসের জন্য anonymous namespace বা static দুটোকেই মানে, আর LLVM-এর নিয়ম বলে ফাংশনের জন্য static, আর anonymous namespace যতটা সম্ভব ছোট রেখে শুধু টাইপের জন্য। আপনার দলের নিয়ম মেনে চলুন, তবে একটি নিয়ম সবখানে এক: header-এ anonymous namespace রাখবেন না. Header যত .cpp-তে ঢোকে, প্রত্যেকে নিজের আলাদা গোপন কপি পায় — ভ্যারিয়েবল হলে প্রতিটি ফাইলের মান আলাদা, যা প্রায়ই আসল উদ্দেশ্যের উল্টো।

ADL — নামটি নিজের পরিবারকেও সাথে আনে

নাম খোঁজার আরেকটি নিয়ম আছে, যা প্রথমে জাদুর মতো লাগে। std::cout << "hi" লেখার সময় আপনি কখনো std::operator<< লেখেন না, তবু compiler ঠিক ফাংশনটি খুঁজে পায়। কারণ argument-dependent lookup (ADL): কোনো ফাংশন পদবি ছাড়া ডাকলে compiler সাধারণ খোঁজার পাশাপাশি argument-গুলোর টাইপ যে namespace-এ আছে, সেখানেও খোঁজে। cout-এর টাইপ std-এর, তাই std-এর ভেতরের operator<<-ও প্রার্থী হয়। একইভাবে দোকানের প্রজেক্টে to_text(price) লিখলে, price-এর টাইপ shop::money::Taka বলে compiler shop::money::to_text পেয়ে যায়। Andrew Koenig-এর নামে একে “Koenig lookup”-ও বলা হয়। সুবিধা হলো operator আর টাইপের সাথে জড়িত ফাংশন স্বাভাবিকভাবে লেখা যায়; ঝুঁকি হলো কখনো এমন ফাংশন বেছে নেওয়া হয় যার কথা আপনি ভাবেননি। তাই নিজের টাইপের সহকারী ফাংশন সবসময় সেই টাইপের namespace-এই রাখুন। Operator overloading পর্ব ২৩-এ ADL আবার কাজে লাগবে।

৪ · #include আসলে কী করে — কপি-পেস্ট আর include guard

এবার ফাইলের দিক। পর্ব ০৩-এ দেখেছেন preprocessor #include-এর জায়গায় header-এর লেখা বসিয়ে দেয়। কথাটা আক্ষরিক — এটি একটি বোকা কিন্তু বিশ্বস্ত কপি-পেস্ট মেশিন। সে C++ বোঝে না, namespace বোঝে না; শুধু ফাইল খুলে লেখা তুলে আনে। এই সরলতা থেকেই একটি বিখ্যাত সমস্যা জন্মায় — diamond include. ধাপে ধাপে দেখুন:

// money.h
namespace shop::money {
    struct Taka { long paisa = 0; };
}

// cart.h
#include "money.h"
namespace shop::cart { money::Taka total(); }

// main.cpp
#include "money.h"
#include "cart.h"
int main() { /* ... */ }

namespace shop::money {
    struct Taka { long paisa = 0; };
}
#include "cart.h"          // এখনো বাকি
int main() { /* ... */ }

namespace shop::money {
    struct Taka { long paisa = 0; };
}
#include "money.h"          // cart.h-এর প্রথম লাইন
namespace shop::cart { money::Taka total(); }
int main() { /* ... */ }

namespace shop::money { struct Taka { long paisa = 0; }; }
namespace shop::money { struct Taka { long paisa = 0; }; }
namespace shop::cart { money::Taka total(); }

$ g++ -std=c++23 -c main.cpp
money.h:2:12: error: redefinition of 'struct shop::money::Taka'
money.h:2:12: note: previous definition of 'struct shop::money::Taka'

#ifndef SHOP_MONEY_H
#define SHOP_MONEY_H
namespace shop::money {
    struct Taka { long paisa = 0; };
}
#endif

// প্রথমবার: SHOP_MONEY_H অজানা → ভেতরে ঢোকো, নামটা define করো
// দ্বিতীয়বার: SHOP_MONEY_H জানা → #endif পর্যন্ত সব বাদ

#pragma once
namespace shop::money {
    struct Taka { long paisa = 0; };
}

// "এই ফাইলটি একটি translation unit-এ একবারই ঢুকবে"
// GCC, Clang, MSVC — সবাই মানে, তবে standard-এর অংশ নয়

৫ · Header-এ কী, .cpp-তে কী — দোকানের প্রজেক্ট ভাগ করা

মূল নীতি একটি বাক্যে: header হলো প্রতিশ্রুতি, .cpp হলো সেই প্রতিশ্রুতি পূরণ। যে জিনিস অন্য ফাইলের জানা দরকার, তার ঘোষণা header-এ; আসল কাজ .cpp-তে। তবে কিছু জিনিস আছে যার পুরো দেহই header-এ রাখতে হয়, কারণ compiler-কে ব্যবহারের জায়গাতেই পুরোটা দেখতে হয়:

এবার রাকিবের দোকানের প্রজেক্টটি আসল রূপে দেখুন — পাঁচটি ফাইল। ট্যাব বদলে প্রতিটি ফাইল পড়ুন (এগুলো একসাথে এক প্রজেক্ট; পাতার রানার একবারে একটি ফাইল চালায়, তাই এখানে চালানোর বোতাম নেই):

#pragma once
#include <string>

namespace shop::money {
    inline constexpr int vat_percent = 15;      // সব ফাইলে একটাই মান

    struct Taka { long paisa = 0; };             // টাইপের সংজ্ঞা: header-এ

    inline Taka from_taka(long tk) { return {tk * 100}; }   // ছোট, inline

    Taka with_vat(Taka t);                       // শুধু ঘোষণা
    std::string to_text(Taka t);                 // শুধু ঘোষণা
}

#include "money.h"        // নিজের header সবার আগে
#include <format>

namespace shop::money {
    namespace {                                  // শুধু এই ফাইলের সহকারী
        long percent_of(long value, int pct) { return value * pct / 100; }
    }

    Taka with_vat(Taka t) {                      // প্রতিশ্রুতি পূরণ
        return {t.paisa + percent_of(t.paisa, vat_percent)};
    }
    std::string to_text(Taka t) {
        return std::format("{}.{:02} Tk", t.paisa / 100, t.paisa % 100);
    }
}

#pragma once
#include <string>
#include <vector>
#include "money.h"         // Item-এর ভেতরে Taka আছে, তাই পুরো সংজ্ঞা লাগবে

namespace shop::cart {
    struct Item { std::string name; money::Taka price; };

    money::Taka total(const std::vector<Item>& items);   // VAT-সহ মোট
}

#include "cart.h"

namespace shop::cart {
    money::Taka total(const std::vector<Item>& items) {
        money::Taka sum;
        for (const auto& it : items) sum.paisa += it.price.paisa;
        return money::with_vat(sum);
    }
}

#include <print>
#include "cart.h"           // cart.h নিজেই money.h আনে — guard থাকায় নিরাপদ

int main() {
    namespace m = shop::money;
    std::vector<shop::cart::Item> items{{"chal", m::from_taka(70)},
                                        {"dal",  {1550}}};
    std::println("Total: {}", m::to_text(shop::cart::total(items)));
}

# প্রতিটি .cpp আলাদা compile, শেষে link — header কমান্ডে নেই
g++ -std=c++23 -Wall -Wextra -c money.cpp
g++ -std=c++23 -Wall -Wextra -c cart.cpp
g++ -std=c++23 -Wall -Wextra -c main.cpp
g++ money.o cart.o main.o -o shop
./shop          # Total: 98.32 Tk

কয়েকটি অভ্যাস খেয়াল করুন। প্রতিটি .cpp নিজের header সবার আগে include করে — তাহলে header নিজে কোনো দরকারি #include ভুলে গেলে সঙ্গে সঙ্গে ধরা পড়ে। প্রতিটি header যা ব্যবহার করে তা নিজেই include করে (cart.h নিজে <vector> আনে, main.cpp-এর ওপর ভরসা করে না) — একে বলে “include what you use”. আর বড় সুবিধাটা হলো: শুধু money.cpp-এর ভেতরের হিসাব বদলালে শুধু সেটিই আবার compile হবে; money.h বদলালে তিনটিই — কারণ তিনটিই সেটা দেখে। Header যত স্থির, build তত দ্রুত।

পাতার রানার একবারে একটি ফাইলই চালাতে পারে। তাই নিচে একই প্রজেক্ট এক ফাইলে সাজানো হয়েছে — প্রতিটি namespace যেন একটি “ফাইল”, মন্তব্যে লেখা আছে আসলে কোনটা কোথায় থাকত:

#include <format>
#include <print>
#include <string>
#include <vector>
namespace shop::money {                       // money.h + money.cpp
    inline constexpr int vat_percent = 15;
    struct Taka { long paisa = 0; };
    namespace { long percent_of(long v, int p) { return v * p / 100; } }
    Taka with_vat(Taka t) { return {t.paisa + percent_of(t.paisa, vat_percent)}; }
    std::string to_text(Taka t) { return std::format("{}.{:02} Tk", t.paisa / 100, t.paisa % 100); }
}
namespace shop::cart {                        // cart.h + cart.cpp
    money::Taka total(const std::vector<money::Taka>& prices) {
        money::Taka sum;
        for (const auto& p : prices) sum.paisa += p.paisa;
        return money::with_vat(sum);
    }
}
int main() {                                  // main.cpp
    std::vector<shop::money::Taka> prices{{7000}, {1550}};   // chal, dal
    std::println("Total: {}", to_text(shop::cart::total(prices)));   // ADL
}

৬ · One Definition Rule — multiple definition আর inline

Include guard দেওয়ার পরও একটি error অনেককে অবাক করে। ধরুন রাকিব ভাবলেন, “with_vat তো ছোট ফাংশন, আলাদা .cpp-র কী দরকার?” — আর পুরো দেহটাই money.h-এ লিখে দিলেন, inline ছাড়া। Compile ঠিকঠাক, কিন্তু link-এ গিয়ে ধাক্কা। কেন, তা বুঝতে C++-এর একটি মৌলিক নিয়ম জানতে হবে — One Definition Rule (ODR):

• সাধারণ (non-inline) ফাংশন আর ভ্যারিয়েবল: পুরো প্রোগ্রামে ঠিক একটি সংজ্ঞা।
• Class, template, inline ফাংশন ও ভ্যারিয়েবল: প্রতিটি translation unit-এ সর্বোচ্চ একটি, আর একাধিক ফাইলে থাকলে সবগুলো হুবহু এক হতে হবে।

#pragma once
namespace shop::money {
    struct Taka { long paisa = 0; };
    Taka with_vat(Taka t) {                 // দেহসহ, inline নয়!
        return {t.paisa + t.paisa * 15 / 100};
    }
}

$ g++ -std=c++23 -c money.cpp cart.cpp main.cpp     ; তিনটিই সফল
$ nm -C money.o cart.o main.o | grep with_vat
T shop::money::with_vat(shop::money::Taka)     ; money.o
T shop::money::with_vat(shop::money::Taka)     ; cart.o
T shop::money::with_vat(shop::money::Taka)     ; main.o

$ g++ money.o cart.o main.o -o shop
/usr/bin/ld: cart.o: in function `shop::money::with_vat(shop::money::Taka)':
cart.cpp:(.text+0x0): multiple definition of `shop::money::with_vat(shop::money::Taka)';
money.o:money.cpp:(.text+0x0): first defined here
collect2: error: ld returned 1 exit status

// money.h
Taka with_vat(Taka t);

// money.cpp
Taka with_vat(Taka t) { return {t.paisa + t.paisa * 15 / 100}; }

$ nm -C *.o | grep with_vat
T shop::money::with_vat(shop::money::Taka)      ; শুধু money.o
U shop::money::with_vat(shop::money::Taka)      ; cart.o চায়

// money.h
inline Taka with_vat(Taka t) { return {t.paisa + t.paisa * 15 / 100}; }

$ nm -C *.o | grep with_vat
W shop::money::with_vat(shop::money::Taka)      ; W = weak: একাধিক বৈধ,
W shop::money::with_vat(shop::money::Taka)      ; linker একটি রাখে
$ g++ money.o cart.o main.o -o shop               ; সফল

C++17-এর inline ভ্যারিয়েবল

একই সমস্যা ভ্যারিয়েবলেও। Header-এ int order_count = 0; লিখলে প্রতিটি .cpp-তে একটি সংজ্ঞা — আবার multiple definition. C++17-এর আগে একমাত্র পথ ছিল header-এ extern ঘোষণা আর একটি .cpp-তে সংজ্ঞা (অংশ ৭)। C++17 থেকে inline variable এসেছে: inline int order_count = 0; — header-এ থাকলেও পুরো প্রোগ্রামে একটাই ভ্যারিয়েবল। ধ্রুবকের জন্য inline constexpr int vat_percent = 15; লিখুন। (শুধু constexpr বা const লিখলেও namespace-এর স্তরে link error হয় না, কারণ সেগুলো নিজে থেকেই internal linkage পায় — তবে তখন প্রতিটি ফাইলে আলাদা কপি থাকে। inline constexpr দিলে সবাই একটাই বস্তু দেখে।)

৭ · extern, forward declaration আর compile সময় বাঁচানো

extern — “ভ্যারিয়েবলটা আছে, অন্য কোথাও”

ফাংশনের ঘোষণা আর সংজ্ঞা আলাদা করা সহজ — দেহ থাকলে সংজ্ঞা, না থাকলে ঘোষণা। ভ্যারিয়েবলে int order_count; নিজেই একটি সংজ্ঞা। শুধু ঘোষণা করতে চাইলে লাগে extern:

// stats.h
namespace shop::stats { extern int order_count; }    // ঘোষণা: জায়গা নেয় না

// stats.cpp
#include "stats.h"
namespace shop::stats { int order_count = 0; }       // একমাত্র সংজ্ঞা

// C++17 থেকে বিকল্প: stats.h-এ  inline int order_count = 0;

নতুন কোডে inline ভ্যারিয়েবল সাধারণত সহজ। তবে মনে রাখুন — যেকোনো উপায়েই পরিবর্তনশীল global ভ্যারিয়েবল সব ফাইল থেকে বদলানো যায়, তাই ভুল খুঁজতে কঠিন। ভালো ডিজাইনে এমন জিনিস কোনো class-এর ভেতরে লুকানো থাকে (পর্ব ২০)।

Forward declaration — পুরো header না টেনে শুধু নামটা

অংশ ৫-এ দেখেছেন, header বদলালে যত ফাইল সেটা include করে, সবাই আবার compile হয়। বড় প্রজেক্টে একটি জনপ্রিয় header বদলানো মানে হাজার ফাইলের build. তাই অভিজ্ঞরা header-এ যতটা সম্ভব কম #include রাখেন। প্রধান হাতিয়ার forward declaration:

// receipt.h
#pragma once
namespace shop::cart { struct Item; }           // forward declaration: "Item নামে একটি টাইপ আছে"

namespace shop::receipt {
    void print_line(const cart::Item& item);     // reference-এর জন্য পুরো সংজ্ঞা লাগে না
}
// receipt.cpp-তে #include "cart.h" — সেখানে সদস্য ব্যবহার করতে পুরো সংজ্ঞা লাগবে

Compiler-এর কাছে শুধু নামটা জানা টাইপকে বলে incomplete type. এর reference বা pointer রাখা যায়, ফাংশনের ঘোষণায় parameter হিসেবে লেখা যায় — কিন্তু তার আকার জানা নেই, তাই সদস্য পড়া, object বানানো বা by-value সদস্য হিসেবে রাখা যায় না। ফলে receipt.h এখন cart.h-এর ওপর নির্ভর করে না: cart.h বদলালে receipt.h include করা ফাইলগুলো আর আবার compile হবে না। একটি সতর্কতা: std-এর নিজের টাইপ (যেমন std::string) নিজে forward declare করা নিষেধ — std namespace-এ কিছু যোগ করা undefined behavior. Stream-এর জন্য standard library নিজেই <iosfwd> দেয়।

৮ · সামনের পথ — C++20 modules আর import std;

এই পর্বের প্রায় সব সমস্যা — guard ভুলে যাওয়া, ODR, ধীর build, header-এর using ছড়িয়ে পড়া — একই উৎস থেকে আসে: #include হলো লেখা কপি করা। ১৯৭০-এর দশকের C থেকে আসা এই ব্যবস্থার পূর্ণ বিকল্প হিসেবে C++20-এ এসেছে modules. এক ঝলকে কেমন দেখায়:

// money.cppm — module interface (এক্সটেনশন compiler-ভেদে আলাদা: .cppm, .ixx …)
export module shop.money;                       // "এই ফাইল shop.money module"

export namespace shop::money {                   // শুধু export করা জিনিস বাইরে দেখা যায়
    struct Taka { long paisa = 0; };
    Taka with_vat(Taka t) { return {t.paisa + t.paisa * 15 / 100}; }
}

// main.cpp
import shop.money;                              // কপি নয়: আগে তৈরি interface পড়া
import std;                                     // C++23: পুরো standard library এক লাইনে

• একবার compile, বহুবার ব্যবহার: module একবার compile হয়ে একটি বাইনারি interface ফাইল বানায়; import সেটাই পড়ে, লেখা আবার বিশ্লেষণ করে না।
• Guard লাগে না: একই module দুবার import করলেও সমস্যা নেই।
• লুকানো থাকে লুকানো: export না করা জিনিস আর module-এর ভেতরের macro বাইরে যায় না — header-এর মতো ছড়িয়ে পড়ে না।
• import std; C++23 standard-এ যোগ হয়েছে (C++20-এ ছিল না)। নতুন MSVC, Clang আর GCC-র সাম্প্রতিক version-এ চালানো যায়, তবে প্রায়ই বাড়তি flag বা build system-এর সাহায্য লাগে।

তাহলে এই পর্বের header কেন শিখলেন? কারণ পৃথিবীর বেশিরভাগ C++ কোড — এবং প্রায় সব library — এখনো header-ভিত্তিক, আর modules-এর জন্য compiler ও build system-এর সমর্থন ধীরে ধীরে পরিপক্ব হচ্ছে। এই কোর্সের কোড তাই header দিয়েই চলবে; modules-এর বিস্তারিত দেখবেন পর্ব ৪২-এ, আর CMake-এ বড় প্রজেক্ট সাজানো পর্ব ৪৭-এ।

৯ · AI-এর যুগে — AI-এর লেখা header যাচাই

“আমার প্রজেক্টটা কয়েকটা ফাইলে ভাগ করে দাও” — AI-কে এমন বললে সে দ্রুত সুন্দর দেখতে কয়েকটি ফাইল দেয়। কিন্তু AI ইন্টারনেটের অগণিত ছোট উদাহরণ থেকে শিখেছে, যেখানে সব কিছু এক ফাইলে, আর using namespace std; সবার ওপরে। সেই অভ্যাস header-এ এলেই সমস্যা। প্রোগ্রাম আজ হয়তো চলবে, কিন্তু দ্বিতীয় .cpp যোগ করার দিন বা কাউকে library হিসেবে দেওয়ার দিন ভাঙবে।

AI সাধারণত header-এ যেসব ভুল করে

AI-এর ভাগ করা প্রজেক্ট হাতে পেলে — চেকলিস্ট

• প্রতিটি .h ফাইলে #pragma once বা সঠিক নামের include guard আছে
• কোনো header-এ using namespace নেই — global অংশে তো নয়ই
• header-এ দেহসহ প্রতিটি সাধারণ ফাংশন inline, constexpr, template, বা class-এর ভেতরে লেখা
• header-এ কোনো ভ্যারিয়েবল থাকলে তা inline, constexpr, বা extern ঘোষণা
• প্রতিটি .cpp আলাদাভাবে -c দিয়ে compile হয় (header-এর #include ঠিক আছে তার প্রমাণ), আর link-এ multiple definition বা undefined reference নেই
• সহকারী ফাংশনগুলো anonymous namespace বা static-এ, আর প্রজেক্টের সব কিছু নিজের namespace-এ