我的问题很简单，我想像使用仿函数作为“比较器”一样使用 lambda，让我稍微解释一下。我有两个大结构，它们都有自己的 operator< 实现，我还有一个 useless使用两个结构的类(这只是这个问题上下文中的类的名称)，一切看起来像这样:

struct be_less
{
    //A lot of stuff
    int val;
    be_less(int p_v):val(p_v){}
    bool operator<(const be_less& p_other) const
    {
        return val < p_other.val;
    }
};

struct be_more
{
    //A lot of stuff
    int val;
    be_more(int p_v):val(p_v){}
    bool operator<(const be_more& p_other) const
    {
        return val > p_other.val;
    }
};

class useless
{
    priority_queue<be_less> less_q;
    priority_queue<be_more> more_q;
public:
    useless(const vector<int>& p_data)
    {
        for(auto elem:p_data)
        {
            less_q.emplace(elem);
            more_q.emplace(elem);
        }
    }
};

我想删除两个结构中的重复，最简单的想法是使结构成为模板并提供两个仿函数来完成比较工作:

template<typename Comp>
struct be_all
{
    //Lot of stuff, better do not duplicate
    int val;
    be_all(int p_v):val{p_v}{}
    bool operator<(const be_all<Comp>& p_other) const
    {
        return Comp()(val,p_other.val);
    }
};

class comp_less
{
public:
    bool operator()(int p_first,
                    int p_second)
    {
        return p_first < p_second;
    }
};

class comp_more
{
public:
    bool operator()(int p_first,
                    int p_second)
    {
        return p_first > p_second;
    }
};

typedef be_all<comp_less> all_less;
typedef be_all<comp_more> all_more;

class useless
{
    priority_queue<all_less> less_q;
    priority_queue<all_more> more_q;
public:
    useless(const vector<int>& p_data)
    {
        for(auto elem:p_data)
        {
            less_q.emplace(elem);
            more_q.emplace(elem);
        }
    }
};

这工作得很好，现在可以肯定的是，我在结构代码中没有任何重复，以两个额外的函数对象为代价。请注意，我非常简化了 operator< 的实现。 , hipotetic real 代码所做的不仅仅是比较两个整数。

然后我在考虑如何使用 lambda 做同样的事情(就像一个实验)。我能够实现的唯一可行的解​​决方案是:

template<typename Comp>
struct be_all
{
    int val;
    function<bool(int,int)> Comparator;
    be_all(Comp p_comp,int p_v):
        Comparator(move(p_comp)),
        val{p_v}
    {}
    bool operator<(const be_all& p_other) const
    {
        return Comparator(val, p_other.val);
    }
};

auto be_less = [](int p_first,
          int p_second)
{
    return p_first < p_second;
};

auto be_more = [](int p_first,
          int p_second)
{
    return p_first > p_second;
};

typedef be_all<decltype(be_less)> all_less;
typedef be_all<decltype(be_more)> all_more;

class useless
{
    priority_queue<all_less> less_q;
    priority_queue<all_more> more_q;
public:
    useless(const vector<int>& p_data)
    {
        for(auto elem:p_data)
        {
            less_q.emplace(be_less,elem);
            more_q.emplace(be_more,elem);
        }
    }
};

这个实现不仅向包含结构的数据添加了一个新成员，而且性能也很差，我准备了一个小测试，我每次都为我在这里展示给你的所有无用类创建一个实例我向构造函数提供了一个包含 200 万个整数的 vector ，结果如下:

1. 执行第一个无用类的构造函数需要 48 毫秒
2. 创建第二个无用类(仿函数)需要 228 毫秒
3. 创建第三个无用类 (lambda) 需要 557 毫秒

显然，我为删除重复项付出的代价非常高，而在原始代码中，重复项仍然存在。请注意第三个实现的性能有多糟糕，比原来的慢十倍，我认为第三个实现比第二个慢的原因是因为 be_all 的构造函数中的附加参数。 ...但是:

实际上还有第四种情况，我仍然使用 lambda 但我摆脱了 Comparator be_all 中附加参数的成员和，代码如下:

template<typename Comp>
struct be_all
{
    int val;
    be_all(int p_v):val{p_v}
    {}
    bool operator<(const be_all& p_other) const
    {
        return Comp(val, p_other.val);
    }
};

bool be_less = [](int p_first,
          int p_second)
{
    return p_first < p_second;
};

bool be_more = [](int p_first,
          int p_second)
{
    return p_first > p_second;
};

typedef be_all<decltype(be_less)> all_less;
typedef be_all<decltype(be_more)> all_more;

class useless
{
    priority_queue<all_less> less_q;
    priority_queue<all_more> more_q;
public:
    useless(const vector<int>& p_data)
    {
        for(auto elem:p_data)
        {
            less_q.emplace(elem);
            more_q.emplace(elem);
        }
    }
};

如果我删除 auto来自 lambda 并使用 bool相反，即使我使用 Comp(val, p_other.val)，代码也会构建在 operator< .

对我来说非常奇怪的是，这第四个实现(没有 Comparator 成员的 lambda)甚至比另一个更慢，最后我能够注册的平均性能如下:

1. 48 毫秒
2. 228 毫秒
3. 557 毫秒
4. 698 毫秒

为什么在这种情况下仿函数比 lambda 快得多？我期待 lambda 至少像普通仿函数一样表现良好，你们中有人可以发表评论吗？第四次实现比第三次慢有什么技术原因吗？

附言:

我使用的编译器是 g++4.8.2 和 -O3。在我的测试中，我为每个 useless 创建对实例进行分类并使用 chrono 我考虑所需的时间:

namespace benchmark
{
    template<typename T>
    long run()
    {
        auto start=chrono::high_resolution_clock::now();
        T t(data::plenty_of_data);
        auto stop=chrono::high_resolution_clock::now();
        return chrono::duration_cast<chrono::milliseconds>(stop-start).count();
    }
}

和:

cout<<"Bad code:  "<<benchmark::run<bad_code::useless>()<<"ms\n";
cout<<"Bad code2: "<<benchmark::run<bad_code2::useless>()<<"ms\n";
cout<<"Bad code3: "<<benchmark::run<bad_code3::useless>()<<"ms\n";
cout<<"Bad code4: "<<benchmark::run<bad_code4::useless>()<<"ms\n";

所有的输入整数集都是相同的，plenty_of_data是一个包含 200 万个整数的 vector 。

谢谢你的时间

最佳答案

您不是在比较 lambda 和仿函数的运行时间。相反，数字表示使用仿函数和 std::function 的区别。 .和 std::function<R(Args...)> ，例如，可以存储任何 Callable满意签名R(Args...) .它通过类型删除来做到这一点。因此，您看到的差异来自 std::function::operator() 中虚拟调用的开销。 .

例如，libc++ implementation(3.5) 有一个基类 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> __base用virtual operator() . std::function存储 __base<...>* .每当你创建一个 std::function可调用 F , template<class F, class _Alloc, class R, class ...Args> class __func 类型的对象被创建，继承自__base<...>并覆盖虚拟 operator() .

关于c++ - 使用 lambda 而不是函数对象，性能不佳，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/28887589/