刘晶ID：Tomsdinary
共5775次访问，排名15962(2)好友0人，关注者1人
我是一个喜欢C++热爱底层编程及算法设计的学生。
Tomsdinary的文章
原创 22 篇
翻译 1 篇
转载 0 篇
评论 1 篇
最近评论
agjyfm：wow gold
文章分类
收藏
    相册
    存档
    软件项目交易
    订阅我的博客
    XML聚合  FeedSky
    订阅到鲜果
    订阅到Google
    订阅到抓虾
    订阅到BlogLines
    订阅到Yahoo
    订阅到GouGou
    订阅到飞鸽
    订阅到Rojo
    订阅到newsgator
    订阅到netvibes

    原创 双向循环链表收藏

    新一篇: 简易垃圾收集类 | 旧一篇: 字符串
    /**
    文件名：       DynamicArray.hpp
    作者：         Tomsdinary
    备注：         本文件中的实现是动态数组实现的线性表模版
    最后修改时间： 2007年10月12日
    */

    #ifndef _DYNAMICARRAY_HPP_
    #define _DYNAMICARRAY_HPP_

    #include     <cstddef>

    namespace Tomsdinary
    {
        template     <typename T>
            class DynamicArray
            {
            public:
            typedef T              value_type;
            typedef T    *             pointer;
            typedef T    &             reference;
            typedef     const T*       const_pointer;
            typedef     const T&       const_reference;
            typedef std::size_t    size_type;
            typedef std::ptrdiff_t pointer_difference;
            public:
                //构造空数组
            DynamicArray ();
                //以指定容量构造数组
            explicit DynamicArray (size_type max_size);
                //以指定容量构造，并用初始值初始化
            DynamicArray (size_type max_size, const_reference item);
                //构造数组，指定容量与增量
            DynamicArray (size_type max_size, size_type increasement);
                //构造数组，指定容量，增量与初始值
            DynamicArray (size_type max_size, const_reference item, size_type increasement);
                //复值构造
            DynamicArray (const DynamicArray<T>& other);
                //析构
            ~DynamicArray();
                //重载等于
            DynamicArray<T>& operator= (const DynamicArray<T>& other);
                //重载方括号运算
            reference operator[] (size_type index)
                {
                    return m_data[index];
            }
                //判断数组是否为空
            bool IsEmpty () const
                {
                    return m_length==0;
            }
                //获得数组当前大小
            size_type GetLength () const
                {
                    return m_length;
            }
                //获得数组当前容量
            size_type GetCapacity () const
                {
                    return m_capacity;
            }
                //获得数组大小增量
            size_type GetIncreasement () const
                {
                    return m_increasement;
            }
                //设置数组大小增量
            void SetIncreasement (size_type increasement)
                {
                m_increasement    =increasement;
            }
                //追加元素
            void AppendElement (const_reference item);
                //指定位置插入元素
            void InsertElement (size_type index, const_reference item);
                //删除末尾元素
            void RemoveEnd ()
                {
                    --m_length;
            }
                //删除指定位置元素 位置版本
            void RemoveElement (size_type index);
                //定位元素
            pointer_difference IndexOf (const_reference item);
                //定位元素 Compare必须是仿函数
            template <typename Compare> 
              pointer_difference IndexOf (const_reference item, Compare Comparer);
                //清空数组，但不释放内存
            void Clear ()
                {
                m_length    =0;
            }
                //升序排序  未实现
            void Sort ();
                //升序排序 Func必须是仿函数
            template <typename Compare> 
                  void Sort (Compare Func); 
                //转置
            void Reverse ();

            public:
                //迭代器内建类
            class Iterator
                {
                public:
                    explicit Iterator(pointer self=NULL)
                    {
                    m_iter    =self;
                }
                reference     operator* () const
                    {
                        return *m_iter;
                }
                pointer     operator-> () const
                    {
                        return m_iter;
                }
                Iterator    & operator++ ()
                    {
                        ++m_iter;
                        return *this;
                }
                Iterator     operator++ (int)
                    {
                    T    * tmp=m_iter;
                        ++m_iter;
                        return Iterator(tmp);
                }
                Iterator    & operator-- ()
                    {
                        --m_iter;
                        return *this;
                }
                Iterator     operator-- (int)
                    {
                    T    * tmp=m_iter;
                        --m_iter;
                        return Iterator(tmp);
                }
                pointer     operator+ (const pointer_difference offset);
                pointer     operator- (const pointer_difference offset);
                public:
                    bool operator< (const Iterator& rbs)
                    {
                        return m_iter<rbs.m_iter;
                }
                    bool operator== (const Iterator& rbs)
                    {
                        return m_iter==rbs.m_iter;
                }
                    bool operator!= (const Iterator& rbs)
                    {
                        return m_iter!=rbs.m_iter;
                }
                private:
                pointer m_iter;
            }    ;  //end of class Iterator

                //迭代器操作 首地址指针
            Iterator Begin ()
                {
                    return Iterator(this->m_data);
            }
                //迭代器操作 最后一个元素后一个元素指针
            Iterator End ()
                {
                    return Iterator(this->m_data+this->m_length);
            }
            private:
                //数组基地址
            T* m_data;
                //动态变化增量
            size_type m_increasement;
                //当前大小
            size_type m_length;
                //当前容量
            size_type m_capacity;
        }    ;  //end of class DynamicArray

        template     <typename T>
            DynamicArray    <T>::DynamicArray ()
            {
            m_data    =NULL;
            m_increasement    =0;
            m_length    =0;
            m_capacity    =0;
        }

        template     <typename T>
            DynamicArray    <T>::DynamicArray (size_type max_size)
            {
            m_data    =new T[max_size];
            m_increasement    =0;
            m_length    =0;
            m_capacity    =max_size;
        }

        template     <typename T>
            DynamicArray    <T>::DynamicArray (size_type max_size, const_reference item)
            {
            m_data    =new T[max_size];
            m_increasement    =0;
            m_length    =max_size;
            m_capacity    =max_size;
            T    * p=m_data;
            T    * q=m_data+max_size;
                while (p<q)
                {
                    *p=item;
                    ++p;
            }
        }

        template     <typename T>
            DynamicArray    <T>::DynamicArray (size_type max_size, size_type increasement)
            {
            m_data    =new T[max_size];
            m_increasement    =increasement;
            m_length    =0;
            m_capacity    =max_size;
        }

        template     <typename T>
            DynamicArray    <T>::DynamicArray (size_type max_size, const_reference item, size_type increasement)
            {
            m_data    =new T[max_size];
            m_increasement    =increasement;
            m_length    =max_size;
            m_capacity    =max_size;
            T    * p=m_data;
            T    * q=m_data+max_size;
                while (p<q)
                {
                    *p=item;
                    ++p
            }
        }

        template     <typename T>
            DynamicArray    <T>::DynamicArray (const DynamicArray<T>& other)
            {
                if (other.m_data==NULL)
                {
                m_data    =NULL;
                m_increasement    =0;;
                m_length    =0;
                m_capacity    =0;
            }
                else
                {
                m_capacity    =other.m_capacity;
                m_length    =other.m_length;
                m_increasement    =other.m_increasement;
                m_data    =mew T[m_capacity];
                T    * p=m_data;
                T    * s=other.m_data;
                T    * t=other.m_data+m_length;
                    while (s<t)
                    {
                        *p=*s;
                        ++p;
                        ++s;
                }
            }
        }

        template     <typename T>
            DynamicArray    <T>::~DynamicArray()
            {
            delete[] m_data;
        }

        template     <typename T>
            DynamicArray    <T>& DynamicArray<T>::operator= (const DynamicArray<T>& other)
            {
                if (this!=&other)
                {
                    if (m_data!=NULL)
                    {
                    delete[] m_data;
                }
                    if (other.m_data==NULL)
                    {
                    m_data    =NULL;
                    m_increasement    =0;;
                    m_length    =0;
                    m_capacity    =0;
                }
                    else
                    {
                    m_capacity    =other.m_capacity;
                    m_length    =other.m_length;
                    m_increasement