الـ Functors وتعبيرات Lambda

جزء من قسم Object Oriented Programming في رحلة C++ على Coddy — الدرس 74 من 104.

تقبل العديد من خوارزميات STL كائنًا قابلًا للاستدعاء (callable object) يقوم بتخصيص سلوكها. لقد رأيت بالفعل استخدام تعبيرات لامبدا (lambdas) مع std::transform. لنستكشف كلًا من الكائنات الدالية (functors) و تعبيرات لامبدا (lambda expressions) - وهما طريقتان لإنشاء كائنات قابلة للاستدعاء في ++C.

الـ functor (كائن دالة) هو عبارة عن فئة (class) تقوم بعمل تحميل زائد (overload) لـ operator()، مما يسمح باستدعاء الكائنات المنشأة منها (instances) وكأنها دوال:

#include <algorithm>
#include <vector>
#include <iostream>

struct MultiplyBy {
    int factor;
    MultiplyBy(int f) : factor(f) {}
    
    int operator()(int x) const {
        return x * factor;
    }
};

int main() {
    std::vector<int> nums = {1, 2, 3, 4};
    std::vector<int> result(nums.size());
    
    std::transform(nums.begin(), nums.end(), result.begin(), MultiplyBy(3));
    // النتيجة: {3, 6, 9, 12}
}

يمكن للكائنات الدالية (Functors) الحفاظ على الحالة بين الاستدعاءات، وهو ما لا تستطيع الدوال العادية القيام به. ومع ذلك، فإن تعريف فئة (class) للعمليات البسيطة يعد أمراً مطولاً. توفر تعبيرات لامدا (Lambda expressions) بديلاً موجزاً:

int factor = 3;
std::transform(nums.begin(), nums.end(), result.begin(),
               [factor](int x) { return x * factor; });

صيغة lambda هي [capture](parameters) { body }. تحدد جملة الالتقاط (capture clause) المتغيرات الخارجية التي يمكن لـ lambda الوصول إليها. استخدم [=] لالتقاط الكل بالقيمة، [&] لالتقاط الكل بالمرجع، أو قم بسرد متغيرات محددة مثل [factor] أو [&factor].

تعبيرات لامدا (Lambdas) مفيدة بشكل خاص للعمليات التي تُنفذ لمرة واحدة مع خوارزميات مثل الفرز بمعايير مخصصة:

std::vector<int> nums = {5, -2, 8, -1};
std::sort(nums.begin(), nums.end(), 
          [](int a, int b) { return std::abs(a) < std::abs(b); });
// مرتبة حسب القيمة المطلقة: {-1, -2, 5, 8}

التحدي

سهل

لنقم ببناء آلة حاسبة للأسعار توضح كلاً من الكائنات الدالية (functors) وتعبيرات لامبدا (lambda expressions) لتطبيق استراتيجيات خصم مختلفة على أسعار المنتجات.

ستقوم بتنظيم الكود الخاص بك عبر ملفين:

Discounts.h: قم بتعريف الكائنات الدالية للخصم والدوال المساعدة هنا.
قم بإنشاء كائن دالي يسمى PercentageDiscount يقوم بتخزين نسبة الخصم (كعدد صحيح). يجب أن يأخذ operator() الخاص به سعراً من نوع double ويعيد السعر بعد الخصم. على سبيل المثال، خصم بنسبة 20% على $100 يجب أن يعيد $80.

قم بإنشاء كائن دالي آخر يسمى FixedDiscount يقوم بتخزين مبلغ ثابت لطرحه (كـ double). يجب أن يأخذ operator() الخاص به سعراً ويعيد السعر مطروحاً منه المبلغ الثابت (ولكن لا يقل أبداً عن 0).

قم بإنشاء دالة تسمى printPrices تأخذ const std::vector<double>& وتطبع جميع الأسعار مفصولة بمسافات، متبوعة بسطر جديد. قم بتنسيق كل سعر بمنزلتين عشريتين.
main.cpp: اقرأ خمسة مدخلات (كل منها في سطر منفصل):
1. سعر المنتج الأول (double)
2. سعر المنتج الثاني (double)
3. سعر المنتج الثالث (double)
4. نسبة الخصم المراد تطبيقها (عدد صحيح، مثلاً 20 لـ 20%)
5. مبلغ الخصم الثابت (double)
قم بإنشاء متجه (vector) بالأسعار الثلاثة واستعرض كلا النهجين:
1. اطبع Original prices: متبوعة بالأسعار
2. استخدم std::transform مع الكائن الدالي PercentageDiscount لإنشاء متجه جديد من الأسعار المخفضة. اطبع After percentage discount: متبوعة بالنتائج
3. استخدم std::transform مع الكائن الدالي FixedDiscount على الأسعار الأصلية لإنشاء متجه آخر. اطبع After fixed discount: متبوعة بالنتائج
4. استخدم std::transform مع تعبير لامبدا يضاعف كل سعر أصلي. اطبع Premium prices (doubled): متبوعة بالنتائج
5. استخدم std::sort مع لامبدا لفرز الأسعار الأصلية بترتيب تنازلي. اطبع Sorted (high to low): متبوعة بالأسعار المرتبة

على سبيل المثال، مع المدخلات 100.00، 50.00، 75.00، 20، و 15.00:

Original prices: 100.00 50.00 75.00 
After percentage discount: 80.00 40.00 60.00 
After fixed discount: 85.00 35.00 60.00 
Premium prices (doubled): 200.00 100.00 150.00 
Sorted (high to low): 100.00 75.00 50.00

يتيح لك هذا التحدي مقارنة الكائنات الدالية (التي تحتفظ بالحالة مثل مبلغ الخصم) مع تعبيرات لامبدا (التي تلتقط المتغيرات للعمليات السريعة والمضمنة). يعمل كلا النهجين بسلاسة مع خوارزميات STL مثل std::transform و std::sort.

ورقة مرجعية

تقبل خوارزميات STL الكائنات القابلة للاستدعاء لتخصيص سلوكها. هناك نهجان شائعان هما الكائنات الدالية (functors) و تعبيرات لامدا (lambda expressions).

الكائن الدالي (functor) هو فئة (class) تقوم بتحميل operator() بشكل زائد، مما يسمح باستدعاء مثيلاتها مثل الدوال:

struct MultiplyBy {
    int factor;
    MultiplyBy(int f) : factor(f) {}
    
    int operator()(int x) const {
        return x * factor;
    }
};

std::transform(nums.begin(), nums.end(), result.begin(), MultiplyBy(3));

يمكن للكائنات الدالية الحفاظ على الحالة بين الاستدعاءات، ولكنها تتطلب تعريفات فئات مطولة.

توفر تعبيرات لامدا (Lambda expressions) بديلاً موجزاً بصيغة [capture](parameters) { body }:

int factor = 3;
std::transform(nums.begin(), nums.end(), result.begin(),
               [factor](int x) { return x * factor; });

تحدد عبارة الالتقاط (capture clause) المتغيرات الخارجية التي يمكن للامدا الوصول إليها:

[=] - التقاط الكل بالقيمة
[&] - التقاط الكل بالمرجع
[factor] - التقاط متغير معين بالقيمة
[&factor] - التقاط متغير معين بالمرجع

تعمل تعبيرات لامدا بشكل جيد مع خوارزميات مثل std::sort لمعايير الفرز المخصصة:

std::sort(nums.begin(), nums.end(), 
          [](int a, int b) { return std::abs(a) < std::abs(b); });

جرّب بنفسك

#include <iostream>
#include <vector>
#include <algorithm>
#include "Discounts.h"

int main() {
    // قراءة المدخلات
    double price1, price2, price3;
    int percentageDiscount;
    double fixedDiscount;
    
    std::cin >> price1;
    std::cin >> price2;
    std::cin >> price3;
    std::cin >> percentageDiscount;
    std::cin >> fixedDiscount;
    
    // إنشاء vector بالأسعار الثلاثة
    std::vector<double> prices = {price1, price2, price3};
    
    // TODO: طباعة "Original prices:" متبوعة بالأسعار باستخدام printPrices
    
    // TODO: استخدام std::transform مع PercentageDiscount functor
    // إنشاء vector جديد للنتائج
    // طباعة "After percentage discount:" متبوعة بالنتائج
    
    // TODO: استخدام std::transform مع FixedDiscount functor على الأسعار الأصلية
    // إنشاء vector جديد للنتائج
    // طباعة "After fixed discount:" متبوعة بالنتائج
    
    // TODO: استخدام std::transform مع lambda تضاعف كل سعر أصلي
    // إنشاء vector جديد للنتائج
    // طباعة "Premium prices (doubled):" متبوعة بالنتائج
    
    // TODO: استخدام std::sort مع lambda لفرز الأسعار الأصلية بترتيب تنازلي
    // طباعة "Sorted (high to low):" متبوعة بالأسعار المفروزة
    
    return 0;
}