其他数据结构通过泛化的Pair,Array,Chain,Auto,Tree,Graphi衍生,不独立设计新的容器,这样可以集中写自己想要的目标实现.

向量 vector

0 没有SmartPtr去控制指针,而是把所有可能的基本操作封装到结点本身的结构体内.

1 为链表的小操作如插入删除列出内部结构体函数,方便以后代码优化,以后增加迭代器的操作就无关内存回收,因为最小粒度操作被封装进结点本身的结构体内方法中.

2 类似python下标的智能索引,-1 是last,-2是倒数第二个,这个功能是可选的.

3 这次特意注意了命名规则,尽量简洁而有据可查.


如果各位路过的有兴趣仔细看下代码,并且指点一二，那就非常感谢了.

/**/ /*  vector.h :base::adt::vector */


#ifndef VECTOR__
 #define  VECTOR__


#pragma warning (disable:  4138 ) /**/ /* comment warning */

#include  " base.h "


namespace  adt
 {
#define  SMART_INDEX
    template<typename VType>
    class /**//*Adt: Double Chain Table*/ vector:public base::adt
    {
    public:
        int smartindex(int & _i,const int& _n)
        {
#ifdef SMART_INDEX
            if(_n==1)
            {
                _i=0;
                return 0;
            }
            if(_i<0)
            {
                _i=-_i;
                _i=_i%_n;
                _i = _n - _i;
            }else
            {
                _i=_i%_n;
            }
#endif
            return 1;
        }
        typedef struct VNode
        {
            VNode*/**//*prior     node*/ prev;
            VNode*/**//*following node*/ next;
            VType  elem;
            int extend_prev(VType  _prev_elem)
            {
                prev=new VNode;
                prev->elem=_prev_elem;
                prev->next=this;

                return 1;
            }
            int extend_prev()
            {
                prev=new VNode;
                prev->next=this;

                return 1;
            }
            int extend_next(VType _nextend_elem)
            {

                next=new VNode;

                next->elem=_nextend_elem;
                next->prev=this;

                return 1;
            }
            int extend_next()
            {

                next=new VNode;
                next->prev=this;

                return 1;
            }
            int inst_node(const VType &_inst_elem)
                /**//* inserts a node between obj and obj's following */
            {
                VNode* _ins_node=new VNode;
                _ins_node->elem=_inst_elem;

                _ins_node->next=this->next;
                _ins_node->next->prev=_ins_node;
                this->next=_ins_node;
                _ins_node->prev=this;
                return 1;
            }
            int remove()
                /**//* deletes the middle node and close its prev and next */
            {
                if(!this->prev||!this->next)
                {
                    return 0;
                }
                this->prev->next=this->next;
                this->next->prev=this->prev;
                delete this;
                return 1;
            }

        };


    public :

        VNode* head;
        VNode* tail;
        VNode* p;

        int n;
        vector(VType *_init_elem=0,int _len=0)
        {

            if(_len<=-1)return;

            p=head=new VNode;
            p->prev=0;


            for(int j=0;j!=_len;j++)
            {
                p->extend_next(_init_elem[j]);
                p=p->next;
            }
            p->extend_next();
            n=_len;


        }
        int rebirth(VType *_re_init_elem,int _len=0)
        {
            vector(_re_init_elem,_len);

            return 1;
        }

        int index(VType _value)
        {

            p=head->next;
            for(int j=0;j!=n;j++)
            {
                if(p->elem==_value)
                {
                    return j;
                }
                p=p->next;
            }


            return -1; 
        }

        VType & operator [](int _i)
        {
            smartindex(_i,n);

            p=head->next;
            for(int j=0;j!=_i;j++)
            {
                p=p->next;
            }

            return p->elem;
        }

        int insert(int _i,VType _obj_elem)
        {
            p=head;

            for(int j=0;j!=_i;j++)
            {
                p=p->next;
            }
            p->inst_node(_obj_elem);

            ++n;

            return 1;
        }
        int isNull()
        {
            if(n==0)return 1;
            else return 0;
        }
        int push(VType _obj)
        {
            insert(n,_obj);
            return 1;
        }
        VType pop()
        {
#ifdef TEST_OPEN
            if(n==0)
                TEST_THROW("Exception in vector pop-function")
#endif
            return remove(-1);
        }
        VType remove(int _i)
        {
            smartindex(_i,n);
            p=head->next;

            for(int j=0;j!=_i;j++)
            {
                p=p->next;
            }

            VType buf=p->elem;

            p->remove();
            --n;

            return buf;

        }
        void operator = (vector& _copy)
        {
            p=head;
            _copy.p=_copy.head;
            for(int i=0;i!=_copy.n;i++)
            {    
                _copy.p=_copy.p->next;
                p->extend_next(_copy.p->elem);
                p=p->next;


            }
            p->extend_next();
            n=_copy.n;

        }
        int free()
        {
            if(n==0)return 1;
            for(int j=0;j!=n;j++)
            {
                head=head->next;
                delete head->prev;
            }
            delete head->next;
            delete head;

            n=0;
            p=0;
            head=0;
            return 1;
        }
        ~vector()
        {
            free();
        }

    };

} ;
 #endif