class template — নিজের জেনেরিক টাইপ বানানো

১ · একই নকশা, ভিন্ন টাইপ — class template কেন

পর্ব ১৩ থেকে আপনি নিয়মিত std::vector ব্যবহার করছেন। কখনো std::vector<int>-এ নম্বর রেখেছেন, কখনো std::vector<std::string>-এ নাম। একবার ভাবুন: standard library-র লেখকেরা কি int-এর জন্য একটি vector, string-এর জন্য আরেকটি, আর আপনার নিজের Student টাইপের জন্য আরও একটি আলাদা করে লিখে রেখেছেন? অসম্ভব — আপনার Student টাইপ তাঁরা চেনেনই না। তাঁরা লিখেছেন একটিমাত্র নকশা, যেখানে উপাদানের টাইপের জায়গাটি ফাঁকা। আপনি <int> লিখে সেই ফাঁকা জায়গা পূরণ করেন, আর compiler তখন int-এর জন্য একটি পুরো class তৈরি করে নেয়।

পর্ব ২৮-এ আপনি একই ধারণা ফাংশনের জন্য দেখেছেন — largest<T>-এর মতো function template, compiler-এর টাইপ বুঝে নেওয়া (deduction), আর প্রতিটি টাইপের জন্য আলাদা সংস্করণ তৈরি হওয়া (instantiation). আজ সেই একই যন্ত্র — template — class-এ। যে template থেকে পুরো একটি class তৈরি হয়, তাকে বলে class template. std::vector, std::array, std::pair, std::optional, std::map — standard library-র প্রায় প্রতিটি container আর সহায়ক টাইপ আসলে class template. এই পর্ব শেষে আপনি নিজের এমন টাইপ লিখতে পারবেন।

একটি বাস্তব উদাহরণ নিন। আপনি একটি দোকানের স্টক রাখার সফটওয়্যার লিখছেন — মোবাইল ফোনের দোকানেও চলবে, শাড়ির দোকানেও। দুই জায়গায় কাজ একই: পণ্য যোগ করা, গোনা, খোঁজা। শুধু “পণ্য” জিনিসটি আলাদা। template ছাড়া আপনাকে PhoneInventory আর SareeInventory নামে দুটি প্রায় হুবহু class লিখতে হতো — আর একটিতে বাগ সারালে অন্যটিতে ভুলে যাওয়ার ঝুঁকি থাকত। template দিয়ে একবারই লেখা যায়:

template <typename Item>              // Item = যেকোনো পণ্যের টাইপ
class Inventory {
    std::vector<Item> items_;
public:
    void add(const Item& it) { items_.push_back(it); }
    std::size_t count() const { return items_.size(); }
};

Inventory<Phone> phones;               // মোবাইলের দোকান
Inventory<Saree> sarees;               // শাড়ির দোকান

প্রথম লাইনের template <typename Item> বলে: “এর পরের class-টি একটি নকশা, আর এতে Item নামে একটি টাইপের ফাঁকা জায়গা আছে।” Item-কে বলে template parameter. Inventory<Phone> লিখলে Phone হলো template argument — ফাঁকা জায়গায় যা বসানো হলো। পর্ব ২৮-এর মতোই typename-এর বদলে class লেখাও চলে; দুটির অর্থ এখানে হুবহু এক।

২ · প্রথম class template — নির্দিষ্ট মাপের Stack<T, N>

stack হলো এমন একটি পাত্র, যেখানে শেষে যা রাখা হয়, সবার আগে সেটিই বের হয় — হোটেলের রান্নাঘরে ধোয়া প্লেটের স্তূপের মতো। আমরা একটি ছোট stack বানাব, যার সর্বোচ্চ ধারণক্ষমতা আগে থেকেই ঠিক করা, তাই heap-এর মেমরি লাগবে না। ভেতরে থাকবে একটি std::array. দুটি template parameter: উপাদানের টাইপ T, আর ধারণক্ষমতা N — একটি সংখ্যা। একটি member function লেখা হয়েছে class-এর ভেতরে, আরেকটি বাইরে, যাতে দুটি নিয়মই চোখে পড়ে:

#include <array>
#include <print>
#include <string>

template <typename T, std::size_t N = 4>          // N has a default value
class Stack {
    std::array<T, N> data_{};
    std::size_t size_ = 0;
public:
    void push(const T& v) { data_[size_++] = v; }  // defined inside the class
    T pop();                                       // only declared here
    bool empty() const { return size_ == 0; }
};

template <typename T, std::size_t N>               // defined outside the class
T Stack<T, N>::pop() { return data_[--size_]; }

int main() {
    Stack<int> a;                                  // means Stack<int, 4>
    for (int i = 1; i <= 4; ++i) a.push(i * 10);
    Stack<std::string, 2> b;
    b.push("bKash"); b.push("Nagad");
    while (!a.empty()) std::print("{} ", a.pop());
    while (!b.empty()) std::print("{} ", b.pop());
}

বাইরে member function লেখার ব্যাকরণ

বাইরের সংজ্ঞাটি ভেঙে পড়ুন: template <typename T, std::size_t N> — “এটিও একটি নকশার অংশ, এই দুটি parameter-সহ।” তারপর ফেরত-টাইপ T. তারপর Stack<T, N>::pop — “Stack-এর এই নির্দিষ্ট রূপের pop.” শুধু Stack::pop লিখলে চলবে না, কারণ Stack একা কোনো class নয়, একটি নকশার নাম। আর default মান (= 4) বাইরের সংজ্ঞায় আবার লেখা যায় না — সেটি শুধু প্রথম ঘোষণায় থাকে। class-এর ভেতরে অবশ্য শুধু Stack লিখলেই compiler বোঝে Stack<T, N>, যেমন একটি copy constructor Stack(const Stack&) লিখতে চাইলে।

প্রতিটি টাইপ, একটি নতুন class

উপরের main-এ compiler আসলে কী করল, ধাপে ধাপে দেখুন। প্রতিটি ধাপে আগে নিজে অনুমান করুন:

1template <typename T, std::size_t N = 4> class Stack {...};2Stack<int> a;3Stack<std::string, 2> b;4a.push(10);   b.pop();5a = b;        // ?

৩ · টাইপ নিজে বুঝে নেওয়া — CTAD আর default template argument

পর্ব ২৮-এ দেখেছেন, function template-এ argument দেখে compiler নিজেই T বুঝে নেয় — largest(3, 7) লিখলেই চলে, largest<int>(3, 7) লিখতে হয় না। কিন্তু C++14 পর্যন্ত class template-এ এই সুবিধা ছিল না। std::pair বানাতে লিখতে হতো std::pair<int, double> p(1, 2.5);, অথবা টাইপ বুঝে নেওয়ার জন্য একটি সহায়ক ফাংশন ডাকতে হতো — std::make_pair(1, 2.5). C++17 থেকে class-এর ক্ষেত্রেও compiler constructor-এর argument দেখে template argument বুঝে নেয়। একে বলে CTAD — class template argument deduction.

std::pair p{1, 2.5};          // C++17: std::pair<int, double>
std::vector v{3, 1, 4};       // std::vector<int>
std::array a{1, 2, 3};        // std::array<int, 3> — N-ও বুঝে নেয়
std::optional o{42};          // std::optional<int>

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

pair-এর একটি constructor:   pair(const T1& x, const T2& y)

argument:   1     → int     ⇒ T1 = int
            2.5   → double  ⇒ T2 = double

ফল:  std::pair<int, double> p{1, 2.5};

{3, 1, 4}  → std::initializer_list<int>
vector(std::initializer_list<T>)  ⇒ T = int

ফল:  std::vector<int>   (৩টি উপাদান)
একইভাবে std::array a{1, 2, 3} → std::array<int, 3>

template <typename T>
struct Box { T value; Box(T v) : value(v) {} };

Box b{"bKash"};
// "bKash" হলো const char[6]; by-value প্যারামিটারে
// array ভেঙে pointer হয়  ⇒ T = const char*
// ফল: Box<const char*> — std::string নয়!

Box(const char*) -> Box<std::string>;   // class-এর বাইরে, একই namespace-এ

Box b{"bKash"};    // এবার Box<std::string>
Box n{7};          // guide খাটে না ⇒ আগের মতো Box<int>

Default template argument — সাধারণ পছন্দ আগে থেকেই দেওয়া

ফাংশনের default argument-এর মতো template parameter-এরও default মান দেওয়া যায় — উপরের Stack-এ N = 4 যেমন। একে বলে default template argument. টাইপ parameter-এরও default হয়। আপনি প্রতিদিন না জেনেই এটি ব্যবহার করছেন: standard-এ std::vector-এর ঘোষণা আসলে এরকম —

template <class T, class Allocator = std::allocator<T>>
class vector;                       // মেমরি কোথা থেকে আসবে — default: সাধারণ heap

template <class T>
class optional;                     // C++17: হয় একটি T, নয়তো কিছুই না

std::vector<int> লিখলে দ্বিতীয় argument নিজে বসে যায়। খুব বিশেষ ক্ষেত্রে — যেমন embedded সিস্টেমে নির্দিষ্ট মেমরি-এলাকা থেকে জায়গা নিতে — নিজের allocator দেওয়া যায়, বাকি সবাই সেটি কখনো দেখেনই না। ভালো default মানে: সাধারণ ব্যবহারকারীর কাছে সরল, বিশেষজ্ঞের কাছে নমনীয়।

এবার নিজের একটি উদাহরণ। কোনো কাজ সফল হলে একটি মান, ব্যর্থ হলে একটি ভুলের বিবরণ ফেরত দিতে চান — যেমন একটি দোকানের অর্ডার-খোঁজা ফাংশন। একটি ছোট Result-ধাঁচের জোড়া বানানো যায়, যেখানে ভুলের টাইপ সাধারণত string:

template <typename Value, typename Error = std::string>
struct Result {
    Value value{};
    Error error{};                          // খালি = কোনো ভুল নেই
    bool ok() const { return error == Error{}; }
};

Result<int> found{42};                      // Error = std::string (default)
Result<int> missing{0, "order not found"};
Result<double, int> http{0.0, 404};          // নিজের পছন্দের Error টাইপ

এটি শেখার জন্য একটি সরল নকশা — এখানে “ভুল নেই” বোঝাতে খালি মান ব্যবহার করা হয়েছে, যা সব Error টাইপের জন্য যুক্তিসংগত নয়। আসল কাজের জন্য C++23-এ standard library-তেই এসেছে std::expected<T, E>, যা পর্ব ৩৭-এ দেখবেন। কিন্তু সেটিও ঠিক এই রকমই একটি class template.

৪ · Non-type parameter — sensor-এর জন্য RingBuffer<T, N>

template parameter সবসময় টাইপ হয় না। Stack-এর N একটি সংখ্যা — একে বলে non-type template parameter. পর্ব ২৮-এ ফাংশনের জন্য এটি দেখেছেন; class-এ এর আসল শক্তি দেখা যায়, কারণ মাপটি টাইপেরই অংশ হয়ে যায়। std::array<int, 5> আর std::array<int, 6> দুটি আলাদা টাইপ — তাই ভুল মাপের array ভুল ফাংশনে পাঠালে compiler তখনই ধরে।

একটি বাস্তব প্রয়োজন: একটি কারখানার তাপমাত্রা sensor প্রতি সেকেন্ডে একটি রিডিং দেয়, আর আপনার কাছে দরকার শুধু শেষ ৬০টি রিডিং — পুরোনোগুলো বাদ যাবে। এর জন্য আদর্শ গঠন হলো ring buffer: নির্দিষ্ট মাপের একটি array, যেখানে শেষ ঘরের পরে লেখা আবার প্রথম ঘরে ফিরে যায়, আর সবচেয়ে পুরোনো রিডিংয়ের ওপর নতুনটি বসে। মেট্রো রেলের ঘূর্ণায়মান টার্নস্টাইলের মতো — ঘর সীমিত, ঘুরে ঘুরে ব্যবহার হয়।

template <typename T, std::size_t N>
class RingBuffer {
    static_assert(N > 0, "RingBuffer needs at least one slot");
    std::array<T, N> buf_{};
    std::size_t head_ = 0, count_ = 0;
public:
    void add(const T& x) {
        buf_[head_] = x;                    // সবচেয়ে পুরোনোটির ওপর লেখা
        head_ = (head_ + 1) % N;            // শেষের পরে আবার ০
        if (count_ < N) ++count_;
    }
    std::size_t size() const { return count_; }
    static constexpr std::size_t capacity() { return N; }
};

RingBuffer<double, 60> temperature;         // শেষ ৬০টি তাপমাত্রা
RingBuffer<int, 8> pulse;                   // শেষ ৮টি হৃৎস্পন্দন

এখানে তিনটি জিনিস খেয়াল করার মতো। এক, N compile-এর সময়ই জানা, তাই মেমরি পুরোপুরি object-এর ভেতরে — কোনো new নেই, heap নেই। ছোট microcontroller-এ, যেখানে heap ব্যবহার এড়ানো হয়, এটা বড় সুবিধা। দুই, static_assert compile-এর সময়েই একটি নিয়ম যাচাই করে: RingBuffer<int, 0> লিখলে প্রোগ্রাম compile-ই হবে না — নইলে % 0 চলার সময় undefined behavior ঘটাত। তিন, capacity() একটি static constexpr ফাংশন: object ছাড়াই RingBuffer<int, 8>::capacity() ডাকা যায়, কারণ উত্তর টাইপের মধ্যেই লেখা।

কোন মান non-type parameter হতে পারে? সবচেয়ে প্রচলিত হলো পূর্ণসংখ্যা (int, std::size_t), bool, enum, আর pointer. শর্ত একটাই: মানটি compile-এর সময় জানা থাকতে হবে। int n; std::cin >> n; RingBuffer<int, n> r; চলবে না — ব্যবহারকারী কত দেবেন, compiler তা জানে না। C++20 থেকে double আর কিছু সরল struct-ও non-type parameter হতে পারে, তবে শুরুতে সংখ্যাই যথেষ্ট। মাপ যদি চলার সময় ঠিক হয়, তাহলে template নয়, std::vector ব্যবহার করুন।

৫ · Specialization — বিশেষ টাইপের জন্য বিশেষ সংস্করণ

কখনো একটি নকশা প্রায় সব টাইপের জন্য ঠিক, কিন্তু একটি বা এক দল টাইপের জন্য আলাদা কিছু দরকার। ধরুন Storage<T> নামে একটি পাত্র অনেকগুলো মান রাখে। bool-এর ক্ষেত্রে প্রতিটি মান রাখতে একটি পুরো বাইট (৮ বিট) খরচ করা অপচয় — একটি বিটেই হয়ে যায়। আবার pointer রাখলে হয়তো আপনি জানতে চান, pointer-গুলো null কি না। এর জন্য C++ দেয় template specialization: নির্দিষ্ট argument-এর জন্য নকশার একটি সম্পূর্ণ আলাদা সংস্করণ লেখা।

মূল সংস্করণটিকে বলে primary template. ঠিক একটি টাইপের জন্য লেখা সংস্করণকে বলে full (explicit) specialization, আর একটি ধাঁচের জন্য লেখাকে partial specialization. ছোট একটি প্রোগ্রামে দেখুন, compiler কোন অনুরোধে কোন সংস্করণ বেছে নেয়:

#include <print>

template <typename T>                 // primary template
struct Storage { static constexpr const char* kind = "generic, 1 slot per value"; };

template <typename T>                 // partial specialization: any pointer
struct Storage<T*> { static constexpr const char* kind = "pointer, null-checked"; };

template <>                           // full specialization: exactly bool
struct Storage<bool> { static constexpr const char* kind = "bool, packed bits"; };

int main() {
    std::println("Storage<int>     : {}", Storage<int>::kind);
    std::println("Storage<double*> : {}", Storage<double*>::kind);
    std::println("Storage<bool>    : {}", Storage<bool>::kind);
    std::println("Storage<bool*>   : {}", Storage<bool*>::kind);
}

Storage<bool*>-এর জন্য compiler ঠিক কীভাবে ভাবল, ধাপে ধাপে দেখুন:

template <typename T> struct Storage        { ... };   // primary
template <typename T> struct Storage<T*>    { ... };   // partial
template <>           struct Storage<bool>  { ... };   // full

অনুরোধ:  Storage<bool*>

চাওয়া হয়েছে:  bool*
আছে:          bool
bool* ≠ bool  ⇒  এই সংস্করণ বাদ

ধাঁচ:          T*
চাওয়া হয়েছে:  bool*
T = bool ধরলে  T* = bool*  ⇒  মেলে

ধাঁচ:  T     (যেকোনো টাইপ)
T = bool* ধরলে মেলে — কিন্তু এটি সবচেয়ে সাধারণ নকশা।
অন্য কোনো specialization মিললে primary পেছনে পড়ে।

T*  শুধু pointer-এর সাথে মেলে
T   সবকিছুর সাথে মেলে
⇒ T* বেশি নির্দিষ্ট  ⇒  Storage<T*> with T = bool

আউটপুট:  Storage<bool*>   : pointer, null-checked

দুটি জরুরি নিয়ম

প্রথম নিয়ম: specialization কিছুই “উত্তরাধিকারে” পায় না। Storage<bool> একটি সম্পূর্ণ নতুন class. primary-তে যত member function আছে, তার একটিও এখানে আপনা-আপনি আসে না — সব আবার লিখতে হয়। তাই একটি ফাংশন বাদ পড়লে Storage<int>-এর সাথে যে generic কোড চলত, Storage<bool>-এ সেটি হঠাৎ compile হবে না। আরও খারাপ: ফাংশনের নাম একই রেখে আচরণ বদলে দিলে compile হবে, কিন্তু ব্যবহারকারীর প্রত্যাশা ভাঙবে। দ্বিতীয় নিয়ম: partial specialization শুধু class template-এর (আর variable template-এর) জন্য। function template-কে partially specialize করা যায় না; সেখানে overloading ব্যবহার করুন (পর্ব ২৮)। standard library-র <type_traits>-এর অনেক type trait — যেমন একটি টাইপ pointer কি না জানার std::is_pointer — ঠিক এই Storage<T*>-এর কৌশলেই লেখা।

সতর্কবার্তা হিসেবে std::vector<bool>

C++98-এর standard library ঠিক এই Storage<bool>-এর বুদ্ধিটি কাজে লাগিয়েছিল: std::vector<bool> একটি full specialization, যা প্রতিটি bool একটি বিটে রাখে — মেমরিতে আট গুণ সাশ্রয়। কিন্তু একটি বিটের কোনো নিজস্ব ঠিকানা নেই, তাই v[0] একটি আসল bool& ফেরত দিতে পারে না। ফেরত দেয় একটি proxy object — দেখতে bool-এর মতো, আসলে একটি ছোট সহকারী object, যে জানে কোন বাইটের কোন বিট বদলাতে হবে।

std::vector<int>  vi{1, 2};   int&  ri = vi[0];   // ঠিক
std::vector<bool> vb{true};   bool& rb = vb[0];   // compile error: bool& নয়, proxy
auto x = vb[0];                // x একটি proxy — vb বদলালে x-ও বদলায়!
bool* p = &vb[0];              // compile error: বিটের ঠিকানা নেই

অর্থাৎ যে generic কোড যেকোনো std::vector<T>-এর সাথে কাজ করে বলে লেখা, T = bool হলে সেটি ভেঙে যেতে পারে। একটি container-এর যে মৌলিক প্রতিশ্রুতি — “v[i] দিলে উপাদানের আসল reference পাবেন” — specialization সেটিই ভেঙেছে। এ কারণে অনেক বিশেষজ্ঞ একে standard library-র একটি অনুশোচনার নকশা বলেন (ভাবনার প্রশ্ন ১-এ বিস্তারিত)। শিক্ষাটা আপনার নিজের কোডের জন্য: specialization শুধু ভেতরের বাস্তবায়ন বদলাবে, বাইরের আচরণ আর প্রতিশ্রুতি নয়। সবচেয়ে বেশি দরকারি নিয়ম, অর্থাৎ invariant, সব সংস্করণে এক থাকতে হবে। বিটে bool রাখতে চাইলে আলাদা নামের টাইপ নিন — যেমন std::bitset<N>.

৬ · using, alias template, static member আর Rule of Zero

লম্বা টাইপের ছোট নাম

template-এর টাইপ দ্রুত লম্বা হয়ে যায়: std::vector<std::vector<int>>, বা RingBuffer<double, 60>. বারবার লিখলে কোড পড়া কঠিন হয়, আর মাপ বদলাতে চাইলে দশ জায়গায় বদলাতে হয়। using দিয়ে একটি টাইপের দ্বিতীয় নাম দেওয়া যায় — একে বলে type alias. আর using-এর সামনে template লাইন বসালে পাওয়া যায় alias template — এমন ডাকনাম, যার নিজেরই একটি ফাঁকা জায়গা আছে:

using Taka = long long;                         // type alias
using MinuteLog = RingBuffer<double, 60>;       // মাপ বদলাতে হলে শুধু এখানে

template <typename T>
using Grid = std::vector<std::vector<T>>;      // alias template
Grid<int>  board(3, std::vector<int>(3));      // ৩×৩ বোর্ড
Grid<char> seats;                               // বাসের সিটের নকশা

template <typename T>
using Readings = RingBuffer<T, 60>;             // টাইপ খোলা, মাপ স্থির

alias কোনো নতুন টাইপ তৈরি করে না — Taka আর long long হুবহু একই টাইপ, একটির জায়গায় অন্যটি নির্দ্বিধায় চলে। এটি শুধু পড়ার সুবিধা আর একটি জায়গায় সিদ্ধান্ত রাখার উপায়। C-এর typedef-ও alias বানায়, কিন্তু typedef-এর সামনে template বসানো যায় না; alias template C++11-এর using-এরই সুবিধা। আধুনিক কোডে তাই using-ই লিখুন।

class template-এর ভেতরেও alias খুব প্রচলিত। standard container-গুলো জানিয়ে দেয় তাদের উপাদানের টাইপ কী — std::vector<int>::value_type হলো int. আপনার Stack-এও লিখতে পারেন using value_type = T;. এতে অন্য generic কোড আপনার container-কে জিজ্ঞেস করতে পারে, “ভেতরে কী আছে?” — ঠিক এই প্রশ্নই ৮ নম্বর অংশের typename-এর ফাঁদে ফিরে আসবে।

static member — প্রতিটি instantiation-এর নিজের

পর্ব ২০-এ দেখেছেন, static member class-এর সব object ভাগ করে নেয় — পুরো প্রোগ্রামে একটিই কপি। class template-এ একটি সূক্ষ্ম কিন্তু যুক্তিসংগত পার্থক্য আছে: যেহেতু প্রতিটি instantiation একটি আলাদা class, প্রত্যেকের static member-ও আলাদা।

template <typename T>
struct Counter {
    inline static int created = 0;      // C++17: header-এই সংজ্ঞা
    Counter() { ++created; }
};

Counter<int> a, b;
Counter<double> c;
// Counter<int>::created == 2,  Counter<double>::created == 1

Counter<int> আর Counter<double> দুটি আলাদা class, তাই তাদের created দুটি আলাদা ভ্যারিয়েবল — কেউ কারও হিসাব জানে না। ঢাকা আর চট্টগ্রামের দুটি শাখা-অফিস একই নিয়মের খাতা ব্যবহার করে, কিন্তু প্রত্যেকের খাতার পাতা আলাদা। এর মানে: সব টাইপ মিলিয়ে একটি সাধারণ গণনা চাইলে template-এর ভেতরের static member দিয়ে হবে না — একটি সাধারণ, non-template base class-এ রাখতে হবে, বা template-এর বাইরে। inline static (C++17) থাকায় এখন আর আলাদা .cpp ফাইলে static member-এর সংজ্ঞা লিখতে হয় না।

template আর Rule of Zero — একসাথে খুব ভালো কাজ করে

পর্ব ২২-এ শিখেছেন Rule of Zero: রিসোর্স রাখুন std::vector, std::string বা std::unique_ptr-এর মতো member-এ, আর নিজের class-এ destructor, copy বা move নিজে লিখবেন না। class template-এ এই নিয়ম আরও বেশি দামি। আমাদের Stack বা RingBuffer-এ কোনো special member function লেখা হয়নি, তবু প্রতিটি T-এর জন্য compiler ঠিক আচরণ তৈরি করে নেয়। T = std::string হলে কপিতে প্রতিটি string কপি হয়। আর T = std::unique_ptr<int> হলে? unique_ptr কপি করা যায় না, তাই Stack<std::unique_ptr<int>>-এর copy constructor নিজে থেকেই deleted হয়ে যায়, কিন্তু move ঠিকই কাজ করে। একটি অক্ষরও না লিখে আপনার template প্রতিটি টাইপের নিয়ম মেনে চলে।

উল্টোটা ভাবুন: আপনি যদি হাতে new T[N] করে নিজের destructor আর copy constructor লিখতেন, তাহলে প্রতিটি সম্ভাব্য T-এর জন্য সেগুলো ঠিক আছে কি না, আপনাকে নিজেকেই ভাবতে হতো — exception ছুড়লে কী হবে, move-only টাইপ এলে কী হবে, কপি মাঝপথে ব্যর্থ হলে কী হবে। standard library-র লেখকেরা ঠিক এই কাজে বছরের পর বছর ব্যয় করেছেন। তাঁদের সেই কাজ member হিসেবে ধার নিন, নিজে আবার লিখবেন না।

৭ · Variadic template আর fold expression — যত খুশি argument

এ পর্যন্ত প্রতিটি template-এর parameter-এর সংখ্যা ছিল নির্দিষ্ট — একটি T, বা T আর N. কিন্তু std::tuple যেকোনো সংখ্যক মান রাখে: std::tuple<int, std::string, double>, আবার std::tuple<char>. আর std::make_unique আপনার টাইপের constructor-এ যতগুলো argument দরকার, সবগুলো পৌঁছে দেয়। এটি সম্ভব হয় variadic template-এর কারণে — যে template যত খুশি template argument নিতে পারে। এটি এসেছে C++11-এ।

মূল যন্ত্রটির নাম parameter pack: তিনটি বিন্দু (...) দিয়ে লেখা একটি “ব্যাগ”, যার ভেতরে শূন্য বা তার বেশি টাইপ বা মান। typename... Args হলো টাইপের ব্যাগ, Args... args হলো মানের ব্যাগ। ব্যাগে কয়টি জিনিস আছে, জানা যায় sizeof...(Args) দিয়ে। আর ব্যাগ খুলে প্রতিটি জিনিসের ওপর একই কাজ করার সবচেয়ে সহজ উপায় C++17-এর fold expression:

template <typename... Args>
void print_all(const Args&... args) {
    (std::print("{} ", args), ...);        // fold expression
    std::println("");
}

print_all(1, "two", 3.5);                  // 1 two 3.5
print_all("Dhaka");                        // Dhaka

(std::print("{} ", args), ...) লাইনের অর্থ: “ব্যাগের প্রতিটি args-এর জন্য বাঁ দিকের কাজটি করো, আর মাঝে comma operator বসিয়ে এগুলো জুড়ে দাও।” comma operator বাঁ থেকে ডানে ক্রমানুসারে চলে, তাই মানগুলো ঠিক ক্রমেই ছাপা হয়। compiler এই এক লাইনকে কীভাবে খুলে দেয়, দেখুন:

1template <typename... Args>2void print_all(const Args&... args) {3    (std::print("{} ", args), ...);4}5print_all(1, "two", 3.5);

এখানেই থামুন — variadic template-এর আরও গভীর কৌশল (perfect forwarding, recursion দিয়ে ব্যাগ খোলা) মূলত লাইব্রেরি-লেখকদের কাজ। আপনার জন্য মূল উপলব্ধি হলো: std::tuple, std::make_unique, emplace_back, std::format — এগুলো কীভাবে “যত খুশি argument” নেয়, এখন আপনি তা জানেন।

৮ · ঘরোয়া ফাঁদ — typename, header আর দীর্ঘ error

dependent name আর typename শব্দ

ধরুন আপনি একটি ফাংশন লিখছেন, যা যেকোনো container-এর প্রথম উপাদান ছাপে। উপাদানের টাইপ জানতে container-কে জিজ্ঞেস করবেন — C::value_type:

template <typename C>
void show_first(const C& c) {
    C::value_type x = c.front();           // error!
    typename C::value_type y = c.front();  // ঠিক
    std::println("{}", y);
}
// GCC: need 'typename' before 'C::value_type'
//      because 'C' is a dependent scope

কেন? template-এর ভেতরে C কী হবে, compiler তা জানে না। C::value_type একটি টাইপও হতে পারে, আবার কোনো static ভ্যারিয়েবলও হতে পারে — C-এর ওপর নির্ভর করে। এমন নামকে বলে dependent name. নিয়ম হলো: অনিশ্চিত হলে compiler ধরে নেয় এটি টাইপ নয়, একটি মান। তাই টাইপ বোঝাতে চাইলে সামনে typename লিখে নিশ্চিত করতে হয়। মনে রাখার সহজ উপায়: template parameter-এর ভেতর থেকে :: দিয়ে কোনো টাইপ বের করলে সামনে typename. C++20 এই নিয়ম কিছু জায়গায় শিথিল করেছে (যেমন using-এর ডান দিকে), কিন্তু ফাংশনের ভেতরের ঘোষণায় আজও লাগে। আর বেশিরভাগ ক্ষেত্রে auto x = c.front(); লিখলে প্রশ্নটাই ওঠে না।

সংজ্ঞা header-এ — নইলে linker error

পর্ব ১১-এ শিখেছেন, সাধারণ class-এর ঘোষণা header file-এ আর সংজ্ঞা .cpp ফাইলে রাখা ভালো অভ্যাস। template-এ এই অভ্যাস মানলে বিপদ। কারণটা instantiation-এর নিয়মেই লুকানো: Stack<int>::pop-এর কোড তৈরি করতে compiler-এর হাতে pop-এর পুরো সংজ্ঞা আর T = int — দুটিই একসাথে থাকা চাই। stack.cpp compile হওয়ার সময় সংজ্ঞা আছে, কিন্তু কেউ সেখানে Stack<int> চায়নি — তাই কিছু তৈরি হয় না। main.cpp compile হওয়ার সময় Stack<int> চাওয়া হলো, কিন্তু সেখানে শুধু ঘোষণা আছে, সংজ্ঞা নেই — তাই compiler ধরে নেয় অন্য কোথাও আছে। শেষে জোড়া দিতে গিয়ে linker কোথাও পায় না:

/usr/bin/ld: main.o: in function `main':
main.cpp:(.text+0x2a): undefined reference to `Stack<int, 4ul>::pop()'
collect2: error: ld returned 1 exit status

এটি একটি ক্লাসিক linker error. সমাধান: template-এর পুরো সংজ্ঞা — class-এর ভেতরের হোক বা বাইরের — header-এই রাখুন। standard library-র প্রায় সব template এভাবেই header-এ থাকে। বিকল্প একটি পথ আছে, যখন আপনি আগেই জানেন কোন কোন টাইপ লাগবে: .cpp ফাইলে template class Stack<int>; লিখে সেই টাইপের জন্য জোর করে কোড তৈরি করানো। একে বলে explicit instantiation. বড় প্রজেক্টে compile-এর সময় কমাতে এটি কাজে লাগে, কিন্তু অজানা টাইপের ব্যবহারকারীর জন্য এটি চলে না।

error message-এর পাহাড়

template-এ ভুল হলে compiler প্রায়ই কয়েক ডজন লাইনের error দেয়, কারণ সে দেখায় কোন instantiation-এর ভেতরে কোন instantiation-এর ভেতরে ভুলটি ঘটেছে। ভয় পাবেন না, পড়ার কৌশলটা জানুন: প্রথম error: লাইনটি খুঁজুন, তারপর “required from here” লেখা লাইনগুলোর মধ্যে আপনার নিজের ফাইলের লাইনটি খুঁজুন — সেখানেই আপনি template-টিকে ভুল টাইপ দিয়ে ডেকেছেন। template-এর শর্ত শুরুতেই স্পষ্ট করে লেখার উপায় C++20-এর concepts, যা পর্ব ৪০-এ দেখবেন; তখন error message-ও অনেক ছোট আর পরিষ্কার হয়।

৯ · AI-এর যুগে — template-কোডের ভুল ধরা

AI টুল template লিখতে খুব আগ্রহী। “এটা generic করে দাও” বললেই সে প্রতিটি class-এর সামনে template <typename T> বসিয়ে দেয় — এমনকি যেখানে আসলে একটিই টাইপ কখনো ব্যবহার হবে। template-কোড compile হলেও তাতে লুকিয়ে থাকতে পারে এমন ভুল, যা শুধু নির্দিষ্ট টাইপ দিয়ে ব্যবহার করলে ধরা পড়ে — কারণ মনে রাখবেন, যে member function ডাকা হয় না, তার কোড তৈরিই হয় না, তাই তার ভুলও অনেক সময় চোখে পড়ে না। সাধারণ ভুলগুলো:

AI-এর template-কোড যাচাইয়ের চেকলিস্ট

• template-টি অন্তত দুটি ভিন্ন টাইপে সত্যিই ব্যবহার হবে — নইলে সাধারণ class-ই যথেষ্ট
• সব member function-এর সংজ্ঞা header-এ; বাইরের সংজ্ঞায় template লাইন আর Name<T>:: ঠিক আছে
• প্রতিটি dependent টাইপের আগে typename (বা auto) আছে
• প্রতিটি specialization primary-র পুরো interface আর প্রতিশ্রুতি রাখে
• ভেতরে কোনো হাতে লেখা new/delete নেই; special member function নিজে লেখা হয়নি
• নিজে অন্তত দুটি টাইপ দিয়ে — একটি move-only, যেমন std::unique_ptr — instantiate করে প্রতিটি member function অন্তত একবার ডেকে দেখেছি