2023 Use a simple vector you created before to create two other more | Assignment Collections

Use a simple vector you created before to create two other more complex vectors with

   A) Memory allocation that doubles size of memory when end reached, and 1/2’s memory when the size reaches 1/4.

   B) Implemented with a singularly linked list.

Main.cpp

#include <cstdlib>
#include “SimpleVector.h”
//System Libraries
#include <iostream> //Input/Output Library
using namespace std;
//User Libraries
//Global Constants, no Global Variables are allowed
//Math/Physics/Conversions/Higher Dimensions – i.e. PI, e, etc…
//Function Prototypes
void fillVec(SimpleVector<int> &);
void addVec(SimpleVector<int> &);
void delVec(SimpleVector<int> &);
void prntVec(SimpleVector<int> &,int);
//Execution Begins Here!
int main(int argc, char** argv) {
    //Declare Variables
    int size;
    //Read in the size
    cout<<“What size vector to test?”<<endl;
    cin>>size;
    SimpleVector<int> sv(size);
    //Initialize or input i.e. set variable values
    fillVec(sv);
    //Display the outputs
    prntVec(sv,10);
    //Add and subtract from the vector
    addVec(sv);
    //Display the outputs
    prntVec(sv,10);
    //Add and subtract from the vector
    delVec(sv);
    //Display the outputs
    prntVec(sv,10);
    //Exit stage right or left!
    return 0;
}
void addVec(SimpleVector<int> &sv){
    int add=sv.size()*0.1;
    for(int i=1;i<=add;i++){
        sv.push_front(i+add-1);
        sv.push_back(i-add);
    }
}
void delVec(SimpleVector<int> &sv){
    int del=sv.size()*0.2;
    for(int i=1;i<=del;i++){
        sv.pop_front();
        sv.pop_back();
    }
}
void fillVec(SimpleVector<int> &sv){
    for(int i=0;i<sv.size();i++){
        sv[i]=i%10;
    }
}
void prntVec(SimpleVector<int> &sv,int n){
    cout<<endl;
    for(int i=0;i<sv.size();i++){
        cout<<sv[i]<<” “;
        if(i%n==(n-1))cout<<endl;
    }
    cout<<endl;
}

SimpleVector.h

// SimpleVector class template
#ifndef SIMPLEVECTOR_H
#define SIMPLEVECTOR_H
#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;          // To point to the allocated array
   int arraySize;    // Number of elements in the array
   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();
   //Adding and subtracting from the Vector
   void push_front(T);
   void push_back(T);
   T    pop_front();
   T    pop_back();
   // 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.                       *
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);
}
// Add 1 or Delete 1 front or back for SimpleVector class. *
template<class T>
void SimpleVector<T>::push_front(T val){
    // Allocate memory for the array.
    T *newarr = 0;
    try
    {
        newarr = new T [arraySize + 1];
    }
    catch (bad_alloc)
    {
        memError();
    }
    *(newarr) = val;//Add value to the front of the new array
    // Copy previous array contents.
    arraySize++;//Increment array size
    for (int count = 1; count < arraySize; count++)
        *(newarr + count) = *(aptr + count – 1);
    delete aptr;//Delete previous array
    aptr = newarr;
}
template<class T>
void SimpleVector<T>::push_back(T val){
    // Allocate memory for the array.
    T *newarr = 0;
    try
    {
        newarr = new T [arraySize + 1];
    }
    catch (bad_alloc)
    {
        memError();
    }
    // Copy previous array contents.
    for (int count = 0; count < arraySize; count++)
        *(newarr + count) = *(aptr + count);
    *(newarr + arraySize) = val;//Add value at back of the array
    arraySize++;//Increment array size
    delete aptr;//Delete previous array
    aptr = newarr;
}
template<class T>
T SimpleVector<T>::pop_front(){
    T dummy = 0;
    if(arraySize != 0)//If array is not empty then only pop
    {
        dummy = *aptr;
        if(arraySize == 1){
            delete aptr;
            aptr = 0;
        }
        else {
            // Allocate memory for the array.
            T *newarr = 0;
            try {
                newarr = new T[arraySize – 1];
            }
            catch (bad_alloc) {
                memError();
            }

            // Copy previous array contents.
            for (int count = 1; count < arraySize; count++)
                *(newarr + count – 1) = *(aptr + count);
            delete aptr;//Delete previous array
            aptr = newarr;
        }
        arraySize–;//Decrease array size
    }
    return dummy;//Return popped value
}
template<class T>
T SimpleVector<T>::pop_back(){
    T dummy = 0;
    if(arraySize != 0)//If array is not empty then only pop
    {
        dummy = *(aptr + arraySize – 1);
        if(arraySize == 1){
            delete aptr;
            aptr = 0;
        }
        else {
            // Allocate memory for the array.
            T *newarr = 0;
            try {
                newarr = new T[arraySize – 1];
            }
            catch (bad_alloc) {
                memError();
            }

            // Copy previous array contents.
            for (int count = 0; count < arraySize – 1; count++)
                *(newarr + count) = *(aptr + count);
            delete aptr;//Delete previous array
            aptr = newarr;
        }
        arraySize–;//Decrease array size
    }
    return dummy;//Return popped value
}
//**************************************
// 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.n”;
   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.n”;
   exit(EXIT_FAILURE);
}
// getElementAt function. The argument is a subscript. *
// This function returns the value stored at the sub-   *
// cript 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];
}
#endif