c++ - std::function のスタンドアロン実装はありますか?

Question

私は組み込みシステムに取り組んでいるので、コード サイズが問題になります。標準ライブラリを使用すると、バイナリ サイズが 40k から 100k に約 60k 増加します。std::function を使用したいのですが、60k では正当化できません。私が使用できるスタンドアロンの実装、または同様のものはありますか? 私はそれを使用して、C++ 11 でバインドされた変数を持つメンバー関数でラムダを暗黙的にキャストしています。

Answer 1

これは、ヘッダーを含まない std::function のようなクラス テンプレートの単純な実装です。必要に応じて動作をカスタマイズできます (移動/転送、空の通話応答など)。

live_demo

// Scroll down for example of usage
namespace bicycle
{
    template<typename Result,typename ...Args>
    struct abstract_function
    {
        virtual Result operator()(Args... args)=0;
        virtual abstract_function *clone() const =0;
        virtual ~abstract_function() = default;
    };

    template<typename Func,typename Result,typename ...Args>
    class concrete_function: public abstract_function<Result,Args...>
    {
        Func f;
    public:
        concrete_function(const Func &x)
            : f(x)
        {}
        Result operator()(Args... args) override
        {
            return f(args...);
        }
        concrete_function *clone() const override
        {
            return new concrete_function{f};
        }
    };

    template<typename Func>
    struct func_filter
    {
        typedef Func type;
    };
    template<typename Result,typename ...Args>
    struct func_filter<Result(Args...)>
    {
        typedef Result (*type)(Args...);
    };

    template<typename signature>
    class function;

    template<typename Result,typename ...Args>
    class function<Result(Args...)>
    {
        abstract_function<Result,Args...> *f;
    public:
        function()
            : f(nullptr)
        {}
        template<typename Func> function(const Func &x)
            : f(new concrete_function<typename func_filter<Func>::type,Result,Args...>(x))
        {}
        function(const function &rhs)
            : f(rhs.f ? rhs.f->clone() : nullptr)
        {}
        function &operator=(const function &rhs)
        {
            if( (&rhs != this ) && (rhs.f) )
            {
                auto *temp = rhs.f->clone();
                delete f;
                f = temp;
            }
            return *this;
        }
        template<typename Func> function &operator=(const Func &x)
        {
            auto *temp = new concrete_function<typename func_filter<Func>::type,Result,Args...>(x);
            delete f;
            f = temp;
            return *this;
        }
        Result operator()(Args... args)
        {
            if(f)
                return (*f)(args...);
            else
                return Result{};
        }
        ~function()
        {
            delete f;
        }
    };
}

// ___________________[ Example of usage ]___________________ //

int func1(double)
{
    return 1;
}
struct Functor2
{
    int operator()(double)
    {
        return 2;
    }
};

double func3(bool,int)
{
    return 3.0;
}
struct Functor4
{
    double operator()(bool,int)
    {
        return 4.0;
    }
};

int main()
{
    int res = 10;
    {
        bicycle::function<int(double)> f{func1};

        res -= f(1.0);
        f = Functor2{};
        res -= f(2.0);
    }
    {
        bicycle::function<double(bool,int)> f1;
        f1 = func3;

        bicycle::function<double(bool,int)> f2{f1};
        res -= f2(true,1);

        f1 = Functor4{};
        f2 = f1;
        res -= f2(false,2);
    }
    return res;
}

Answer 2

std::function には例外が必要だったので、60k はコンパイラによって追加された例外処理から来ました。std::function は、「bad_function_call」という 1 つの例外のみをスローします。そのため、例外をスローしたコードを削除しました。空の関数が呼び出された場合にセグ フォールトが発生するようになり、60k 節約できました。