Visual C++ - qSort with Strings - c++

Question

Yes, I want to use the qsort() function with two strings, most likely those will be tested as character arrays. When I run it,I get an unhandled exception in qsort.c at the line(151):
if (__COMPARE(context, lo, mid) > 0) {
swap(lo, mid, width);
}
This is my code:
#include <iostream>
#include <iomanip>
using namespace std;
struct SaleSlip{
char name[20];
int ProdID;
double value;
};
int compare(void const *a, void const *b);
ostream& operator<<(ostream& out, SaleSlip& sales);
int main(){
SaleSlip sales[17] = {
{"Eric", 1, 200000.00},
{"Sookie", 2, 200.00},
{"Sookie", 4, 200.50},
{"Bill", 3, 5000.00},
{"Bill", 5, 7500.00},
{"Tara", 4, 350.50},
{"Eric", 2, 200.00},
{"Tara", 2, 200.00},
{"Tara", 4, 350.50},
{"Bill", 5, 2500.00},
{"Sookie", 1, 50000.00},
{"Sookie", 2, 200.00},
{"Eric", 5, 10000.00},
{"Tara", 2, 200.00},
{"Tara", 4, 150.50},
{"Bill", 5, 1000.00},
{"Sookie", 4, 400.50}
};
cout << "The array before sorting is: " << endl;
for(int i = 0; i < 17; i++)
cout << sales[i];
qsort(sales[0].name, 17, (sizeof(sales)/sizeof(char*)), compare);
cout << "The array after sorting is: ";
system("pause");
return 0;
}
ostream& operator<<(ostream& out, SaleSlip& sales){
out << setiosflags(ios::left | ios::fixed) << setw(7) << sales.name << setw(3) << sales.ProdID
<< setprecision(2) << sales.value << endl;
return out;
}
int compare(void const *a, void const *b) {
return strcmp(*(const char **)a, *(const char **)b);
}
I am testing in compare properly? Am I calling qsort properly?

Answer 1

You probably want your compare function to take SaleSlip pointers as the argument. In the compare function do strcmp(a->name,b->name). Of course your arguments to qsort will change to become SaleSlip structs.

Answer 2

What you are doing wrong is:
I. You pass in 17 as both the element size and the element count to qsort(). That's wrong, the 2nd argument is the number of elements in the array, the 3rd one is the size of one individual element.
II. you want to sort the array, but you don't pass in the address of its first element, but a pointer to the name member of the first element. Take this and the incorrect element size, and from now on, all the pointers qsort() operates on are quite arbitrary, and using them is not any good. What you could do is:
I. Write a proper comparator function and don't try to include nasty tricks:
qsort(sales, sizeof(sales) / sizeof(sales[0]), sizeof(sales[0]), comp);
int comp(const void *a, const void *b)
{
// the two lines below are the aesthetic reason
// for NOT using qsort() in C++. The ugly cast is not needed in C.
const SaleSlip *s1 = static_cast<const SaleSlip *>(a);
const SaleSlip *s2 = static_cast<const SaleSlip *>(b);
return strcmp(s1->name, s2->name);
}
II. Or, even better: use std::sort, std::string and define SaleSlip::operator <:
class SaleSlip {
bool operator <(const SaleSlip &that) {
return this->name < that.name;
}
};
std::sort(sales, sales + sizeof(sales) / sizeof(sales[0]));
Bonus: don't use hard-coded sizes and types. 17 is dangerous, sizeof(array) / sizeof(SaleSlip) is better but still not perfect, sizeof(array) / sizeof(array[0]) is entirely safe, no matter what you do with the base type and the element count of the array.

Answer 3

Three problems:
The first argument should just be sales - the array you want to sort.
The size argument should be sizeof(SaleSlip) - the size of each element.
The comparison is doing something very strange. To get a pointer to the name, you want static_cast<const SaleSlip*>(a)->name (or (const char*)a if you like to live dangerously).
These problems can be avoided by using the C++ std::sort function (and std::string for the string), which is type-safe and (often) more efficient than qsort. Then you simply do
std::sort(std::begin(sales), std::end(sales),
[](SaleSlip const & a, SaleSlip const & b) {return a.name < b.name;});

Answer 4

Use std::sort : qsort is harder to use in almost every case, and less efficient.
First, write a order function:
struct SaleSlip{
char name[20];
int ProdID;
double value;
};
bool order( SaleSlip const& lhs, SaleSlip const& rhs ) {
return strncmp(lhs.name, rhs.name, sizeof(lhs.name))<0;
}
then feed this to std::sort:
std::sort( &sales[0], &sales[sizeof(sales)/sizeof(sales[0])], order );
and your are done.
In C++11, that line is better:
std::sort( std::begin(sales), std::end(sales), order );
You can also replace name with a std::string rather than work with a fixed sized buffer, but I understand there are reasons to work with raw char buffers. If you do so, simply change order to return lhs.name < rhs.name.
The problems in your original code, above and beyond the choice to use qsort, is that the blocks of memory you are sorting are SaleSlip objects, not char* objects. First, fix your compare function (and give it a better name):
int compare_pvoid_SaleSlips(void const *a, void const *b) {
SalesSlip const* lhs = static_cast<SalesSlip const*>(a);
SalesSlip const* rhs = static_cast<SalesSlip const*>(b);
return strncmp(lhs->name, rhs->name, sizeof(lhs->name)/sizeof(lhs->name[0]));
}
Next, fix your call to qsort:
qsort(&sales[0], 17, (sizeof(sales)/sizeof(sales[0])), compare_pvoid_SaleSlips);
which should work. However, following this method will be slower, more error prone, more brittle, and in every way worse in a C++ program than the std::sort solution.