Related Articles
C qsort() vs C++ sort()
• Difficulty Level : Medium
• Last Updated : 14 Aug, 2018

Standard C library provides qsort function that can be used for sorting an array. Following is the prototype of qsort() function.

```// Sort an array of any type. The parameters are, base
// address of array, size of array and pointer to
// comparator function
void qsort (void* base, size_t num, size_t size,
int (*comparator)(const void*, const void*));```

It requires a pointer to the array, the number of elements in the array, the size of each element and a comparator function. We have discussed qsort comparator in detail here.

C++ Standard Library provides a similar function sort() that originated in the STL. We have discussed C++ sort here. Following are prototypes of C++ sort() function.

```// To sort in default or ascending order.
template
void sort(T first, T last);

// To sort according to the order specified
// by comp.
template
void sort(T first, T last, Compare comp);
```

The order of equal elements is not guaranteed to be preserved. C++ provides std::stable_sort that can be used to preserve order.

Comparison to qsort and sort()
1. Implementation details:
As the name suggests, qsort function uses QuickSort algorithm to sort the given array, although the C standard does not require it to implement quicksort.

C++ sort function uses introsort which is a hybrid algorithm. Different implementations use different algorithms. The GNU Standard C++ library, for example, uses a 3-part hybrid sorting algorithm: introsort is performed first (introsort itself being a hybrid of quicksort and heap sort) followed by an insertion sort on the result.

2. Complexity :
The C standard doesn’t talk about its complexity of qsort. The new C++11 standard requires that the complexity of sort to be O(Nlog(N)) in the worst case. Previous versions of C++ such as C++03 allow possible worst case scenario of O(N^2). Only average complexity was required to be O(N log N).

3. Running time:
STL’s sort ran faster than C’s qsort, because C++’s templates generate optimized code for a particular data type and a particular comparison function.

STL’s sort runs 20% to 50% faster than the hand-coded quicksort and 250% to 1000% faster than the C qsort library function. C might be the fastest language but qsort is very slow.

When we tried to sort one million integers on C++14, Time taken by C qsort() was 0.247883 sec and time taken by C++ sort() was only 0.086125 sec

 `// C++ program to demonstrate performance of``// C qsort and C++ sort() algorithm``#include ``using` `namespace` `std;`` ` `// Number of elements to be sorted``#define N 1000000`` ` `// A comparator function used by qsort``int` `compare(``const` `void` `* a, ``const` `void` `* b)``{``    ``return` `( *(``int``*)a - *(``int``*)b );``}`` ` `// Driver program to test above functions``int` `main()``{``    ``int` `arr[N], dupArr[N];`` ` `    ``// seed for random input``    ``srand``(``time``(NULL));`` ` `    ``// to measure time taken by qsort and sort``    ``clock_t` `begin, end;``    ``double` `time_spent;`` ` `    ``// generate random input``    ``for` `(``int` `i = 0; i < N; i++)``        ``dupArr[i] = arr[i] = ``rand``()%100000;`` ` `    ``begin = ``clock``();``    ``qsort``(arr, N, ``sizeof``(``int``), compare);``    ``end = ``clock``();`` ` `    ``// calculate time taken by C qsort function``    ``time_spent = (``double``)(end - begin) / CLOCKS_PER_SEC;`` ` `    ``cout << ``"Time taken by C qsort() - "``         ``<< time_spent << endl;`` ` `    ``time_spent = 0.0;`` ` `    ``begin = ``clock``();``    ``sort(dupArr, dupArr + N);``    ``end = ``clock``();`` ` `    ``// calculate time taken by C++ sort``    ``time_spent = (``double``)(end - begin) / CLOCKS_PER_SEC;`` ` `    ``cout << ``"Time taken by C++ sort() - "``         ``<< time_spent << endl;`` ` `    ``return` `0;``}`

Output :

```Time taken by C qsort() - 0.247883
Time taken by C++ sort() - 0.086125 ```

C++ sort() is blazingly faster than qsort() on equivalent data due to inlining. sort() on a container of integers will be compiled to use std::less::operator() by default, which will be inlined and sort() will be comparing the integers directly. On the other hand, qsort() will be making an indirect call through a function pointer for every comparison which compilers fails to optimize.

4. Flexibility:
STL’s sort works for all data types and for different data containers like C arrays, C++ vectors, C++ deques, etc and other containers that can be written by the user. This kind of flexibility is rather difficult to achieve in C.

5. Safety:
Compared to qsort, the templated sort is more type-safe since it does not require access to data items through unsafe void pointers, as qsort does.