C++类中三大函数详解(构造、析构和拷贝)

　　目录

　　前言

　　今天和大家分享一下C++中在创建类的时候编译器会提供给一个类至少三个函数，分别是默认构造函数，析构函数，拷贝构造函数。

　　一.构造函数

　　1.构造函数的作用

　　我们在创建好类的对象之后，首先对它的每一个成员属性赋值之后再对它们进行输出操作，如果不赋值就输出，这些值就会是垃圾值。而为了代码的简介，一次性为所有成员属性初始化，C++的类提供了这样的一个函数—构造函数。

　　2.构造函数的语法 类名(){}

　　1）构造函数，没有返回值也不写void

　　2） 函数名称与类名相同

　　3）构造函数可以有参数，因此可以发生重载

　　4）程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次

　　二.析构函数

　　1.析构函数的作用

　　析构函数的作用与构造函数相反，一般是执行对象的清理工作，当对象的生命周期结束的时候，会自动的调用。析构函数的作用并不是删除对象，在对象撤销它所占用的内存之前，做一些清理的工作。清理之后，这部分内存就可以被系统回收再利用了。在设计这个类的时候，系统也会默认的提供一个析构函数。在对象的生命周期结束的时候，程序就会自动执行析构函数来完成这些工作。同构造函数，用户自己定义，系统自动调用。

　　2.析构函数的语法~类名(){}

　　1）析构函数，没有返回值也不写void

　　2） 函数名称与类名相同,在名称前加上符号 ~

　　3）析构函数不可以有参数，因此不可以发生重载

　　4） 程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次

　　代码演示：

　　class Person

　　{

　　public:

　　//构造函数

　　Person()

　　{

　　cout << "Person的构造函数调用" << endl;

　　}

　　//析构函数

　　~Person()

　　{

　　cout << "Person的析构函数调用" << endl;

　　}

　　};

　　void test01()

　　{

　　Person p;

　　}

　　int main()

　　{

　　test01();

　　system("pause");

　　return 0;

　　}

　　三.构造函数的分类及调用

　　1.两种分类方式：

　　按参数分为： 有参构造和无参构造

　　按类型分为： 普通构造和拷贝构造

　　2.三种调用方式：

　　括号法

　　显示法

　　隐式转换法

　　//1、构造函数分类

　　// 按照参数分类分为 有参和无参构造 无参又称为默认构造函数

　　// 按照类型分类分为 普通构造和拷贝构造

　　class Person {

　　public:

　　//无参（默认）构造函数

　　Person() {

　　cout << "无参构造函数!" << endl;

　　}

　　//有参构造函数

　　Person(int a) {

　　age = a;

　　cout << "有参构造函数!" << endl;

　　}

　　//拷贝构造函数

　　Person(const Person& p) {

　　age = p.age;

　　cout << "拷贝构造函数!" << endl;

　　}

　　//析构函数

　　~Person() {

　　cout << "析构函数!" << endl;

　　}

　　public:

　　int age;

　　};

　　//2、构造函数的调用

　　//调用无参构造函数

　　void test01() {

　　Person p; //调用无参构造函数

　　}

　　//调用有参的构造函数

　　void test02() {

　　//2.1 括号法，常用

　　Person p1(10);

　　//注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明

　　//Person p2();

　　//2.2 显式法

　　Person p2 = Person(10);

　　Person p3 = Person(p2);

　　//Person(10)单独写就是匿名对象 当前行结束之后，马上析构

　　//2.3 隐式转换法

　　Person p4 = 10; // Person p4 = Person(10);

　　Person p5 = p4; // Person p5 = Person(p4);

　　//注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明

　　//Person p5(p4);

　　}

　　int main() {

　　test01();

　　//test02();

　　system("pause");

　　return 0;

　　}

　　四.拷贝构造函数调用时机

　　C++中拷贝构造函数调用时机通常有三种情况

　　1.使用一个已经创建完毕的对象来初始化一个新对象

　　2.值传递的方式给函数参数传值

　　3.以值方式返回局部对象

　　class Person {

　　public:

　　Person() {

　　cout << "无参构造函数!" << endl;

　　mAge = 0;

　　}

　　Person(int age) {

　　cout << "有参构造函数!" << endl;

　　mAge = age;

　　}

　　Person(const Person& p) {

　　cout << "拷贝构造函数!" << endl;

　　mAge = p.mAge;

　　}

　　//析构函数在释放内存之前调用

　　~Person() {

　　cout << "析构函数!" << endl;

　　}

　　public:

　　int mAge;

　　};

　　//1. 使用一个已经创建完毕的对象来初始化一个新对象

　　void test01() {

　　Person man(100); //p对象已经创建完毕

　　Person newman(man); //调用拷贝构造函数

　　Person newman2 = man; //拷贝构造

　　//Person newman3;

　　//newman3 = man; //不是调用拷贝构造函数，赋值操作

　　}

　　//2. 值传递的方式给函数参数传值

　　//相当于Person p1 = p;

　　void doWork(Person p1) {}

　　void test02() {

　　Person p; //无参构造函数

　　doWork(p);

　　}

　　//3. 以值方式返回局部对象

　　Person doWork2()

　　{

　　Person p1;

　　cout << (int *)&p1 << endl;

　　return p1;

　　}

　　void test03()

　　{

　　Person p = doWork2();

　　cout << (int *)&p << endl;

　　}

　　int main() {

　　//test01();

　　//test02();

　　test03();

　　system("pause");

　　return 0;

　　}

　　五.构造函数调用规则

　　默认情况下，c++编译器至少给一个类添加3个函数

　　1．默认构造函数(无参，函数体为空)

　　2．默认析构函数(无参，函数体为空)

　　3．默认拷贝构造函数，对属性进行值拷贝

　　构造函数调用规则如下：

　　如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造

　　如果用户定义拷贝构造函数，c++不会再提供其他构造函数

　　class Person {

　　public:

　　//无参（默认）构造函数

　　Person() {

　　cout << "无参构造函数!" << endl;

　　}

　　//有参构造函数

　　Person(int a) {

　　age = a;

　　cout << "有参构造函数!" << endl;

　　}

　　//拷贝构造函数

　　Person(const Person& p) {

　　age = p.age;

　　cout << "拷贝构造函数!" << endl;

　　}

　　//析构函数

　　~Person() {

　　cout << "析构函数!" << endl;

　　}

　　public:

　　int age;

　　};

　　void test01()

　　{

　　Person p1(18);

　　//如果不写拷贝构造，编译器会自动添加拷贝构造，并且做浅拷贝操作

　　Person p2(p1);

　　cout << "p2的年龄为： " << p2.age << endl;

　　}

　　void test02()

　　{

　　//如果用户提供有参构造，编译器不会提供默认构造，会提供拷贝构造

　　Person p1; //此时如果用户自己没有提供默认构造，会出错

　　Person p2(10); //用户提供的有参

　　Person p3(p2); //此时如果用户没有提供拷贝构造，编译器会提供

　　//如果用户提供拷贝构造，编译器不会提供其他构造函数

　　Person p4; //此时如果用户自己没有提供默认构造，会出错

　　Person p5(10); //此时如果用户自己没有提供有参，会出错

　　Person p6(p5); //用户自己提供拷贝构造

　　}

　　int main() {

　　test01();

　　system("pause");

　　return 0;

　　}

　　六.深拷贝与浅拷贝

　　浅拷贝：简单的赋值拷贝操作

　　深拷贝：在堆区重新申请空间，进行拷贝操作

　　示例：

　　class Person {

　　public:

　　//无参（默认）构造函数

　　Person() {

　　cout << "无参构造函数!" << endl;

　　}

　　//有参构造函数

　　Person(int age ,int height) {

　　cout << "有参构造函数!" << endl;

　　m_age = age;

　　m_height = new int(height);

　　cout << "拷贝构造函数!" << endl;

　　//如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题

　　m_age = p.m_age;

　　m_height = new int(*p.m_height)

　　}

　　//拷贝构造函数

　　Person(const Person& p) {

　　;

　　}

　　//析构函数

　　~Person() {

　　cout << "析构函数!" << endl;

　　if (m_height != NULL)

　　{

　　delete m_height;

　　}

　　}

　　public:

　　int m_age;

　　int* m_height;

　　};

　　void test01()

　　{

　　Person p1(18, 180);

　　Person p2(p1);

　　cout << "p1的年龄： " << p1.m_age << " 身高： " << *p1.m_height << endl;

　　cout << "p2的年龄： " << p2.m_age << " 身高： " << *p2.m_height << endl;

　　}

　　int main() {

　　test01();

　　system("pause");

　　return 0;

　　}

　　总结：

　　如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

　　到此这篇关于C++类中三大函数(构造、析构和拷贝)的文章就介绍到这了,更多相关C++类的三大函数内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

　　您可能感兴趣的文章: