تعبيرات Lambda بعمق

جزء من قسم البرمجة كائنية التوجه في رحلة C++ على Coddy. الدرس 85 من 104.

تعبيرات Lambda، التي قُدّمت في C++11، هي دوال مجهولة يمكنك تعريفها بشكل مضمن. رغم أنك رأيت تعبيرات Lambda أساسية مع خوارزميات STL، فإن فهم صياغتها الكاملة يتيح إمكانات قوية لالتقاط المتغيرات والتحكم في كيفية الوصول إليها.

صيغة lambda الكاملة هي: [capture](parameters) mutable -> return_type { body }. يحدد بند capture المتغيرات الخارجية التي يمكن لـ lambda الوصول إليها وكيفية ذلك:

#include <iostream>

int main() {
    int x = 10;
    int y = 20;
    
    auto byValue = [x]() { return x * 2; };        // نسخة من x
    auto byRef = [&y]() { y += 5; };               // مرجع إلى y
    auto allByValue = [=]() { return x + y; };     // نسخ الكل
    auto allByRef = [&]() { x++; y++; };           // مرجع للكل
    auto mixed = [x, &y]() { y += x; };            // مزج الاثنين
    
    byRef();
    std::cout << y << "\n";  // 25
}

تكون المتغيرات الملتقطة بالقيمة، افتراضيًا، من النوع const داخل lambda. تسمح الكلمة المفتاحية mutable بتعديل هذه النسخ:

int counter = 0;
auto increment = [counter]() mutable {
    return ++counter;  // يُعدِّل نسخة الـ lambda
};

std::cout << increment() << "\n";  // 1
std::cout << increment() << "\n";  // 2
std::cout << counter << "\n";      // 0 - الأصلي دون تغيير

أضاف C++14 التقاطات التهيئة، مما يتيح لك إنشاء متغيرات جديدة أو نقل الكائنات إلى لامبدا:

auto ptr = std::make_unique<int>(42);
auto lambda = [p = std::move(ptr)]() {
    return *p;
};  // تم نقل الملكية إلى lambda

تكون دوال لامدا مفيدة بشكل خاص في OOP عندما تحتاج إلى تمرير السلوك كمعامل - لاستخدامه مع callbacks أو المقارنات المخصصة أو معالجات الأحداث - من دون تعريف كائنات دوال منفصلة.

التحدي

سهل

لنَبْنِ نظامًا لمعالجة الأحداث يعرض قوة تعبيرات lambda مع أوضاع capture مختلفة. ستنشئ موزّع أحداث بسيطًا يخزّن عمليات callback ويستدعيها، موضحًا كيف يمكن لـ lambdas التقاط الحالة الخارجية بطرق متعددة.

ستنظّم الشيفرة عبر ثلاثة ملفات:

EventDispatcher.h: عرّف EventDispatcher class يدير عمليات callback الخاصة بالأحداث.
يجب أن يخزّن الموزّع عمليات callback باستخدام std::vector من std::function<void()>. ضمّن هذه methods:
- addCallback(std::function<void()> callback): adds عملية callback إلى القائمة
- fireAll(): يستدعي جميع عمليات callback المخزّنة بالترتيب
- clear(): يزيل جميع عمليات callback
ستحتاج إلى تضمين <functional> و<vector>.
EventDispatcher.cpp: نفّذ methods الخاصة بالموزّع. يجب أن تكرّر method fireAll() ببساطة عبر جميع عمليات callback وتستدعي كل واحدة منها.
main.cpp: اقرأ مدخلين:
1. رقمًا أساسيًا (عددًا صحيحًا)
2. معاملًا (عددًا صحيحًا)
أنشئ EventDispatcher واعرض تقنيات capture مختلفة لـ lambda من خلال إضافة ثلاث عمليات callback:
1. lambda تلتقط الرقم الأساسي by value وتطبع: Base value: [base]
2. lambda تلتقط المعامل by reference، وتزيده بمقدار 1، ثم تطبع: Multiplier after increment: [multiplier]
3. lambda mutable تلتقط متغير counter (تمت تهيئته إلى 0) by value، وتزيده في كل مرة تُستدعى فيها، وتطبع: Call count: [counter]
بعد إضافة جميع عمليات callback، استدعِ fireAll() مرتين لترى كيف تتصرف أوضاع capture المختلفة عبر الاستدعاءات المتعددة. بين استدعاءَي fireAll()، اطبع --- كفاصل.

أخيرًا، بعد الجولتين، اطبع القيمة النهائية لمتغير المعامل من main لإظهار تأثير capture by reference عليه: Final multiplier: [multiplier]

على سبيل المثال، عند استخدام المدخلين 10 و5:

Base value: 10
Multiplier after increment: 6
Call count: 1
---
Base value: 10
Multiplier after increment: 7
Call count: 1
Final multiplier: 7

عند استخدام المدخلين 42 و0:

Base value: 42
Multiplier after increment: 1
Call count: 1
---
Base value: 42
Multiplier after increment: 2
Call count: 1
Final multiplier: 2

لاحظ السلوكيات الأساسية: يحافظ الالتقاط by value على base الأصلي دون تغيير، بينما يعدّل الالتقاط by reference متغير multiplier الفعلي في main (ويتراكم التعديل عبر الاستدعاءات)، ويقرأ counter الخاص بـ lambda mutable القيمة 1 في كل جولة. يحدث ذلك لأن fireAll() يكرّر عبر عمليات callback باستخدام النسخ by value: تستدعي كل جولة نسخة جديدة من std::function المخزّنة، ويبدأ counter الملتقَط فيها من 0 ثم تزداد قيمته إلى 1، ولذلك لا تتقدم حالة عملية callback المخزّنة نفسها.

جرّب بنفسك

#include <iostream>
#include "EventDispatcher.h"

using namespace std;

int main() {
    int base;
    int multiplier;
    cin >> base;
    cin >> multiplier;
    
    EventDispatcher dispatcher;
    
    // TODO: أضف lambda يلتقط base BY VALUE
    // يجب أن يطبع: "Base value: [base]"
    
    // TODO: أضف lambda يلتقط multiplier BY REFERENCE
    // It should increment multiplier by 1, then print: "Multiplier after increment: [multiplier]"
    
    // TODO: أضف MUTABLE lambda يلتقط counter (مُهيَّأ إلى 0) بالقيمة
    // يجب أن يزيد counter ويطبع: "Call count: [counter]"
    
    // TODO: استدعِ fireAll() لاستدعاء جميع callbacks
    
    // TODO: اطبع "---" كفاصل
    
    // TODO: استدعِ fireAll() مرة أخرى
    
    // TODO: Print the final multiplier value: "Final multiplier: [multiplier]"
    
    return 0;
}