Adding Functions to an Implementation of Vector - c++

Question

I have this implementation of vector that I've been working on for a few days using examples from a textbook:
#include <iostream>
#include <string>
#include <cassert>
#include <algorithm>
#include <cstring>
// Vector.h
using namespace std;
template <class T>
class Vector
{
public:
typedef T * iterator;
Vector();
Vector(unsigned int size);
Vector(unsigned int size, const T & initial);
Vector(const Vector<T> & v); // copy constructor
~Vector();
unsigned int capacity() const; // return capacity of vector (in elements)
unsigned int size() const; // return the number of elements in the vector
bool empty() const;
iterator begin(); // return an iterator pointing to the first element
iterator end(); // return an iterator pointing to one past the last element
T & front(); // return a reference to the first element
T & back(); // return a reference to the last element
void push_back(const T & value); // add a new element
void pop_back(); // remove the last element
void reserve(unsigned int capacity); // adjust capacity
void resize(unsigned int size); // adjust size
void erase(unsigned int size); // deletes an element from the vector
T & operator[](unsigned int index); // return reference to numbered element
Vector<T> & operator=(const Vector<T> &);
private:
unsigned int my_size;
unsigned int my_capacity;
T * buffer;
};
template<class T>//
Vector<T>::Vector()
{
my_capacity = 0;
my_size = 0;
buffer = 0;
}
template<class T>
Vector<T>::Vector(const Vector<T> & v)
{
my_size = v.my_size;
my_capacity = v.my_capacity;
buffer = new T[my_size];
for (int i = 0; i < my_size; i++)
buffer[i] = v.buffer[i];
}
template<class T>//
Vector<T>::Vector(unsigned int size)
{
my_capacity = size;
my_size = size;
buffer = new T[size];
}
template<class T>//
Vector<T>::Vector(unsigned int size, const T & initial)
{
my_size = size; //added = size
my_capacity = size;
buffer = new T [size];
for (int i = 0; i < size; i++)
buffer[i] = initial;
}
template<class T>//
Vector<T> & Vector<T>::operator = (const Vector<T> & v)
{
delete[ ] buffer;
my_size = v.my_size;
my_capacity = v.my_capacity;
buffer = new T [my_size];
for (int i = 0; i < my_size; i++)
buffer[i] = v.buffer[i];
return *this;
}
template<class T>//
typename Vector<T>::iterator Vector<T>::begin()
{
return buffer;
}
template<class T>//
typename Vector<T>::iterator Vector<T>::end()
{
return buffer + size();
}
template<class T>//
T& Vector<T>::Vector<T>::front()
{
return buffer[0];
}
template<class T>//
T& Vector<T>::Vector<T>::back()
{
return buffer[size - 1];
}
template<class T>
void Vector<T>::push_back(const T & v)
{
if (my_size >= my_capacity)
reserve(my_capacity +5);
buffer [my_size++] = v;
}
template<class T>//
void Vector<T>::pop_back()
{
my_size--;
}
template<class T>//
void Vector<T>::reserve(unsigned int capacity)
{
if(buffer == 0)
{
my_size = 0;
my_capacity = 0;
}
if (capacity <= my_capacity)
return;
T * new_buffer = new T [capacity];
assert(new_buffer);
copy (buffer, buffer + my_size, new_buffer);
my_capacity = capacity;
delete[] buffer;
buffer = new_buffer;
}
template<class T>//
unsigned int Vector<T>::size()const
{
return my_size;
}
template<class T>//
void Vector<T>::resize(unsigned int size)
{
reserve(size);
my_size = size;
}
template<class T>//
T& Vector<T>::operator[](unsigned int index)
{
return buffer[index];
}
template<class T>//
unsigned int Vector<T>::capacity()const
{
return my_capacity;
}
template<class T>//
Vector<T>::~Vector()
{
delete[]buffer;
}
template<class T>
void Vector<T>::erase(unsigned int size)
{
}
int main()
{
Vector<int> v;
v.reserve(2);
assert(v.capacity() == 2);
Vector<string> v1(2);
assert(v1.capacity() == 2);
assert(v1.size() == 2);
assert(v1[0] == "");
assert(v1[1] == "");
v1[0] = "hi";
assert(v1[0] == "hi");
Vector<int> v2(2, 7);
assert(v2[1] == 7);
Vector<int> v10(v2);
assert(v10[1] == 7);
Vector<string> v3(2, "hello");
assert(v3.size() == 2);
assert(v3.capacity() == 2);
assert(v3[0] == "hello");
assert(v3[1] == "hello");
v3.resize(1);
assert(v3.size() == 1);
assert(v3[0] == "hello");
Vector<string> v4 = v3;
assert(v4.size() == 1);
assert(v4[0] == v3[0]);
v3[0] = "test";
assert(v4[0] != v3[0]);
assert(v4[0] == "hello");
v3.pop_back();
assert(v3.size() == 0);
Vector<int> v5(7, 9);
Vector<int>::iterator it = v5.begin();
while (it != v5.end())
{
assert(*it == 9);
++it;
}
Vector<int> v6;
v6.push_back(100);
assert(v6.size() == 1);
assert(v6[0] == 100);
v6.push_back(101);
assert(v6.size() == 2);
assert(v6[0] == 100);
v6.push_back(101);
cout << "SUCCESS\n";
}
So far it works pretty well, but I want to add a couple of functions to it that I can't find examples for, a SWAP function that would look at two elements of the vector and switch their values and and an ERASE function that would delete a specific value or range of values in the vector. How should I begin implementing the two extra functions?

Answer 1

I would use this as an exercise to see how the iterator design pattern works.
vector does not have a swap because this operation can be done in a more generic way with iterators. The std::swap algorithm does this for you,
see here
Similarly for the erase, you might want to use std::transform algorithm - http://www.cplusplus.com/reference/algorithm/transform/ - depending exactly what you mean by erase (do you mean delete or overwrite?)

Answer 2

Implementing swap should be very easy. Make a copy of buffer[A], assign buffer[B] to buffer[A], assign the copy to buffer[B].
Erase should also be fairly straight forward. Given a range of elements to erase, shift the elements after the range to the left by the size of the range, then resize the vector.

Answer 3

You don't need to define your own swap function, as the <iostream> header includes the function std::swap. But, if you don't want to use the std::swap, you can define your own swap function just like this:
template<typename _Tp>
void swap(_Tp &a, _Tp &b)
{
_Tp tempVal = a;
a = b;
b = tempVal;
}
Now about the erase function: because you are implementing the vector with an array, your erase function should:
1)call the destructor of the element you want to erase(if it has)
2)move all the elements which where at the right of the deleted element one position to the left
3)return a random access iterator pointing to the new location of the element that followed the last element erased by the function call, which is the vector end if the operation erased the last element in the sequence.
4)resize the vector
Suppose that you have the erase function, which erases one element, then the version of erase which erases all the elements devoted by the iterators a, b would look like that:
iterator
erase(iterator first, iterator last)
{
while (first != last)
first = erase(first);
return last;
}

Answer 4

Swapping two elements is easy, because std::swap will do that for you.
Erasing means that you will have to copy elements following the erased one(s) to fill the "hole". Then subtract from size.
BTW, you have a problem where you copy and assign from another vector. You copy the other vector's capacity, but allocate size elements in the buffer. This will come back and bite you later! :-)