sgi中的list解析

template <typename _Tp>
class Alloc
{
    Alloc()
    {
        printf("alloc...");
    }
    _Tp* allocate(size_t n)
    {
        _Tp* Alltp = malloc(n*_Tp);
        return Alltp;
    }
    void deallocate(_Tp* __p, size_t n)
    {
        free(__p);
    }
};


struct _Slist_node_base
{
    _Slist_node_base* _M_next;
};

template <class _Tp>
struct _Slist_node : public _Slist_node_base
{
    _Tp _M_data;
};

//在sgi中的list为单向列表   每个节点只有一个next指针   
//需要list_make_link 函数将各个节点连接起来  
inline _Slist_node_base*__slist_make_link(_Slist_node_base* __prev_node, _Slist_node_base* __new_node)
{
    __new_node->_M_next = __prev_node->_M_next;
    __prev_node->_M_next = __new_node;
    return __new_node;
}

template <class _Tp, class _Alloc>
struct _Slist_base {
    typedef _Alloc allocator_type;
    //allocator_type get_allocator() const { return allocator_type(); }

    _Slist_base() { _M_head._M_next = 0; }


    ~_Slist_base() { _M_erase_after(&_M_head, 0); }

protected:
//父类中用于空间的分配 不涉及对象的创建
    typedef Alloc<_Slist_node<_Tp> > _Alloc_type;
    _Slist_node<_Tp>* _M_get_node() { return _Alloc_type::allocate(1); }
    void _M_put_node(_Slist_node<_Tp>* __p) { _Alloc_type::deallocate(__p, 1); }

//在父类的析构函数中，先进行destroy方法析构各节点，然后进行 put_node方法进行空间的释放
    _Slist_node_base* _M_erase_after(_Slist_node_base* __pos)
    {
        _Slist_node<_Tp>* __next = (_Slist_node<_Tp>*) (__pos->_M_next);
        _Slist_node_base* __next_next = __next->_M_next;
        __pos->_M_next = __next_next;
        destroy(&__next->_M_data);
        _M_put_node(__next);
        return __next_next;
    }

protected:
    //父类中node_base类中包含的 第一个list节点 不包含值 只作为起点  
    _Slist_node_base _M_head;
};



template <typename _Tp, typename _Alloc = Alloc<_Tp> >
class slist : private _Slist_base<_Tp, _Alloc>
{
//在list类中，有创建节点的create_node 方法：
    //第一步：调用的是父类的 get_node方法，父类的get_node方法会调用allocate的方法来分配空间    
    //第二步：调用construct方法在分配好的空间中构造节点

public:
    typedef _Tp value_type;
public:
    explicit slist() : _Base() {}

    slist(size_type __n, const value_type& __x,
        ) : _Base()
    {
        _M_insert_after_fill(&this->_M_head, __n, __x);
    }

    explicit slist(size_type __n) : _Base()
    {
        _M_insert_after_fill(&this->_M_head, __n, value_type());
    }
};
    //即 get_node put_node 用于空间的分配和释放 （调用allocate分配器 malloc  free ）
    //construct destroy STL中规定的方法来构造和销毁对象（主要用到在指定空间的 new 操作）

    //其余的函数就没什么问题了
int main()
{
    slist<int> demo;
    return 0;
}