So kompilieren Sie einen Dekorator - C ++, Python und seine eigene Implementierung. Teil 1

Diese Artikelserie befasst sich mit der Möglichkeit, einen Dekorator in C ++ zu erstellen , den Funktionen ihrer Arbeit in Python, und wir werden auch eine der Optionen für die Implementierung dieser Funktionalität in unserer eigenen kompilierten Sprache betrachten, wobei der allgemeine Ansatz zum Erstellen von Closures verwendet wird - Closure-Konvertierung und Modernisierung des Syntaxbaums.

Dekorateur in C ++

Alles begann mit der Tatsache, dass mein Freund VoidDruid beschlossen hat, einen kleinen Compiler als Diplom zu schreiben, dessen Hauptmerkmal Dekorateure sind. Selbst während der Vorverteidigung, als er alle Vorteile seines Ansatzes skizzierte, einschließlich der Änderung des AST, fragte ich mich: Ist es wirklich unmöglich, dieselben Dekorateure in das großartige und leistungsstarke C ++ zu implementieren und auf komplizierte Begriffe und Ansätze zu verzichten? Als ich dieses Thema googelte, fand ich keine einfachen und allgemeinen Ansätze zur Lösung dieses Problems (übrigens stieß ich nur auf Artikel über die Implementierung des Entwurfsmusters) und setzte mich dann hin, um meinen eigenen Dekorateur zu schreiben.

Bevor ich jedoch zu einer direkten Beschreibung meiner Implementierung übergehe, möchte ich kurz darauf eingehen, wie Lambdas und Closures in C ++ angeordnet sind und was der Unterschied zwischen ihnen ist. Machen Sie sofort einen Vorbehalt, dass ich standardmäßig C ++ 20 meine, wenn kein bestimmter Standard erwähnt wird. Kurz gesagt, Lambdas sind anonyme Funktionen, und Schließungen sind Funktionen, die Objekte aus ihrer Umgebung verwenden. So kann beispielsweise ab C ++ 11 ein Lambda wie folgt deklariert und aufgerufen werden:

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}
    {}
};

Wie Sie sehen können, haben wir einen neuen, nicht standardmäßigen Konstruktor hinzugefügt, der unseren Parameter als Referenz verwendet und als Mitglied der Klasse speichert. Aus diesem Grund müssen Sie beim Festlegen von [&] oder [=] äußerst vorsichtig sein, da der gesamte Kontext innerhalb des Abschlusses gespeichert wird und dies aus dem Speicher heraus möglicherweise nicht optimal ist. Außerdem haben wir den Operator des Castings auf einen Funktionszeiger verloren, da jetzt für seinen normalen Aufruf Kontext benötigt wird. Und jetzt wird der obige Code nicht kompiliert:

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. Dieser Code kann nur mit Version C ++ 14 und höher kompiliert werden, da der zurückgegebene Typ nicht im Voraus bekannt ist. Leider muss ich damit leben und habe keine anderen Möglichkeiten gefunden.
2. Für make muss die Funktion std :: übergeben werden, und die Übergabe einer Funktion nach Namen führt zu Kompilierungsfehlern. Und das ist überhaupt nicht so bequem, wie wir möchten! Wir können keinen Code wie diesen schreiben:
   
   

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

   
   
3. Es ist auch nicht möglich, eine Klassenmethode zu dekorieren.
   

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)...
            );
        };
    }
};