八、单链表的实现

1、链式存储结构线性表的实现：

LinkList设计要点：类模板

• 通过头结点访问后继节点
• 定义内部结点类型Node，用于描述数据域和指针域
• 实现线性表的关键操作（增、删、改、查等）

2、LinkList

template <typename T>
class LinkList : public List<T>
{
protected:
    struct Node : public Object 
    {
        T value;
        Node* next;
    };
    
    Node m_header;
    int m_length;
    
public:
    LinkList() {}
};

具体实现

template <typename T>
class LinkList : public List<T>
{
protected:
    struct Node : public Object
    {
        T value;    // 数据域
        Node* next; // 指针域
    };

    mutable Node m_header;  // 头结点
    int m_length;   // 记录链表长度

public:
    LinkList()
    {
        m_header.next = NULL;
        m_length = 0;
    }
	
	// 链表末尾插入元素
    bool insert(const T& e)
    {
        return insert(m_length, e);
    }
    // 指定位置插入元素
    bool insert(int i, const T& e)
    {
        // 注意i的范围
        bool ret = ((i>=0) && (i<=m_length));
        cout << "ret  = " << ret <<  endl;
        if (ret)
        {
            Node* node = new Node();
            if (node != NULL)
            {
                // current的目标指向其实都是目标位置的前一个，比如：在第0个位置增加元素，current指向的是header
                Node* current = &m_header;
                for(int p = 0; p < i; p++)
                {
                    current = current->next;
                }
                node->value = e;
                node->next = current->next;
                current->next = node;

                m_length++;
            }
            else
            {
                cout << "THROW_EXCEPTION" << endl;
                THROW_EXCEPTION(NoEnoughMemoryException, "No memory to insert new element");
            }
        }

        return ret;
    }
	// 删除指定位置元素
    bool remove(int i)
    {
        // 注意i的范围
        bool ret = ((i>=0) && (i<m_length));
        if (ret)
        {
            Node* current = &m_header;
            for(int p = 0; p < i; p++)
            {
                current = current->next;
            }

            Node* toDel = current->next;
            current->next = toDel->next;

            delete toDel;
            m_length--;
        }
        return ret;
    }
    // 设定指定位置的元素
    bool set(int i, const T& e)
    {
        // 注意i的范围
        bool ret = ((i>=0) && (i<m_length));
        if (ret)
        {
            Node* current = &m_header;
            for(int p = 0; p < i; p++)
            {
                current = current->next;
            }
            current->next->value = e;
        }
        return ret;
    }
    // get函数用起来不方便，重载一下
    T get(int i) const
    {
        T ret;
        if (get(i, ret))
        {
            return ret;
        }
        else
        {
            THROW_EXCEPTION(IndexOutOfBoundsException, "Invalid parameter i to get element...");
        }
    }
	// 获取指定位置的元素
    bool get(int i, T& e) const
    {
        bool ret = ((i>=0) && (i<m_length));
        if (ret)
        {
            Node* current = &m_header;
            for(int p = 0; p < i; p++)
            {
                current = current->next;
            }

            e = current->next->value;
            // get是const成员函数，按理来说不能修改成员变量的值，Node* current=&m_header，会被误认为要更改成员变量的值，故报错
            // 解决方案是对m_header加上mutable，开一个例外
        }

        return ret;
    }
    int length() const
    {
        return m_length;
    }
    void clear()
    {
        // 释放每一个结点
        while(m_header.next)
        {
            Node* toDel = m_header.next;
            m_header.next = toDel->next;
            delete toDel;
        }
        m_length = 0;
    }
    ~LinkList()
    {
        clear();
    }
};

问题：头结点隐患，实现代码优化

创建m_header时，会调用T value，用泛指类型创建头结点的数据域，当泛指类型为用户自定义类型时，用用户自定义的类类型在库中创建对象，就有可能出错了，而且在外部看来，并没有用该类型创建对象，问题定位很麻烦。

解决办法：构造头结点时，不调用泛指类型创建头结点，而是按内存分布自己重建构造一个类对象，注意一定要和以前的头结点的内存分布一样，不仅是成员变量的内存大小，同样也要和以前一样继承于Object

// 直接创建头结点，存在隐患
mutable Node m_header;

// 重新构造之后的头结点
mutable struct : public Object
{
    char reserved[sizeof(T)];   // 没实际作用，占空间
    Node* next;
} m_header;

class Test
{
public:
    Test()
    {
        throw 0;
    }
};
int main()
{
    LinkList<Test> list;
// 没有重新构造头结点之前，会抛一个异常，是应该用test创建类的时候抛的异常，但是这里应该没有创建test类，使用了test作为类型，创建的LinkList的类对象。出现异常的原因是在用单链表创建类的时候，创建头结点时会调用Test的构造函数，由此引发异常

    cout << "sofrware"<< endl;
    // 重新构造之后，以下这样也会报错，但是原因就会是用户自己创建的类对象，方便查找错误
    Test t;
    list.insert(t);

重新构造后的头结点在内存布局上和之前没有差异，差异在于不管泛指类型是什么，都不会去调用泛指类型的构造函数了。虽然它们在内存布局上是一样的，但是新构造的头结点是个空类型，不能直接用，使用时要进行类型转换

Node* ret = reinterpret_cast<Node*>(&m_header);

优化后的完整代码：

template <typename T>
class LinkList : public List<T>
{
protected:
    struct Node : public Object
    {
        T value;    // 数据域
        Node* next; // 指针域
    };
    // 重新构造头结点
    mutable struct : public Object
    {
        char reserved[sizeof(T)];   // 没实际作用，占空间
        Node* next;
    } m_header;

    int m_length;   // 记录链表长度
	
	// 位置定位函数，重复使用，进行抽象，方便使用
    Node* position(int i) const
    {
        Node* ret = reinterpret_cast<Node*>(&m_header);
        for(int p = 0; p < i; p++)
        {
            ret = ret->next;
        }
        return ret;
    }

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

    bool insert(const T& e)
    {
        return insert(m_length, e);
    }
    
    bool insert(int i, const T& e)
    {
        // 注意i的范围
        bool ret = ((i>=0) && (i<=m_length));
        cout << "ret  = " << ret <<  endl;
        if (ret)
        {
            Node* node = new Node();
            if (node != NULL)
            {
                Node* current = position(i);
                node->value = e;
                node->next = current->next;
                current->next = node;
                m_length++;
            }
            else
            {
            	THROW_EXCEPTION(NoEnoughMemoryException, "No memory to insert new element");
            }
        }
        return ret;
    }

    bool remove(int i)
    {
        // 注意i的范围
        bool ret = ((i>=0) && (i<m_length));
        if (ret)
        {
            Node* current = position(i);
            Node* toDel = current->next;
            current->next = toDel->next;
            delete toDel;
            m_length--;
        }
        return ret;
    }
    bool set(int i, const T& e)
    {
        bool ret = ((i>=0) && (i<m_length));
        if (ret)
        {
            position(i)->next->value = e;
        }
        return ret;
    }
    // get函数用起来不方便，重载一下
    T get(int i) const
    {
        T ret;
        if (get(i, ret))
        {
            return ret;
        }
        else
        {
            THROW_EXCEPTION(IndexOutOfBoundsException, "Invalid parameter i to get element...");
        }
    }

    bool get(int i, T& e) const
    {
        bool ret = ((i>=0) && (i<m_length));
        if (ret)
        {
            e = position(i)->next->value;
        }
        return ret;
    }
    
    int length() const
    {
        return m_length;
    }
    
    void clear()
    {
        // 释放每一个结点
        while(m_header.next)
        {
            Node* toDel = m_header.next;
            m_header.next = toDel->next;
            delete toDel;
        }
        m_length = 0;
    }
    
    ~LinkList()
    {
        clear();
    }
};

注意每次代码修改之后都要进行测试，有可能由于修改的代码引入了新的bug

3、小结

通过类模板实现链表，包含头结点和长度成员

定义结点类型，并通过堆中的结点对象构成链式存储

为了避免构造错误的隐患，头结点类型需要重定义

代码优化是编码完成后必不可少的环节