#ifndef VECTOR_H
#define VECTOR_H
#include <algorithm>
template <typename Object>
class Vector
{
public:
explicit Vector(int initSize = 0) : theSize{
initSize },
theCapacity{
initSize + SPARE_CAPACITY }
{
objects = new Object[theCapacity];
}
Vector(const Vector & rhs) : theSize{
rhs.theSize },
theCapacity{
rhs.theCapacity }, objects{
nullptr }
{
objects = new Object[theCapacity];
for (int k = 0; k < theSize; ++k)
objects[k] = rhs.objects[k];
}
Vector & operator= (const Vector & rhs)
{
Vector copy = rhs;
std::swap(*this, copy);
return *this;
}
~Vector()
{
delete [] objects;
}
Vector(Vector && rhs) : theSize{
rhs.theSize },
theCapacity{
rhs.theCapacity }, objects{
rhs.objects }
{
rhs.objects = nullptr;
rhs.theSize = 0;
rhs.theCapacity = 0;
}
Vector & operator= (Vector && rhs)
{
std::swap(theSize, rhs.theSize);
std::swap(theCapacity, rhs.theCapacity);
std::swap(objects, rhs.objects);
return *this;
}
void resize(int newSize)
{
if (newSize > theCapacity)
reserve(newSize * 2);
theSize = newSize;
}
void reserve(int newCapacity)
{
if (newCapacity < theSize)
return;
Object *newArray = new Object[newCapacity];
for (int k = 0; k < theSize; ++k)
newArray[k] = std::move(objects[k]);
theCapacity = newCapacity;
std::swap(objects, newArray);
delete [] newArray;
}
Object & operator[] (int index)
{
return objects[index];
}
const Object & operator[] (int index) const
{
return objects[index];
}
bool empty() const
{
return size() == 0;
}
int size() const
{
return theSize;
}
int capacity() const
{
return theCapacity;
}
void push_back(const Object & x)
{
if (theSize == theCapacity)
reserve(2 * theCapacity + 1);
objects[theSize++] = x;
}
void push_back(Object && x)
{
if (theSize == theCapacity)
reserve(2 * theCapacity + 1);
objects[theSize++] = std::move(x);
}
void pop_back()
{
--theSize;
}
const Object & back() const
{
return objects[theSize - 1];
}
typedef Object * iterator;
typedef const Object * const_iterator;
iterator begin()
{
return &objects[0];
}
const_iterator begin() const
{
return &objects[0];
}
iterator end()
{
return &objects[size()];
}
const_iterator end() const
{
return &objects[size()];
}
static const int SPARE_CAPACITY = 16;
private:
int theSize;
int theCapacity;
Object * objects;
};
#endif
#include "Vector.h"
#include <iostream>
#include <algorithm>
using namespace std;
template <typename Object>
void print(const Vector<Vector<Object> >& Vec)
{
int n = Vec.size();
for (int i = 0; i < n; ++i) {
cout << "Vec[" << i << "]:";
for (int j = 0; j < Vec[i].size(); ++j)
cout << " " << Vec[i][j];
cout << endl;
}
}
class CompareVector
{
public:
bool operator() (const Vector<int>& lhs, const Vector<int>& rhs)
{
return lhs.size() < rhs.size(); }
};
int main()
{
const int N = 20;
Vector<Vector<int> > Vec(N);
Vector<int> v;
for (int i = N - 1; i > 0; --i) {
v.push_back(i);
Vec[i] = v;
}
print(Vec);
sort(Vec.begin(), Vec.end(), CompareVector{
});
print(Vec);
return 0;
}