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. #include #include “SimpleVector.h” //System Libraries #include //Input/Output Library using namespace std; //User Libraries //Global Constants, no Global Variables are allowed //Math/Physics/Conversions/gher Dimensions – i.e. PI, e, etc… //Function Prototypes void fillVec(SimpleVector &); void addVec(SimpleVector &); void delVec(SimpleVector &); void prntVec(SimpleVector &,int); //Execution Begins Here! int main(int argc, char** argv) { //Declare Variables int size; //Read in the size cout<<"What size vector to test?"<>size; SimpleVector 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 &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 &sv){ int del=sv.size()*0.2; for(int i=1;i<=del;i++){ sv.pop_front(); sv.pop_back(); } } void fillVec(SimpleVector &sv){ for(int i=0;i &sv,int n){ cout< #include // Needed for bad_alloc exception #include // Needed for the exit function using namespace std; template 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 SimpleVector::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 SimpleVector::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 f
or SimpleVector class. * template void SimpleVector::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 void SimpleVector::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 T SimpleVector::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 T SimpleVector::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 SimpleVector::~SimpleVector() { if (arraySize > 0) delete [] aptr; } // memError function. Displays an error message and // terminates the program when memory allocation fails. template void SimpleVector::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 void SimpleVector::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 T SimpleVector::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 T &SimpleVector::operator[](const int &sub) { if (sub < 0 || sub >= arraySize) subError(); return aptr[sub]; }