發現簡單的測試還是比較好用的,于是考慮重寫代碼,取消庫前綴,做一些庫結構上的改變.

暫時先不考慮寫內存泄露檢測庫.

等有空,可以再把測試時測試代碼自動輸出測試文檔的部分寫下.



#ifdef TEST_OPEN


#ifndef TEST__
#define TEST__


#include <iostream>

using std::cout;
using std::endl;






#define FLAG__  cout<<"[test:flag]";

#define SHOW__(X) cout<<X<<endl;



#define TEST_THROW(X)  throw string(X);
#define TEST_BEGIN   try{
#define TEST_END     }catch(string TEST_CATCH){ cout<<TEST_CATCH<<endl;}


#endif
#endif

#ifndef TEST_OPEN

#define TEST_BEGIN 
#define TEST_END
#define TEST_THROW(X)
#define SHOW__(X)
#define FLAG__


#endif




讓測試能夠原封不動的保留其代碼而不需要在不需要的時候注釋掉他們 只需要通過一條#define TEST_OPEN 啟動或者關閉其功能.




TEST_BEGIN  / TEST_END 用于獲取庫調用時出現的庫使用者越界或者其他極端條件下造成的異常.


對于自己宏的命名規則只兩種:

XXX_XXXX :

XXXX__ 



#define TEST_OPEN



#include <iostream>
#include <string>

using namespace std;

#include "base.h"
#include "ptr.h"
#include "runtime.h"
#include "tree.h"
#include "array.h"
#include "vector.h"



void test_runtime()
{
    using os::chaos;
    using os::runtime;
    chaos c;
    runtime t_;
    t_.begin();
    for(int i=0;i!=1110;i++)
    cout<<c.getRandom(5,10)<<endl;
    t_.end();
    cout<<"get time:"<<t_.getDTime()<<"ms"<<endl;
}
void test_ptr()
{

    using code::ptr;

    ptr<string> str,str2;
    str ="lost butterfly.";
    str2=str;
    cout<<str()<<endl
        <<str2()<<endl;
    str2.free();
    cout<<str()<<endl;

}

void test_tree()
{
    using adt::tree;
    tree<int> t,t2;
    t.set(1);
    t.goLeft(1);
    t.goRight(2);
    t.setLeft(3);
    t.setRight(4);
    int list[10]={0},list2[20]={0};
    t.travel(list,1);
    for(int i=0;i!=t.n;i++)
     cout<<list[i]<<endl;
    t2=t;
    t2.travel(list2,1);
    cout<<":\n";
    
    for(int i=0;i!=t2.n;i++)
     cout<<list2[i]<<endl;
}

void test_array()
{
    using adt::array;
    
    array<int> ar(5,0),ar2(10,1);
    
    ar[0]=1;
    ar[1]=2;
    ar[4]=3;
    for(int i=0;i!=ar.n_;i++)
        cout<<ar[i]<<endl;
    ar=ar2;
    ar2[3]=2;
    for(int i=0;i!=ar2.n_;i++)
        cout<<ar2[i]<<endl;
}
void test_vector()
{
    using adt::vector;
    
    vector<int> v,v2;
    v2.push(3);
    v2.push(4);
    v2[1]=5;
    v2.pop();
    v=v2;
    FLAG__
    cout<<v.pop()<<endl;
    //cout<<v.isNull();

    TEST_BEGIN
    cout<<v.pop()<<endl;
    TEST_END

    //cout<<v.isNull();
}
int main()
{

    test_ptr();
    test_tree();
    test_runtime();
    test_array();
    test_vector();

    
    return 1;
}



初步對整個庫的部分實現順序和命名規則,1 左邊是原則

1 左邊是約定

2 右邊是實現順序,從左到右.

臨時草稿在這個程度上還是沒什么問題的,必要時列出AOV防止實現的沖突


對于表中自己設定的"屬性名首字母大寫",恐怕我還是喜歡小寫.
有的時候為了讓庫的使用者知道某些封裝的屬性雖然是public但不應該去擅自修改值的,可以后綴帶"_". 成員函數也如此,是內置且開放方法但不推薦直接使用的函數.




另外從現在開始在vector以及以后的所有代碼里增加對代碼的維護test,

#ifndef VECTOR__
#define VECTOR__

#pragma warning (disable: 4138)

#include "base.h"http://it includes  test.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()
        {
            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