2 complex Vector

 can you do this for sure and if so how will you start doing i just want make sure you will be able to do it because a lot people here say they can than after i accept the bid before the due date by few hours they say sorry i cant do the assignment it one will be based on array and with size dynamically expanding and shrinking Another one based on linkedlist.
Use a simple vector you created before to create two other more complex vectors with
   1) Memory allocation that doubles size of memory when end reached, and 1/2’s memory when the size reaches 1/4.
   2) 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