デコレータのコンパイル方法-C ++、Python、および独自の実装。パート1

この一連の記事では、C ++でデコレーターを作成する可能性、Pythonでの作業の機能に焦点を当て、独自のコンパイル済み言語でこの機能を実装するためのオプションの1つについて、クロージャーを作成するための一般的なアプローチ（クロージャー変換と構文ツリーの近代化）を使用して検討します。

C ++のデコレーター

それはすべて、私の友人であるVoidDruidが小さなコンパイラを卒業証書として書くことに決めたという事実から始まりました。その主な機能はデコレータです。防御前でも、彼がASTの変更を含む彼のアプローチのすべての利点を概説したとき、私は不思議に思っていました：偉大で強力なC ++でこれらの同じデコレーターを実装し、複雑な用語やアプローチなしで行うことは本当に不可能ですか？このトピックをグーグルで調べたところ、この問題を解決するための単純で一般的なアプローチは見つかりませんでした（ところで、デザインパターンの実装に関する記事だけに出くわしました）。その後、自分のデコレーターを書き始めました。

ただし、実装の直接の説明に移る前に、C ++のラムダとクロージャーがどのように配置されているか、およびそれらの違いについて少しお話したいと思います。特定の標準についての言及がない場合は、デフォルトで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. 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)...
            );
        };
    }
};