lambda ও function object — দরকারের জায়গাতেই ছোট ফাংশন

১ · সমস্যাটা আগে — এক লাইনের নিয়মের জন্য পুরো একটি ফাংশন?

পর্ব ৩৩-এ আপনি দেখেছেন, STL algorithm-গুলো কাজের “কাঠামো” নিজে দেয়, আর আপনাকে শুধু “নিয়মটি” দিতে হয়। std::ranges::sort জানে কীভাবে সাজাতে হয়, কিন্তু জানে না আপনি দাম দিয়ে সাজাবেন, নাকি নাম দিয়ে। count_if জানে কীভাবে গুনতে হয়, কিন্তু জানে না কোন শিক্ষার্থীকে “পাস” ধরবেন। এই নিয়ম পাঠানোর জন্য দরকার এমন কিছু, যাকে ফাংশনের মতো ডাকা যায় — একটি predicate (হ্যাঁ/না উত্তর দেয় এমন নিয়ম) বা একটি comparator (দুটির মধ্যে কে আগে, তা বলে এমন নিয়ম)।

C++11-এর আগে এর দুটি উপায় ছিল, আর দুটিই অস্বস্তিকর। প্রথম উপায়: ফাইলের কোথাও একটি সাধারণ ফাংশন লেখা, যেমন bool cheaper(const Product&, const Product&). কিন্তু যে নিয়ম মাত্র একবার, একটি জায়গায় লাগে, তার জন্য আলাদা নাম আর আলাদা জায়গা — পড়ার সময় পাঠককে লাফ দিয়ে অন্য জায়গায় গিয়ে দেখতে হয় নিয়মটা কী। আর পাসের নম্বর যদি চলার সময় ব্যবহারকারী ঠিক করেন (ধরুন ৪০ বা ৫০), সাধারণ ফাংশন সেই মান নিজের সাথে রাখতে পারে না — global ভ্যারিয়েবল ছাড়া।

দ্বিতীয় উপায় পর্ব ২৩-এর function object, অর্থাৎ functor: একটি class, যার operator() আছে, আর ভেতরে পাসের নম্বরটি একটি data member হিসেবে থাকে। এটি কাজ করে, আর মান সঙ্গে রাখতেও পারে। কিন্তু এক লাইনের নিয়মের জন্য লিখতে হয় পুরো একটি class:

// পুরোনো পথ: functor (পর্ব ২৩) — কাজ করে, কিন্তু অনেক লেখা
struct PassesAt {
    int limit;                                       // সঙ্গে রাখা তথ্য
    bool operator()(int marks) const { return marks >= limit; }
};
auto n = std::ranges::count_if(marks, PassesAt{40});   // ব্যবহার অনেক দূরে, অন্য জায়গায়

// আধুনিক পথ: lambda — নিয়মটি ঠিক যেখানে দরকার
int limit = 40;
auto m = std::ranges::count_if(marks, [limit](int x) { return x >= limit; });

দ্বিতীয় লাইনটি পড়ুন: “marks-এর মধ্যে কয়টি এমন, যার মান limit বা তার বেশি।” নিয়মটি ঠিক সেখানেই লেখা, যেখানে ব্যবহার হচ্ছে, আর limit-এর মান সঙ্গে নিয়ে গেছে। এটাই lambda — C++11 থেকে ভাষার অংশ।

২ · lambda-র গঠন — চারটি অংশ

একটি পূর্ণ lambda দেখতে এমন: [capture](params) -> ret { body }. প্রতিটি অংশ আলাদা করে দেখুন:

সবচেয়ে ছোট বৈধ lambda হলো []{} — কিছু capture করে না, কিছু নেয় না, কিছু করে না। কয়েকটি সাধারণ রূপ:

auto hello  = [] { std::println("hello"); };          // প্যারামিটার নেই, () বাদ
auto square = [](int x) { return x * x; };            // ফেরত-টাইপ: int (নিজে বুঝে নেয়)
auto ratio  = [](int a, int b) -> double {            // ফেরত-টাইপ নিজে লেখা
    if (b == 0) return 0;                             // 0 (int) কে double বানাবে
    return static_cast<double>(a) / b;
};
hello();                 // সাধারণ ফাংশনের মতো ডাক
int s = square(7);       // 49
[](int x) { std::println("{}", x); }(5);   // লিখেই সঙ্গে সঙ্গে ডাকা — পরে কাজে লাগবে

ratio-তে ফেরত-টাইপ কেন লিখতে হলো, লক্ষ করুন। দুটি return-এর একটি দেয় int (0), অন্যটি double. ফেরত-টাইপ না লিখলে compiler দুটি আলাদা টাইপ দেখে error দিত — সব return-কে একই টাইপ দিতে হয়। -> double লিখে দিলে সমস্যা মেটে। বেশিরভাগ ছোট lambda-তে অবশ্য এটা লাগে না।

আরেকটি বিষয়: lambda-কে প্রায় সবসময় auto ভ্যারিয়েবলে রাখা হয়। কেন? কারণ প্রতিটি lambda-র টাইপ আলাদা আর নামহীন — আপনি টাইপটির নাম লিখতেই পারবেন না। পরের অংশে দেখবেন, কেন এমন।

৩ · ভেতরে কী ঘটে — compiler বানায় একটি closure class

lambda কোনো জাদু নয়। compiler প্রতিটি lambda expression দেখে একটি নতুন, নাম-ছাড়া class বানায় — যাকে বলে closure type. আর lambda expression-টি যেখানে লেখা, চলার সময় সেখানে সেই class-এর একটি object তৈরি হয় — যার নাম closure. অর্থাৎ lambda হলো আপনার লেখা কোড, আর closure হলো চলার সময়ের object — ঠিক যেমন class আর object-এর সম্পর্ক। পর্ব ২৩-এর functor-টি compiler আপনার হয়ে লিখে দিচ্ছে। ধাপে ধাপে দেখুন:

int limit = 40;
auto pass = [limit](int m) { return m >= limit; };
bool ok = pass(45);

class __lambda_7 {          // আসল নাম লুকানো; প্রতিটি lambda-র আলাদা
    ...
};
// দুটি হুবহু একই lambda লিখলেও দুটি আলাদা class হয়

class __lambda_7 {
    int limit;              // [limit] থেকে — নিজের একটি কপি
public:
    __lambda_7(int l) : limit(l) {}   // তৈরির সময় কপি নেয়
};
// [&limit] হলে এখানে থাকত: int& limit;

class __lambda_7 {
    int limit;
public:
    __lambda_7(int l) : limit(l) {}
    bool operator()(int m) const { return m >= limit; }
};          //                ^^^^^ তাই body-তে limit বদলানো যায় না

__lambda_7 pass{limit};          // lambda expression = closure object তৈরি
bool ok = pass.operator()(45);   // pass(45) আসলে এই ডাক
// ফল: 45 >= 40, তাই true

এই ছবিটি নিজের চোখে দেখতে চাইলে Andreas Fertig-এর বানানো অনলাইন টুল C++ Insights-এ যেকোনো lambda লিখুন — সেটি ঠিক এমন একটি class দেখায়। একবার এই রূপান্তর বুঝে গেলে lambda-র প্রায় সব নিয়ম — কেন auto লাগে, কেন ডিফল্টে বদলানো যায় না, কেন reference capture বিপজ্জনক — যুক্তি দিয়ে নিজেই বের করতে পারবেন।

৪ · Capture — কী সঙ্গে যাবে, আর কীভাবে

lambda-র body শুধু তিন রকম জিনিস দেখতে পায়: নিজের প্যারামিটার, নিজের ভেতরে ঘোষিত ভ্যারিয়েবল, আর capture করা জিনিস। (global ভ্যারিয়েবল আর static ভ্যারিয়েবলও দেখা যায়, capture ছাড়াই — কারণ সেগুলো সবসময় বেঁচে থাকে।) বাইরের একটি local ভ্যারিয়েবল ব্যবহার করতে চাইলে তাকে capture list-এ নাম দিয়ে আনতে হয়। এখানে দুটি মৌলিক পথ:

Capture by value হলো সেই চিরকুটে সংখ্যাটি লিখে দেওয়া; capture by reference হলো চিরকুটে লেখা “অফিসের হোয়াইটবোর্ডে যা লেখা আছে, সেটা দেখে নেবেন।” দ্বিতীয়টি সবসময় সর্বশেষ মান দেখায় — যতক্ষণ হোয়াইটবোর্ডটি আছে। একটি ফলাফল-প্রকাশের দৃশ্যে দুটির পার্থক্য দেখুন: পাসের নম্বর আগে ৪০ ধরা হয়েছিল, পরে বোর্ড সিদ্ধান্ত নিল ৫০.

#include <print>

int main() {
    int threshold = 40;
    auto byValue = [threshold](int m) { return m >= threshold; };   // copy now
    auto byRef   = [&threshold](int m) { return m >= threshold; };  // live link
    threshold = 50;                                                  // rule changes
    std::println("45 passes? value: {}, ref: {}", byValue(45), byRef(45));

    int calls = 0;
    auto counter = [calls]() mutable { return ++calls; };            // own copy
    counter();
    counter();
    std::println("counter: {}, outer calls: {}", counter(), calls);
}

প্রথম অংশটি চলার সময় প্রতিটি ধাপে কী ঘটে, দেখুন। প্রতিটি ধাপে আগে নিজে অনুমান করুন:

1int threshold = 40;2auto byValue = [threshold](int m) { ... };3auto byRef = [&threshold](int m) { ... };4threshold = 50;5println(..., byValue(45), byRef(45));

সব capture-এর রূপ এক জায়গায়

প্রতিটি ভ্যারিয়েবলের নাম আলাদা করে না লিখে একবারে বলে দেওয়ার উপায়ও আছে — একে বলে default capture. পুরো তালিকা:

Init-capture — সঙ্গে নতুন কিছু বানিয়ে নেওয়া

C++11-এর capture শুধু বিদ্যমান ভ্যারিয়েবল কপি বা reference করতে পারত। ধরুন একটি বড় std::vector lambda-র ভেতরে নিতে চান, কিন্তু কপি করতে চান না — সরিয়ে (move) নিতে চান। অথবা capture-এর মুহূর্তে একটি হিসাব করে রাখতে চান। C++14 এনেছে init-capture: capture list-এ একটি নতুন নাম আর তার প্রাথমিক মান।

std::vector<int> orders = loadOrders();              // ধরুন লাখখানেক উপাদান
auto report = [list = std::move(orders)] {             // কপি নয়, সরিয়ে নেওয়া
    return list.size();
};                                                     // orders এখন খালি (moved-from)

auto upload = [file = std::make_unique<Log>()] { /* file closure-এর মালিকানায় */ };
auto withTax = [rate = vat / 100.0](double p) { return p * (1 + rate); };  // হিসাব একবার

std::move-এর বিস্তারিত পর্ব ৩৬-এ। আপাতত জানুন: [list = std::move(orders)] মানে closure-এর ভেতরে list নামের একটি সদস্য, যা orders-এর ডেটা নিজের করে নিল। std::unique_ptr-এর মতো move-only type, যার কপিই হয় না, lambda-তে নেওয়ার একমাত্র পরিষ্কার পথ এটিই। (আর এমন lambda নিজেও কপি করা যায় না — এটা পরে std::function-এর আলোচনায় গুরুত্বপূর্ণ হবে।)

mutable — নিজের কপি বদলানোর অনুমতি

অংশ ৩-এ দেখেছেন, closure-এর operator() ডিফল্টভাবে const. তাই [calls] { return ++calls; } compile হয় না — const ফাংশনে সদস্য বদলানো নিষেধ। mutable লিখলে operator() থেকে const সরে যায়, আর lambda নিজের কপি বদলাতে পারে — যেমন উপরের counter. মনে রাখুন: এটি বাইরের ভ্যারিয়েবল বদলায় না, বদলায় closure-এর নিজের সদস্য। বাইরেরটা বদলাতে চাইলে capture by reference. আর একটি সূক্ষ্ম ফাঁদ: mutable lambda কপি করলে দুটি কপি আলাদা গোনে, কারণ প্রত্যেকের নিজের সদস্য আছে। কোনো algorithm যদি আপনার lambda-কে ভেতরে কপি করে নেয়, আপনার counter হয়তো আপনার হাতের কপিতে বাড়বেই না।

this capture — member function-এর ভেতরে lambda

class-এর member function-এর ভেতরে lambda থেকে সদস্য ব্যবহার করতে হলে this capture করতে হয়। [this] কপি করে শুধু this pointer — object-টি নয়। তাই lambda object-এর চেয়ে বেশি দিন বাঁচলে আবারও সেই মৃত ঠিকানার সমস্যা। C++17-এর [*this] পুরো object কপি করে নেয়, যা পরে চলবে এমন কাজে নিরাপদ। একটি পুরোনো ফাঁদ: member function-এর ভেতরে [=] লিখলে this চুপচাপ capture হয় — দেখতে “সব কপি”, আসলে object-এর ঠিকানা। C++20 এই নিঃশব্দ this-capture-কে deprecated করেছে (এখনো compile হয়, তবে compiler সতর্ক করতে পারে); এখন স্পষ্ট লিখুন [=, this] বা [*this].

struct Shop {
    int discount = 10;
    auto priceRule() {
        return [this](int p) { return p - p * discount / 100; };   // Shop-এর ঠিকানা
    }
    auto priceRuleCopy() {
        return [*this](int p) { return p - p * discount / 100; };  // Shop-এর কপি (C++17)
    }
};

৫ · Dangling capture — যে lambda তার ভ্যারিয়েবলের চেয়ে বেশি দিন বাঁচে

পর্ব ১৮-এ আপনি lifetime আর dangling reference দেখেছেন: যে reference-এর object মরে গেছে, তা দিয়ে পড়া বা লেখা undefined behavior. lambda-তে এই বিপদ লুকিয়ে থাকে আরও ভালোভাবে, কারণ reference-টি কোডে কোথাও চোখে পড়ে না — সেটি থাকে একটি & চিহ্নের আড়ালে, closure-এর ভেতরে।

নিয়মটি সরল: reference capture তখনই নিরাপদ, যখন lambda তার capture করা ভ্যারিয়েবলের আগে শেষ হয়। count_if-এর ভেতরে দেওয়া lambda সঙ্গে সঙ্গে চলে আর algorithm শেষ হলে বাতিল হয় — সেখানে [&] নিরাপদ। কিন্তু যে lambda সংরক্ষিত হয় — একটি callback তালিকায়, একটি thread-এ, একটি ফাংশন থেকে ফেরত দিয়ে — সেটি তৈরির জায়গার scope-এর পরেও বাঁচে। একটি অ্যাপের বাটনে ক্লিক গোনার উদাহরণে দেখুন (এই কোড চালাবেন না):

std::vector<std::function<void()>> onClick;   // বাটনের handler তালিকা

void addCounter() {
    int clicks = 0;                                  // addCounter-এর local
    onClick.push_back([&clicks] { ++clicks; });      // reference সংরক্ষিত হলো!
}                                                    // clicks এখানে ধ্বংস

addCounter();
// ... কিছুক্ষণ পরে ব্যবহারকারী বাটন চাপলেন ...
onClick[0]();          // মৃত clicks-এ লেখা: undefined behavior

1std::vector<std::function<void()>> onClick;2void addCounter() {3    int clicks = 0;4    onClick.push_back([&clicks] { ++clicks; });5}6onClick[0]();   // পরে, বাটন চাপলে

একই ভুলের আরও দুটি পরিচিত রূপ আছে। প্রথমটি ফাংশন থেকে lambda ফেরত দেওয়া, যেখানে local ভ্যারিয়েবল reference-এ ধরা: return [&rate](int p) { ... }; — ফাংশন ফেরত দেওয়ার সঙ্গে সঙ্গে rate মরে। দ্বিতীয়টি thread: একটি std::thread-কে [&] lambda দিয়ে চালিয়ে detach করলে, মূল ফাংশন আগে শেষ হয়ে গেলে thread মৃত ভ্যারিয়েবল পড়ে (পর্ব ৪৫)। তিনটি ক্ষেত্রেই প্রশ্ন একটাই: এই lambda কতক্ষণ বাঁচবে, আর আমার capture করা জিনিস কতক্ষণ? উত্তর অনিশ্চিত হলে value capture বেছে নিন। AddressSanitizer (-fsanitize=address, পর্ব ১৮) চালিয়ে পরীক্ষা করলে এমন ভুলের অনেকগুলো ধরা পড়ে।

৬ · Generic lambda আর STL algorithm-এ lambda

প্যারামিটারে auto — একটি lambda, অনেক টাইপ

C++14 থেকে lambda-র প্যারামিটারে auto লেখা যায়। একে বলে generic lambda. তখন closure-এর operator() নিজেই একটি template হয়ে যায় (পর্ব ২৮) — প্রতিটি নতুন টাইপে ডাকলে compiler একটি নতুন সংস্করণ বানায়।

auto twice = [](auto x) { return x + x; };
twice(4);                       // 8      — int সংস্করণ
twice(2.5);                     // 5.0    — double সংস্করণ
twice(std::string("ha"));       // "haha" — string সংস্করণ

// compiler-এর চোখে closure-এর ভেতরটা মোটামুটি এমন:
// template <typename T> auto operator()(T x) const { return x + x; }

C++20 আরেক ধাপ এগিয়ে template lambda এনেছে: capture list-এর পরে সরাসরি template প্যারামিটার। এটি কাজে লাগে যখন টাইপটির নাম body-তে দরকার, বা দুটি প্যারামিটার একই টাইপের হতেই হবে:

// T-কে নাম দিয়ে ধরা: vector-এর উপাদানের টাইপ জানা দরকার
auto firstOr = []<typename T>(const std::vector<T>& v, T fallback) {
    return v.empty() ? fallback : v.front();
};
firstOr(std::vector{3, 1, 2}, 0);    // 3 — T = int

STL algorithm-এ lambda — যেখানে lambda সবচেয়ে বেশি দেখা যায়

পর্ব ৩৩-এর প্রায় প্রতিটি algorithm একটি callable নেয়। lambda নেওয়ার জন্য যেসব ফাংশন বানানো, তাদের সাধারণ নাম higher-order function — যে ফাংশন অন্য ফাংশনকে প্যারামিটার হিসেবে নেয়। তিনটি পরিচিত ব্যবহার একটি দোকানের উদাহরণে দেখুন — দাম অনুযায়ী পণ্য সাজানো (দাম সমান হলে নাম অনুযায়ী), ঈদের সেলের ছাড় হিসাব, আর ৩০০ টাকার কম দামের পণ্য গোনা:

#include <algorithm>
#include <print>
#include <string>
#include <vector>

struct Product { std::string name; int price; };

auto make_discount(int percent) {                          // returns a lambda
    return [percent](int price) { return price - price * percent / 100; };
}

int main() {
    std::vector<Product> items{{"pen", 20}, {"bag", 900}, {"cap", 250}, {"ink", 20}};
    std::ranges::sort(items, [](const Product& a, const Product& b) {
        if (a.price != b.price) return a.price < b.price;  // cheaper first
        return a.name < b.name;                             // tie: by name
    });
    auto eidSale = make_discount(10);
    for (const auto& p : items) std::println("{}: {} -> {}", p.name, p.price, eidSale(p.price));
    auto cheap = std::ranges::count_if(items, [](const Product& p) { return p.price < 300; });
    std::println("under 300: {}", cheap);
}

comparator লেখার সময় একটি নিয়ম মানতেই হবে: এটি “কঠোরভাবে কম” (<) বোঝাবে, কখনো <= নয়। <= লিখলে সমান দুটি উপাদানে “a আগে” আর “b আগে” দুটিই সত্য হয়, যা sort-এর শর্ত (strict weak ordering) ভাঙে — ফল undefined behavior: ভুল ক্রম থেকে crash পর্যন্ত যেকোনো কিছু। আর দাম-তারপর-নাম ধরনের তুলনা আরও সংক্ষেপে লেখা যায় std::tie(a.price, a.name) < std::tie(b.price, b.name) দিয়ে।

শিক্ষার্থীর নম্বর থেকে পাসের সংখ্যা গোনা, বা প্রত্যেককে একটি করে বার্তা দেখানো — দুটিই এক লাইনে:

int passMark = 40;                                   // চলার সময় ঠিক হতে পারে
auto passed = std::ranges::count_if(marks, [passMark](int m) { return m >= passMark; });

int total = 0;
std::ranges::for_each(marks, [&total](int m) { total += m; });   // [&] এখানে নিরাপদ:
                                                                 // lambda এখনই চলে শেষ

এখানে std::ranges::count_if আর std::ranges::for_each দুটিই lambda সঙ্গে সঙ্গে চালিয়ে শেষ করে, তাই [&total] সম্পূর্ণ নিরাপদ — অংশ ৫-এর নিয়মটি মিলিয়ে দেখুন। (মোট যোগফলের জন্য অবশ্য std::accumulate বা std::ranges::fold_left আরও পরিষ্কার; for_each এখানে শুধু reference capture দেখাতে।) পরের পর্বের ranges আর views-এ lambda আরও কেন্দ্রীয় — সেখানে filter আর transform-কে শুধু lambda দিয়েই বলা হয় কী করতে হবে।

৭ · Callable রাখা — auto, std::function, না function pointer?

lambda একবার লিখে সঙ্গে সঙ্গে algorithm-এ দেওয়া এক কথা। কিন্তু অনেক সময় একে কোথাও রাখতে হয় — একটি ভ্যারিয়েবলে, একটি class-এর সদস্যে, একটি তালিকায়। আর প্রতিটি closure-এর টাইপ আলাদা ও নামহীন হওয়ায় প্রশ্ন ওঠে: সেই ভ্যারিয়েবলের টাইপ কী লিখবেন? তিনটি উত্তর:

std::function — যেকোনো callable-এর একটি বাক্স

std::function (হেডার <functional>) একটি “বাক্স”, যার গায়ে শুধু স্বাক্ষর লেখা — যেমন std::function<int(int)> মানে “int নেয়, int দেয় এমন যেকোনো কিছু।” ভেতরে কী আছে — সাধারণ ফাংশন, lambda, নাকি পর্ব ২৩-এর functor — বাইরে থেকে বোঝা যায় না, দরকারও নেই। আসল টাইপ লুকিয়ে একটি সাধারণ টাইপ দেখানোর এই কৌশলকে বলে type erasure. এর দাম তিনটি: ডাকটি পরোক্ষ (ভেতরে virtual ফাংশনের মতো একটি ব্যবস্থা), তাই compiler সাধারণত inline করতে পারে না; capture বড় হলে closure রাখতে heap থেকে মেমরি নিতে হতে পারে (ছোট হলে অনেক বাস্তবায়ন বাক্সের ভেতরেই রাখে — small buffer optimization); আর বাক্সটি খালিও হতে পারে। একটি std::function ভ্যারিয়েবল তার জীবনে কী কী ধরে রাখতে পারে, দেখুন:

1std::function<int(int)> price;      // খালি2price = half;                        // int half(int p)3price = [](int p) { return p - 10; };4price = [pct](int p) { return p - p * pct / 100; };5price = Tax{15};                     // functor6price = nullptr;                     // আবার খালি

একটি GUI-ধাঁচের ঘটনা-ব্যবস্থা

std::function-এর সবচেয়ে স্বাভাবিক ব্যবহার হলো callback তালিকা — যেখানে নানা জায়গা থেকে নানা ধরনের lambda এসে একটি ঘটনার জন্য অপেক্ষা করে। একটি অনলাইন দোকানের “কার্টে যোগ করুন” বাটনের কথা ভাবুন: ক্লিক হলে কার্টের সংখ্যা বাড়বে, একটি বার্তা দেখাবে, আর analytics-এ একটি গণনা যাবে। তিনটি কাজ তিনজন আলাদা প্রোগ্রামার লিখেছেন, তিনটি আলাদা closure টাইপ — তবু এক তালিকায়:

struct Button {
    std::vector<std::function<void()>> onClick;     // event handler-এর তালিকা
    void click() const { for (const auto& h : onClick) h(); }
};

Cart cart;                                           // buy-এর চেয়ে বেশি দিন বাঁচে
Button buy;
buy.onClick.push_back([&cart] { cart.add(); });      // reference: cart বেঁচে থাকবে তো?
buy.onClick.push_back([] { std::println("added to cart"); });
buy.onClick.push_back([tag = std::string("buy-btn")] { track(tag); });  // নিজের কপি
buy.click();                                         // তিনটি handler পরপর চলে

এখানে প্রতিটি event handler-এর capture-সিদ্ধান্ত আলাদা, আর প্রতিটির পেছনে lifetime-এর একটি প্রশ্ন আছে। [&cart] ঠিক আছে শুধু যদি cart বাটনের চেয়ে বেশি দিন বাঁচে — এখানে cart আগে তৈরি, তাই পরে ধ্বংস হবে (পর্ব ২১-এর উল্টো ক্রম)। এই ধরনের নকশায় std::function প্রায় অপরিহার্য, কারণ তালিকার প্রতিটি উপাদানের টাইপ এক হতে হয়। কিন্তু একটি local lambda রাখতে, বা একটি ফাংশনে callable পাঠাতে std::function দরকার নেই — সেখানে auto বা template প্যারামিটার যথেষ্ট, আর দ্রুততর। আরেকটি সীমা: std::function-এ রাখা জিনিস কপি করা যায় এমন হতে হয়। তাই unique_ptr capture করা lambda এতে আঁটে না; C++23-এর std::move_only_function সেই ফাঁক পূরণ করে।

function pointer — capture-ছাড়া lambda-র বিশেষ সুবিধা

যে lambda কিছুই capture করে না, তার closure-এ কোনো data member নেই — ফলে তার operator()-এর কোনো object-এর দরকারই নেই। তাই C++ নিয়ম করেছে: capture-ছাড়া lambda নিজে থেকেই একই স্বাক্ষরের function pointer-এ রূপান্তরিত হয়। এটি C লাইব্রেরির সাথে কাজ করতে খুব কাজের, কারণ C শুধু function pointer চেনে:

int (*op)(int, int) = [](int a, int b) { return a + b; };   // ঠিক আছে
// int (*bad)(int) = [k](int a) { return a + k; };          // error: capture আছে

std::qsort(arr, n, sizeof(int), [](const void* a, const void* b) {
    int x = *static_cast<const int*>(a), y = *static_cast<const int*>(b);
    return (x > y) - (x < y);                                // C-এর qsort-এ lambda
});

capture-সহ lambda-র state রাখার একটি জায়গা দরকার, আর একটি function pointer শুধু কোডের একটি ঠিকানা — সেখানে ডেটা রাখার জায়গা নেই। তাই সেটি রূপান্তর হয় না। C API-গুলো এই সমস্যা সমাধান করে একটি বাড়তি void* প্যারামিটার দিয়ে, যার মাধ্যমে আপনি নিজের ডেটার ঠিকানা পাঠান — ভাবনার প্রশ্ন ০৪-এ বিস্তারিত।

৮ · lambda ফেরত দেওয়া, সঙ্গে সঙ্গে ডাকা, আর নিজেকে ডাকা

Factory — ফাংশন থেকে lambda ফেরত

অংশ ৬-এর make_discount একটি ছোট কিন্তু শক্তিশালী ধারণা দেখিয়েছে: একটি ফাংশন যা নিয়ম বানিয়ে দেয়। C++14 থেকে ফেরত-টাইপে auto লিখলেই lambda ফেরত দেওয়া যায় — আসল টাইপের নাম লিখতে হয় না। একই factory থেকে ভিন্ন নিয়ম:

auto make_discount(int percent) {
    return [percent](int p) { return p - p * percent / 100; };   // percent কপি: নিরাপদ
}
auto eid    = make_discount(10);     // প্রতিটি closure-এ নিজের percent
auto boishakh = make_discount(15);
auto bad = [](int percent) {
    return [&percent](int p) { return p - p * percent / 100; };  // ভুল: percent মরবে
};

ফেরত দেওয়া lambda প্রায় সবসময় সংরক্ষিত হয়, তাই এখানে reference capture প্রায় সবসময় ভুল — উপরের bad-এ percent একটি প্যারামিটার, ফাংশন শেষ হলেই যা ধ্বংস হয়। factory-তে সবসময় value বা init-capture. ফাংশন যদি নানা পথে নানা lambda ফেরত দেয় (যেমন if-else-এ দুটি আলাদা lambda), তাহলে auto চলবে না, কারণ দুটির টাইপ আলাদা; তখন ফেরত-টাইপ হিসেবে std::function লাগে।

সঙ্গে সঙ্গে ডাকা lambda — জটিল const মান বানাতে

কখনো একটি ভ্যারিয়েবলের মান ঠিক করতে কয়েক লাইনের যুক্তি লাগে — if-else, লুপ। সাধারণ পথে লিখতে হয় আগে ভ্যারিয়েবল ঘোষণা, তারপর শাখায় শাখায় মান বসানো — ফলে ভ্যারিয়েবলটি const করা যায় না। সমাধান: একটি lambda লিখে সঙ্গে সঙ্গে ডাকা — IIFE (immediately invoked function expression):

const std::string grade = [&] {       // শেষে () — লিখেই ডাকা
    if (marks >= 80) return "A+";
    if (marks >= 70) return "A";
    if (marks >= 40) return "Pass";
    return "Fail";
}();                                  // grade এখন const, আর কখনো বদলাবে না

এখানে [&] নিরাপদ, কারণ lambda তৈরি হয়েই চলে আর শেষ হয়ে যায় — কোথাও সংরক্ষিত হয় না। কোডটি বলে দেয়: “grade একবারেই ঠিক হবে, তারপর আর কেউ বদলাবে না।” ভুল করে পরে কেউ grade-এ নতুন মান বসাতে চাইলে compiler আটকাবে।

নিজেকে ডাকা — recursive lambda

lambda-র নিজের কোনো নাম নেই, তাই body থেকে নিজেকে ডাকা সহজ নয় — auto fact = [](int n) { ... fact(n - 1) ... }; compile হয় না, কারণ fact-এর টাইপ তখনো ঠিকই হয়নি। পুরোনো সমাধান ছিল std::function-এ রেখে reference-এ নিজেকে capture করা (ধীর), বা নিজেকে একটি প্যারামিটার হিসেবে পাঠানো। C++23-এর “deducing this” (explicit object parameter) এটি পরিষ্কার করেছে:

// C++23: প্রথম প্যারামিটার "this auto self" — lambda নিজেই
auto fact = [](this auto self, int n) -> long long {
    return n <= 1 ? 1 : n * self(n - 1);
};
fact(10);    // 3628800

// C++14 পথ: নিজেকে প্যারামিটার হিসেবে পাঠানো
auto fib = [](auto& me, int n) -> int { return n < 2 ? n : me(me, n - 1) + me(me, n - 2); };
fib(fib, 10);   // 55

তবে সত্যি বলতে, recursive lambda বাস্তবে কম দরকার হয়। নিয়মটি নিজেকে ডাকার মতো জটিল হলে প্রায়ই একটি নাম দেওয়া ফাংশনই বেশি পরিষ্কার।

std::bind — পুরোনো পথ, এখন এড়িয়ে চলুন

C++11-এর সাথে std::bind-ও এসেছিল (Boost.Bind থেকে): একটি ফাংশনের কিছু argument আগে থেকে বসিয়ে নতুন callable বানানো। কিন্তু একই কাজ lambda দিয়ে বেশি পরিষ্কার, আর প্রায়ই দ্রুত:

using namespace std::placeholders;
auto addVat1 = std::bind(addTax, _1, 15);             // _1 মানে? কোনটা কোথায় যায়?
auto addVat2 = [](int price) { return addTax(price, 15); };   // সরাসরি পড়া যায়

bind-এর placeholder (_1, _2) পড়তে কঠিন, overload করা ফাংশনে বিভ্রান্ত হয়, আর বাড়তি argument নীরবে ফেলে দেয়। Scott Meyers তাঁর Effective Modern C++ বইয়ে সোজাসুজি বলেছেন: std::bind-এর চেয়ে lambda বেছে নিন। পুরোনো কোডে দেখলে চিনে রাখুন, নতুন কোডে লিখবেন না।

৯ · AI-এর যুগে — lambda-র ভুল ধরা

AI টুল lambda লিখতে খুব পছন্দ করে — কোড ছোট দেখায়, আধুনিক দেখায়। আর বেশিরভাগ সময় কোডটি compile হয় এবং ছোট পরীক্ষায় ঠিকঠাক চলে। সমস্যা হলো, lambda-র সবচেয়ে বড় ভুল — dangling capture — ঠিক এমন যে ছোট পরীক্ষায় ধরা পড়ে না। callback পরে চলে, thread পরে চলে, আর তখন মৃত মেমরিতে যা ছিল তা হয়তো এখনো আছে। নিচের প্রবণতাগুলো চোখে রাখুন:

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

• প্রতিটি lambda-র জন্য জিজ্ঞেস করেছি: এটি কি সঙ্গে সঙ্গে চলে শেষ হয়, নাকি কোথাও সংরক্ষিত হয় বা অন্য thread-এ যায়?
• সংরক্ষিত lambda-তে কোনো local ভ্যারিয়েবল & দিয়ে ধরা নেই; [&]/[=]-এর বদলে নাম ধরে capture
• member function-এ this capture থাকলে নিশ্চিত হয়েছি object lambda-র চেয়ে বেশি দিন বাঁচে, নইলে [*this]
• std::function শুধু সেখানে, যেখানে নানা টাইপের callable এক টাইপে রাখতে হয়; বাকি জায়গায় auto বা template
• comparator কঠোর < ব্যবহার করে; লম্বা lambda-কে নাম দেওয়া ফাংশনে সরিয়েছি
• -fsanitize=address দিয়ে চালিয়ে দেখেছি, callback পরে চালালে কোনো ASan error (যেমন stack-use-after-return) আসে না