كيفية تجميع الديكور - C ++ و Python وتنفيذها الخاص. الجزء الأول

سيتم تخصيص هذه السلسلة من المقالات لإمكانية إنشاء مصمم في C ++ ، وسيتم النظر في ميزات عملهم في Python ، وسيتم النظر في أحد خيارات تنفيذ هذه الوظيفة بلغتها المترجمة ، باستخدام النهج العام لإنشاء عمليات الإغلاق - تحويل الإغلاق وتحديث شجرة بناء الجملة.

الديكور في C ++

بدأ كل شيء بحقيقة أن صديقي VoidDruid قرر كتابة مترجم صغير كدبلوم ، السمة الرئيسية هي الديكور. حتى خلال فترة ما قبل الدفاع ، عندما أوجز جميع مزايا منهجه ، والتي تضمنت تغيير AST ، تساءلت: هل من المستحيل حقًا تنفيذ هذه الديكورات نفسها في C ++ العظيم والقوي والاستغناء عن أي مصطلحات ونهج معقدة؟ من خلال البحث في هذا الموضوع ، لم أجد أي طرق بسيطة وعامة لحل هذه المشكلة (بالمناسبة ، لقد صادفت فقط مقالات حول تنفيذ نمط التصميم) ثم جلست لكتابة الديكور الخاص بي.

ومع ذلك ، قبل الانتقال إلى وصف مباشر للتنفيذ ، أود أن أتحدث قليلاً عن كيفية ترتيب lambdas والإغلاق في C ++ وما هو الفرق بينهما. قم بالحجز على الفور أنه إذا لم يكن هناك ذكر لمعيار معين ، فإنني أعني بشكل افتراضي C ++ 20. باختصار ، lambdas هي وظائف مجهولة ، والإغلاق هي وظائف تستخدم كائنات من بيئتها. على سبيل المثال ، بدءًا من C ++ 11 ، يمكن الإعلان عن لامدا واستدعاءها على النحو التالي:

int main() 
{
    [] (int a) 
    {
        std::cout << a << std::endl;
    }(10);
}

int main() 
{
    auto lambda = [] (int a) 
    {
        std::cout << a << std::endl;
    };
    lambda(10);
}

class __lambda_60_19
{
public: 
    inline void operator()(int a) const
    {
        std::cout.operator<<(a).operator<<(std::endl);
    }
    
    using retType_60_19 = void (*)(int);
    inline operator retType_60_19 () const noexcept
    {
        return __invoke;
    };
    
private: 
    static inline void __invoke(int a)
    {
        std::cout.operator<<(a).operator<<(std::endl);
    }    
};

void (*p_lambda) (int) = lambda;
p_lambda(10);

int main()
{
    int a = 10;
    auto closure = [&a] () { a += 1; };
    closure();
}

class __lambda_61_20
{
public:
    inline void operator()()
    {
        a += 1;
    }
private:
    int & a;
public:
    __lambda_61_20(int & _a)
    : a{_a}
    {}
};

كما ترى ، قمنا بإضافة مُنشئ جديد غير افتراضي يأخذ معلمتنا حسب المرجع ويحفظها كعضو في الفصل. في الواقع ، هذا هو السبب في أنك بحاجة إلى توخي الحذر الشديد عند تعيين [&] أو [=] ، لأنه سيتم تخزين السياق بأكمله داخل الإغلاق ، ويمكن أن يكون هذا مثاليًا تمامًا من الذاكرة. بالإضافة إلى ذلك ، فقدنا عامل الإرسال إلى مؤشر دالة ، نظرًا لأن سياق المكالمة العادي مطلوب الآن. والآن لن يتم تجميع الرمز أعلاه:

int main()
{
    int a = 10;
    auto closure = [&a] () { a += 1; };
    closure();
    void (*ptr)(int) = closure;
}

std::function<void()> function = closure;
function();

namespace Decorator
{
    template<typename R, typename ...Args>
    static auto make(const std::function<R(Args...)>& f)
    {
        std::cout << "Do something" << std::endl;
        return [=](Args... args) 
        {
            return f(std::forward<Args>(args)...);
        };
    }
};

void myFunc(int a)
{
    std::cout << "here" << std::endl;
}

int main()
{
    std::function<void(int)> f = myFunc;
    auto decorated = Decorator::make(f);
    decorated(10);
}

1. لا يمكن ترجمة هذا الرمز إلا مع الإصدار C ++ 14 والإصدارات الأحدث ، لأنه لا يمكن معرفة النوع الذي تم إرجاعه مسبقًا. لسوء الحظ ، يجب أن أعيش مع هذا ولم أجد خيارات أخرى.
2. make يتطلب تمرير الوظيفة std :: ، ويمرر دالة بالاسم إلى أخطاء في الترجمة. وهذا ليس مناسبًا على الإطلاق كما نود! لا يمكننا كتابة رمز مثل هذا:
   
   

   Decorator::make([](){});
   Decorator::make(myFunc);
   void(*ptr)(int) = myFunc;
   Decorator::make(ptr);

   
   
3. أيضا ، لا يمكن تزيين طريقة الفصل.
   

namespace Decorator
{
    template<typename Function>
    static auto make(Function&& func)
    {
        return [func = std::forward<Function>(func)] (auto && ...args) 
        {
            std::cout << "Do something" << std::endl;
            return std::invoke(
                func,
                std::forward<decltype(args)>(args)...
            );
        };
    }
};

int main()
{
    auto decorated_1 = Decorator::make(myFunc);
    decorated_1(1,2);

    auto my_lambda = [] (int a, int b) 
    { 
        std::cout << a << " " << b <<std::endl; 
    };
    auto decorated_2 = Decorator::make(my_lambda);
    decorated_2(3,4);

    int (*ptr)(int, int) = myFunc;
    auto decorated_3 = Decorator::make(ptr);
    decorated_3(5,6);

    std::function<void(int, int)> fun = myFunc;
    auto decorated_4 = Decorator::make(fun);
    decorated_4(7,8);

    auto decorated_5 = Decorator::make(decorated_4);
    decorated_5(9, 10);

    auto decorated_6 = Decorator::make(&MyClass::func);
    decorated_6(MyClass(10));
}

namespace Decorator
{
    template<typename Function>
    static auto make(Function&& func)
    {
        return [func = std::forward<Function>(func)] 
        <typename ...Args> (Args && ...args) 
        {
            return std::invoke(
                func,
                std::forward<Args>(args)...
            );
        };
    }
};