#include <iostream>
#include <cassert>
#include <string.h>
using namespace std;
template <class Type>
class vector{
public:
vector();
vector(int i);
~vector(){if (ptr) delete [] ptr; isize = 0;};
void push_back(Type v);
// void push_back(Type& v);
void pop_back();
Type& operator[](int i);
int size(){return isize;}
int capacity(){return icapacity;}
typedef Type* iterator;
Type* begin();
Type* end();
Type& back();
bool empty();
private:
Type *ptr;
int index;
int isize;
int icapacity;
static const int factor = 2;
static const int defaultsize = 4;
};
template <class Type>
Type* vector<Type>::begin()
{
return ptr;
}
template <class Type>
Type* vector<Type>::end()
{
if (index)
return ptr + index;
else
return NULL;
}
template <class Type>
Type& vector<Type>::back()
{
if (index)
return ptr[index-1];
}
template <class Type>
bool vector<Type>::empty()
{
return !(index > 0);
}
template <class Type>
Type& vector<Type>::operator[](int i)
{
assert(i<index);
return ptr[i];
}
template <class Type>
void vector<Type>::pop_back()
{
if (index <= 0)
return;
index--;
}
#if 0
template <class Type>
void vector<Type>::push_back(Type& v)
{
int old_capa;
Type *newptr = NULL;
if (index < icapacity){
ptr[index++] = v;
isize++;
}
else
{
if (icapacity){
old_capa = icapacity;
icapacity += factor * defaultsize;
}
else{
old_capa = 0;
icapacity = defaultsize;
}
try{
newptr = new Type[icapacity]();
}catch(const bad_alloc &e){
cout << e.what();
return;
}
if (ptr && old_capa){
memcpy(newptr, ptr, old_capa * sizeof(Type));
delete [] ptr;
}
ptr = newptr;
ptr[index++] = v;
isize++;
}
}
#endif
template <class Type>
void vector<Type>::push_back(Type v)
{
int old_capa;
Type *newptr = NULL;
if (index < icapacity){
ptr[index++] = v;
isize++;
}
else
{
if (icapacity){
old_capa = icapacity;
icapacity += factor * defaultsize;
}
else{
old_capa = 0;
icapacity = defaultsize;
}
try{
newptr = new Type[icapacity]();
}catch(const bad_alloc &e){
cout << e.what();
return;
}
if (ptr && old_capa){
memcpy(newptr, ptr, old_capa * sizeof(Type));
delete [] ptr;
}
ptr = newptr;
ptr[index++] = v;
isize++;
}
}
template <class Type>
vector<Type>::vector(int i)
{
Type *p;
icapacity = i * factor;
ptr = new Type[icapacity]();
if (ptr){
isize = i;
index = i;
}
else{
isize = 0;
icapacity = 0;
index = 0;
}
}
template <class Type>
vector<Type>::vector()
{
ptr = NULL;
isize = 0;
icapacity = 0;
index = 0;
}
template <class Type>
class stack
{
public:
stack();
~stack();
//void push(Type &v);
void push(Type v);
Type& pop();
bool empty();
private:
vector<Type> vec;
};
template <class Type>
Type& stack<Type>::pop()
{
Type& p = vec.back();
vec.pop_back();
return p;
}
template <class Type>
void stack<Type>::push(Type v)
{
vec.push_back(v);
}
#if 0
template <class Type>
void stack<Type>::push(Type &v)
{
vec.push_back(v);
}
#endif
template <class Type>
bool stack<Type>::empty()
{
return vec.empty();
}
template <class Type>
stack<Type>::stack()
{
}
template <class Type>
stack<Type>::~stack()
{
while(!vec.empty())
vec.pop_back();
}
template <class Type>
class pipe
{
public:
private:
};
int main()
{
int i;
vector<int> v(10);
stack<int> s;
for(i=0; i<10; i++)
v[i] = i+1;
for(i=0; i<10; i++)
cout << " " << v[i];
cout << endl;
v.push_back(23);
v.push_back(323);
v.push_back(999);
v.push_back(i);
cout << v.size() << v.capacity() << endl;
for(vector<int>::iterator it=v.begin(); it!=v.end(); ++it)
cout << " " << *it;
cout << endl;
while(!v.empty()){
cout << " " << v.back();
v.pop_back();
}
cout << endl;
s.push(10);
s.push(11);
s.push(i);
cout << s.pop() << " " << s.pop() << " " << s.pop() << endl;
}