20120918-向量实现《数据结构与算法分析》

#include <iostream>
#include <list>
#include <string>
#include <vector>
#include <bitset>
using namespace std;

template <typename Container,typename Object>
void change(Container & c,const Object & newValue)//改变新值
{
	typename Container::ierator itr = c.begin();
	while( itr != c.end())
	{
		*itr++ = newValue;
	}
}

template <typename Container,typename Object>
void print(const list<int> & lst,ostream & out = cout)//打印值，并且归0
{
	typename Container::iterator itr = lst.begin();
	while( itr != lst.end())
	{
		cout<<*itr<<endl;
		*itr=0;
		itr++;
	}
}

template <typename Container>
void printCollection( const Container & c)//打印任何容器
{
	if (c.empty())
		cout<<"(empty)";
	else
	{
		typename Container::const_iterator itr = c.begin();
		cout << "[" << *itr++;

		while(itr != c.end())
		{
			cout << ","<<*itr++;
		}

		cout<<"]"<<endl;
	}
}
template <typename Object>//Vector类向量实现
class Vector
{
	public:
		explicit Vector(int initSize = 0):theSize(initSize),theCapacity(initSize+SPARE_CAPACITY)
		{
			objects = new Object[theCapacity];
		}
		Vector(const Vector & rhs) : objects(NULL)
		{
			operator=(rhs);
		}
		~Vector()
		{
			delet [] objects;
		}
		
		const Vector & operator = (const Vector & rhs)
		{
			if(this != &rhs)
			{
				delete [] objects;
				theSize = rhs.size();
				theCapacity = rhs.theCapacity();

				objects = new Object[ capacity() ];
				for(int k=0; k<size() ; k++)
					objects[k] = rhs.objects[k];
			}
		return *this;
		}

		void resize( int newSize)
		{
			if(newSize > theCapacity)
				reserve( newSize*2+1);
			theSize = newSize;
		}

		void reserve( int newCapacity)
		{
			if(newCapacity < theSize)
				return;

			Object *oldArray = objects;

			objects = new Object[ newCapacity];
			for( int k=0; k<theSize ; k++)
				objects[k] = oldArray[k];

			theCapacity = newCapacity;

			delete [] oldArray;
		}

		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 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()];
		}

		enum {SPARE_CAPACITY=16};

		private:
			int theSize;
			int theCaacity;
			Object *objects;
}
int main()
{
	list<string> a;
	list<int> b;
	list<int> c;
	c.push_back(123);
	a.push_back("123");
	a.push_back("ooo");
	a.push_back("456");
	a.push_back("ooo");
	a.push_back("789");
	printCollection(a);
	printCollection(b);
	printCollection(c);
	return 0;
}