构造函数(三) 拷贝构造函数

什么是拷贝构造函数

拷贝听起来真高级 拷贝构造函数形如

class_name(const class_name &object_name)

拷贝构造函数是一种特殊的构造函数，只有一个参数，这个参数是本类中的一个对象，以引用的形式传参，一般用const修饰，使参数值不变。

如果没有定义拷贝构造函数，编译器会自动隐式生成一个拷贝构造函数，用来简单的复制类中每个成员变量。

一个简单的类对象拷贝

#include <bits/stdc++.h> using namespace std; class A { private : int a, b; public : A(int x, int y) : a(x), b(y) {} void print() { printf("%d %d\n", a, b); } }; int main() { A a(10, 20); A b = a; b.print(); return 0; }

输出

10 20

具体看一下拷贝构造函数怎么用。

#include <bits/stdc++.h> using namespace std; class A { private : int a, b; public : A(int x, int y) : a(x), b(y) {} A(const A &c) { a = c.a; b = c.b; } void print() { printf("%d %d\n", a, b); } }; int main() { A a(10, 20); A b = a; b.print(); return 0; }

这样手动的写如何复制

为什么要引用

为什么用引用的方式传参呢。 举个反例

#include <bits/stdc++.h> using namespace std; class A { private : int a; public : A(int x) : a(x) {} A(const A c) { a = c.a; } void print() { printf("%d\n", a); } }; int main() { A a(10); A b = a; b.print(); return 0; }

A b = a时，调用了传值型的拷贝构造函数， 相当于b.A(a)， 因为是传的值，所以要用a的值创建一个副本对象c，让c的值为a，则又需要调用构造函数c.A(a)，这样会无限创造副本对象c，无限调用c.A(a); 所以引用是为了防止无限递归。 其实没有加引用的话编译器也是不过编译的。

拷贝构造函数的调用时机

1. 对象需要通过另一个对象对其进行赋值

A a(10, 20); A b = a;

2. 当函数的参数是类的对象

#include <bits/stdc++.h> using namespace std; class A { private : int a, b; public : A(int x, int y) : a(x), b(y) {} A(const A &c) {a = c.a, b = c.b;} void print() {printf("%d\n", a * b);} }; void fun(A c) { //函数的形参是类的对象 c.print(); } int main() { A a(10, 20); fun(a); //实参是类的对象，调用函数时将复制一个新对象c return 0; }

3. 当函数的返回值是类的对象

#include <bits/stdc++.h> using namespace std; class A { private : int a, b; public : A(int x, int y) : a(x), b(y) {} A(const A &c) {a = c.a, b = c.b;} void print() {printf("%d\n", a * b);} }; A fun() { A b(20, 10); return b; //函数的返回值是类的对象 } int main() { A a = fun(); //fun()返回 A 类的临时对象，并赋值给a a.print(); return 0; }

深拷贝和浅拷贝

默认拷贝构造函数可以完成对象的数据值得简单复制，这就是浅拷贝。

对象的成员是指向堆时，浅拷贝只是将指针简单复制一遍，指向了原有的内存，而深拷贝是将新建的指针指向了一块新的内存。

浅拷贝

浅拷贝就是将数据简单复制一下，就像上面讲的。

看这段代码

#include <bits/stdc++.h> using namespace std; class A { private : int *p; public : A(int x) { p = new int(x); printf("Constructor\n"); } A(const A &oth) { this->p = new int(*oth.p); printf("Constructor\n"); } ~A() { if (p != NULL) delete p; printf("Destructor\n"); } void print() { printf("%d\n", *p); } }; int main() { A a(10); A b = a; return 0; }

这是段代码出错了，为什么？

如图所示，

b把a的指针简单复制了一遍，两者都指向了同一块内存，释放内存的时候被释放了两次，导致出错。

深拷贝

对于上面的代码，我们手写一个拷贝构造函数，像这样

#include <bits/stdc++.h> using namespace std; class A { private : int *p; public : A(int x) { p = new int(x); printf("Constructor\n"); } A(const A &oth) { this->p = new int(*oth.p); printf("Constructor\n"); } ~A() { if (p != NULL) delete p; printf("Destructor\n"); } void print() { printf("%d\n", *p); } }; int main() { A a(10); A b = a; return 0; }

我们给b初始化时，给它新开辟了一段内存空间 这样，深拷贝就没有上述浅拷贝时内存释放两次的情况了。

转载于:https://www.cnblogs.com/lykkk/p/10631210.html

相关资源：JAVA上百实例源码以及开源项目