为什么在这段代码中，C ++中的排序比C中的qsort（对于字符串数组）要慢得多？

Question

在《 C ++编程语言》（第4版）一书中， Stroustrup说排序比qsort快得多，但是在我的实验中，我得到了不同的结果，有人可以帮助我解释为什么吗？

这是我的代码：

double begin_time=0, end_time=0, elapsed_time=0;

vector<string> vs1 = { "fsfaa", "errer", "weesa", "yuyre", "wedsa", "xcxcx" };
begin_time = clock();

for (int i = 0; i < 1000000; i++)
{
    std::sort(vs1.begin(), vs1.end());
}

end_time = clock();
elapsed_time = double(end_time - begin_time) / CLOCKS_PER_SEC;

printf("\n\nElapsed time: %f\n", elapsed_time);

const char* vs[] = { "fsfaa", "errer", "weesa", "yuyre", "wedsa", "xcxcx" };
begin_time = clock();

for (int i = 0; i < 1000000; i++)
{
    std::qsort(vs, sizeof(vs) / sizeof(*vs), sizeof(*vs), (int(*)(const void*, const void*))compare_function);
}

end_time = clock();
elapsed_time = double(end_time - begin_time) / CLOCKS_PER_SEC;
printf("\n\nElapsed time: %f\n", elapsed_time);

和，

int compare_function(const void * a, const void * b) {
const char *pa = *(const char**)a;
const char *pb = *(const char**)b;

return strcmp(pa, pb);

}

结果如下（Windows / Visual Studio）：

Elapsed time: 0.245000
Elapsed time: 0.090000

更新：感谢您的建议，我将代码更改如下：

int compFunc_2(const void * a, const void * b) {
    const char *pa = *(char**)a;
    const char *pb = *(char**)b;

    return strcmp(pa, pb);
}

bool compFunc(const char *c1, const char *c2)
{
    return strcmp(c1, c2) < 0;
}

string gen_random_str(int len)
{
    string str;
    string w = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

    for (int i = 0; i < len; i++)
    {
        str += w[rand() % sizeof(w)];
    }
    return str;
}

char *convert(const std::string & s)
{
    char *pc = new char[s.size() + 1];
    strcpy(pc, s.c_str());
    return pc;
}


int main()
{

    srand((unsigned)time(0));
    const int str_num = 1000000;
    vector<string> vs;
    vector<char*>  vc;
    vector<char*>  vc2; //
    char**  as = new char*[str_num];

    for (int i = 0; i < str_num; i++)
    {
        string tmp = gen_random_str(10);  // length is 10
        vs.push_back(tmp);
        as[i] = new char(tmp.size() + 1);
        strcpy(as[i], tmp.c_str());
    }
    transform(vs.begin(), vs.end(), std::back_inserter(vc), convert);
    transform(vs.begin(), vs.end(), std::back_inserter(vc2), convert);



    double begin_time = 0, end_time, elapsed_time;

    begin_time = clock();
    std::qsort(&vc[0], str_num, sizeof(vc[0]), (int(*)(const void*, const void*))compFunc_2);
    end_time = clock();
    elapsed_time = double(end_time - begin_time) / CLOCKS_PER_SEC;
    printf("\n[1] vector<char*>(qsort) Elapsed time: %f", elapsed_time);

    begin_time = clock();
    std::sort(vc2.begin(), vc2.end(), compFunc);
    end_time = clock();
    elapsed_time = double(end_time - begin_time) / CLOCKS_PER_SEC;
    printf("\n[2] vector<char*>(sort) Elapsed time: %f", elapsed_time);



    printf("\nOther test:");
    begin_time = clock();
    std::qsort(as, str_num, sizeof(as[0]), (int(*)(const void*, const void*))compFunc_2);
    end_time = clock();
    elapsed_time = double(end_time - begin_time) / CLOCKS_PER_SEC;
    printf("\n[3] char array(qsort)   Elapsed time: %f", elapsed_time); 

    begin_time = clock();
    std::sort(vs.begin(), vs.end());
    end_time = clock();
    elapsed_time = double(end_time - begin_time) / CLOCKS_PER_SEC;
    printf("\n[4] vector<string>(sort) Elapsed time: %f", elapsed_time);

    // clean
    cin.get();
    return 0;
}

而且，我在计算机上得到了结果：

[1] vector<char*>(qsort) Elapsed time: 1.752000
[2] vector<char*>(sort) Elapsed time: 6.004000
Other test:
[3] char array(qsort)   Elapsed time: 1.691000
[4] vector<string>(sort) Elapsed time: 46.663000

有人说，是的，[1]和[3] / [4]之间没有比较 （由于数据不同），但是我仍然对[1]和[2]感到困惑，为什么排序似乎仍然慢点？ （我已经关闭了VS中的Optimize），任何帮助将不胜感激。

Answer 1

基准测试中有许多问题使您无法从中得出任何结论：

1. 您可以将std::sort std::strings的std::vector与qsort的char* s数组进行比较。 正确的基准应该使用相同的数据结构。

2. 设置大小6不能代表基准几个数量级。

3. 两种算法都进行了排序，因此尽管每个算法执行一百万次迭代，但实际上只有第一个执行排序。 以下999999迭代“排序”已对数据进行排序。

4. 您对排序后的数据没有任何意义，因此编译器甚至可能删除您的代码。

Answer 2

发现了问题，正如@ manni66指出的那样，我犯了一个大错误。.我使用Debug模式，当我更改为Release模式时，结果是合理的：

[1] vector<char*>(qsort) Elapsed time: 0.559000
[2] vector<char*>(sort) Elapsed time: 0.530000
Other test:
[3] char array(qsort)   Elapsed time: 0.512000
[3] vector<string>(sort) Elapsed time: 0.620000