关于深拷贝和浅拷贝

深拷贝和浅拷贝的认识:

浅拷贝:就是被拷贝对象和拷贝对象公用同一块空间,即两个对象的指针指向同一块空间。

深拷贝:就是被拷贝对象和拷贝对象有各自的空间,拷贝对象将新开辟一块空间,再将被拷贝对象拷贝下来。

下面是关于深拷贝和浅拷贝的实现

class String

{

public:

//传统写法

String& operator=(const String& s)   //运算符的重载

{

if (this != &s)

{

/*delete[] _str;    //先将_str释放,然后开辟空间,再拷贝

_str = new char[strlen(s._str) + 1];

strcpy(_str, s._str);*/

char* tmp = new char[strlen(s._str) + 1];

strcpy(tmp, s._str); //先用临时对象tmp开辟空间,在将字符串拷贝到

delete[] _str;      tmp;然后释放_str,最后在将tmp地址赋值给_str

_str = tmp;

}

return *this;

}

String(char* str = "")    //构造函数

:_str(new char[strlen(str) + 1])

{

strcpy(_str, str);

}

String(const String& s)     //拷贝构造函数

:_str(new char[strlen(s._str) + 1])

{

strcpy(_str, s._str);

}

~String()        //析构函数

{

if (_str)    //如果_str不为空,就用将_str释放

{

delete[] _str;

}

}

//现代写法

String(const String& s)    //拷贝构造函数

:_str(NULL)

{

String tmp(s._str);  //开辟临时对象,在将字符串拷贝到临时对象tmp

swap(_str, tmp._str); //交换_str和tmp._str指针值,此时tmp指向NULL

而_str指向字符串

}

String& operator=(const String& s)      //运算符的重载

{

if (&s != this)

{

String tmp(s._str);    //方法同上

swap(_str, tmp._str);

}

return *this;

}

String& operator=(String s)      //运算符的重载优化

{

swap(_str, s._str);  //对上面函数就行了优化,传入对象过程中就进行了拷贝

所以直接交换指针值就可以了

return *this;

}

private:

char * _str;

};

时间: 2024-11-06 16:08:38

关于深拷贝和浅拷贝的相关文章

【转载】C++拷贝构造函数(深拷贝,浅拷贝)

对于普通类型的对象来说,它们之间的复制是很简单的,例如:int a=88;int b=a; 而类对象与普通对象不同,类对象内部结构一般较为复杂,存在各种成员变量.下面看一个类对象拷贝的简单例子. #include <iostream>using namespace std;class CExample {private:     int a;public:     CExample(int b)     { a=b;}     void Show ()     {        cout<

完全理解python深拷贝和浅拷贝

import copya = [1, 2, 3, 4, ['a', 'b']]  #原始对象b = a  #赋值,传对象的引用c = copy.copy(a)  #对象拷贝,浅拷贝d = copy.deepcopy(a)  #对象拷贝,深拷贝a.append(5)  #修改对象aa[4].append('c')  #修改对象a中的['a', 'b']数组对象print 'a = ', aprint 'b = ', bprint 'c = ', cprint 'd = ', d 输出结果:a = 

javaScript之深拷贝与浅拷贝

js中有两种数据类型: 1.  基本类型  :  Number.String.Boolean.Null.Undefined 2.  复杂类型  :  Object .Array 深拷贝和浅拷贝只针对复杂类型的数据,因为基本类型数据的定义都会重新开辟新的内存. 浅拷贝拷贝的是内存地址,只是增加一个指针指向已有的内存,这时多个数据共用一个内存空间:深拷贝是新增了指针并且新开辟了内存空间,新指针指向新的内存. 浅拷贝: var a={ name:'WangJing', sex:'女', age:'25

C++拷贝构造函数(深拷贝,浅拷贝)

http://www.cnblogs.com/BlueTzar/articles/1223313.html 对于普通类型的对象来说,它们之间的复制是很简单的,例如:int a=88;int b=a; 而类对象与普通对象不同,类对象内部结构一般较为复杂,存在各种成员变量.下面看一个类对象拷贝的简单例子. 1 #include <iostream> 2 using namespace std; 3 4 class CExample { 5 private: 6 int a; 7 public: 8

python 中 深拷贝和浅拷贝的理解

在总结 python 对象和引用的时候,想到其实 对于python的深拷贝和浅拷贝也可以很好对其的进行理解. 在python中,对象的赋值的其实就是对象的引用.也就是说,当创建一个对象,然后赋给另外一个变量之后,实际上只是拷贝了这个对象的引用. 我们先用  利用切片操作和工厂方法list方法 来阐述一下浅拷贝. 举个栗子: Tom = ['Tom', ['age', 10]] Jack = Tom[:] ……切片操作 June = list(Tom) 接下来查看一下 上述三个变量的引用: >>

实现CMyString类--深拷贝与浅拷贝

实现CMyString类,实现赋值运算符函数(深拷贝与浅拷贝(写时拷贝)) 深拷贝:赋值运算符函数说明 步骤1.释放原来的内存空间 步骤2.再重新开辟要赋值的对象的大小的空间 步骤3.再将另一个对象的值拷贝给this对象 友元函数的说明:由于输出重载需要俩个参数,不能再隐含this指针,故使用友元函数 代码如下: <span style="font-size:18px;">class CMyString { public: CMyString() :str(new char

python 深拷贝和浅拷贝之可变和不可变对象总结

了解深拷贝和浅拷贝之前先要理解可变与不可变对象 python只允许使用引用传递,有可变对象和不可变对象,可变对象:list,dict.不可变对象有:int,string,float,tuple Python int,string,float,tuple不可变举栗子: def int_object(): i = 89 j = 89 print(id(89)) print('i id:' + str(id(i))) print('j id:' + str(id(j))) print(i is j)

深拷贝与浅拷贝

一.浅拷贝和深拷贝 所谓浅拷贝,就是由默认的拷贝构造函数所实现的对数据成员逐一赋值.若类中含有指针类型的数据,这种方式只是简单的把指针的指向赋值给新成员,但并没有给新成员分配内存,因此这种方式必然会导致错误.为了解决浅拷贝出现的错误,必须显示的定义一个拷贝构造函数,使之不但复制数据成员,而且为对象分配各自的内存空间,这就是所谓的深拷贝. 二.浅拷贝 浅拷贝就是由默认的拷贝构造函数所实现的数据成员逐一赋值.通常默认的拷贝构造函数能够胜任这个工作,但是若类中含有指针类型的数据,这种数据成员逐一赋值的

【转】 C++的深拷贝与浅拷贝

对于普通类型的对象来说,它们之间的复制是很简单的,例如:int a=88;int b=a; 而类对象与普通对象不同,类对象内部结构一般较为复杂,存在各种成员变量.下面看一个类对象拷贝的简单例子. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 #include <iostream> using namespace std; class CExample { private:      int a; public:      CE

python 深拷贝与浅拷贝

浅拷贝的方式有: lst=[1,2,3] (1)直接赋值: lst_cp = lst (2)for循环遍历生成:lst_cp= [i for i in lst] (3)copy模块下,copy.copy仍为浅拷贝 深拷贝的方式 (1)借助copy模块 >>> import copy >>> lst_cp = copy.deepcopy(lst) 以上方法的测试: 注意:因为string类型是不可变类型,所以修改string元素时会新创建一个地址空间放置数据 (1)直接赋