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

<br>#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;
}