एक डेकोरेटर - सी ++, पायथन और इसके स्वयं के कार्यान्वयन को कैसे संकलित किया जाए। भाग 1

लेखों की यह श्रृंखला सी ++ में एक डेकोरेटर बनाने की संभावना के लिए समर्पित होगी , पायथन में उनके काम की विशेषताएं, और अपनी स्वयं की संकलित भाषा में इस कार्यक्षमता को लागू करने के विकल्पों में से एक पर विचार किया जाएगा, क्लोजर बनाने के लिए सामान्य दृष्टिकोण का उपयोग करते हुए - सिंटैक्स ट्री के रूपांतरण और आधुनिकीकरण।

सी ++ में डेकोरेटर

यह सब इस तथ्य से शुरू हुआ कि मेरे दोस्त VoidDruid ने एक डिप्लोमा के रूप में एक छोटा संकलक लिखने का फैसला किया, जिसकी प्रमुख विशेषता सज्जाकार है। पूर्व-रक्षा के दौरान भी, जब उन्होंने अपने दृष्टिकोण के सभी लाभों को रेखांकित किया, जिसमें एएसटी को बदलना शामिल था, तो मैंने सोचा: क्या वास्तव में महान और शक्तिशाली सी ++ में इन समान सज्जाकारों को लागू करना असंभव है और बिना किसी जटिल शब्दों और दृष्टिकोण के? इस विषय को देखते हुए, मुझे इस समस्या को हल करने के लिए कोई सरल और सामान्य दृष्टिकोण नहीं मिला (वैसे, मैं डिजाइन पैटर्न के कार्यान्वयन के बारे में केवल लेख भर में आया था) और फिर अपने खुद के डेकोरेटर को लिखने के लिए बैठ गया।

हालांकि, मेरे कार्यान्वयन के प्रत्यक्ष विवरण पर जाने से पहले, मैं थोड़ा बात करना चाहूंगा कि सी ++ में लैम्ब्डा और क्लोजर कैसे व्यवस्थित होते हैं और उनके बीच क्या अंतर है। तुरंत एक आरक्षण करें कि यदि किसी विशिष्ट मानक का उल्लेख नहीं है, तो डिफ़ॉल्ट रूप से मेरा मतलब है C ++ 20। संक्षेप में, लैम्ब्डा अनाम फ़ंक्शन हैं, और क्लोज़र फ़ंक्शंस हैं जो अपने वातावरण से वस्तुओं का उपयोग करते हैं। उदाहरण के लिए, 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. बनाने के लिए 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)...
            );
        };
    }
};