I am trying to fill out a program where the method definitions will be written underthe .h file the following attributes in the .h file are When I run my program I get these errors. Is there anyway to fix these issues? the program --main cpp-- #include "vector.h" #include <iostream> #include <string> #include <fstream> #include <cassert> #include <sstream> using namespace std; int main() { /* Type your test code here. You will not be submitting this code. It's only for testing. */ return 0; } vector.h / / vector class template #ifndef Vector_Vector_h #define Vector_Vector_h #include <iostream> #include <new> // Needed for bad_alloc exception #include <cstdlib> // Needed for the exit function #include <stdexcept> namespace CIST2362 { template<class T> class vector { private: T *aptr; // To point to the allocated array unsigned long arraySize; // Number of elements in the array unsigned long arrayCapacity; // number of memory locations available to the vector // increase capacity void increaseCapacity(unsigned long); public: // Default constructor vector(); // Constructor declaration vector(unsigned long); // Resize the vector - changes the size attribute void resize(unsigned long n); // Resizes the vector and initializes the unused locations - updates the size attribute void resize(unsigned long n, const T &val); // Copy constructor declaration vector(const vector &); // Destructor declaration ~vector(); // Accessor to return the array size unsigned long size() const; // Accessor to return the array capacity unsigned long capacity() const; // Accessor to test empty status bool empty() const; // Accessor to return a specific element T &at(int position); // Overloaded [] operator declaration T &operator[](const int &); // back element of the vector T &back(); // front element of the vector T &front(); void push_back(T); // New push_back member T pop_back(); // New pop_back member // insert element at position int insert(unsigned long, const T &); // erase a range of values void erase(unsigned long, unsigned long); // erase one element at a position void erase(unsigned long); }; /* This is where your method definitions will be written. This default constructor * the first method you need to complete. To compile the program, you should create * empty stubs for each of the declared methods. */ template<class T> vector<T>::vector() { } } #endif my code vector.h // vector class template #ifndef Vector_Vector_h #define Vector_Vector_h #include <iostream> #include <new> // Needed for bad_alloc exception #include <cstdlib> // Needed for the exit function #include <stdexcept> namespace CIST2362 { template<class T> class vector { private: T *aptr; // To point to the allocated array unsigned long arraySize; // Number of elements in the array unsigned long arrayCapacity; // number of memory locations available to the vector // increase capacity void increaseCapacity(unsigned long); public: // Defau.

1. I am trying to fill out a program where the method definitions will be written underthe .h file
the following attributes in the .h file are
When I run my program I get these errors. Is there anyway to fix these issues?
the program
--main cpp--
#include "vector.h"
#include <iostream>
#include <string>
#include <fstream>
#include <cassert>
#include <sstream>
using namespace std;
int main()
{
/*
Type your test code here.
You will not be submitting this code. It's only for testing.
*/
return 0;
}
vector.h
/ / vector class template
#ifndef Vector_Vector_h
#define Vector_Vector_h
#include <iostream>
#include <new> // Needed for bad_alloc exception
#include <cstdlib> // Needed for the exit function
#include <stdexcept>
namespace CIST2362 {
template<class T>
class vector {
private:

2. T *aptr; // To point to the allocated array
unsigned long arraySize; // Number of elements in the array
unsigned long arrayCapacity; // number of memory locations available to the vector
// increase capacity
void increaseCapacity(unsigned long);
public:
// Default constructor
vector();
// Constructor declaration
vector(unsigned long);
// Resize the vector - changes the size attribute
void resize(unsigned long n);
// Resizes the vector and initializes the unused locations - updates the size attribute
void resize(unsigned long n, const T &val);
// Copy constructor declaration
vector(const vector &);
// Destructor declaration
~vector();
// Accessor to return the array size
unsigned long size() const;
// Accessor to return the array capacity
unsigned long capacity() const;
// Accessor to test empty status
bool empty() const;
// Accessor to return a specific element
T &at(int position);
// Overloaded [] operator declaration
T &operator[](const int &);
// back element of the vector
T &back();
// front element of the vector
T &front();

3. void push_back(T); // New push_back member
T pop_back(); // New pop_back member
// insert element at position
int insert(unsigned long, const T &);
// erase a range of values
void erase(unsigned long, unsigned long);
// erase one element at a position
void erase(unsigned long);
};
/* This is where your method definitions will be written. This default constructor
* the first method you need to complete. To compile the program, you should create
* empty stubs for each of the declared methods.
*/
template<class T>
vector<T>::vector() {
}
}
#endif
my code
vector.h
// vector class template
#ifndef Vector_Vector_h
#define Vector_Vector_h
#include <iostream>
#include <new> // Needed for bad_alloc exception
#include <cstdlib> // Needed for the exit function
#include <stdexcept>
namespace CIST2362 {
template<class T>
class vector {
private:
T *aptr; // To point to the allocated array

4. unsigned long arraySize; // Number of elements in the array
unsigned long arrayCapacity; // number of memory locations available to the vector
// increase capacity
void increaseCapacity(unsigned long);
public:
// Default constructor
vector();
// Constructor declaration
vector(unsigned long);
// Resize the vector - changes the size attribute
void resize(unsigned long n);
// Resizes the vector and initializes the unused locations - updates the size attribute
void resize(unsigned long n, const T &val);
// Copy constructor declaration
vector(const vector &);
// Destructor declaration
~vector();
// Accessor to return the array size
unsigned long size() const;
// Accessor to return the array capacity
unsigned long capacity() const;
// Accessor to test empty status
bool empty() const;
// Accessor to return a specific element
T &at(int position);
// Overloaded [] operator declaration
T &operator[](const int &);
// back element of the vector
T &back();
// front element of the vector
T &front();

5. void push_back(T); // New push_back member
T pop_back(); // New pop_back member
// insert element at position
int insert(unsigned long, const T &);
// erase a range of values
void erase(unsigned long, unsigned long);
// erase one element at a position
void erase(unsigned long);
};
/* This is where your method definitions will be written. This default constructor
* the first method you need to complete. To compile the program, you should create
* empty stubs for each of the declared methods.
*/
template<class T>
vector<T>::vector() {
arraySize = 0;
arrayCapacity = 10;
aptr = new long[arrayCapacity];
}
vector<T>::vector(unsigned long){
arraySize = size;
arrayCapacity = size;
aptr = new long[arrayCapacity];
}
vector<T>::resize(unsigned long n){
aptr.resize(arrayCapacity)
}
vector<T>::resize(unsigned long n){
aptr.resize(arrayCapacity)
}
vector<T>::resize(unsigned long n, const T &val){
}
vector<T>::vector(const vector &){
arraySize = obj.arraySize;
arrayCapacity = obj.arrayCapacity;
aptr = new long[arrayCapacity];
for (long i = 0; i < arraySize; i++)
aptr[i] = obj.aptr[i]

6. }
vector<T>::~vector(){
delete [] aptr;
}
vector<T>::unsigned long size(){
return arraySize;
}
vector<T>::unsigned long capacity(){
return arrayCapacity;
}
vector<T>::bool empty()const{
if (T.empty()){
bool T.empty() = true;
}else false;
}
vector<T>::T &at(int position){
if( position <0 || position >=arraySize)
{
std::cout << "ERROR: Subscript out of range.n";
}
return aptr[position];
}
vector<T>::T &operator[](const int &){
return aptr[];
}
vector<T>::T &back(){
T.back(arrayCapacity);
}
vector<T>::T &front(){
T.front(arrayCapacity);
}
vector<T>::arraySize(T){
if (arraySize == arrayCapacity)
{
arrayCapacity += arraySize;
int *temp = new long[arrayCapacity];
for (long i = -1; i < arraySize; i++){
temp[i] = aptrPtr[i];
delete[] aptrPtr;

7. aptr = temp;
}
aptrPtr[arraySize] = T;
arraySize++;
}
vector<T>::T pop_back(){
return aptrPtr[--arraySize];
}
vector<T>::insert(unsigned long, const T &){
T.insert (position,arrayCapacity);
}
vector<T>::erase(unsigned long, unsigned long){
T.erase (position,arrayCapacity);
}
vector<T>::erase(unsigned long){
T.erase (position);
}
}
#endif
- T*aptr. The pointer being used for the internal array maintained by the vector class. You may
change this name if you want :) - T &at(int): access the element at the given index and throws
an - unsigned long arraySize: The value that represents the current number exception if out of
bounds of elements in the vector - T &operator[](const int &): access the element at the given
index - unsigned long arrayCapacity: The value that represents the current and does not check
bounds for efficiency purposes. allocated memory capacity of the vector (must always be >=
arraySize) - T &back(): access the last element in the vector - T &front(): access the first
element in the vector You will find the following private method: Modifying methods: - void
increaseCapacity(unsigned long): This method is used for - void push_back(T): adds an element
to the end of the vector increasing the capacity of the vector. It should not be public, but other
methods in the class would need it. NOTE: You may add more private methods if you see
opportunities for code reuse across the needs of the - T pop_back(): removes the last element of
the vector and returns it public vector methods. - int insert(unsigned long, const T &): Inserts the
element in the 2nd parameter at the position given by the 1st parameter - void erase(unsigned
long, unsigned long): Removes the elements starting with the element at the position of the first
parameter up to the You will find the following public methods: There are 3 constructors.
element before the position in the 2nd parameter i.e. do not remove the - vector(): This
constructor creates a vector with a capacity of 10 and size element at the position of the 2nd
parameter. of 0 . - vector(unsigned long): This constructor creates a vector with the capacity
given by the parameter and size will be 0 . - vector(const vector &): This is the copy constructor

8. for the class There 2 resize methods: - void resize(unsigned long n ): Resize the vector based on
this parameter. Resize can make it smaller or larger; if it's made smaller the capacity is
unchanged (makes the vector more efficient). - void resize(unsigned long n , const T &): Resize
the vector, and if it's made larger then fill in the new elements with value of the 2 nd parameter.
The destructor: vector(): This needs to clean up all memory allocated to the vector Accessor
methods: - unsigned long size() const: returns the size attribute of the vector - unsigned long
capacity() const: returns the capacity attribute of the vector - bool empty() const returns true if
the vector is empty, and false otherwise vector.h:141:9: error: template argument 1 is invalid