C++:How to Make sort function work with Double and Integer type

[Saladsamurai]

So I have a simple selection sort function written. It takes an array of type double as the array to be sorted. If I declare the array to be of type int in my main program and then pass it to my sSort function, it gets mad. There must be a way that programmers deal with this kind fo stuff.

Here is the code if needed:

/* SORTING ALGORITHMS: Etter Chapter6_5 p281         */ 
/*----------------------------------------------------
 This is a driver program to test the sorting 
 functions below.
 ----------------------------------------------------*/
#include <iostream>
#include <iomanip>
using namespace std;

// funtion prototype
void sSort(double sortableArray[], int numElements);

// driver program
int main () {
    // declare objects
	double x[11] = {1.1,1.0,1.5,1.4,1.3,1.8,1.9,1.2,1.7,1.6,2.0};
	int n(11);
	
	// set format flags for standard output
	cout.setf(ios::fixed); //decimal notation
	cout.precision(2); // out to 2 places
	
	// display initial state of x[]
	cout << "********************" << endl;
	cout << "Unsorted: \n";
	for (int i=0;i<=n-1;++i)
	{
		cout << x[i] << endl;
	}
	
	// call sorting algorithm Select Sort
	sSort(x,n); 
	
	// display final state of x[]
	cout << "********************" << endl;
	cout << "Sorted: \n";
	for (int i=0;i<=n-1;++i)
	{
		cout << x[i] << endl;
	}
	
	
	
	
    return 0;
}

/*----------------------------------------------------
 SELECTION SORT: this function sorts an array with n
 elements into ascending order
 ----------------------------------------------------*/
void sSort(double x[], int n)
{
	// declare local objects
	int m;
	double hold;
	// implement selection sort algorithm
	for (int k=0;k<=n-2;++k)
	{
		// find position of smallest value in array
		// beginning at k
		m=k;
		for (int j=k+1;j<=n-1;++j)
		{
			if (x[j]<x[m])
				m = j;
		}
		// exchange smallest value with value at k
		hold = x[m];
		x[m] = x[k];
		x[k] = hold;
	}
	// void return
	return;
}
/*---------------------------------------------------*/

 

[rcgldr]

You could create a typedef for the arraytype:

#typedef ARRAYTYPE double

or

#typedef ARRAYTYPE int

Then use arraytype instead of int or double:

void sSort(ARRAYTYPE x[], int n){...}

Since this is C++, you could also duplicate sSort() to create one that sorts integers:

void sSort(int x[], int n){...}

You can leave both versions of sSort() in your program. as C++ will treat them as separate functions since their input parameters are different.

 

[I like Serena]

In C++ so called templates have been introduced.
If you define your function like this:

template<class X>
void sSort(X sortableArray[], int numElements)
{
   // Replace all occurrences of double by X
}

that should do the trick.

 

[chiro]

Hey Saladsamurai.

The problem is in this line:

double hold;

When your array is an integer, this variable doesn't change (needs to be the same data type, but instead its a double not an int). Different format, no casting and you're bound to get something screwed up.

As mentioned above, this is why templates are used.

 

[LudusRex]

I would like to point out that in order to make the sort function work with both double and integer types, you will need to make some modifications to your code. Currently, your sSort function is only able to sort arrays of type double, as it uses the < operator to compare elements. However, with integers, you cannot use the < operator as it will only compare the integer values and not take into account their decimal places.

To make this function work with both double and integer types, you can implement a template function. This will allow you to pass in different data types to the function and have it work accordingly. For example, you can use the < operator for double arrays and the < operator for integer arrays.

Another approach would be to use the std::sort function from the <algorithm> library. This function takes in a range of elements and a comparison function, which you can define to handle both double and integer types. This would be a more efficient and flexible solution.

In conclusion, there are multiple ways to make the sort function work with double and integer types. It is important to carefully consider your options and choose the best approach for your specific situation.