function template — একবার লিখুন, যেকোনো টাইপে চালান

১ · সমস্যাটা আগে — একই ফাংশন, তিনবার লেখা

ধরুন আপনি একটি অনলাইন বাজারের অ্যাপ লিখছেন। এক জায়গায় দুটি পণ্যের দামের মধ্যে বড়টি চাই, আরেক জায়গায় দুটি দোকানের রেটিংয়ের মধ্যে বড়টি, আর আরেক জায়গায় দুটি নামের মধ্যে বর্ণানুক্রমে পরেরটি। পর্ব ৯-এর function overloading দিয়ে আপনি এভাবে লিখতে পারেন:

int largest(int a, int b)                       { return (a < b) ? b : a; }
double largest(double a, double b)              { return (a < b) ? b : a; }
std::string largest(std::string a, std::string b) { return (a < b) ? b : a; }
// কাল long-এর জন্য লাগবে, পরশু Money টাইপের জন্য...

তিনটি ফাংশনের শরীর হুবহু এক: (a < b) ? b : a. পার্থক্য শুধু টাইপের নামে। এটি একটি কপি-পেস্টের কারখানা। নতুন টাইপ এলে আবার একটি কপি। আর কোনোদিন যুক্তিতে একটি ভুল ধরা পড়লে — ধরুন সমান হলে কোনটি ফেরত দেবেন, সেই নিয়ম বদলাতে হলো — তখন সবগুলো কপি খুঁজে খুঁজে বদলাতে হবে। একটি বাদ পড়লেই দুই টাইপে দুই রকম আচরণ, আর কেউ টের পাবে না।

C++-এ এই ছাঁচের নাম template. যে template একটি ফাংশন বানানোর নিয়ম দেয়, তাকে বলে function template. আর টাইপের নাম না বেঁধে একবার যুক্তি লেখার এই চিন্তাধারাকে বলে generic programming — এই মডিউলের পুরো বিষয়। পর্ব ১৩ থেকে আপনি যে std::vector<int> ব্যবহার করে আসছেন, সেটিও একটি template থেকে বানানো; পরের পর্বে সেই class template-এর কথা আসবে। আজ শুরু করছি সবচেয়ে সরল রূপ দিয়ে: ফাংশন।

২ · পুরোনো পথ: macro — আর তার লুকানো ফাঁদ

template আসার আগে, আর C-তে আজও, “যেকোনো টাইপে চলবে” এমন কোডের প্রচলিত উপায় ছিল macro:

#define MAX(a, b) ((a) > (b) ? (a) : (b))

int    m1 = MAX(3, 7);        // 7
double m2 = MAX(2.5, 1.5);    // 2.5 — "যেকোনো টাইপে চলে"!

দেখতে চমৎকার। কিন্তু macro কোনো ফাংশন নয়। এটি preprocessor-এর একটি লেখা-বদলের নিয়ম: compile শুরুর আগেই MAX(x, y) লেখাটি অক্ষরে অক্ষরে বদলে বসানো হয়। preprocessor C++ বোঝে না — সে টাইপ চেনে না, scope চেনে না, শুধু লেখা চেনে। ফলে তিনটি সমস্যা:

• টাইপ যাচাই নেই। MAX(3, "hello") লিখলে macro আপত্তি করে না; compiler পরে বদলানো লেখায় অদ্ভুত error দেয়, macro-র নাম পর্যন্ত বলে না।
• নাম সবখানে ঢুকে পড়ে। macro namespace মানে না। অন্য কোনো লাইব্রেরিতে max নামে ফাংশন থাকলে এবং কেউ max নামে macro বানালে, সেই ফাংশনের ঘোষণাও বদলে যায়। Windows-এর windows.h-এর min/max macro এই কারণে বহু বছর ধরে C++ প্রোগ্রামারদের ভোগাচ্ছে।
• argument একাধিকবার হিসাব হতে পারে। এটিই সবচেয়ে নীরব ফাঁদ, যাকে বলে double evaluation. নিচে ধাপে ধাপে দেখুন।

1int i = 6;2int m = MAX(i++, 5);3// বদলে হলো: ((i++) > (5) ? (i++) : (5))45int m2 = largest(i++, 5);   // template, i = 6 থেকে

৩ · প্রথম function template — template <typename T>

তিনটি largest-কে এক করার জন্য টাইপের নামের জায়গায় একটি “ফাঁকা ঘর” রাখুন, আর তার নাম দিন T:

template <typename T>          // "T নামে একটি টাইপ আসবে"
T largest(T a, T b) {           // যেখানে টাইপ ছিল, সেখানে T
    return (a < b) ? b : a;
}

প্রথম লাইনটি template-এর ঘোষণা। কোণ বন্ধনীর ভেতরের typename T হলো একটি template parameter — ফাংশনের parameter যেমন একটি মানের জন্য জায়গা রাখে, এটি তেমনি একটি টাইপের জন্য জায়গা রাখে। T নামটি শুধু প্রচলিত রীতি; Item বা Number লিখলেও চলে। typename-এর বদলে class লেখাও এখানে হুবহু একই অর্থ বহন করে (template <class T>) — পুরোনো কোডে প্রায়ই দেখবেন। T-এর জায়গায় যে আসল টাইপ বসে (int, double…), তাকে বলে template argument.

এবার এই একটি ছাঁচ দিয়ে দামের তুলনা, নামের তুলনা — সব করা যাক। প্রথমবারের মতো চালিয়ে দেখুন:

#include <print>
#include <string>

template <typename T>
T largest(T a, T b) {
    return (a < b) ? b : a;
}

int main() {
    std::println("{}", largest(3, 7));            // T = int
    std::println("{}", largest(120.5, 99.75));    // T = double (price)
    std::string x = "Rahim", y = "Karim";
    std::println("{}", largest(x, y));            // T = std::string
    std::println("{}", largest<double>(3, 2.5));  // T given explicitly
    // largest(3, 2.5);   // error: is T int or double?
}

একটি জিনিস আলাদা করে মনে রাখুন: largest নিজে কোনো ফাংশন নয় — এটি একটি ফাংশন-পরিবারের নিয়ম। largest<int> একটি আসল ফাংশন, largest<std::string> আরেকটি। দুটির ঠিকানা আলাদা, মেশিন কোড আলাদা। কোনো টাইপে কখনো ডাকা না হলে সেই টাইপের ফাংশন কখনো তৈরিই হয় না।

৪ · Deduction — compiler কীভাবে T খুঁজে পায়

আপনি largest(3, 7) লিখলেন, কিন্তু T কী, তা বলেননি। compiler প্রতিটি argument-এর টাইপকে parameter-এর ছাঁচের সাথে মিলিয়ে T বের করে। এই প্রক্রিয়ার নাম template argument deduction — পর্ব ৫-এর auto-র type deduction-এর মতোই, কারণ auto-র নিয়ম আসলে template-এর নিয়ম থেকেই নেওয়া। ধাপে ধাপে দেখুন, একটি ডাক থেকে আসল ফাংশন পর্যন্ত:

1template <typename T>2T largest(T a, T b) { return (a < b) ? b : a; }34int r = largest(3, 7);

যখন দুই দিক থেকে দুই উত্তর আসে

এবার সেই মন্তব্য করা লাইনটি: largest(3, 2.5). এখানেই নতুনরা সবচেয়ে বেশি হোঁচট খান, কারণ সাধারণ ফাংশনে int থেকে double-এ রূপান্তর নিজে থেকেই হয়ে যায়। deduction-এ তা হয় না:

template <typename T>
T largest(T a, T b);

largest(3, 2.5);     // 3 হলো int, 2.5 হলো double

a ← 3     থেকে:  T = int
b ← 2.5   থেকে:  T = double

T একটাই হতে পারে  →  দ্বন্দ্ব!
(deduction-এর সময় int → double রূপান্তর ধরা হয় না)

error: no matching function for call to
       'largest(int, double)'
note: candidate: 'template<class T> T largest(T, T)'
note:   template argument deduction/substitution failed:
note:   deduced conflicting types for parameter 'T'
        ('int' and 'double')

largest<double>(3, 2.5);   // ১. T নিজে বলে দিন: 3 → 3.0
largest(3.0, 2.5);         // ২. argument-এর টাইপ মেলান

template <typename A, typename B>   // ৩. দুটি আলাদা টাইপ মেনে নিন
auto largest2(A a, B b) { return (a < b) ? b : a; }
largest2(3, 2.5);          //    ফল double: 3.0

deduction-এর আরও কিছু নিয়ম জেনে রাখুন। by value parameter (T a) হলে argument-এর const আর reference বাদ পড়ে, আর array হয়ে যায় pointer — auto-র মতোই। const T& parameter হলে array থাকে array. আর return টাইপ থেকে কখনো T বের করা হয় না: template <typename T> T make();-কে ডাকতে হলে make<int>() লিখতেই হবে, কারণ কোনো argument নেই যা দেখে compiler অনুমান করবে।

৫ · Instantiation — ছাঁচ থেকে আসল ফাংশন, আর কেন template header-এ থাকে

একই template যখন দুটি ভিন্ন টাইপে ডাকা হয়, তখন compiler দুটি সম্পূর্ণ আলাদা ফাংশন বানায়। প্রতিটির নিজের মেশিন কোড, নিজের symbol. ঘটনাটি ধাপে ধাপে দেখুন:

template <typename T>
T largest(T a, T b) { return (a < b) ? b : a; }

// কেউ ডাকেনি → compiler শুধু ব্যাকরণ দেখে রাখল,
// কোনো ফাংশন বানাল না।

int largest<int>(int a, int b) {
    return (a < b) ? b : a;      // int-এর <: একটি CPU নির্দেশ
}

std::string largest<std::string>(std::string a, std::string b) {
    return (a < b) ? b : a;      // string-এর operator<:
}                                // অক্ষর ধরে ধরে তুলনা, একটি লুপ

int largest<int>(int, int)
std::string largest<std::string>(std::string, std::string)

// দুটি আলাদা symbol, দুটি আলাদা মেশিন কোড।
// largest<double> নেই — কেউ double দিয়ে ডাকেনি।

কেন template-এর পুরো সংজ্ঞা header-এ থাকে

পর্ব ১১-এ শিখেছিলেন: সাধারণ ফাংশনের ঘোষণা header file-এ, সংজ্ঞা .cpp-তে। template-এ এই অভ্যাস ভেঙে যায়। কারণ লুকিয়ে আছে compile হওয়ার ধরনে। প্রতিটি .cpp ফাইল আলাদাভাবে compile হয় — একেকটি translation unit. ধরুন main.cpp largest(3, 7) ডাকল, কিন্তু সে শুধু header-এর ঘোষণাটুকু দেখে:

// largest.h — শুধু ঘোষণা (ভুল পথ)
template <typename T> T largest(T a, T b);

// largest.cpp — সংজ্ঞা এখানে
template <typename T> T largest(T a, T b) { return (a < b) ? b : a; }

// main.cpp
#include "largest.h"
int main() { return largest(3, 7); }
// linker: undefined reference to 'int largest<int>(int, int)'

main.cpp compile করার সময় compiler-এর T = int সংস্করণ বানানো দরকার, কিন্তু ছাঁচের শরীর তার সামনে নেই। সে ধরে নেয়, অন্য কোথাও নিশ্চয় তৈরি আছে, আর একটি অপূর্ণ ডাক রেখে যায়। ওদিকে largest.cpp compile করার সময় compiler-এর কাছে শরীর আছে, কিন্তু সেই ফাইলে কেউ int দিয়ে ডাকেনি — তাই সে কিছুই বানায় না। শেষে linker খুঁজে পায় না: একটি linker error. দুজনের কাছে আধখানা করে তথ্য, কারও কাছে পুরোটা নেই।

সমাধান: template-এর পুরো সংজ্ঞা header-এ রাখুন। তখন যে ফাইল যে টাইপে ডাকে, সেই ফাইলেই compiler ছাঁচটি পুরো দেখে সংস্করণ বানাতে পারে। দুটি ফাইল যদি একই largest<int> বানায়? সমস্যা নেই — template থেকে তৈরি ফাংশন ODR-এর নিয়মে inline ফাংশনের মতো ছাড় পায়: একাধিক ফাইলে একই সংজ্ঞা থাকতে পারে, linker একটি রেখে বাকিগুলো ফেলে দেয়। এজন্যই standard library-র বেশিরভাগ template-কোড header-এর ভেতরে, আর অনেক জনপ্রিয় লাইব্রেরি পুরোপুরি header-only library.

Code bloat — টাইপ-প্রতি একটি কপির দাম

প্রতিটি টাইপের জন্য আলাদা ফাংশন মানে প্রোগ্রামের আকার বাড়তে পারে। দশটি টাইপে ডাকা একটি বড় template থেকে দশটি বড় ফাংশন তৈরি হয়। এর নাম code bloat. ছোট ফাংশনে এটি নগণ্য — compiler প্রায়ই সেগুলো inline করে ফেলে, আর কিছু linker হুবহু একই মেশিন কোডের ফাংশন একটিতে মিলিয়েও দেয়। কিন্তু অনেক টাইপে ব্যবহৃত বিশাল template-ভারী কোডে executable-এর আকার আর compile-এর সময় — দুটিই চোখে পড়ার মতো বাড়ে। ভারসাম্যের একটি পুরোনো কৌশল: টাইপ-নির্ভর নয় এমন বড় অংশটি একটি সাধারণ ফাংশনে সরিয়ে রাখা, আর template-কে শুধু পাতলা মোড়ক রাখা।

৬ · একাধিক টাইপ, auto return, abbreviated template আর non-type parameter

একাধিক type parameter আর auto return

৪ নম্বর অংশের তৃতীয় সমাধানে দুটি type parameter দেখেছেন: template <typename A, typename B>. তখন প্রশ্ন ওঠে — ফেরত টাইপ কী লিখবেন? A, না B? C++14 থেকে উত্তর সহজ: auto লিখুন, compiler return-এর হিসাব দেখে টাইপ ঠিক করবে (return type deduction). (a < b) ? b : a-তে একটি int আর একটি double থাকলে ফল double, তাই largest2(3, 2.5) ফেরত দেয় 3.0. আগে থেকে টাইপটি নাম ধরে চাইলে standard library-র std::common_type_t<A, B> লেখা যায়, যা দুই টাইপের “মিলনের” টাইপ বলে দেয়।

Abbreviated function template — C++20-এর সংক্ষিপ্ত রূপ

C++20 থেকে parameter-এর টাইপের জায়গায় সরাসরি auto লিখলেই ফাংশনটি template হয়ে যায়। একে বলে abbreviated function template:

auto twice(auto x) { return x + x; }
// হুবহু সমান:
template <typename T> auto twice(T x) { return x + x; }

auto bigger(auto a, auto b) { return (a < b) ? b : a; }
// সাবধান: এটি template <typename A, typename B> — দুটি আলাদা টাইপ!

লিখতে ছোট, পড়তে সহজ। কিন্তু একটি সূক্ষ্ম পার্থক্য মনে রাখুন: প্রতিটি auto parameter একটি আলাদা template parameter. “দুটি argument-এর টাইপ এক হতেই হবে” — এই শর্ত বোঝাতে চাইলে পুরোনো template <typename T> রূপটিই লিখতে হবে। ছোট সহায়ক ফাংশনে auto রূপ চমৎকার; যেখানে টাইপগুলোর সম্পর্ক গুরুত্বপূর্ণ, সেখানে নাম দেওয়া T.

Non-type template parameter — টাইপ নয়, একটি মান

template parameter সবসময় টাইপ হতে হবে, এমন নয়। একটি compile-time ধ্রুবক মানও হতে পারে: template <int N>. একে বলে non-type template parameter. পর্ব ১৩-এর std::array<int, 5>-এর 5 ঠিক এমনই একটি parameter. মানটি compile-এর সময় জানা থাকতে হয় — একটি literal, constexpr ভ্যারিয়েবল ইত্যাদি; ব্যবহারকারীর ইনপুট থেকে পড়া মান চলবে না। C++20 থেকে double আর কিছু সরল class টাইপও এখানে চলে, তবে সাধারণ ব্যবহার পূর্ণসংখ্যা।

এবার তিনটি বাস্তব কাজ একসাথে: যেকোনো সংখ্যার vector-এর যোগফল (sum_all), একটি sensor-এর গড়বড়ে মানকে সীমার ভেতরে আনা (clamp_to_range), আর নির্দিষ্ট হারে ভ্যাট যোগ — হারটি non-type parameter হিসেবে:

#include <print>
#include <vector>

template <typename T>
T sum_all(const std::vector<T>& v) {
    T total{};                               // 0 for numbers
    for (const T& x : v) total += x;
    return total;
}
template <typename T>
T clamp_to_range(T value, T lo, T hi) { return value < lo ? lo : (hi < value ? hi : value); }

template <int Percent>                       // non-type parameter
int add_vat(int taka) { return taka + taka * Percent / 100; }

int main() {
    std::vector<int> sales{120, 80, 200};
    std::vector<double> temps{30.5, 31.25, 29.75};
    std::println("{} {}", sum_all(sales), sum_all(temps));
    std::println("{} {}", clamp_to_range(1023, 0, 1000), clamp_to_range(-4.5, 0.0, 50.0));
    std::println("{}", add_vat<15>(200));
}

৭ · Overloading আর specialization — কোনো এক টাইপের জন্য আলাদা নিয়ম

কখনো কখনো ছাঁচটি কোনো একটি টাইপে ভুল কাজ করে। সবচেয়ে বিখ্যাত উদাহরণ: C-ধাঁচের string literal.

auto w = largest("apple", "mango");
// "apple" আর "mango" by value-তে pointer হয়ে যায়: T = const char*
// a < b তুলনা করে দুটি ঠিকানা, লেখা নয়!
// কোনটি বড় হবে, তা নির্ভর করে লেখা দুটি মেমরিতে কোথায় বসেছে

এটি compile হয়, চলেও — কিন্তু ফল লেখার বর্ণানুক্রমের সাথে সম্পর্কহীন। দুটি আলাদা object-এর ঠিকানা < দিয়ে তুলনার ফল C++-এ unspecified. এমন টাইপের জন্য আলাদা নিয়ম দেওয়ার দুটি পথ আছে।

// পথ ১ (পছন্দের): একটি সাধারণ, non-template overload
const char* largest(const char* a, const char* b) {
    return std::strcmp(a, b) < 0 ? b : a;      // অক্ষর ধরে তুলনা, <cstring>
}

// পথ ২: full specialization — "T = const char* হলে এই শরীর"
template <>
const char* largest<const char*>(const char* a, const char* b) {
    return std::strcmp(a, b) < 0 ? b : a;
}

প্রথম পথে আপনি একই নামে একটি সাধারণ ফাংশন যোগ করছেন; overload resolution তখন template আর সাধারণ ফাংশনকে পাশাপাশি বিচার করে। একটি নিয়ম এখানে গুরুত্বপূর্ণ: দুজন সমান ভালো মিললে সাধারণ (non-template) ফাংশন জেতে। তাই largest("apple", "mango") এখন সাধারণ ফাংশনটি ডাকে। দ্বিতীয় পথটি template specialization: template <> দিয়ে বলা হয়, “এই template-এর T = const char* সংস্করণ আমি নিজে লিখে দিচ্ছি।”

দুটিই এখানে কাজ করে। তবু অভিজ্ঞ C++ প্রোগ্রামারদের পরামর্শ: function template-এর জন্য overloading বেছে নিন, specialization নয়। কারণ specialization নিজে overload resolution-এ অংশ নেয় না। compiler আগে শুধু “মূল” template আর সাধারণ ফাংশনগুলোর মধ্যে বিচার করে; মূল template জিতলে তবেই দেখে, এর কোনো specialization আছে কি না। একাধিক overload করা template থাকলে কোন specialization কোন মূল template-এর অংশ, তা নিয়ে এমন চমক তৈরি হয় যে অভিজ্ঞরাও ভুল অনুমান করেন। Herb Sutter-এর একটি বহুল পঠিত প্রবন্ধের শিরোনামই ছিল “Why Not Specialize Function Templates?”. তা ছাড়া function template-এর আংশিক (partial) specialization ভাষাতেই নেই — class template-এ আছে, পরের পর্বে দেখবেন। সবচেয়ে সরল সমাধান অবশ্য তৃতীয়টি: C-ধাঁচের string-ই এড়িয়ে চলুন। ডাকার সময় T হিসেবে std::string_view বলে দিলে তুলনা হয় লেখা ধরে, ঠিকানা ধরে নয়।

৮ · T-এর অলিখিত শর্ত, ভয়ংকর error, আর requires-এর এক ঝলক

largest-এর কোথাও লেখা নেই যে T-কে < দিয়ে তুলনা করা যেতে হবে। কিন্তু শরীরে a < b আছে, তাই শর্তটি লুকিয়ে আছে। একইভাবে sum_all নীরবে চায়: T-এর T{} বানানো যায় আর += চলে। এই অলিখিত চাহিদাগুলোকে অনেকে বলেন T-এর implicit interface — virtual ফাংশনের base class-এর মতো কোনো লিখিত চুক্তি নেই, শুধু “যা ব্যবহার করা হয়েছে, তা থাকতে হবে”। শর্ত না মিললে কী হয়?

struct Point { int x, y; };          // < সংজ্ঞায়িত নেই
largest(Point{1, 2}, Point{3, 4});

In instantiation of 'T largest(T, T) [with T = Point]':
  required from here
error: no match for 'operator<' (operand types are 'Point' and 'Point')
    |     return (a < b) ? b : a;
    |             ~~^~~
note: candidate: 'operator<(int, int)' (built-in) ...
note:   no known conversion for argument 1 from 'Point' to 'int'
... (আরও বহু লাইন: std::string, std::vector, std::pair-এর operator< কেন মেলেনি)

খেয়াল করুন, error আসছে template-এর ভেতর থেকে — যে লাইন আপনি লেখেননি, এমনকি হয়তো কখনো দেখেননি। এখানে template ছোট বলে বার্তাটি সহনীয়। কিন্তু STL-এর গভীর template-এ (যেমন std::sort-কে ভুল টাইপ দিলে) একই ভুলে কয়েকশো লাইনের বার্তা আসতে পারে, যার প্রথম আর শেষ কয়েক লাইন ছাড়া প্রায় সবই compiler-এর ভেতরের চিন্তাভাবনা। template-এর দুর্নামের বড় অংশ এই error message.

C++20 শর্তটি মুখে বলার উপায় দিয়েছে। template-এর মাথায় একটি requires clause বা সরাসরি একটি concept-এর নাম:

#include <concepts>

template <std::totally_ordered T>            // শর্ত: T-তে < > <= >= == != চলে
T largest(T a, T b) { return (a < b) ? b : a; }

// একই কথা অন্যভাবে:
template <typename T>
    requires std::totally_ordered<T>
T smallest(T a, T b) { return (b < a) ? b : a; }

// largest(Point{1, 2}, Point{3, 4}) এখন:
// error: no matching function ... constraints not satisfied
// note: the required expression 'a < b' is invalid ...

std::totally_ordered হলো standard library-র একটি তৈরি concept (header <concepts>), যার অর্থ: এই টাইপের দুটি মানকে সব রকম তুলনা অপারেটরে সংগতভাবে তুলনা করা যায়। এখন ভুল টাইপ দিলে error আসে ডাকার জায়গায়, template-এর ভেতরে ঢোকার আগেই, আর বার্তা সরাসরি বলে কোন শর্ত মেলেনি। শর্তটি ফাংশনের ঘোষণাতেই লেখা, তাই পাঠকও দেখেই বোঝেন কোন টাইপ চলবে। concept নিজে লেখা, নানা শর্ত মেলানো আর concept দিয়ে overload বাছাই — পুরো বিষয়টি পর্ব ৪০-এ। আপাতত অভ্যাসটুকু নিন: নতুন template লিখলে T-এর শর্তটি নাম ধরে লিখে দিন।

৯ · Template বনাম virtual — compile-time বনাম run-time polymorphism

পর্ব ২৫-এ virtual ফাংশন দিয়ে “একই ডাক, ভিন্ন কাজ” দেখেছেন। template-ও একই জিনিস দেয়: একই largest ডাক int-এ এক কাজ করে, string-এ আরেক কাজ। পার্থক্য হলো সিদ্ধান্তটি কখন হয়। virtual-এ চলার সময়, vtable দেখে (dynamic binding). template-এ compile-এর সময়, টাইপ দেখে — একে বলে static polymorphism.

একটি সরল প্রশ্নে বাছাই করুন: টাইপটি কে জানে, আর কখন? compile-এর সময়েই সব টাইপ জানা, আর গতি গুরুত্বপূর্ণ — template. টাইপ ঠিক হয় চলার সময় (ব্যবহারকারী মেনু থেকে বেছে নেন, ফাইল থেকে পড়া হয়), বা নতুন টাইপ বাইরের কেউ পরে যোগ করবে — virtual. standard library নিজেই দুটি মেশায়: std::sort পুরোপুরি template, তাই হাতে-লেখা লুপের মতো দ্রুত; আবার std::function ভেতরে চলার সময়ের dispatch ব্যবহার করে যেকোনো callable ধরে রাখে।

১০ · AI-এর যুগে — template-কোড যাচাই

AI টুল template লিখতে খুব আগ্রহী — “generic” কোড দেখতে পেশাদার লাগে। কিন্তু আসল প্রশ্ন সবসময় আগে: এখানে কি আদৌ template দরকার? যে ফাংশন জীবনে শুধু int নিয়েই কাজ করবে, তাকে template বানালে কোনো লাভ নেই, আছে শুধু লম্বা error আর header-এ ঠেলে দেওয়া কোড। আরেকটি প্রবণতা: শর্তহীন template, যা ভুল টাইপ পেলে compiler-এর ভেতর থেকে কয়েকশো লাইনের error দেয়; আর specialization দিয়ে এমন কাজ করা, যা একটি সাধারণ overload-ই করত। পুরোনো অনলাইন কোড থেকে শেখা বলে AI মাঝে মাঝে macro-র MAX-ও লিখে দেয়। সাধারণ ভুলগুলো:

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

• প্রতিটি template-এর জন্য জিজ্ঞেস করেছি: এটি কি সত্যিই একাধিক টাইপে ব্যবহৃত হবে?
• T-এর শর্ত requires বা concept দিয়ে লেখা; একটি ভুল টাইপ দিয়ে ডেকে দেখেছি error ছোট আর পরিষ্কার
• কোথাও macro দিয়ে MAX/MIN বা এমন “generic” কাজ নেই
• template-এর পুরো সংজ্ঞা header-এ; আলাদা .cpp-তে থাকলে explicit instantiation আছে কি না দেখেছি
• specialization থাকলে ভেবেছি, একটি সাধারণ overload দিয়ে একই কাজ হয় কি না
• মিশ্র টাইপে ডেকে দেখেছি (যেমন int আর double), আর ফলের টাইপ আমার প্রত্যাশামতো