C++ HW: This homework is intended to test your knowledge on template functions a
ID: 3852487 • Letter: C
Question
C++ HW:
This homework is intended to test your knowledge on template functions and overloaded operators. You will be asked to write a bubble sorting program on template class.
Bubble sorting is a prevailing method to sort an array in either descending or ascending order. Before you start, make sure you’re able to write a small bubble-sorting function to sort an int array, which has two functions as below
void swap(a, b)
void bubbleSorting(int array[ ], const int& size)
Try to use char, double, float array instead of int array, and test your program to make sure all work fine in descending or ascending order. Then a natural intuition comes out that you could use template function to re-write this bubble-sort function.
Write a template class Holder which has a private template member variable element which might be char, double, float, int or string type. You should design member functions as below
• Default constructor Any appropriate operation inside is encouraged, and left empty is also fine
• Constructor with one argument Pass in value of outside to element by argument
• Destructor
• Overloaded operator + =
Take a Holder object as argument, and would return a newly created Holder object with summed/equal element.
• Overloaded stream << and >>
• Appropriate accessor function
Besides, you should also design a non-member overloaded operator - which takes two Holder object and return a third object with difference value of element.
Write a main function to test bubble sorting for a Holder array.
1. Read from command line two positive integers. First int would be the size of Holder array (size is integers from 4 to 8), and second int would be either 1 or 2 (1 means ascending order and 2 means descending order).
Should judge ar g c 3 or not, should judge whether input numbers are positive and integers within designated range. For example, would test ./solution abc -2, ./solution -1.3 1.456, ./solution 10.346 string, and all these should fail and exit erroneously.
2. Create a Holder dynamic array
After creating the array, you should use overloaded stream À to enable user to define some (not all) Holder objects in the array, and rest of objects in the array should be defined by calling all different overloaded + - = operators.
3. Call overloaded stream >> to print the current array (before sorted)
4. Bubble sort the Holder array by invoking your bubbleSort function, and call overloaded stream À to print the current array (after sorted). Make sure the array is actually sorted well! The class right now might still lack some important overloaded operator for bubble sorting. Which operator is still missing? You should be able to figure it out by thinking, discussing and google.
Explanation / Answer
#include <iostream>
using namespace std;
template <typename T>
void Swap(T &a, T &b);
template <typename T>
void BubbleSort(T array[], const int &size, bool ascending = true);
template <typename T>
void Display(T array[], const int &size);
//define the templated class Holder
template <typename T>
class Holder
{
T element;
public:
//default constructor
Holder() {}
//constructor with
Holder(T val)
{
element = val;
}
//destructor
~Holder(){}
//accessor
T getElement() const
{
return element;
}
//+ operator to do sum
Holder operator + (const Holder &other)
{
Holder h(element + other.element);
return h;
}
//assignment operator =
Holder operator = (const Holder &other)
{
element = other.element ;
return *this;
}
//operator > for used for comparison
bool operator > (const Holder &other)
{
return element > other.element;
}
//overloaded << operator
friend ostream & operator << (ostream &out, const Holder &h)
{
out << h.element ;
return out;
}
//overloaded >> operator
friend istream & operator >> (istream &in, Holder &h)
{
in >> h.element;
return in;
}
};
//non member operator - for Holder<T>
template <typename T>
Holder<T> operator - (const Holder<T> &h1, const Holder<T> &h2)
{
Holder<T> h(h1.getElement() - h2.getElement());
return h;
}
int main(int argc, char *argv[])
{
//check if correct number of arugments are passed
if(argc != 3)
{
cout << "Need 2 arguements !" << endl;
cout << "Usage: " << argv[0] << " <size> <sort_order>" << endl;
return -1;
}
int size = atoi (argv[1]), sort = atoi(argv[2]);
if(size <4 || size > 8)
{
cout << "size should be an int value in the range 4 - 8" <<endl;
return -1;
}
if(sort != 1 && sort != 2)
{
cout << "sort order should be either 1(ascending) or 2(descending)" << endl;
return -1;
}
//allocate memory for an Holder<int> array
Holder<int> *holderArr = new Holder<int>[size];
//get all but 3 elements input from user. The last 3 elemnts are filled using operators defined
for(int i = 0; i < size - 3; i++)
{
cout << "Enter an holder value (int): " ;
cin >> holderArr[i];
}
//fill the rest of array elements using the operators defined
holderArr[size - 3] = holderArr[0]; //using assignment operator
holderArr[size - 2] = holderArr[0] + holderArr[1]; //using member + operator
holderArr[size - 1 ] = holderArr[0] - holderArr[1]; //using non-member - operator
cout << "Before sorting the holder array contents " << endl;
Display(holderArr, size);
BubbleSort(holderArr, size, sort == 1);
cout << "After sorting the holder array contents " << endl;
Display(holderArr, size);
return 0;
}
template <typename T>
void Swap(T &a, T &b)
{
T temp;
temp = a;
a = b;
b = temp;
}
template <typename T>
void BubbleSort(T array[], const int &size , bool ascending)
{
for(int i = 0; i < size; i++)
{
for(int j = 0; j < size - i; j++)
{
if((ascending && array[j] > array[j+1]) || (!ascending && array[j+1] > array[j]))
Swap(array[j], array[j+1]);
}
}
}
template <typename T>
void Display(T array[], const int &size)
{
for(int i = 0; i < size; i++)
cout << array[i] << endl;
}
output
/a.out 5 2
Enter an holder value (int): 5
Enter an holder value (int): 7
Before sorting the holder array contents
5
7
5
12
-2
After sorting the holder array contents
12
7
5
5
-2
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.