第二十七课 再论智能指针（上）

思考：

　　使用智能指针替换单链表LinkLIst中的原生指针是否可行？

将LinkList.h中的Node指针全部改成智能指针：

#ifndef LINKLIST_H
#define LINKLIST_H

#include "List.h"
#include "Exception.h"
#include "SmartPointer.h"

namespace DTLib
{

template < typename T >
class LinkList : public List<T>
{
protected:
    struct Node : public Object
    {
        T value;
        SmartPointer<Node> next;
    };

    mutable struct : public Object
    {
        char reserved[sizeof(T)];
        SmartPointer<Node> next;
    }m_header;

    int m_length;
    int m_step;
    SmartPointer<Node> m_current;

    Node* position(int i) const    //  O(n)
    {
        //Node* ret = reinterpret_cast<Node*>(&m_header);
        SmartPointer<Node> ret = reinterpret_cast<Node*>(&m_header);

        for(int p = 0; p < i; p++)
        {
            ret = ret->next;
        }

        return ret.get();
    }

    virtual Node* create()
    {
        return new Node();
    }

    virtual void destroy(Node* pn)
    {
        delete pn;
    }

public:
    LinkList()
    {
        m_header.next = NULL;
        m_length = 0;
        m_step = 1;
        m_current = NULL;
    }

    bool insert(const T& e)
    {
        return insert(m_length, e);
    }

    bool insert(int i, const T& e)   // O(n)
    {
        bool ret = ((0 <= i) && (i <= m_length));

        if( ret )
        {
            Node* node = create();

            if( node != NULL )
            {
                Node* current = position(i);

                node->value = e;
                node->next = current->next;
                current->next = node;

                m_length++;
            }
            else
            {
                THROW_EXCEPTION(NoEnoughMemoryException, "No memery to insert new element...");
            }
        }

        return ret;
    }

    bool remove(int i)   // O(n)
    {
        bool ret = ((0 <= i) && (i < m_length));

        if( ret )
        {
            SmartPointer<Node> current = position(i);

            SmartPointer<Node> toDel = current->next;

            if( m_current == toDel )
            {
                m_current = toDel->next;
            }

            current->next = toDel->next;

            m_length--;

            // destroy(toDel);

        }

        return ret;
    }

    bool set(int i, const T& e)   //  O(n)
    {
        bool ret = ((0 <= i) && (i < m_length));

        if( ret )
        {
            position(i)->next->value = e;
        }

        return ret;
    }

    T get(int i) const
    {
        T ret;

        if( get(i, ret) )
        {
            return ret;
        }
        else
        {
            THROW_EXCEPTION(IndexOutOfBoundsException, "Invalid parameter i to get element ...");
        }

        return ret;
    }

    bool get(int i, T& e) const    // O(n)
    {
        bool ret = ((0 <= i) && (i < m_length));

        if( ret )
        {
            e = position(i)->next->value;
        }

        return ret;
    }

    int find(const T& e) const    //  O(n)
    {
        int ret = -1;
        int i = 0;

        SmartPointer<Node> node = m_header.next;

        //while( node )
        while( node.isNull() )
        {
            if( node->value == e )
            {
                ret = i;
                break;
            }
            else
            {
                node = node->next;
                i++;
            }
        }

        return ret;
    }

    int length() const   // O(1)
    {
        return m_length;
    }

    void clear()    //  O(n)
    {
        //while( m_header.next )
        while( m_header.next.isNull() )
        {
            //Node* toDel = m_header.next;
            SmartPointer<Node> toDel = m_header.next;

            m_header.next = toDel->next;

            m_length--;

            // destroy(toDel);
        }

        // m_length = 0;
    }

    bool move(int i, int step = 1)
    {
        bool ret = (0 <= i) && (i < m_length) && (step > 0);

        if( ret )
        {
            m_current = position(i)->next;
            m_step = step;
        }

        return ret;
    }

    bool end()
    {
        //return (m_current == NULL);
        return m_current.isNull();
    }

    T current()
    {
        if( !end() )
        {
            return m_current->value;
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException, "No value at current position ...");
        }
    }

    bool next()   //每次移动step步
    {
        int i = 0;

        while((i < m_step) && !end())
        {
            m_current = m_current->next;
            i++;
        }

        return (i == m_step);
    }

    ~LinkList()   //  O(n)
    {
        clear();
    }
};

}

#endif // LINKLIST_H

测试程序如下：

#include <iostream>
#include "LinkList.h"

using namespace std;
using namespace DTLib;


int main()
{
    LinkList<int> list;

    for(int i = 0; i < list.length(); i++)
    {
        list.insert(i);
    }

    for(list.move(0); !list.end(); list.next())
    {
        cout << list.current() << endl;
    }

    return 0;
}

运行结果如下：

程序直接崩溃了。

 我们的SmartPointer设计中，一片堆空间最多只能由一个指针标识，但是我们设计的和遍历有关的函数，例如move、end、current、next，在遍历时一片堆空间会由多个指针指向，所以程序崩溃了。

改进方案：

我们需要创建一个中间类pointer，并且它还有两个子类。

SharedPointer支持一片堆空间由多个指针指向，也支持自动释放。

在设计上做了改动，所以SmartPointer也得做改动。

pointer类中的析构函数是纯虚函数，因为pointer是一个抽象父类，需要由子类继承才能生成对象。

Object的析构函数就是纯虚的，所以pointer中就没有必要再写一遍了。

只要pointer没有实现自己的析构函数，那么它就还是一个抽象类。

添加Pointer.h文件，内容如下：

#ifndef POINTER_H
#define POINTER_H

#include "Object.h"

namespace DTLib
{

template < typename T >
class Pointer : public Object
{
protected:
    T* m_pointer;

public:
    Pointer(T* p = NULL)
    {
        m_pointer = p;
    }

    T* operator->()
    {
        return m_pointer;
    }

    T& operator* ()
    {
        return *m_pointer;
    }

    bool isNull()
    {
        return (m_pointer == NULL);
    }

    T* get()
    {
        return m_pointer;
    }

    // 不需要析构函数，这里继承自Object，只要不实现具体的析构函数，这个类就是抽象类
};

}

#endif // POINTER_H

SmartPointer.h的内容更改如下：

#ifndef SMARTPOINTER_H
#define SMARTPOINTER_H

#include "Pointer.h"

namespace DTLib
{

template <typename T>
class SmartPointer : public Pointer<T>
{
public:
    SmartPointer(T *p = NULL) : Pointer<T>(p)
    {

    }

    SmartPointer(const SmartPointer<T>& obj)
    {
        this->m_pointer = obj.m_pointer;

        const_cast<SmartPointer<T>&>(obj).m_pointer = NULL;
    }

    SmartPointer<T>& operator= (const SmartPointer<T>& obj)
    {
        if(this != &obj)
        {
            T* p = this->m_pointer;

            this->m_pointer = obj.m_pointer;

            const_cast<SmartPointer<T>&>(obj).m_pointer = NULL;

            delete p;
        }

        return *this;
    }

    ~SmartPointer()   // 肯定需要这个析构函数，否则还是抽象类
    {
        delete this->m_pointer;
    }
};

}

#endif // SMARTPOINTER_H

第25-36行的赋值操作符改成了异常安全的，将delete操作放到了最后。

SmartPointer.h中删掉了一些重载函数，放到了Pointer.h中，SmartPointer继承自Pointer。

测试程序如下：

#include <iostream>
#include "SmartPointer.h"

using namespace std;
using namespace DTLib;


class Test : public Object
{
public:
    Test()
    {
        cout << "Test()" << endl;
    }

    ~Test()
    {
        cout << "~Test()" << endl;
    }
};

int main()
{
    SmartPointer<Test> sp = new Test();

    return 0;
}

结果如下：

可以看到自动调用了Test的析构函数。

思考：