Add a bubble or selection sort Template to the program. Main must work with int,
ID: 2247079 • Letter: A
Question
Add a bubble or selection sort Template to the program.
Main must work with int, double, float, char.
#include <iostream>
#include <new> // Needed for bad_alloc exception
#include <cstdlib> // Needed for the exit function
using namespace std;
template <class T>
class SimpleVector
{
private:
T *aptr;
int arraySize;
void memError(); // Handles memory allocation errors
void subError(); // Handles subscripts out of range
public:
// Default constructor
SimpleVector()
{ aptr = 0; arraySize = 0;}
// Constructor declaration
SimpleVector(int);
// Copy constructor declaration
SimpleVector(const SimpleVector &);
// Destructor declaration
~SimpleVector();
// Accessor to return the array size
int size() const
{ return arraySize; }
// Accessor to return a specific element
T getElementAt(int position);
// Overloaded [] operator declaration
T &operator[](const int &);
};
//************************************************************
// Constructor for SimpleVector class. Sets the size of the *
// array and allocates memory for it. *
//************************************************************
// To point to the allocated array // Number of elements in the array
template <class T>
SimpleVector<T>::SimpleVector(int s)
{
arraySize = s;
// Allocate memory for the array.
try
{
aptr = new T [s];
}
catch (bad_alloc)
{
memError();
}
// Initialize the array.
for (int count = 0; count < arraySize; count++)
*(aptr + count) = 0;
}
//*******************************************
// Copy Constructor for SimpleVector class. *
//*******************************************
template <class T>
SimpleVector<T>::SimpleVector(const SimpleVector &obj)
{
// Copy the array size.
arraySize = obj.arraySize;
// Allocate memory for the array.
aptr = new T [arraySize];
if (aptr == 0)
memError();
// Copy the elements of obj's array.
for(int count = 0; count < arraySize; count++)
*(aptr + count) = *(obj.aptr + count);
}
//**************************************
// Destructor for SimpleVector class. *
//**************************************
template <class T>
SimpleVector<T>::~SimpleVector()
{
if (arraySize > 0)
delete [] aptr;
}
//********************************************************
// memError function. Displays an error message and *
// terminates the program when memory allocation fails. *
//********************************************************
template <class T>
void SimpleVector<T>::memError()
{
cout << "ERROR:Cannot allocate memory. ";
exit(EXIT_FAILURE);
}
//************************************************************
// subError function. Displays an error message and *
// terminates the program when a subscript is out of range. *
//************************************************************
template <class T>
void SimpleVector<T>::subError()
{
cout << "ERROR: Subscript out of range. ";
exit(EXIT_FAILURE);
}
//*******************************************************
// getElementAt function. The argument is a subscript. *
// This function returns the value stored at the *
// subcript in the array. *
//*******************************************************
template <class T>
T SimpleVector<T>::getElementAt(int sub)
{
if (sub < 0 || sub >= arraySize)
subError();
return aptr[sub];
}
//********************************************************
// Overloaded [] operator. The argument is a subscript. *
// This function returns a reference to the element *
// in the array indexed by the subscript. *
//********************************************************
template <class T>
T &SimpleVector<T>::operator[](const int &sub)
{
if (sub < 0 || sub >= arraySize)
subError();
return aptr[sub];
}
// This program demonstrates the SimpleVector template.
#include <iostream>
//#include "SimpleVector.h"
using namespace std;
int main()
{
const int SIZE = 10;
int count;
SimpleVector<int> intTable(SIZE);
SimpleVector<double> doubleTable(SIZE);
for (count = 0; count < SIZE; count++)
{
cout <<" Enter the value: ";
cin>> intTable[count];
cout<<endl;
doubleTable[count] = (count * 2.14);
}
cout << "These values are in intTable: ";
for (count = 0; count < SIZE; count++)
cout << intTable[count] << " ";
cout << endl<<endl;
cout << "These values are in doubleTable: ";
for (count = 0; count < SIZE; count++)
cout << doubleTable[count] << " ";
cout << endl<< endl;
cout << " Adding 5 to each element of intTable"
<< " and doubleTable. ";
for (count = 0; count < SIZE; count++)
{
intTable[count] = intTable[count] + 5; doubleTable[count] = doubleTable[count] + 5.0;
}
cout << intTable[count] << " "; cout << endl;
cout << "These values are in doubleTable: "; for (count = 0; count < SIZE; count++)
cout << doubleTable[count] << " ";
cout << endl;
// Use the standard ++ operator on the elements.
cout << " Incrementing each element of intTable and"
<< " doubleTable. ";
for (count = 0; count < SIZE; count++) {
intTable[count]++;
doubleTable[count]++;
}
// Display the values in the SimpleVectors. cout << "These values are in intTable: "; for (count = 0; count < SIZE; count++)
cout << intTable[count] << " "; cout << endl;
cout << "These values are in doubleTable: "; for (count = 0; count < SIZE; count++)
cout << doubleTable[count] << " ";
cout << endl;
return 0; }
Explanation / Answer
#include <iostream>
#include <new> // Needed for bad_alloc exception
#include <cstdlib> // Needed for the exit function
using namespace std;
template <class T>
class SimpleVector
{
private:
T *aptr;
int arraySize;
void memError(); // Handles memory allocation errors
void subError(); // Handles subscripts out of range
public:
// Default constructor
SimpleVector()
{ aptr = 0; arraySize = 0;}
// Constructor declaration
SimpleVector(int);
// Copy constructor declaration
SimpleVector(const SimpleVector &);
// Destructor declaration
~SimpleVector();
// Accessor to return the array size
int size() const
{ return arraySize; }
// Accessor to return a specific element
T getElementAt(int position);
// Overloaded [] operator declaration
T &operator[](const int &);
// sort
void sort();
};
//************************************************************
// Constructor for SimpleVector class. Sets the size of the *
// array and allocates memory for it. *
//************************************************************
// To point to the allocated array // Number of elements in the array
template <class T>
SimpleVector<T>::SimpleVector(int s)
{
arraySize = s;
// Allocate memory for the array.
try
{
aptr = new T [s];
}
catch (bad_alloc)
{
memError();
}
// Initialize the array.
for (int count = 0; count < arraySize; count++)
*(aptr + count) = 0;
}
//*******************************************
// Copy Constructor for SimpleVector class. *
//*******************************************
template <class T>
SimpleVector<T>::SimpleVector(const SimpleVector &obj)
{
// Copy the array size.
arraySize = obj.arraySize;
// Allocate memory for the array.
aptr = new T [arraySize];
if (aptr == 0)
memError();
// Copy the elements of obj's array.
for(int count = 0; count < arraySize; count++)
*(aptr + count) = *(obj.aptr + count);
}
//**************************************
// Destructor for SimpleVector class. *
//**************************************
template <class T>
SimpleVector<T>::~SimpleVector()
{
if (arraySize > 0)
delete [] aptr;
}
//********************************************************
// memError function. Displays an error message and *
// terminates the program when memory allocation fails. *
//********************************************************
template <class T>
void SimpleVector<T>::memError()
{
cout << "ERROR:Cannot allocate memory. ";
exit(EXIT_FAILURE);
}
//************************************************************
// subError function. Displays an error message and *
// terminates the program when a subscript is out of range. *
//************************************************************
template <class T>
void SimpleVector<T>::subError()
{
cout << "ERROR: Subscript out of range. ";
exit(EXIT_FAILURE);
}
//*******************************************************
// getElementAt function. The argument is a subscript. *
// This function returns the value stored at the *
// subcript in the array. *
//*******************************************************
template <class T>
T SimpleVector<T>::getElementAt(int sub)
{
if (sub < 0 || sub >= arraySize)
subError();
return aptr[sub];
}
//********************************************************
// Overloaded [] operator. The argument is a subscript. *
// This function returns a reference to the element *
// in the array indexed by the subscript. *
//********************************************************
template <class T>
T &SimpleVector<T>::operator[](const int &sub)
{
if (sub < 0 || sub >= arraySize)
subError();
return aptr[sub];
}
template <class T>
void SimpleVector<T>::sort() {
for (int i = 0; i<arraySize - 1; i++)
for (int j = 0; j < arraySize - i - 1; j++)
if (aptr[j] > aptr[j+1]) {
T tmp = aptr[j];
aptr[j] = aptr[j+1];
aptr[j+1] = tmp;
}
}
int main()
{
const int SIZE = 10;
int count;
SimpleVector<int> intTable(SIZE);
SimpleVector<double> doubleTable(SIZE);
for (count = 0; count < SIZE; count++)
{
cout <<" Enter the value: ";
cin>> intTable[count];
cout<<endl;
doubleTable[count] = (count * 2.14);
}
cout << "These values are in intTable: ";
for (count = 0; count < SIZE; count++)
cout << intTable[count] << " ";
cout << endl<<endl;
cout << "These values are in doubleTable: ";
for (count = 0; count < SIZE; count++)
cout << doubleTable[count] << " ";
cout << endl<< endl;
cout << "sorting... " << endl;
intTable.sort();
doubleTable.sort();
cout << "These values are in intTable: ";
for (count = 0; count < SIZE; count++)
cout << intTable[count] << " ";
cout << endl<<endl;
cout << "These values are in doubleTable: ";
for (count = 0; count < SIZE; count++)
cout << doubleTable[count] << " ";
cout << endl<< endl;
cout << " Adding 5 to each element of intTable"
<< " and doubleTable. ";
for (count = 0; count < SIZE; count++)
{
intTable[count] = intTable[count] + 5; doubleTable[count] = doubleTable[count] + 5.0;
}
cout << intTable[count] << " "; cout << endl;
cout << "These values are in doubleTable: "; for (count = 0; count < SIZE; count++)
cout << doubleTable[count] << " ";
cout << endl;
// Use the standard ++ operator on the elements.
cout << " Incrementing each element of intTable and"
<< " doubleTable. ";
for (count = 0; count < SIZE; count++) {
intTable[count]++;
doubleTable[count]++;
}
// Display the values in the SimpleVectors. cout << "These values are in intTable: "; for (count = 0; count < SIZE; count++)
cout << intTable[count] << " "; cout << endl;
cout << "These values are in doubleTable: "; for (count = 0; count < SIZE; count++)
cout << doubleTable[count] << " ";
cout << endl;
return 0; }
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.