Warum C++ 11 std :: sort() ist nicht schneller beim Sortieren von std :: string?

Question

std :: sort() verwendet swap(), um Elemente auszutauschen, wobei swap jetzt in C++ 11 die Semantik "move()" in swap() verwendet, um das Kopieren zu vermeiden.

Ich denke, das ist besonders nützlich für std :: string. Also habe ich ein Experiment entworfen, um dies zu überprüfen out:

1. ich einen Vektor von 10.240.000 Elementen (std :: string) konstruiert werden diese Elemente durch den Zufall() Funktion konstruiert.

2. Verwenden Sie std :: sort, um alle Elemente zu sortieren und die Zeitdauer auszudrucken.

#include<string> 
#include<algorithm> 
#include<vector> 
#include<cstdlib> 
#include<cstdio> 
#include<iostream> 
#include<ctime> 
using namespace std; 
string randomString() 
{ 
    int iBuf[10]; 
    for(size_t i=0;i<10;++i) 
    { 
     double rand0to1=(double)rand()/RAND_MAX; 
     iBuf[i]=rand0to1*92+33; 
    } 
    char ret[6]; 
    snprintf(ret, 6, "%c%c%c%c%c\n", 
     iBuf[0],iBuf[1],iBuf[2],iBuf[3],iBuf[4]); 
    return ret; 
} 
int main() 
{ 
    srand(time(NULL)); 
    const size_t scale=10240000; 
    vector<string> vs; 
    vs.reserve(scale); 
    for(size_t i=0;i<scale;++i) 
    { 
     vs.push_back(randomString()); 
    } 
    cout<<vs.size()<<"End vector construction\n"; 
    clock_t begin=clock(); 
    sort(vs.begin(),vs.end()); 
    clock_t end=clock(); 
    double duration=(double)(end-begin)/CLOCKS_PER_SEC; 
    cout<<"sort "<<scale<<"Time elapse="<<duration<<"seconds\n"; 
    return 0; 
} 

Answer 1

wo Swap jetzt in C++ 11 uses "move()" Semantik in swap() Kopie zu vermeiden.

Das ist, was die nicht spezialisierte/nicht überladene swap() jetzt tut. Es gab eine Überlastung std::swap(std::basic_string) seit vor C++ 11 und es musste nie den Speicherpuffer einer der Argument-Strings kopieren.

Ich denke, das für std besonders nützlich ist :: string

Aufgrund dessen, was ich sagte im letzten Absatz, std::string insbesondere ist ein Fall, in dem Schritt Semantik Swapping keinen Vorteil bringen.

Der generische move-basierte Austausch ist wahrscheinlich gut genug für viele Anwendungsfälle und ermöglicht einen effizienten Austausch für einen benutzerdefinierten beweglichen Typ, ohne dass Sie den Swap spezialisieren müssen. Aber ein spezialisierter Tausch kann immer noch (möglicherweise nur marginal) effizienter sein.

Warum C++ 11 std :: sort() ist nicht schneller beim Sortieren von std :: string?

Da der generische move-basierte Swap keinen Vorteil gegenüber dem bereits existierenden spezialisierten Swap bietet.