blocks|key|2997298|text|在没有启用优化的情况下，这两种排序算法应该具有相当的性能。C%2B%2B+sort明显优于qsort的原因是，编译器可以内联正在进行的比较，因为编译器具有关于正在使用什么函数执行比较的类型信息。您是否在启用优化的情况下运行这些测试？如果没有，请尝试将其打开并再次运行此测试。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2997299|entityMap^0|X|4|15|5|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

The two sorting algorithms, without optimizations enabled, should have comparable performance. The reason that the C++ <code>sort</code> tends to appreciably beat <code>qsort</code> is that the compiler can inline the comparisons being made, since the compiler has type information about what function is being used to perform the comparison. Did you run these tests with optimization enabled? If not, try turning it on and running this test again.

blocks|key|284101|text|clock+()不是可行的计时时钟。您应该使用特定于平台的较高分辨率计时器，如Windows高性能计时器。更重要的是，调用clock()的方法是首先将文本输出到控制台，该控制台包含在时间中。这肯定会使测试无效。此外，请确保使用所有优化进行编译。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|284102|最后，我复制并粘贴了您的代码，qsort获得了0.016，std::sort获得了0.008。|284103|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

std::clock() is not a viable timing clock. You should use a platform-specific higher resolution timer, like the Windows High Performance Timer. More than that, the way that you call clock() is that first, text is output to the console, which is included in the time. This definitely invalidates the test. In addition, make sure that you compiled with all optimizations.

Finally, I copied and pasted your code, and got 0.016 for qsort and 0.008 for std::sort.

blocks|key|281932|text|qsort可能比预期执行得更好的另一个原因是，较新的编译器可以通过函数指针内联和优化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|281933|如果C标头定义了qsort的内联实现，而不是在库中实现它，并且编译器支持间接函数内联，那么qsort可以与std::sort一样快。|281934|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Another reason that qsort may perform much better than expected is that newer compilers can inline and optimize through the function pointer.

If the C header defines an inline implementation of qsort instead of implementing it inside of a library and the compiler supports indirect function inlining, then qsort can be just as fast as std::sort.

blocks|key|3210815|text|在我的机器上添加一些肉(使数组成为1000万个元素并将其移动到数据部分)，并使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3210816|g%2B%2B+-Wall+-O2+-osortspeed+sortspeed.cpp|code-block|syntax|javascript|3210817|我得到的结果是|3210818|C+quick-sort+time+elapsed:+3.48
C%2B%2B+quick-sort+time+elapsed:+1.26|3210819|还要注意现代的“绿色”CPU，它们可能被配置为根据系统的负载以不同的速度运行。在进行基准测试时，这种行为可能会让您抓狂(在我的机器上，我有一个小脚本来修复我在进行速度测试时使用的CPU时钟)。|3210820|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

On my machine adding some meat (making the array 10 million elements and moving it in the data section) and compiling with

<pre><code>g++ -Wall -O2 -osortspeed sortspeed.cpp
</code></pre>

I get as result

<pre><code>C quick-sort time elapsed: 3.48
C++ quick-sort time elapsed: 1.26
</code></pre>

Be also careful about modern "green" CPUs that may be configured to run at a variable speed depending on the load of the system. When benchmarking, this kind of behavior can drive you crazy (on my machine I've a small script that fixes CPU clock that I use when making speed tests).

blocks|key|2997573|text|我很惊讶，竟然没有人提到缓存。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2997574|在您的代码中，首先要接触ary和*ary_copy*，以便它们在qsort时驻留在缓存中。在qsort期间，*ary_copy*可能会被逐出。在执行std::sort时，必须从内存或更大(读取速度较慢)的缓存级获取元素。当然，这取决于您的缓存大小。|2997575|尝试反向测试，即通过运行std::sort开始。|2997576|正如一些人所指出的那样，使数组变得更大将使测试更加公平。原因是大型数组不太可能放入缓存中。|2997577|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

I am surprised that no one mentions caches.

In your code, you start by touching ary and *ary_copy* so they are resident in the cache at the time of qsort. During qsort, *ary_copy* might get evicted. At the time of std::sort, the elements would have to be fetched from memory or a larger (read slower) cache level. This will of course depend on your cache sizes.

Try to reverse the test, i.e., start by running std::sort.

As some people have pointed out; making the array larger will make the test more fair. The reason is that a large array is less likely to fit in cache.

blocks|key|285412|text|编写准确的基准测试是很困难的，所以让Nonius来为我们做吧！让我们在一个包含一百万个随机整数的向量上测试qsort、不带内联的std::sort和带内联(缺省值)的std::sort。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|285413|//+sort.cpp
#define+NONIUS_RUNNER
#include+<nonius.h%2B%2B>
#include+<random>
#include+<algorithm>

//+qsort
int+comp(const+void*+a,+const+void*+b)+{
++++const+int+arg1+=+*static_cast<const+int*>(a);
++++const+int+arg2+=+*static_cast<const+int*>(b);

++++//+we+can't+simply+return+a+-+b,+because+that+might+under/overflow
++++return+(arg1+>+arg2)+-+(arg1+<+arg2);
}

//+std::sort+with+no+inlining
struct+compare_noinline+{
++++__attribute__((noinline))+bool+operator()(const+int+a,+const+int+b)+{
++++++++return+a+<+b;
++++}
};

//+std::sort+with+inlining
struct+compare+{
++++//+the+compiler+will+automatically+inline+this
++++bool+operator()(const+int+a,+const+int+b)+{
++++++++return+a+<+b;
++++}
};

std::vector<int>+gen_random_vector(const+size_t+size)+{

++++std::random_device+seed;
++++std::default_random_engine+engine{seed()};
++++std::uniform_int_distribution<int>+dist{std::numeric_limits<int>::min(),+std::numeric_limits<int>::max()};

++++std::vector<int>+vec;
++++for+(size_t+i+=+0;+i+<+size;+i+%2B=+1)+{
++++++++const+int+rand_int+=+dist(engine);
++++++++vec.push_back(rand_int);
++++}

++++return+vec;
}

//+generate+a+vector+of+a+million+random+integers
constexpr+size_t+size+=+1'000'000;
static+const+std::vector<int>+rand_vec+=+gen_random_vector(size);

NONIUS_BENCHMARK("qsort",+[](nonius::chronometer+meter)+{

++++//+Nonius+does+multiple+runs+of+the+benchmark,+and+each+one+needs+a+new
++++//+copy+of+the+original+vector,+otherwise+we'd+just+be+sorting+the+same
++++//+one+over+and+over
++++const+size_t+runs+=+static_cast<size_t>(meter.runs());
++++std::vector<std::vector<int>>+vectors{runs};
++++std::fill(vectors.begin(),+vectors.end(),+rand_vec);

++++meter.measure([&](const+size_t+run)+{

++++++++std::vector<int>&+current_vec+=+vectors[run];

++++++++std::qsort(current_vec.data(),+current_vec.size(),+sizeof(int),+comp);

++++++++return+current_vec;
++++});
});

NONIUS_BENCHMARK("std::sort+noinline",+[](nonius::chronometer+meter)+{

++++const+size_t+runs+=+static_cast<size_t>(meter.runs());
++++std::vector<std::vector<int>>+vectors{runs};
++++std::fill(vectors.begin(),+vectors.end(),+rand_vec);

++++meter.measure([&](const+size_t+run)+{

++++++++std::vector<int>&+current_vec+=+vectors[run];

++++++++std::sort(current_vec.begin(),+current_vec.end(),+compare_noinline{});

++++++++return+current_vec;

++++});
});

NONIUS_BENCHMARK("std::sort+inline",+[](nonius::chronometer+meter)+{

++++const+size_t+runs+=+static_cast<size_t>(meter.runs());
++++std::vector<std::vector<int>>+vectors{runs};
++++std::fill(vectors.begin(),+vectors.end(),+rand_vec);

++++meter.measure([&](const+size_t+run)+{

++++++++std::vector<int>&+current_vec+=+vectors[run];

++++++++std::sort(current_vec.begin(),+current_vec.end(),+compare{});

++++++++return+current_vec;

++++});
});|code-block|syntax|javascript|285414|使用Apple+Clang+7.3.0编译，|285415|$+clang%2B%2B+-std=c%2B%2B14+-stdlib=libc%2B%2B+-O3+-march=native+sort.cpp+-o+sort
$+./sort|285416|在我的1.7+GHz+i5+Macbook+Air上运行它，我们得到|285417|qsort++++++++++++++++211+ms+%2B/-+6+ms
std::sort+noinline+++127+ms+%2B/-+5+ms
std::sort+inline++++++87+ms+%2B/-+4+ms|285418|因此，没有内联的std::sort大约比qsort快1.7倍(可能是因为不同的排序算法)，而内联凹凸的速度高达2.4倍。当然，这是一个令人印象深刻的加速，但远远低于670%25。|285419|entityMap|0|LINK|mutability|MUTABLE|url|https://nonius.io/^0|1H|5|1S|9|2B|9|I|6|0|0|0|0|0|0|0|8|9|K|5|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@$9|19|A|1A|1|1B]]|E|$]]|$1|F|3|G|5|H|7|1C|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1D|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|1E|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1F|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1G|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1H|8|@$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1M|8|@]|D|@]|E|$]]]|V|$W|$5|X|Y|Z|E|$10|11]]]]

Writing accurate benchmarks is difficult, so let's get <a href="https://nonius.io" rel="noreferrer">Nonius</a> to do it for us! Let's test <code>qsort</code>, <code>std::sort</code> with no inlining, and <code>std::sort</code> with inlining (the default) on a vector of a million random integers.

<pre class="lang-cpp prettyprint-override"><code>// sort.cpp
#define NONIUS_RUNNER
#include &lt;nonius.h++&gt;
#include &lt;random&gt;
#include &lt;algorithm&gt;

// qsort
int comp(const void* a, const void* b) {
 const int arg1 = *static_cast&lt;const int*&gt;(a);
 const int arg2 = *static_cast&lt;const int*&gt;(b);

 // we can't simply return a - b, because that might under/overflow
 return (arg1 &gt; arg2) - (arg1 &lt; arg2);
}

// std::sort with no inlining
struct compare_noinline {
 __attribute__((noinline)) bool operator()(const int a, const int b) {
 return a &lt; b;
 }
};

// std::sort with inlining
struct compare {
 // the compiler will automatically inline this
 bool operator()(const int a, const int b) {
 return a &lt; b;
 }
};

std::vector&lt;int&gt; gen_random_vector(const size_t size) {

 std::random_device seed;
 std::default_random_engine engine{seed()};
 std::uniform_int_distribution&lt;int&gt; dist{std::numeric_limits&lt;int&gt;::min(), std::numeric_limits&lt;int&gt;::max()};

 std::vector&lt;int&gt; vec;
 for (size_t i = 0; i &lt; size; i += 1) {
 const int rand_int = dist(engine);
 vec.push_back(rand_int);
 }

 return vec;
}

// generate a vector of a million random integers
constexpr size_t size = 1'000'000;
static const std::vector&lt;int&gt; rand_vec = gen_random_vector(size);

NONIUS_BENCHMARK("qsort", [](nonius::chronometer meter) {

 // Nonius does multiple runs of the benchmark, and each one needs a new
 // copy of the original vector, otherwise we'd just be sorting the same
 // one over and over
 const size_t runs = static_cast&lt;size_t&gt;(meter.runs());
 std::vector&lt;std::vector&lt;int&gt;&gt; vectors{runs};
 std::fill(vectors.begin(), vectors.end(), rand_vec);

 meter.measure([&amp;](const size_t run) {

 std::vector&lt;int&gt;&amp; current_vec = vectors[run];

 std::qsort(current_vec.data(), current_vec.size(), sizeof(int), comp);

 return current_vec;
 });
});

NONIUS_BENCHMARK("std::sort noinline", [](nonius::chronometer meter) {

 const size_t runs = static_cast&lt;size_t&gt;(meter.runs());
 std::vector&lt;std::vector&lt;int&gt;&gt; vectors{runs};
 std::fill(vectors.begin(), vectors.end(), rand_vec);

 meter.measure([&amp;](const size_t run) {

 std::vector&lt;int&gt;&amp; current_vec = vectors[run];

 std::sort(current_vec.begin(), current_vec.end(), compare_noinline{});

 return current_vec;

 });
});

NONIUS_BENCHMARK("std::sort inline", [](nonius::chronometer meter) {

 const size_t runs = static_cast&lt;size_t&gt;(meter.runs());
 std::vector&lt;std::vector&lt;int&gt;&gt; vectors{runs};
 std::fill(vectors.begin(), vectors.end(), rand_vec);

 meter.measure([&amp;](const size_t run) {

 std::vector&lt;int&gt;&amp; current_vec = vectors[run];

 std::sort(current_vec.begin(), current_vec.end(), compare{});

 return current_vec;

 });
});
</code></pre>

Compiling with Apple Clang 7.3.0,

<pre class="lang-none prettyprint-override"><code>$ clang++ -std=c++14 -stdlib=libc++ -O3 -march=native sort.cpp -o sort
$ ./sort
</code></pre>

and running it on my 1.7 GHz i5 Macbook Air, we get

<pre class="lang-none prettyprint-override"><code>qsort 211 ms +/- 6 ms
std::sort noinline 127 ms +/- 5 ms
std::sort inline 87 ms +/- 4 ms
</code></pre>

So <code>std::sort</code> with no inlining is about 1.7x faster than <code>qsort</code> (perhaps due to different sorting algorithms), and inlining bumps that up to about 2.4x faster. Certainly an impressive speedup, but much less than 670%.

blocks|key|285442|text|为什么没有人在C标准库的比较函数中提到额外的内存获取？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|285443|在C标准库中，void*用于保存所有类型的成员数据，这意味着当实际访问成员数据时，必须执行void*指针一次额外的取消引用。|285444|struct+list+{
++++++++void+*p_data;+//+deference+this+pointer+when+access+real+data
++++++++struct+list+*prev;
++++++++struct+list+*next;
};|code-block|syntax|javascript|285445|然而，在STL中，借助模板的代码生成功能，在C标准库中使用void*保存的成员数据可以直接放在类型中，从而避免在访问时额外取消引用。|285446|template+<typename+T>
class+list+{
public:
++++++++T+data;+//+access+data+directly
++++++++list+*prev;
++++++++list+*next;
};|285447|因此，从理论上讲，std::sort比qsort更快。|285448|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Why there's no one mentions that extra memory fetch in the C standard library's compare function?
In the C standard library, void* is used to hold all types of member data, which means that when the member data is actually accessed, the void* pointer must be performed once additional dereference.
<pre><code>struct list {
 void *p_data; // deference this pointer when access real data
 struct list *prev;
 struct list *next;
};
</code></pre>
However, in STL, with the help of template's code generation capabilities, member data saved with void* in the C standard library can be directly placed inside the type, avoiding additional dereferences during access.
<pre><code>template &lt;typename T&gt;
class list {
public:
 T data; // access data directly
 list *prev;
 list *next;
};
</code></pre>
So, in theory, std::sort is faster than qsort.

blocks|key|3211026|text|我不确定是不是快了670%25。它必须是为显示std::sort速度而量身定做的特定数据集。一般来说，std::sort确实比qsort快，这是因为以下几点：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3211027|3211028|qsort在void*上操作，首先需要取消引用，其次需要数据类型的大小来执行交换。因此，qsort的交换操作是按字节进行的。查看qsort实现，注意它的SWAP宏是一个循环。这是Jon+Bentley的视频，解释了时间差(从45米开始)：https://www.youtube.com/watch?v=aMnn0Jq0J-E&t=2700s|ordered-list-item|3211029|3211030|3211031|+inline可能会让它更快一点，但这是微优化，而不是主要的contributor.|3211032|3211033|3211034|std::sort实际上是一种称为Introsort的混合算法。C+qsort是一个纯粹的快速排序实现。给定一个不适合快速排序的数据集，std::sort改为堆排序。因此，如果你为qsort创建了一个糟糕的输入，它将变得非常慢。|3211035|3211036|3211037|上面的分析代码是不够的。应增加输入大小。10万是远远不够的。将其增加到1M或10M，然后重复多次排序，然后取平均值或中位数。如有必要，可将它们编译成单独的二进制文件并单独运行。|3211038|3211039|entityMap|0|LINK|mutability|MUTABLE|url|https://www.youtube.com/watch?v=aMnn0Jq0J-E&t=2700s|1|https://en.wikipedia.org/wiki/Introsort^0|L|9|1D|9|1P|5|0|0|0|5|6|5|18|5|1S|5|24|4|3B|1F|0|0|0|0|1|6|0|0|0|0|9|Y|5|1W|9|2I|5|H|9|1|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|1E|8|@$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]|$9|1N|A|1O|B|C]]|D|@$9|1P|A|1Q|1|1R]]|E|$]]|$1|J|3|-4|5|6|7|1S|8|@]|D|@]|E|$]]|$1|K|3|-4|5|6|7|1T|8|@]|D|@]|E|$]]|$1|L|3|M|5|I|7|1U|8|@$9|1V|A|1W|B|C]]|D|@]|E|$]]|$1|N|3|-4|5|6|7|1X|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|1Y|8|@]|D|@]|E|$]]|$1|P|3|Q|5|I|7|1Z|8|@$9|20|A|21|B|C]|$9|22|A|23|B|C]|$9|24|A|25|B|C]|$9|26|A|27|B|C]]|D|@$9|28|A|29|1|2A]]|E|$]]|$1|R|3|-4|5|6|7|2B|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|2C|8|@]|D|@]|E|$]]|$1|T|3|U|5|I|7|2D|8|@]|D|@]|E|$]]|$1|V|3|-4|5|6|7|2E|8|@]|D|@]|E|$]]|$1|W|3|-4|5|6|7|2F|8|@]|D|@]|E|$]]]|X|$Y|$5|Z|10|11|E|$12|13]]|14|$5|Z|10|11|E|$12|15]]]]

I am not sure with 670% faster. It must have been a specific dataset tailored to show the speed of <code>std::sort</code>. In general, <code>std::sort</code> is indeed faster than <code>qsort</code> because of a couple of these things:
<ol>
<li><code>qsort</code> operates on <code>void*</code>, which first requires a dereference, and second requires the size of the data type to perform the swaps. Therefore, the swap operation of <code>qsort</code> is done every byte. Look at <code>qsort</code> implementation and notice its <code>SWAP</code> macro is a loop. Here's the video by Jon Bentley explaining the timing differences (starts at 45m): <a href="https://www.youtube.com/watch?v=aMnn0Jq0J-E&amp;t=2700s" rel="nofollow noreferrer">https://www.youtube.com/watch?v=aMnn0Jq0J-E&amp;t=2700s</a>
</li>
<li>The <code>inline</code> may make it speed up a bit, but that's micro-optimization, not the major contributor.
</li>
<li><code>std::sort</code> is actually a hybrid algorithm called <a href="https://en.wikipedia.org/wiki/Introsort" rel="nofollow noreferrer">Introsort</a>. C <code>qsort</code> is a pure quicksort implementation. Given a dataset that's terrible for quicksort, <code>std::sort</code> changes to heapsort instead. So if you create a bad input for <code>qsort</code>, it will be unbearably slow.
</li>
<li>The profiling code above is insufficient. Input size should be increased. 100K is hardly enough. Increase it to 1M or 10M, then repeat the sorting multiple times then take the average or median. If necessary, compile them into a separate binary and run them separately.
</li>
</ol>

According to Scott Meyers, in his Effective STL book - item 46. He claimed that <a href="http://en.cppreference.com/w/cpp/algorithm/sort" rel="nofollow noreferrer"><code>std::sort</code></a> is about 670% faster than <a href="http://en.cppreference.com/w/cpp/algorithm/qsort" rel="nofollow noreferrer"><code>std::qsort</code></a> due to the fact of inline. I tested myself, and I saw that qsort is faster :( ! Could anyone help me to explain this strange behavior?
<pre><code>#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;algorithm&gt;

#include &lt;cstdlib&gt;
#include &lt;ctime&gt;
#include &lt;cstdio&gt;

const size_t LARGE_SIZE = 100000;

struct rnd {
 int operator()() {
 return rand() % LARGE_SIZE;
 }
};

int comp( const void* a, const void* b ) {
 return ( *( int* )a - *( int* )b );
}

int main() {
 int ary[LARGE_SIZE];
 int ary_copy[LARGE_SIZE];
 // generate random data
 std::generate( ary, ary + LARGE_SIZE, rnd() );
 std::copy( ary, ary + LARGE_SIZE, ary_copy );
 // get time
 std::time_t start = std::clock();
 // perform quick sort C using function pointer
 std::qsort( ary, LARGE_SIZE, sizeof( int ), comp );
 std::cout &lt;&lt; &quot;C quick-sort time elapsed: &quot; &lt;&lt; static_cast&lt;double&gt;( clock() - start ) / CLOCKS_PER_SEC &lt;&lt; &quot;\n&quot;;
 // get time again
 start = std::clock();
 // perform quick sort C++ using function object
 std::sort( ary_copy, ary_copy + LARGE_SIZE );
 std::cout &lt;&lt; &quot;C++ quick-sort time elapsed: &quot; &lt;&lt; static_cast&lt;double&gt;( clock() - start ) / CLOCKS_PER_SEC &lt;&lt; &quot;\n&quot;;
}
</code></pre>
This is my result:
<pre><code>C quick-sort time elapsed: 0.061
C++ quick-sort time elapsed: 0.086
Press any key to continue . . .
</code></pre>
Update
Effective STL 3rd Edition ( 2001 ) 
Chapter 7 Programming with STL 
Item 46: Consider function objects instead of functions as algorithm parameters.

Performance of qsort vs std::sort?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

根据斯科特·迈耶斯的说法，在他的有效STL书中-项目46。他声称，由于内联的事实，比快大约670%。我测试了自己，我发现qsort更快:(！有人能帮我解释一下这种奇怪的行为吗？#include <iostream>#include <vector>#include <algorithm>#include <cstdli...

问qsort与std::sort的性能比较？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问qsort与std::sort的性能比较？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问qsort与std::sort的性能比较？
EN