Question

我正在研究嵌入式系统，因此代码大小是一个问题。使用标准库将我的二进制大小提高了大约60k，从40k到100k。我想使用std :: function，但我不能证明它是60k。是否有可以使用的独立实现或类似的东西？我正在使用它在c ++ 11中使用绑定变量隐式地在成员函数中强制抛出lambda。

Answer 1

这里是std :: function-like类模板的简单实现，不包含任何头文件。您可以根据需要自定义行为（如移动/转发，空呼叫响应等）：

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

60k来自编译器添加的异常处理，因为std :: function需要例外。 std :: function只抛出一个异常“bad_function_call”。所以我删除了抛出异常的代码，现在如果调用一个空函数就会出现seg错误，并且我自救了60k。

是否有std :: function的独立实现？

2 个答案: