第二十六课 典型问题分析（Bugfix）

问题1：

glibc中的strdup实现如下：

没有对参数s进行空指针判断。

我们的Exception.cpp中应做改进：

在第12行进行判断空指针操作。

 问题2：

t1在析构时会抛出异常，我们在remove一个对象时，要保证链表还是合法的，也就是保证异常安全性。

如上图，我们期望打印的链表长度为2。

示例程序：

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

using namespace std;
using namespace DTLib;

class Test : public Object
{
    int m_id;
public:
    Test(int id = 0)
    {
        m_id = id;
    }

    ~Test()
    {
        if( m_id == 1 )
        {
            throw m_id;
        }
    }
};

int main()
{
    LinkList<Test> list;
    Test t0(0), t1(1), t2(2);

    try
    {
        list.insert(t0);
        list.insert(t1);
        list.insert(t2);

        list.remove(1);
    }
    catch(int e)
    {
        cout << e << endl;
        cout << list.length() << endl;
    }

    return 0;
}

结果如下：

程序直接崩溃了。

vc下的运行结果如下：

打印e的值为1，链表长度为3，意味着单链表的状态出问题了。

我们的remove函数没有考虑异常安全性。

修改LinkList.h：

#ifndef LINKLIST_H
#define LINKLIST_H

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

namespace DTLib
{

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;
    int m_step;
    Node* m_current;

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

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

        return ret;
    }

    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 )
        {
            Node* current = position(i);

            Node* toDel = current->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;

        Node* node = m_header.next;

        while( node )
        {
            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 )
        {
            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);
    }

    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

在remove函数中，先让m_length--，再做摧毁节点的操作。

在clear函数中，注释掉原来的196行，添加第191行，每次摧毁前让m_length--。

问题3：

测试程序如下：

结果如下：

删除之后，游标m_current指向这个释放之后的内存，current函数返回的是这个释放了的内存中保存的value。

 图解：

删除之后current函数返回的这块被释放了的堆内存中的value的值，所以会打印出随机值。

修改LinkList.h中的remove函数：

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

        if( ret )
        {
            Node* current = position(i);

            Node* toDel = current->next;

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

            current->next = toDel->next;

            m_length--;

            destroy(toDel);

        }

        return ret;
    }

我们添加了第11-14行，在删除时，先进行判断，如果m_current和toDel指向的是同一个节点，那么先将m_current指向toDel的下一个节点，然后再删除。

运行结果如下：

 问题4：

 程序改进：

void destroy(Node* pn)
    {
        SNode* space = reinterpret_cast<SNode*>(m_space);
        SNode* psn = dynamic_cast<SNode*>(pn);

        for(int i = 0; i<N; i++)
        {
            if( psn == (space + i))
            {
                m_used[i] = 0;
                psn->~SNode();
                break;
            }
        }
    }

添加了第12行的break。

问题5：

StaticLinkList的构造函数中没有申请系统资源，从资源方面来看不用提供析构函数。

不提供析构函数的第二个条件是，该类为一个独立的类，没有任何继承关系，但是我们StaticLinkList不满足。

StaticLinkList继承自LinkList，LinkList中有析构函数，且这个析构函数调用了一个虚函数，但是多态是不会发生的。

构造函数和析构函数中不会发生多态。

StaticLinkList类中没有clear函数，因此，默认的析构函数会调用到LinkList的析构函数，进一步调用到clear函数，这个clear函数在子类和在父类中调用是一样的。

如果子类StaticLinkList中也有一个clear函数版本，那就要提供析构函数了。因为这两个含本的析构函数都要调用到。

但是我们再仔细观察可以发现，在clear函数中还调用了destroy函数，而这个函数在子类和父类中各有一个版本。

子类中的版本是：

父类中提供的版本是：

 这意味着父类中的析构函数被调用的时候，调用到的destroy一直是父类中的destroy。子类中的destroy无法被调用到，因为析构函数中不能发生多态。

析构时父类中的destroy直接delete掉申请的空间，而这个空间是在我们的预留区域中申请的，不是堆空间，因此，可能会出现bug，造成程序的不稳定，因为delete关键字只能释放堆空间。

改进程序，添加子类的析构函数：

#ifndef STATICLINKLIST_H
#define STATICLINKLIST_H

#include "LinkList.h"

namespace DTLib
{

template< typename T, int N >
class StaticLinkList : public LinkList<T>
{
protected:
    // Node和泛指类型T有关系，因此，不能直接在子类中使用sizeof(Node),而应该
    // sizeof(LinkList<T>::Node)
    // unsigned char m_space[sizeof(typename LinkList<T>::Node) * N];  // 预留空间
    typedef typename LinkList<T>::Node Node;

    struct SNode : public Node
    {
        void* operator new(unsigned int size, void* loc)
        {
            (void)size; // 消除 size没有使用的警告
            return loc;
        }
    };

    unsigned char m_space[sizeof(SNode) * N];  // 预留空间
    int m_used[N];   //预留空间的标记数组

    Node* create()
    {
        SNode* ret = NULL;

        for(int i = 0; i < N; i++)
        {
            if( !m_used[i] )
            {
                ret = reinterpret_cast<SNode*>(m_space) + i;
                ret = new(ret)SNode(); //在指定空间ret上调用SNode类的构造函数。
                m_used[i] = 1;
                break;
            }
        }

        return ret;
    }

    void destroy(Node* pn)
    {
        SNode* space = reinterpret_cast<SNode*>(m_space);
        SNode* psn = dynamic_cast<SNode*>(pn);

        for(int i = 0; i<N; i++)
        {
            if( psn == (space + i))
            {
                m_used[i] = 0;
                psn->~SNode();
                break;
            }
        }
    }

public:
    StaticLinkList()
    {
        for(int i = 0; i < N; i++)
        {
            m_used[i] = 0;
        }
    }

    int capacity()
    {
        return N;
    }

    ~StaticLinkList()
    {
        this->clear();
    }
};

}

#endif // STATICLINKLIST_H

添加了第78-81行的析构函数，这时的clear是从父类继承来的，但是clear中的destroy函数就是子类自己实现的了。

这样的话析构时，先调用子类的析构函数，然后是子类继承过来的clear函数，然后子类的destroy函数。子类的析构函数执行完时，再调用父类的析构函数，然后父类的clear函数，最后调用父类的destroy函数。但是单步执行时，我们发现并没有调用到父类的destroy函数，这里可能令人迷惑，其实是因为调用父类的析构函数时，clear函数中的while循环已经不成立的，也就不会再调用父类的destroy函数了。单步执行时要注意这一点，调用不到父类的destroy是因为条件不成立，而不是其他的机制导致的。如下：

从子类的析构函数执行完，到调用到父类的析构函数时，clear函数中的190行的条件已经不成立了。

我们在子类的析构函数和destroy函数，父类的析构函数和destroy函数加上打印，测试程序如下：

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

using namespace std;
using namespace DTLib;


int main()
{
    StaticLinkList<int, 10> list;

    list.insert(0);

    cout << list.get(0) << endl;

    return 0;
}

结果如下：

问题6：

没有必要定义多维数组的类，由一位数组就可以构成。

示例程序：

#include <iostream>
#include "StaticLinkList.h"
#include "DynamicArray.h"

using namespace std;
using namespace DTLib;


int main()
{
    StaticLinkList<int, 10> list;

    DynamicArray< DynamicArray<int> > d;

    d.resize(3);

    for(int i=0; i < d.length(); i++)
    {
        d[i].resize(3);
    }

    for(int i=0; i<d.length(); i++)
    {
        for(int j=0; j<d[i].length(); j++)
        {
            d[i][j] = i * j;
        }
    }

    for(int i=0; i<d.length(); i++)
    {
        for(int j=0; j<d[i].length(); j++)
        {
            cout << d[i][j] << " ";
        }

        cout << endl;
    }

    return 0;
}

结果如下：

还可以构造不规则的数组：

#include <iostream>
#include "StaticLinkList.h"
#include "DynamicArray.h"

using namespace std;
using namespace DTLib;


int main()
{
    StaticLinkList<int, 10> list;

    DynamicArray< DynamicArray<int> > d;

    d.resize(3);

    for(int i=0; i < d.length(); i++)
    {
        d[i].resize(i + 1);
    }

    for(int i=0; i<d.length(); i++)
    {
        for(int j=0; j<d[i].length(); j++)
        {
            d[i][j] = i + j;
        }
    }

    for(int i=0; i<d.length(); i++)
    {
        for(int j=0; j<d[i].length(); j++)
        {
            cout << d[i][j] << " ";
        }

        cout << endl;
    }

    return 0;
}

第19行使得每个数组元素大小不一样，运行结果如下：

实践经验：