2 complex Vector

 
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

Don't use plagiarized sources. Get Your Custom Essay on
2 complex Vector
Just from $10/Page
Order Essay
Calculator

Calculate the price of your paper

Total price:$26
Our features

We've got everything to become your favourite writing service

Need a better grade?
We've got you covered.

Order your paper

Order your essay today and save 15% with the discount code ATOM