模板2——顺序表的实现(现代写法的进一步解析,更深层次的深浅拷贝)

之前我们讲解了关于模板方面的知识,今天我们用模板来实现顺序表。
这次顺序表的实现和之前没有太大区别,但还是有几点需要我们来重点进行详解。
我们先来看下面这段代码

#include<iostream>
#include<string>
#include<assert.h>

using namespace std;
template<typename T>

class SeqList     
{
public:
    SeqList()
        :_a(NULL), _size(0), _capacity(0)
    {}

    SeqList(const SeqList<T>& d)
    {
        _a = (T*)malloc(d._a, sizeof(T)*_size); //注:问题一  
        memcpy(d._a, _a, sizeof(T)*_size);
        _size = d._size;
        _capacity = d._size;
    }

    //l1  = l2;
    SeqList<T>& operator=(SeqList<T> d) 
    {                                 
        swap(_size, d._size);         
        swap(_capacity, d._capacity);
        swap(_a, d._a);

        return *this;
    }

    ~SeqList()      //注:问题二
    {
        if (_a)
        {
            free(_a);  
            _size = _capacity = 0;
        }
    }

    void PushBack(const T& x)  
    {
        CheckCapacity();
        _a[_size] = x;
        _size++;
    }

    void PopBack()
    {
        if (_size > 0)
        _size--;
    }

    void PushFront(const T& x)   
    {
        CheckCapacity();
        for (int i = _size; i>0; i--)
        {
            _a[i] = _a[i - 1];
        }
        _a[0] = x;
        _size++;
    }

    void PopFront()
    {
        if (_size == 0)
        {
            return;
        }
        else
        {
            for (int i = 1; i < _size; i++)
            {
                _a[i - 1] = _a[i];
            }
            _size--;
        }
    }

    T& Back()
    {
        assert(_size>0);
        return _a[_size-1];
    }

    bool Empty()
    { 
        return _size == 0;
    }

    void Insert(size_t pos, const T& x) 
    {
        if (pos > _size)
        {
            cout << "pos错误" << endl;
            return;
        }
        else
        {
            CheckCapacity();
            for (int i = _size; i > pos; i--)
            {
                _a[i] = _a[i - 1];
            }
            _a[pos] = x;
            _size++;
        }
    }

    void Erase(size_t pos)  
    {
        if (_size == 0)
        {
            return;
        }
        else
        {
            if (pos >= _size)
            {
                cout << "pos 错误" << endl;
                return;
            }
            for (int i = pos; i < _size; i++)
            {
                _a[i] = _a[i + 1];
            }
            _size--;
        }
    }

    int Find(const T& x)
    {
        for (int i = 0; i < _size; i++)
        {
            if (x == _a[i])
            {
                return i;
            }
        }
        return -1;
    }

    void CheckCapacity()   //注:问题三
    {
        if (_size > _capacity)
        {
            _capacity = _capacity * 2 + 3;
            _a = (T*)realloc(_a, (_capacity) * sizeof(T));
        }
    }

    void print()
    {
        for (size_t i = 0; i < _size; i++)
        {
            cout << _a[i] << " ";
        }
        cout << endl;
    }

protected:
    T* _a;
    size_t _size;
    size_t _capacity;
};

这里有必要再讲讲实现下面赋值运算符重载的现代写法的实现原理
首先看上面代码(l1 = l2),赋值运算符重载中的局部变量d是由l2拷贝构造而来,函数体内通过swap函数将this指针指向的l1与d发生了交换,即l1与l2发生了交换,局部变量d现在指向之前l1指向的地址,而l1指向d原先指向的地址,也就是l1被赋值成了l2,而局部变量d一出函数就会自动销毁,就会调用它的析构函数,会使得它指向的内存释放,从而实现l1与l2的交换。看下图

这里写图片描述
注:swap函数也不能乱用,一般来说,swap函数适用于内置类型,下面看这句代码

swap(*this,l);   //直接交换两个对象岂不更好?

这段代码会出现什么情况呢?我们先看看swap函数是如何实现的。
这里写图片描述
我们用的swap函数是这个模板实例化来的,它的倒数第二行,和倒数第三行都调用了赋值运算符重载,这样就造成递归调用,一直生成栈帧,直至出现栈溢出问题。
那我们一般如何实现这种问题呢?一般我们写自己的Swap函数实现这一问题

void Swap(SeqList<T>&  d)
    {
        swap(_size, d._size);        
        swap(_capacity, d._capacity);      
        swap(_a, d._a);
    }

下面呢才是今天的重点,我们来看上面代码,这些代码在int, char等这种类型下是可以被顺利执行的,但是一旦换成string类型就会出现问题,在执行插入操作时,代码就会崩掉,这是什么问题呢?这就看问题三(看代码标识),在CheckCapacity()函数中,我们开空间用的是realloc函数,这就有个问题,realloc函a数只负责开空间,但不初始化,所以在插入操作的赋值语句时挂了,调试你会发现它的_a就是NULL,所以就会出现问题。所以我们用new[]来开空间,这时你前面析构函数中用free就会出现问题,所以连同拷贝构造函数中的malloc一起一改。这就完成了?哈哈,你太天真了。看下面这段验证代码:

void Test5()
{
    SeqList<string> s1;
    s1.PushBack("111");
    s1.PushBack("222222222222222222222222222222222222222");
    s1.PushBack("333");
    s1.PushBack("444");
    s1.print();
}

这里写图片描述
但是改为s1.PushBack(“22222222222”);又是正常输出,或者你将s1.PushBaack(“444”)这句给屏蔽了,同样会正常输出。所以有理由相信在一个范围内就正常,超过就会出现异常。这里涉及到更深层次的深浅拷贝。

我们先来了解一下string是如何实现的。string里面由下面四部分组成,这是一种空间换时间的优化,如果存的字符串小于16,他就会将字符串存于它自带的空间_Buf,而大于等于16时,他就会重开一份空间存放这个字符串,用_Ptr指向这块内存。你可以在vs08上面验证一下(调试窗口就可以看),我用的vs15不能展示出来。

struct string
{
  string* _Buf;  
  string* _Ptr;
    size_t _Mysize;
    size_t _Myres;
};

看懂了上面string的具体实现后,上面所提问题就简单了,我用一幅图来说明问题
这里写图片描述

所以这里就不能使用memcpy()函数,它的本质就是值拷贝,所以我们用下面代码解决这个问题。里面调用了赋值运算符的重载,即就是实现深拷贝。

for (int i = 0; i < _size; i++)
    {
        tmp[i] = _a[i]; 
    }

下面是改善之后的代码:

#include<iostream>
#include<string>
#include<assert.h>

using namespace std;
template<typename T>   

class SeqList
{
public:
    SeqList()
        :_a(NULL), _size(0), _capacity(0)
    {}

    SeqList(const SeqList<T>& d)
    {
        if (_a)
        {
            _a = new T[d._size];
            for (int i = 0; i < d._size; i++)
            {
                _a[i] = d._a[i];
            }
        }
        else
        {
            _a = NULL;
        }
        _size = d._size;
        _capacity = d._size;
    }

    SeqList<T>& operator=(SeqList<T> d)
    {
        swap(_size, d._size);
        swap(_capacity, d._capacity);
        swap(_a, d._a);

        return *this;
    }


    ~SeqList()
    {
        if (_a)
        {
            delete[] _a;
            _size = _capacity = 0;
        }

    }

    void PushBack(const T& x)  //尾插
    {
        CheckCapacity();
        _a[_size] = x;
        _size++;
    }

    void PopBack()
    {
        if (_size > 0)
        _size--;
    }

    void PushFront(const T& x)    //头插
    {
        CheckCapacity();
        for (int i = _size; i>0; i--)
        {
            _a[i] = _a[i - 1];
        }
        _a[0] = x;
        _size++;
    }

    void PopFront()
    {
        if (_size == 0)
        {
            return;
        }
        else
        {
            for (int i = 1; i < _size; i++)
            {
                _a[i - 1] = _a[i];
            }
            _size--;

        }
    }

    T& Back()
    {
        assert(_size>0);
        return _a[_size-1];
    }

    bool Empty()
    {
        return _size == 0;
    }

    void Insert(size_t pos, const T& x)  //指定位置处插入指定值
    {
        if (pos > _size)
        {
            cout << "pos错误" << endl;
            return;
        }
        else
        {
            CheckCapacity();
            for (int i = _size; i > pos; i--)
            {
                _a[i] = _a[i - 1];
            }
            _a[pos] = x;
            _size++;
        }
    }

    void Erase(size_t pos)   //删除指定位置的数值
    {
        if (_size == 0)
        {
            return;
        }
        else
        {
            if (pos >= _size)
            {
                cout << "pos 错误" << endl;
                return;
            }
            for (int i = pos; i < _size; i++)
            {
                _a[i] = _a[i + 1];
            }
            _size--;
        }
    }

    int Find(const T& x)
    {
        for (int i = 0; i < _size; i++)
        {
            if (x == _a[i])
            {
                return i;
            }
        }
        return -1;
    }

    void CheckCapacity()
    {
        if (_size >= _capacity)
        {
            _capacity = _capacity * 2 + 3;
            T* tmp = new T[_capacity];
            if (_a)
            {
                //memcpy(tmp, _a, sizeof(T)*_size);//会使得指向同一块内存,下面delete[]之后,会调用析构函数,释放这块内存,造成另一指针野指针
                for (int i = 0; i < _size; i++)
                {
                    tmp[i] = _a[i];
                }
                delete[] _a;
            }
            _a = tmp;
        }
    }

    void print()
    {
        for (size_t i = 0; i < _size; i++)
        {
            cout << _a[i] << " ";
        }
        cout << endl;
    }


private:
    T* _a;
    size_t _size;
    size_t _capacity;
};

//头插,头删
void Test1()
{
    SeqList<int> s1;
    s1.PushFront(1);
    s1.PushFront(2);
    s1.PushFront(3);
    s1.PushFront(4);
    s1.print();
    s1.PopFront();
    s1.PopFront();
    s1.PopFront();
    s1.PopFront();
    s1.PopFront();
    s1.print();
}

//尾插,尾删
void Test2()
{
    SeqList<int> s1;
    s1.PushBack(1);
    s1.PushBack(2);
    s1.PushBack(3);
    s1.PushBack(4);
    s1.print();
    s1.PopBack();
    s1.PopBack();
    s1.PopBack();
    s1.PopBack();
    s1.PopBack();
    s1.print();
}

//Insert/Erase/Find
void Test3()
{
    SeqList<int> s1;
    s1.PushBack(1);
    s1.PushBack(2);
    s1.PushBack(3);
    s1.PushBack(4);
    s1.print();
    //int ret = s1.Find(1);
    //s1.Insert(ret, 99);
    //ret = s1.Find(2);
    //s1.Insert(ret, 88);
    //ret = s1.Find(3);
    //s1.Insert(ret, 77);
    //ret = s1.Find(4);
    //s1.Insert(ret, 66);
    //s1.print();
    //int ret = s1.Find(1);
    //s1.Erase(ret);
    //s1.print();

    //ret = s1.Find(3);
    //s1.Erase(ret);
    //s1.print();

    //ret = s1.Find(4);
    //s1.Erase(ret);
    //s1.print();
    //
    //ret = s1.Find(2);
    //s1.Erase(ret);
    //s1.print();
    s1.Erase(0);
    s1.print();
}
//构造函数,赋值运算符重载
void Test4()
{
    SeqList<int> s1;
    SeqList<int> s2(s1);
    SeqList<int> s3;
    s3 = s1;
    s3.PushBack(1);
    s3.PushBack(2);
    s3.PushBack(3);
    s3.PushBack(4);
    s3.print();
    s3.PopBack();
    s3.PopBack();
    s3.PopBack();
    s3.PopBack();
    s3.PopBack();
    s3.print();
}

//深层次的深浅拷贝
void Test5()
{
    SeqList<string> s1;
    s1.PushBack("111");
    s1.PushBack("2222222222222222222222222222222222222222222222");
    s1.PushBack("333");
    s1.PushBack("444");
    s1.print();
}

int main()
{
    Test5();
    system("pause");
    return 0;
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值