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

最新推荐文章于 2022-11-02 21:13:35 发布
置顶 最新推荐文章于 2022-11-02 21:13:35 发布
阅读量504 收藏
点赞数 1
分类专栏： c++ 文章标签： 深浅拷贝 顺序表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Pg_dog/article/details/69939190
版权

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

#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;
}
pg_dog
关注
专栏目录
顺序表、结构体、深拷贝、重载运算符，快速排序的综合运用
weixin_38512198的博客
06-12 325
/************************************************ *  快速排序的类模板 * ************************************************/ template void quickSort(T num[], int size) { quickSort(num, 0, size - 1); }
前端知识点——js篇
sunygoal的博客
10-25 256
==是严格意义上的相等，会比较两边的数据类型和值大小。==是非严格意义上的相等。值和引用地址都相等才相等。
关于顺序表交并集的一些思考——深浅拷贝问题
小哨的博客
04-04 950
关于链表交并集的一些思考——深浅拷贝问题 该题所用到的链表 下面展示 链表的底层实现。 #pragma once #include<iostream> using namespace std; //1、试用顺序表表示集合，并确定合适的约定，在此基础上编写算法以实现集合的交、并、差等运算，并分析各算法的时间性能。（3*） enum Error_code { Success, Range...
Java版顺序表的浅拷贝与深拷贝（一）
菜鸟闯天下的专栏
10-06 1663
Java版顺序表的浅拷贝与深拷贝（一） 　　Java的类采用拷贝构造方法实现复制对象功能，声明格式如下： 类（类  对象）{ 　　this.成员变量 = 参数对象.成员变量；//逐域赋值，以参数的实例值初始化当前实例 } 　　一个类的拷贝构造方法通常实现为成员变量逐域赋值，即将当前对象的各成员变量赋值为实例参数对应的各成员变量的值，称为浅拷贝。 　　在Java中的类采用引用模型，当一个
顺序表的模板实现
lzjsqn的专栏
11-10 445
头文件 #pragma oncetemplate <typename T>class SeqList { public: SeqList(int capcity); ~SeqList(); int getLength(); int getCapacity(); int insert(T &t, int pos); int get(int pos,T& t);
顺序表模板类
c_whatever的博客
04-28 320
#pragma once const int size = 50; template &lt;typename T&gt; class Nodelist { private: T * elem; int length; public: Nodelist();//构造空表 ~Nodelist() = default;//销毁空表 Nodelist(const Nodelist&amp;...
神秘的java
stay hungry,stay foolish!
11-02 1644
1.单元测试不再怕！一文学会SpringBoot单元测试2.一文搞懂🔥SpringBoot自动配置原理3.封装属于自己的Spring-Boot-Starter4.爽!🔥自定义SpringBoot的@EnableXXX注解1.灰度发布是什么？
前端面试问题（适用于面试回答思路）
yaminne的博客
03-28 5021
原型和原型链 原型：构造函数的 prototype 属性指向了一个对象，这个对象正是调用该构造函数而创建的实例的原型。也即，每个构造函数的实例都有一个原型，叫原型对象，由实例对象的内置属性_proto_指向。每个原型都有一个 constructor 属性指向关联的构造函数。 原型用法：构造函数创建的实例可以访问实例的属性和方法，也可以访问原型的属性和方法。对于原型只能访问自己的属性和方法。考虑这一特性，如果对象公有的属性和方法，我们可以添加到原型上面，对象需要的时候直接访问原型的属性和方法就可以。 当读取实
JavaScript知识点全面概括与总结(中)
BayMin0-0的博客
03-23 262
61.cookie的理解 cookie 是服务器提供的一种用于维护会话状态信息的数据，通过服务器发送到浏览器，浏览器保存在本地，当下一次有同源的请求时，将保存的 cookie 值添加到请求头部，发送给服务端。这可以用来实现记录用户登录状态等功能。cookie 一般可以存储 4k 大小的数据，并且只能够被同源的网页所共享访问。 服务器端可以使用 Set-Cookie 的响应头部来配置 cookie 信息。一条cookie 包括了5个属性值 expires、domain、path、secure、HttpOnl
python web面试题部分汇总
lyp_CSDN的博客
09-14 4194
** 0.深拷贝和浅拷贝的区别?** 1. copy.copy 浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象。好处:只拷贝引用,不增加内存 2. copy.deepcopy 深拷贝 拷贝对象及其子对象 好处:可用于备份,源数据被修改它不会被影响 可变类型(list,dict):浅拷贝只拷贝第一层,深拷贝会拷贝所有层 不可变类型(int,string,float,tuple):深浅拷贝都一................................................
用深拷贝的方法封装动态顺序表（构造、拷贝构造、赋值、析构、尾插/删、任意位置插入/删除、扩容等）
汐梦的博客
04-26 228
#include&lt;iostream&gt;using namespace std;#include&lt;assert.h&gt;typedef int DataType;class SeqList{public: SeqList(size_t capacity = 10)     //给容量一个缺省值10      构造函数   :_array(new DataType[sizeof(D...
数据结构线性结构-顺序表基本操作-标准写法
AC是绝对不可能的
07-02 289
欢迎来我的新博客哦~戳我~ （如果有错误欢迎指出哦~） /* * 内 容：静态顺序表 动态线性表 * 最后修改日期：2020.7.02 */ #include <iostream> using namespace std; /* // 静态顺序表 #define MaxSize 50 //顺序表最大长度 struct SqList { int data[MaxSize];//顺序表元素 int length; //顺序表现在的长度 }; // 静态顺...
大道至简-数据结构：实现一个顺序表（可当成模板使用）
Code杂货店
04-29 2037
概述 一共三个文件，分别是SeqList.h,SeqList.cpp,main.cpp，分别为声明头文件，实现源文件，和测试源文件。 该顺序表采用的是动态分配内存的设计，容量不足时会自动扩容为原来的2倍，但没有进行缩容操作的设计。 // SeqList.h #ifndef SEQLIST_SEQLIST_H #define SEQLIST_SEQLIST_H typedef int ElemTy...
顺序表的浅拷贝和深拷贝
weixin_45821324的博客
09-14 568
顺序表的浅拷贝和深拷贝 在学习数据结构过程中，我们会经常涉及到对表，树或是图的增添，删除等操作，不可避免的，我们会涉及到Java中引用变量的赋值问题，由此引出了Java中关于浅拷贝和深拷贝的问题 浅拷贝：当成员变量的数据类型是基本数据类型时，浅拷贝能够实现对对象的复制功能；当成员变量的数据类型是引用数据类型时，浅拷贝只复制了数组引用或对象引用，没有实现对象复制功能 深拷贝：当一个类包含数组或对象等引用类型的成员变量时，该类声明的拷贝构造方法不仅要负责对象的所有基本类型成员变量值，还要为引用类型变量申请存储空
Java版顺序表的浅拷贝与深拷贝（二）
菜鸟闯天下的专栏
10-07 1323
Java版顺序表的浅拷贝与深拷贝（二） Java版顺序表的浅拷贝与深拷贝（一）
顺序表
YimiH2的博客
09-26 411
线性表和链表是数据结构中很重要的存储数据的结构，也是数据结构最基础的内容 一.顺序表（静态） 顺序表是用一段地址连续的存储单元依次存放数据元素的线性结构。地址连续的空间我们一般采用数组来表示，顺序表又分为静态顺序表和动态顺序表，静态顺序表只可存储固定数量的数据，而动态顺序表则可以通过在使用过程中的不断扩容来改变其容量的大小。 1.创建顺序表 创建一个顺序表需要一个存放数据的数组和一个标志其容量的...
C++数据结构 1.Swap函数
Birate的博客
09-27 891
在C语言中我们使用两种交换函数: 摒弃这种： void swap(int x,int y)  值传递方式，拷贝值，导致原值不会改变 使用：void swap(int *x,int*y);  指针（地址）方式传递           #define swap(x,y,t) ((t)=(x),(x)=(y),(y)=(t))  宏定义方式 在C++中我们除了可以使用以上两种还有: void ...
C++之模版应用（顺序表）
Dandelion_gong的博客
04-06 645
C语言中Swap()函数大家都很熟悉：void Swap(int &a, int &b) { int temp = 0; temp = a; a = b; b = temp; } void Swap(double &a, double &b) { int temp = 0; temp = a; a = b; b = temp; }不难看
C++之String类的实现
weixin_45975835的博客
11-14 201
String类的具体实现源码 #include<iostream> #include<string> #include<assert.h> using namespace std; class String { friend ostream& operator<<(ostream& _cout, const String& s) { for (int i = 0; i < s.size();
C语言动态顺序表实现详解及代码
"C语言实现动态顺序表的代码示例，包括初始化、插入、删除、查找等操作。" 在编程领域，动态顺序表是一种常见的数据结构，它在内存中分配一块可变大小的空间来存储数据，能够随着数据量的增长自动进行扩容。与静态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值