Question

我很好奇，为什么在我的情况下使用lambda函数的实现比具有等效对象的实现快得多。为了让您了解比例：使用10 ^ 4值，快速值小于1秒，慢速值需要数十秒。对于10 ^ 5个值，快速值仍然在一秒钟内完成，但慢速值则需要几分钟。

我想对两个数组的值进行排序，就像我对其中一个数组进行排序一样。通过示例更容易理解： [5 1 2 0]变为[0 1 2 5] [3 5 6 7]至[7 5 6 3]

互联网上有各种各样的方法如何做到这一点，但这不是我想要问的。我做了两个实现：一个使用带有重载operator（）的对象和一个带有lambda函数的对象＃34;比较＆＃34;。

以下代码取消注释lambda函数版本。要使用比较对象，只需注释掉＆＃34;使用lambda函数进行比较＆＃34;并取消注释＆＃34;使用比较对象＆＃34;进行比较。

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <ctime>

void sortTwoVectorsByFirstVector(std::vector< float >& sortBySelf, std::vector< float >& sortByOther)
{
    // init sort indices
    std::vector < uint32_t > sortIndices(sortBySelf.size());
    for (uint32_t i = 0; i < sortIndices.size(); ++i) {
        sortIndices[i] = i;
    }

    //******** begin: compare using compare object
//    struct CompareClass {
//        std::vector< float > m_values;
//        inline bool operator()(size_t i, size_t j)
//        {
//            return (m_values[i] < m_values[j]);
//        }
//    } compareObject { sortBySelf };
//    std::sort(sortIndices.begin(), sortIndices.end(), compareObject);
    //******* end: compare using compare object

    //********  begin: compare using lambda function
    std::sort(sortIndices.begin(), sortIndices.end(), [&sortBySelf](size_t i, size_t j) {return sortBySelf[i] < sortBySelf[j];});
    //********  end: compare using lambda function

    // collect the sorted elements using the indices
    std::vector< float > sortedBySelf_sorted;
    std::vector< float > sortByOther_sorted;
    sortedBySelf_sorted.resize(sortBySelf.size());
    sortByOther_sorted.resize(sortBySelf.size());

    for (uint32_t i = 0; i < sortBySelf.size(); ++i) {
        sortedBySelf_sorted[i] = sortBySelf[sortIndices[i]];
        sortByOther_sorted[i] = sortByOther[sortIndices[i]];
    }

    sortBySelf.swap(sortedBySelf_sorted);
    sortByOther.swap(sortByOther_sorted);
}

float RandomNumber()
{
    return std::rand();
}
int main()
{
    int vectorSize = 100000;
    std::vector< float > a(vectorSize);
    std::vector< float > b(vectorSize);

    std::srand(100);
    std::generate(a.begin(), a.end(), RandomNumber);
    std::generate(b.begin(), b.end(), RandomNumber);

    std::cout << "started" << std::endl;

    sortTwoVectorsByFirstVector(a, b);

    std::cout << "finished" << std::endl;
}

如果有人能说清楚这会带来巨大的性能差距，那将会很酷。

Answer 1

您手动编写的课程会复制vector：

std::vector< float > m_values;  //<< By value

lambda表达式仅引用它：

[&sortBySelf](size_t i, size_t j) {return sortBySelf[i] < sortBySelf[j];}

如果您按副本sortBySelf进行了&，那么他们可能会有相似的表现。

为什么C ++ Lambda函数作为比较函数比等效对象快得多

1 个答案: