Question

In C++, you are implementing the vector class in the VectorStub zip. You need to implement all of the methods, and that's it. You cannot add any new properties. Your solutions must conform to the Big O notations next to each method.

A few things to remember about templates:

1. All the code is in the h file
2. When testing a template, any method you don't call gets deleted. So make sure you test them all, or you might secretly have one that doesn't compile.
3. If you make your Vector not a template (change all the T's to int or something) it becomes easy to test as long as you remember to re-template it. (VS has trouble autocompleting a template since the code doesn't exist yet.)
4. I'm going to drop your vector in to my project, so don't bother changing main unless you want to test something differently.

The hard part of this is the memory management, so take special care with Reserve, the constructors, and the destructor.

Vector.h
// I am going to match the names that STL uses so you don't get confused in the real world. I'm skipping operator [] for a specific reason that
// doesn't come up for a few weeks.

template
class Vector
{
   T* mData;
   int mSize;
   int mCapacity;// For testing purposes, initialize this to 15. Whenever you allocate new memory, double it.

   T mUndefined;// Lots of STL functions say that doing something naughty gets "undefined behavior". It could throw, crash, make you eggs, or return nonsense.
               // Return this undefined one if anybody ever tries to go out of bounds.

public:
   Vector()// O(1)
   {
       mSize = 0;
       mData = nullptr;
   }
   Vector(const Vector& tOther) : Vector()// O(n)
   {
   }
   Vector &operator =(const Vector& tRHS)// O(n)
   {
       return *this; // This line is weird so I'm just giving it to ya. It's just the definition of an =
   }
   void PushBack(const T &tItem)// O(1)
   {
       // We take a const reference, but we _copy_ it in to our personal array.
   }
   void PopBack()// O(1)
   {
   }
   void PushFront(const T &tItem)// O(n)
   {
   }
   void PopFront()// O(n)
   {
   }
   T& At(int tWhere)// O(1)
   {
       return mUndefined;
   }
   void Erase(int tWhere)// O(n)
   {
       // Keep an eye on this one. We'll change its prototype next week
   }
   void Insert(int tWhere, const T& tWhat)// O(n)
   {
       // Keep an eye on this one. We'll change its prototype next week
   }
   void Clear()// O(1)
   {
   }
   int Size()// O(1)
   {
       return 0;
   }
   void Reserve(int tCount)// O(n)
   {
   }
   int Capacity()// O(1)
   {
       return 0;
   }
};

Answer 1

template <typename T>
class Vector
{
T* mData;
int mSize;
int mCapacity;// For testing purposes, initialize this to 15. Whenever you allocate new memory, double it.

T mUndefined;// Lots of STL functions say that doing something naughty gets "undefined behavior". It could throw, crash, make you eggs, or return nonsense.
// Return this undefined one if anybody ever tries to go out of bounds.

public:
Vector()// O(1)
{
mCapacity = 0;
mSize = 0;
mData = nullptr;
}
Vector(const Vector& tOther) : Vector()// O(n)
{
mCapacity = tOther.mCapacity;
mSize = tOther.mSize;
mData = new T[mCapacity];
for(int i = 0; i < mSize; i++)
mData[i] = tOther.mData[i];
}

Vector &operator =(const Vector& tRHS)// O(n)
{
if(this != &tRHS){
delete mData;
mCapacity = tRHS.mCapacity;
mSize = tRHS.mSize;
mData = new T[mCapacity];
for(int i = 0; i < mSize; i++)
mData[i] = tRHS.mData[i];
}
return *this; // This line is weird so I'm just giving it to ya. It's just the definition of an =
}
void PushBack(const T &tItem)// O(1)
{
// We take a const reference, but we _copy_ it in to our personal array.
Reserve(mSize + 1);
mData[mSize++] = tItem;
}
void PopBack()// O(1)
{
if(mSize > 0)
mSize--;
}
void PushFront(const T &tItem)// O(n)
{
Reserve(mSize + 1);
for(int i = mSize-1; i >= 0; i--)
mData[i+1] = mData[i];
mSize++;
}

void PopFront()// O(n)
{
if(mSize > 0){
for(int i = 1; i < mSize; i++)
mData[i-1] = mData[i];
mSize--;
}
}

T& At(int tWhere)// O(1)
{
if(tWhere < 0 || tWhere >= mSize)
return mUndefined;
else
return mData[tWhere];
}
void Erase(int tWhere)// O(n)
{
// Keep an eye on this one. We'll change its prototype next week
if(tWhere >= 0 && tWhere < mSize){
for(int i = tWhere+1; i < mSize; i++)
mData[i-1] = mData[i];
mSize--;
}
}
void Insert(int tWhere, const T& tWhat)// O(n)
{
// Keep an eye on this one. We'll change its prototype next week
if(tWhere >= 0 && tWhere < mSize){
Reserve(mSize+1);
for(int i = mSize-1; i>= tWhere; i--)
mData[i+1] = mData[i];
mData[tWhere] = tWhat;
mSize++;
}

}
void Clear()// O(1)
{
mSize = 0;
mCapacity = 0;
delete mData;
mData = nullptr;
}
int Size()// O(1)
{
return mSize;
}
void Reserve(int tCount)// O(n)
{
if(mCapacity < tCount){
mCapacity = tCount;
T* temp = new T[mCapacity];
for(int i = 0; i < mSize; i++)
temp[i] = mData[i];
if(mData != nullptr)
delete mData;
mData = temp;
}
}
int Capacity()// O(1)
{
return mCapacity;
}
};