C++数据结构第26课、典型问题分析（Bugfix）

1、问题1

— 创建异常对象时的空指针问题

分析：glibc 中的 strdup 函数的函数参数是 默认认为字符串不为空的，但是我们如果如上图那样定义异常对象，相当于调用strdup(0)。所以，修改方法为：

Exception.cpp

void Exception::init(const char* message, const char* file, int line)
{
	m_message = strdup(message);
}

m_message = (message ? strdup(message) : nullptr);

2、问题2

— LinkList 中的数据元素删除

#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;
}

Qt 编译器直接崩溃，VS 编译器也直接崩溃，因为析构函数中不能抛出异常。但是VS 编译器输出了 1 和 3。按理说我们移除了一个元素，为什么编译器长输出的长度还是3而不是2呢？

原因在于我们的 remove() 函数写的有问题，我们应该先 m_length--，再去销毁对象，这样的话就算析构函数抛出异常，我们的长度也是没问题的。

bool remove(int i)
{
    bool ret = (0 <= i && i < m_length);
    if(ret)
    {
        Node* current = position(i);

        Node* toDel = current->next;
        current->next = toDel->next;
        destroy(toDel);
        m_length--;
    }
    return ret;
}

改成：

bool remove(int i)
{
    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;
}

如果 remove 函数写的有问题，那么 clear() 函数也有问题：

void clear()
{
	while(m_header.next != nullptr)
	{
	    Node* toDel = m_header.next;
	    m_header.next = toDel->next;
	    destroy(toDel);
	}
	m_length = 0;
}

改成：

void clear()
{
	while(m_header.next != nullptr)
	{
	    Node* toDel = m_header.next;
	    m_header.next = toDel->next;
	    m_length--;
	    destroy(toDel);
	}
}

3、问题3

— LinkList 中遍历操作与删除操作的混合使用

#include <iostream>
#include "LinkList.h"
using namespace std;
using namespace XiebsLib;

int main()
{
    LinkList<int> list;

    for(int i = 0; i < 5; i++)
    {
        list.insert(i);
    }
    
    for(list.move(0); !list.end(); list.next())
    {
        if(list.current() == 3)
        {
            list.remove(list.current());
            cout << list.current() << endl;
        }
    }
    
    for(list.move(0); !list.end(); list.next())
    {
        cout << list.current() << endl;
    }
    
    return 0;

为什么 我们遍历操作与删除操作的混合使用是输出 list.current()会显示随机值？原因就在于 remove() 函数中有点问题：

3 这个地方被 remove 了，但是 m_current 依旧指向了原来的内存，我们可以把m_current 指向下一个内存。

bool remove(int i)
{
    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 remove(int i)
{
    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;
}

修改后输出结果：

4、问题4

— StaticLinkList 中数据元素删除时的效率问题

解决办法：if 函数里面 加上 break 即可。

void destroy(Node* pn)
{
    SNode* space = reinterpret_cast<SNode*>(m_space);
    SNode* pst = dynamic_cast<SNode*>(pn);
    for(int i = 0; i < N; i++)
    {
        if(pst == (space + i))
        {
            m_used[i] = 0;
            pst->~SNode();
            break;
        }
    }
}

5、问题5

StaticLinkList 是否需要提供析构函数

#include <iostream>
#include "LinkList.h"
#include "StaticLinkList.h"
using namespace std;
using namespace XiebsLib;

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

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

    for(int i = 0; i < 5; i++)
    {
        cout << list.get(i) << endl;
    }
}

当程序结束时，肯定会调用父类的析构函数，父类的析构函数长这样：

~LinkList()
{
    clear();
}
void clear()
{
    while(m_header.next != nullptr)
    {
        Node* toDel = m_header.next;
        m_header.next = toDel->next;
        m_length--;
        destroy(toDel);
    }
}

destroy() 函数被我们重写了，但是 clear() 函数在析构函数中，析构函数中是不会发生多态的，所以上面那个程序调用的永远都是父类的 destroy()函数。父类的 destroy()函数为：

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

我们都知道 StaticLinkList 里面 new 出来的空间不一定是在堆里面的，如果不在堆空间，你去 delete pn 显然会出现错误。

解决方法：在子类中的析构函数中调用 clear() 函数。

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

6、问题6

— DTLib 是否有必要增加多维数组类？
答：没必要，因为多维数组的本质：数组的数组

main.cpp

#include <iostream>

#include "StaticLinkList.h"
#include "DynamicArray.h"
using namespace std;
using namespace DTLib;

int main()
{
    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;
}