爲什麼C++ Lambda函數比等效函數的速度快得多

我很好奇，爲什麼在我的情況下使用lambda函數的實現比具有等效對象的實現要快得多。爲了給你一個規模的想法：10^4的值，快速的一個需要遠遠少於一秒，慢的需要幾十秒。有10^5的價值，快速的一個仍然在一秒之內完成，但慢的需要幾分鐘。爲什麼C++ Lambda函數比等效函數的速度快得多

我想以同樣的方式對兩個數組的值進行排序，就好像我將它們中的一個排序一樣。以一個例子更容易理解： [5 1 2 0]變成[0 1 2 5] [3 5 6 7]到[7 5 6 3]

互聯網有很多種方法怎麼做那，但那不是我想問的。我做了兩個實現：一個使用帶有重載操作符（）的對象，另一個使用lambda函數作爲「比較」。

下面的代碼的lambda函數版本未註釋。要使用比較對象，只需註釋「使用lambda函數進行比較」中的內容並取消「使用比較對象進行比較」的註釋。

#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; 
}

這很酷，如果有人能夠說清楚，這個巨大的性能差距來自何處。

來源

2016-06-29 yar

+12

您手動編寫的類複製向量，lambda表達式不會。 –

感謝您的快速回答！ – yar

你手工編寫的類副本vector：

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

Lambda表達式只是引用它：

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

如果通過拷貝（不&）把sortBySelf那麼他們很可能也有類似的性能。

來源

2016-06-30 00:13:29

謝謝！我現在反過來，改變了「std :: vector < float > m_values;」到「std :: vector < float >＆m_values;」。但我不明白的是：初始化時只複製一次（對吧？）。對於10^5個元素，這不會花費幾秒鐘。 – yar

@ user3022712：'std :: sort'被允許複製給定的仿函數*任意次數*。我可以看到天真的實現至少複製了函子'O（log（n））'次。 –

爲什麼C++ Lambda函數比等效函數的速度快得多

回答

相關問題