C++ 拷贝构造和拷贝赋值、简单String 类的实现

最新推荐文章于 2022-09-19 13:49:48 发布
最新推荐文章于 2022-09-19 13:49:48 发布
阅读量266 收藏 1
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guaiderzhu1314/article/details/113348695
版权

用编译器自动分配的缺省拷贝构造函数已经可以满足绝大部分的场景。但如果类当中封装了，指针形式的成员变量，那么就要注意避免浅拷贝问题。

1. 深拷贝和浅拷贝

1. 浅拷贝

在这里插入图片描述

  • 浅拷贝的可能出现的两个错误：
    • 1. 逻辑错误： 导致不同对象之间的数据共享
    • 2. 语法错误： 对象销毁时出现 “double free” 的异常
#include <iostream>
#include <unistd.h>
using namespace std;

class Integer{
public:
    Integer(int pi=0){
        // 这下就有了对象维护的动态资源
        m_pi = new int(pi);
    }
    // 对象被销毁时，析构函数自动执行
    ~Integer(void){
        cout << "析构函数" << endl;
        delete(m_pi);
    }

    // // 这个自定义的浅拷贝构造 和 系统自动分配的效果是一样的
    // // 这里显示的把它写出来，便于理解
    // Integer(const Integer& that){
    //     cout << "浅拷贝构造函数" << endl;
    //     m_pi = that.m_pi;
    // }

    void print(void){
        cout << *m_pi << endl;
    }
private:
    int* m_pi;
};

int main(void){
    // 栈区对象
    Integer i1(100);
    i1.print();
    // 拷贝构造
    // 缺省拷贝构造函数，对指针形式的成员变量m_pi是按字节复制的，相当于只是拷贝了地址
    // i1 和 i2 的 m_pi 是相同的，指向同一块内存
    // 那么i1 和 i2两个独立的对象共享数据m_pi， 产生逻辑错误，这样不好
    Integer i2(i1);
    i2.print();

    return 0;
} // i1 和 i2离开主函数的时候都将调用析构函数，~Integer ，将同一块内存释放了两次
  // 会产生double free的错误，语法错误


$ ./a.out 
100
100
析构函数
析构函数
*** Error in `./a.out': double free or corruption (fasttop): 0x0000000000db7c20 ***
======= Backtrace: =========
....
Aborted

2. 深拷贝

在这里插入图片描述

#include <iostream>
#include <unistd.h>
using namespace std;

class Integer{
public:
    Integer(int pi=0){
        // 这下就有了对象维护的动态资源
        m_pi = new int(pi);
    }
    // 对象被销毁时，析构函数自动执行
    ~Integer(void){
        cout << "析构函数" << endl;
        delete(m_pi);
    }

    // 自定义的深拷贝构造
    Integer(const Integer& that){
        cout << "深拷贝构造函数" << endl;
        // 在拷贝数据之前，需要给新对象 i2 的 m_pi 指向一块新的内存去接收这个数据
        // 不然新的对象 i2 的 m_pi, 没法接收这个数据, 强行拷贝过去会造成非法内存访问
        m_pi = new int;
        *m_pi = *that.m_pi;
    }

    void print(void){
        cout << *m_pi << endl;
    }

private:
    int* m_pi;
};

int main(void){
    // 栈区对象
    Integer i1(100);
    i1.print();
    Integer i2(i1);
    i2.print();
    return 0;
}


$ ./a.out 
100
深拷贝构造函数
100
析构函数
析构函数
moonx@moonx
  • 解释下上面代码中说的 非法内存访问
#include <iostream>
using namespace std;

int main(void) {
    int *a;
    // 上面只是定义了整数类型指针变量a
    // 但a 中的地址还没有指向任何存储区
    // 下面直接用 10 初始化 a所指向的存储区是不对的
    *a = 10;
    return 0;
}

$ ./a.out 
Segmentation fault

2. 拷贝赋值

在这里插入图片描述

2.1 浅拷贝赋值函数

  • 比浅拷贝还多了一个内存泄露的问题
#include <iostream>
#include <unistd.h>
using namespace std;

class Integer{
public:
    Integer(int pi=0){
        // 这下就有了对象维护的动态资源
        m_pi = new int(pi);
    }
    // 对象被销毁时，析构函数自动执行
    ~Integer(void){
        cout << "析构函数" << endl;
        delete(m_pi);
    }

    // 自定义的深拷贝构造
    Integer(const Integer& that){
        cout << "深拷贝构造函数" << endl;
        m_pi = new int;
        *m_pi = *that.m_pi;
    }

    /*// 这个自定义的缺省拷贝赋值函数 和 系统自动分配的缺省拷贝赋值函数 效果是一样的
    // 这里显示的写出来是为了便于理解系统自动分配的 缺省拷贝赋值函数
    // i3 = i2 ==> i3.operator=(i3)
    // (i3 = i2) 返回值是 i3， 所以 operator= 的返回值类型是Integer&
    // 所以return *this, 目的是和内置基本类型保持语义的一致性
    // 参数中 const是为了接收常量型实参，&为了提高传参效率
    Integer& operator=(const Integer& that){
        // 按字节复制，浅拷贝
        m_pi = that.m_pi;
        cout << "自定义缺省拷贝赋值函数" << endl;
        return *this;
    }
    */

    void print(void){
        cout << *m_pi << endl;
    }

private:
    int* m_pi;
};

int main(void){
    // 栈区对象
    Integer i1(100);
    i1.print();
    //拷贝构造，效果等同于 Interger i2 = i1; 这个=不是赋值，是初始化
    Integer i2(i1); 
    i2.print();

    Integer i3;
    // 拷贝赋值函数（左调右参）
    // i3, i2 都是已经存在的对象,但不是基本类型，编译器不知道如何完成赋值操作
    // 编译器会将i3 = i2转为，i3.operator=(i2); i3当做函数的调用对象, 右边的对象当做参数。
    // 如果没有定义自己的拷贝赋值操作符函数，编译器会为该类提供缺省的拷贝赋值操作符函数 operator=
    // 但这个缺省拷贝赋值函数也是浅拷贝，需要自己定义深拷贝赋值函数
    i3 = i2;
    return 0;
}

$ ./a.out 
100
深拷贝构造函数
100
析构函数
析构函数
*** Error in `./a.out': double free or corruption (fasttop): 0x000000000075a050 ***
  • 上面的代码只演示了浅拷贝赋值函数的一个问题： 产生过数据共享， double free 的异常
  • 除了这个double free 的异常， 还可能产生内存泄露
    在这里插入图片描述
  • 上图中 如果 Integer i2(200), 那么i2对象的 m_pi 指向放着数字200的存储区，经过浅拷贝赋值 i2 = i1, i2对象的m_pi指向放着数字100的存储区。那么就会造成内存泄露。
  • 而深拷贝是把i2原本指向的存储区的内容，从200 改成了100。

2.2 深拷贝赋值函数

在这里插入图片描述

  • 对比两个对象地址，防止自赋值
  • 释放旧内存的目的是，可能要拷贝到旧内存中的数据, 和旧内存中原本数据的类型、大小都不一致
  • 本例子中写 释放旧内存 和 分配新内存显得有些多余，但如果 this 和 that中 m_pi 执行的内存中数据类型和大小都不一样，就不多余了。
#include <iostream>
#include <unistd.h>
using namespace std;

class Integer{
public:
    Integer(int pi=0){
        // 这下就有了对象维护的动态资源
        m_pi = new int(pi);
    }
    // 对象被销毁时，析构函数自动执行
    ~Integer(void){
        cout << "析构函数" << endl;
        delete(m_pi);
    }

    // 自定义的深拷贝构造
    Integer(const Integer& that){
        cout << "深拷贝构造函数" << endl;
        m_pi = new int;
        *m_pi = *that.m_pi;
    }

    // 自定义深拷贝赋值函数
    // i3 = i2 ==> i3.operator=(i3)
    // (i3 = i2) 返回值是 i3， 所以 operator= 的返回值类型是Integer&，return *this, 目的是和内置基本类型保持语义的一致性
    // 参数中 const是为了接收常量型实参，&为了提高传参效率
    Integer& operator=(const Integer& that){
        if(this != &that){ //防止自赋值
            delete m_pi;    // 释放旧内存 
            m_pi = new int; // 分配新内存
            *m_pi = *that.m_pi; // 拷贝新数据
            cout << "自定义深拷贝赋值函数" << endl;
        }
        return *this;   // 返回自引用
    }

    void print(void){
        cout << *m_pi << endl;
    }

private:
    int* m_pi;
};

int main(void){
    // 栈区对象
    Integer i1(100);
    i1.print();
    //拷贝构造，效果等同于 Interger i2 = i1; 这个=不是赋值，是初始化
    Integer i2(i1); 
    i2.print();

    Integer i3;
    i3 = i2;
    return 0;
}

3. String 类的实现

  • s实现一个字符串类String, 为其提供可接收C风格字符串的 构造函数、析构函数、拷贝构造函数、拷贝赋值函数

3.1 构造函数

在这里插入图片描述

3.2 析构函数

在这里插入图片描述

3.3 拷贝构造函数

在这里插入图片描述

3.4 拷贝赋值函数

在这里插入图片描述

#include <iostream>
#include <cstring>
using namespace std;

class String{
public:
    // 构造函数
    String(const char* str = ""){
        // new char[3] 分配一个字符数组，数组中有3个连续的存储区，每个存储区只能保存单个字符
        // m_str 指向字符数组中第一个元素的存储区
        m_str = new char[strlen(str) + 1];
        // 所以这里直接赋值 *m_str = *str, 仅仅是拷贝首元素的值
        // strcpy(3)可以把字符串拷贝到字符数组中
        strcpy(m_str, str);
    }
    // 析构函数
    ~String(void){
        delete[] m_str;
        m_str = NULL;
    }
    // 拷贝构造函数(深拷贝)
    String(const String& that){
        m_str = new char[strlen(that.m_str) + 1];
        strcpy(m_str, that.m_str);
    }
    // 拷贝赋值函数(深拷贝)
    String& operator=(const String& that){
        if(this != &that){
            // 没有办法保证this和that中的m_str指向的字符串长度是一样的,直接拷贝可能放不下，或者不能完全覆盖
            // 所以先把this中m_str指向的存储区释放掉，再重新分配和that中m_str指向的存储区一样长度的存储区
            delete[] m_str;
            m_str = new char[strlen(that.m_str) + 1];
            strcpy(m_str, that.m_str);
           /* 
            //这里还要一个更高级的写法
            // 深拷贝构造完成了，新内存的分配，和数据的拷贝。 但这都是针对tmp对象的
            String tmp(that);
            // swap 会再让 this->m_str 指向 tmp对象 维护的动态内存 *tmp.m_str
            // 然后再把 tmp.m_str 指向 this->m_str 原来指向的内存
            swap(m_str, tmp.m_str);
            // 对象tmp离开作用域时，调用析构函数，释放tmp.m_str指向的内存。
            // 即this.m_str原先指向的存储区被释放，防止了内存泄露的问题
            */
        }
        return *this;
    }
    // 向下（C）访问的接口
    const char* c_str(void){
        return m_str;
    }
private:
    char* m_str;
};

int main(void){
    String s1 = "xuehui"; // or String s1("xuehui")
    cout << s1.c_str() << endl;

    String s2(s1);  // or String s2= s1;
    cout << s2.c_str() << endl;

    String s3 = "xue";
    // 下面语句编译时会转为 s3.operator=(s1)
    s3 = s1;
    cout << s3.c_str() << endl;
}


$ ./a.out 
xuehui
xuehui
xuehui

4. 忠告和建议

在这里插入图片描述

  • 拷贝构造 和 拷贝赋值 通常是成对出现，且逻辑相同的。
半只因
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++实现 类string的 普通构造函数， 拷贝构造函数 析构函数 和赋值函数
10-04
C++实现 类string的 普通构造函数， 拷贝构造函数 析构函数 和赋值函数
C++string赋值操作 string赋值拷贝操作
qq_36711295的博客
08-15 3225
C++string赋值操作 string赋值拷贝操作 #include <iostream> #include <string> using namespace std; //string& operator=(const char* s); //char* 类型字符串 赋值给当前的字符串 //string& operator=(const string& s); //把字符串s赋值给当前的字符串 //string& operator=(char c
c++ String类（拷贝构造，拷贝赋值，析构）
CrazyRabbitttt
09-28 524
#ifndef _MYSTRING_ #define _MYSTRING_ class String { public: String(const char* cstr = 0); //构造函数 String(const String& cstr); //拷贝构造，传入的是一个String对象 String& operator =(const String& cstr);// 拷贝赋值 ~String(); //析构函数 char* getstr()const.
拷贝构造与拷贝赋值
cape的博客
10-18 1768
区别： 拷贝构造函数用来初始化对象； 而拷贝赋值用来把已经初始化过的对象进行赋值。 代码：Sales_data类中的拷贝构造函数和拷贝赋值运算符定义如下：//Sales_data类的拷贝构造函数定义 Sales_data::Sales_data(const Sales_data &orig): bookNo(org.bookNo), //使用string的拷贝构造函数
拷贝构造和拷贝赋值
ingy
05-19 595
拷贝构造表示有新的对象被定义： Object obj1 = obj2; //新的Object对象obj1被定义，此时调用拷贝构造函数（copy construction） 拷贝赋值表示没有新的对象被定义： obj1 = obj2; //obj1是一个已经被声明过的对象，此时调用的是拷贝赋值（copy assignment） ...
详解C++ 编写String 的构造函数、拷贝构造函数、析构函数和赋值函数
08-29
主要介绍了详解C++ 编写String 的构造函数、拷贝构造函数、析构函数和赋值函数的相关资料,这里提供实例帮助大家理解掌握这部分内容，需要的朋友可以参考下
详解C++中构造函数，拷贝构造函数和赋值函数的区别和实现
01-01
C++中一般创建对象，拷贝或赋值的方式有构造函数，拷贝构造函数，赋值函数这三种方法。下面就详细比较下三者之间的区别以及它们的具体实现 1.构造函数 构造函数是一种特殊的类成员函数，是当创建一个类的对象时，它...
C++ — 构造函数 赋值函数 拷贝构造函数
01-07
1. 类的声明，构造函数，拷贝构造函数，赋值函数 代码实现 class String { public: String(const char* initChar); String(const String& str); String& operator = (const String& str); private: char*...
[每天一道面试题 c++] Day2 实现string类的拷贝赋值成员
qq_39621037的博客
03-26 109
Day-2 问题 实现string类的拷贝赋值成员 参考答案 参考:让我们一步一步实现一个完整的 String 类：构造、拷贝、赋值、移动和析构 #include<iostream> #include<cstring> #define DEBUG class String{ private: char* m_data; public: String(const char* str=nullptr); String
一说 拷贝构造函数 && 拷贝赋值函数
bigchen
07-26 301
特别说明： 拷贝构造函数和拷贝赋值函数要成对出现 移动构造函数和移动赋值函数也要成对出现 拷贝构造函数是在对象被创建时调用的，而赋值函数只能在已经存在了的对象调用。看下面代码： String a("hello"); String b("world"); String c = a;//这里c对象被创建调用的是拷贝构造函数 //一般是写成 c(a);这里是与后面比较 c = b;//前面c对象已经创建，所以这里是赋值函数 上面说明出现“=.
C++学习之拷贝构造和拷贝赋值
u013511885的博客
11-25 392
浅拷贝和深拷贝 1）如果类中包含了指针形式的成员变量，缺省的拷贝构造只是复制了指针变量自身，而没有复制指针所指向的内容，这种拷贝方式被称为浅拷贝。 2）浅拷贝将会导致不同对象之间的数据共享，如果数据在堆区，析构时还可能会引发"double free",导致进程终止，所以就必须自定义一个指针复制指针所指向内容的拷贝构造函数，即深拷贝。#include <iostream> using ...
从C到C++快速入门（12. String类、拷贝构造函数、析构函数）
dylan的博客
12-10 177
string类、拷贝构造函数、析构函数
自定义实现字符串拷贝——C实现
ling08140814的博客
05-12 2256
在C/C++库函数中，有字符串拷贝函数strcpy， 其接口函数为：char *strcpy(char *str1,char *str2); 现编程实现strcpy函数的功能。 说明：str1指向的空间内存应足够大，至少可以放下str2的内容（包括结束符）。 C代码： #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include&...
【c++string】拷贝构造和赋值运算符重载的深浅拷贝
m0_72964546的博客
09-19 815
浅拷贝会使2个对象的成员变量指向同一块空间1深拷贝解决了两个对象的成员变量指向一块空间的问题。
【C++】string类的模拟实现@STL —— 深浅拷贝
浮光掠影
03-16 2060
每一天全情投入，累积一些小幸福~
C++ 基础与深度分析 Chapter11 类与面向对象编程（构造函数：缺省、单一、拷贝、移动、赋值）
爱学习的大叔的博客
06-30 425
C++ 基础与深度分析 Chapter11 类与面向对象编程（构造、析构与复制成员函数）
C++ 类拷贝构造函数和赋值运算符 & 禁止类的拷贝
Y_jay的博客
03-30 872
1、通常我们定义一个类时，不显示的定义类的拷贝构造函数和拷贝赋值运算符时，编译器会生成两个默认的函数： class Foo{ Foo(const Foo&);//1 Foo& operator=(const Foo&)//2 }; 1是拷贝构造函数，2是拷贝赋值运算符。Foo类可以做如下操作： Foo f1; Foo f2(f1); Foo f2 ...
C++深浅拷贝——实现String类
if9600的博客
03-26 429
实现C++中的String类
C++ STL中 string类的模拟实现
Butayarou的博客
03-15 609
一、前言 在C++的STL中，string 是一个专门管理字符串的类，可以将 string类 简单地理解成 一个只存字符的顺序表。 因此，自己在进行模拟实现时，跟写顺序表差不多。 推荐的 C/C++ 参考文档：http://www.cplusplus.com 二、模拟实现的意义何在？ 为了更好地理解 string类 的底层实现原理，加深对 string类 的认知。 三、string类的模拟实现 首先，先定义 string类。当然，为了防止命名冲突，将它放在一个命名空间里面，这个命名空间就叫
请实现 c++ string类的构造函数、拷贝构造函数、+操作符函数
最新发布
07-12
下面是一个示例实现 C++ 的 string 类的构造函数、拷贝构造函数和 + 操作符函数： ```cpp #include <cstring> // 用于字符串操作的标准库 class String { private: char* data; // 存储字符串的字符数组 int ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值