Question

#include <iostream>

using namespace std;

template <typename Item>
class MyArray{
private:
   Item *myarray;
   int size;
   int used;
   void doubleSize();
public:
   MyArray();
   ~MyArray();
   int length();
   void insertHead(Item i);
   void insertTail(Item i);
   void deleteHead();
   void deleteTail();
   void sortAscending();
   void sortDescending();
   Item operator [](int i){
       return myarray[i];
   }
};

template <typename Item>
MyArray<Item>::MyArray(){
   size = 5;
   used = 0;
   myarray = new Item[size];
}

template <typename Item>
MyArray<Item>::~MyArray(){
   delete[] myarray;
}

template <typename Item>
int MyArray<Item>::length(){
   return used;
}

template <typename Item>
void MyArray<Item>::doubleSize(){
   if(used == size){
       size *= 2;
       Item *newArr = new Item[size];
       for(int i = 0; i < used; ++i){
           newArr[i] = myarray[i];
       }
       myarray = newArr;
   }
}

template <typename Item>
void MyArray<Item>::insertHead(Item i){
   doubleSize();
   for(int i = used; i > 0; --i){
       myarray[i] = myarray[i - 1];
   }
   used++;
   myarray[0] = i;
}

template <typename Item>
void MyArray<Item>::insertTail(Item i){
   doubleSize();
   myarray[used++] = i;
}

template <typename Item>
void MyArray<Item>::deleteHead(){
   if(used > 0){
       for(int i = 0; i < used - 1; ++i){
           myarray[i] = myarray[i + 1];
       }
       --used;
   }
}

template <typename Item>
void MyArray<Item>::deleteTail(){
   if(used > 0){
       --used;
   }
}

template <typename Item>
void MyArray<Item>::sortAscending(){
   for(int i = 0; i < used; ++i){
       for(int j = 0; j < used - 1; ++j){
           if(myarray[j] > myarray[j + 1]){
               Item temp = myarray[j];
               myarray[j] = myarray[j + 1];
               myarray[j + 1] = temp;
           }
       }
   }
}

template <typename Item>
void MyArray<Item>::sortDescending(){
   for(int i = 1; i < used; ++i){
       for(int j = i; j > 0; --j){
           if(myarray[j] > myarray[j - 1]){
               Item temp = myarray[j];
               myarray[j] = myarray[j - 1];
               myarray[j - 1] = temp;
           }
       }
   }
}

int main(){
   MyArray<int> a1;
   a1.insertTail(35);
   a1.insertTail(45);
   a1.insertHead(55);
   a1.sortDescending();
   a1.deleteTail();
   cout << "Number of elements in a1= " << a1.length() << endl;
   for(int i = 0; i < a1.length(); i++)
       cout << a1[i] << endl;
   return 0;
}

Implement a generic (template) class called MyArray. A generic class is a general version of a class; it is a homogenous data structure that handles multiple data types. MyArray will be similar to C++ arrays but will not be constrained to a fixed size. The array size will grow dynamically when the user inserts an element to a full array. The class should not use vectors. Instead, you should use dynamic memory allocation (a dynamic array).

The code is fine but I need to make a main functions

Write a main( ) method that provides a menu driven interface that allows the user to test whether each member function of myArray is working properly. The menu should provide the following functionalities:

o Create a new array: allows the user to create an array of one of the following types: bool, char, double, float, int, string

o Get Length: the current number of elements used in the array

o Insert a new element at the head of the array

o Insert a new element at the tail of the array

o Delete the first element

o Delete the last element

o Sort the elements in ascending order

o Sort the elements in descending order

o Print all the elements in the array

o Quit the program