【贪玩巴斯】c++核心编程，你需要敲出这些程序！（三）{对象的初始化、构造函数的调用以及分类深、拷贝浅拷贝} //2021-04-11

最新推荐文章于 2021-09-13 21:16:50 发布

贪玩巴斯

最新推荐文章于 2021-09-13 21:16:50 发布

阅读量127

点赞数 1

分类专栏： C++初学笔记（入门、核心、进阶）文章标签： c++ 编程语言

本文链接：https://blog.csdn.net/D16100/article/details/116043885

版权

C++初学笔记（入门、核心、进阶）专栏收录该内容

20 篇文章 0 订阅

订阅专栏

// main.cpp

// _day3

// Created by AchesonD16 贪玩巴斯 on 2021/4/14.

1、对象的初始化

//C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置。

1.1 构造函数和析构函数

//对象的初始化和清理也是两个非常重要的安全问题

//一个对象或者变量没有初始状态，对其使用后果是未知

//同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

//c++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。

//对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供

//编译器提供的构造函数和析构函数是空实现。

//构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。

//析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。

构造函数

//构造函数语法：类名(){}

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

//函数名称与类名相同

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

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

析构函数

//析构函数语法： ~类名(){}

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

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

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

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

#include <iostream>

using namespace std;

class Person

{

public:

//构造函数

Person()

{

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

}

~Person()

{

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

}

};

//void test1()

//{

// Person p;

//}

int main()

{

// test1();(两种方式都会初始化)

// Person p;(都会初始化)

system("pause");

return 0;

}

*/

1.2 构造函数的分类及调用

//构造函数

//构造函数的分类及调用

//两种分类方式：

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

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

//三种调用方式：

// 括号法

// 显示法

// 隐式转换法

// 代码如下：

1.2.1 构造函数分类

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

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

#include<iostream>

using namespace std;

class Person

{

public:

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

Person()

{

cout << "无参（默认）构造函数" << endl;

}



//有参构造函数

Person(int a)

{

age = a;

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

}



//拷贝构造函数

Person(const Person& p) // const常量修饰，表示拷贝过来的值不能随意修改

{

age = p.age;

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

}



~Person()

{

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

}



public:

int age;



};

1.2.2 构造函数的调用

//调用无参构造函数

void test1()

{

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

}

//调用有参构造函数

void test2()

{



//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()

{

test1();

test2();



system("pause");

return 0;



}

结果：

无参（默认）构造函数

析构函数!

有参构造函数！

有参构造函数！

拷贝构造函数!

有参构造函数！

拷贝构造函数!

析构函数!

析构函数!

析构函数!

析构函数!

析构函数!

*/

1.2.3 拷贝构造函数调用时机

//拷贝构造函数调用时机

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

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

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

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

#include<iostream>

using namespace std;

class Person

{

public:

Person()

{

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

mAge = 0;

}

Person(int age)

{

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

mAge = age;

}

Person(const Person& p)

{

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

}

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

~Person()

{

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

}

public:

int mAge;

};

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

void test1()

{

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

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

Person newman2 = man; //拷贝构造

//Person newman3;

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

}

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

//相当于 Person p1 = p;

void doWork(Person p1)

{}

void test2()

{

Person p; //无参构造函数

doWork(p);

}

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

Person doWork2()

{

Person p1;

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

return p1;

}

void test3()

{

Person p = doWork2();

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

}

int main()

{

//test1();

//test2();

test3();

system("pause");

return 0;

}

结果：

test1()

有参构造函数！

拷贝构造函数！

拷贝构造函数！

析构函数！

析构函数！

test2()

无参构造函数！

拷贝构造函数！

析构函数！

析构函数！

test3()

无参构造函数！

0x16fdff42c

0x16fdff42c

析构函数！

*/

1.2.4 构造函数调用规则

//构造函数调用规则

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

//1、默认构造函数（无参，函数体为空）

//2、默认析构函数（无参，函数体为空）

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

//构造函数调用规则如下：

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

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

#include <iostream>

using namespace std;

class Person

{

public:

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

Person()

{

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

}

//有参构造函数

Person(int a)

{

age = a;

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

}

//析构函数

~Person()

{

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

}

public:

int age;

};

void test1()

{

Person p1(18);

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

Person p2(p1);

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

}

void test2()

{

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

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

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

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

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

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

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

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

}

int main()

{

test1();

system("pause");

return 0;

}

结果：

有参构造函数！

p2的年龄为：18

析构函数！

析构函数！

*/

1.2 深拷贝与浅拷贝

//深拷贝与浅拷贝

//深浅拷贝是面试经典的问题，也是常见的一个坑

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

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

//示例：

#include <iostream>

using namespace std;

class Person

{

public:

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

Person()

{

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

}

//有参构造函数

Person(int age , int height)

{

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



m_age = age;

m_height = new int(height);

}

//拷贝构造函数

Person(const Person& p)

{

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

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

m_age = p.m_age;

m_height = new int(*p.m_height);

}



//析构函数

~Person()

{

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

if(m_height != NULL)

{

delete m_height;

m_height = NULL;

}

}

public:

int m_age;

int* m_height;

};

void test1()

{

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()

{

test1();

system("pause");

return 0;

}

结果：

有参构造函数！

拷贝构造函数！

p1的年龄：18 身高： 180

p2的年龄：18 身高： 180

析构函数！

析构函数！

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

   并且要在析构函数中写下delete。释放

*/

贪玩巴斯

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
【贪玩巴斯】c++核心编程，你需要敲出这些程序！（三）{对象的初始化、构造函数的调用以及分类深、拷贝浅拷贝} //2021-04-11

//// main.cpp// _day3//// Created by AchesonD16 贪玩巴斯on 2021/4/14.//1、对象的初始化//C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置。1.1构造函数和析构函数//对象的初始化和清理也是两个非常重要的安全问题//一个对象或者变量没有初始状态，对其使用后果是未知//同样的使用完一个对象或变量，没有及时清理...
复制链接

扫一扫