C++学习（9）—— 对象的初始化及清理
1. 构造函数和析构函数
对象的初始化和清理是两个非常重要的安全问题
一个对象或者变量没有初始状态，对其使用后果是未知
同样的使用完一个对象或者变量，没有及时清理，也会造成一些安全问题
C++利用了构造函数和析构函数解决上述问题，这两个函数会被编译器自动调用，完成对象初始化和清理工作。对象的初始化和清理工作是编译器强制要求我们做的事情，因此如果我们不提供构造和析构，编译器会提供。编译器提供的构造函数和析构函数是空实现。
- 构造函数：主要作用于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
- 析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。
构造函数语法：类名（）{}
- 构造函数，没有返回值也不写void
- 函数名称与类名相同
- 构造函数可以有参数，因此可以发生重载
- 程序在调用对象时会自动调用构造，无须手动调用，而且只会调用一次
析构函数语法：~类名（）{}
- 析构函数，没有返回值也不写void
- 函数名称与类名相同，在名称前加上符号~
- 构造函数不可以有参数，因此不可以发生重载
- 程序在对象销毁前会自动调用构造，无须手动调用，而且只会调用一次
#include<iostream>
#include<string>
using namespace std;
class Person{
//1.1构造函数
public:
Person(){
cout << "构造函数调用" << endl;
}
~Person(){
cout << "析构函数调用" << endl;
}
};
void test01(){
Person p;
}
int main(){
//test01();
Person p;
system("pause");
return 0;
}
2. 构造函数的分类及调用
两种分类方式：
- 按参数分为：有参构造和无参构造
- 按类型分类：普通构造和拷贝构造
三种调用方式：
- 括号法
- 显式法
- 隐式转换法
#include<iostream>
#include<string>
using namespace std;
class Person{
//1.1构造函数
public:
int age;
Person(){
cout << "无参（默认）构造函数调用" << endl;
}
Person(int a){
age = a;
cout << "有参构造函数调用" << endl;
}
Person(const Person &p){
age = p.age;
cout << "拷贝构造函数调用" << endl;
}
~Person(){
cout << "析构函数调用" << endl;
}
};
//调用
void test01(){
/*****括号法*****/
Person p1; //默认构造函数的调用
Person p2(10); //有参构造函数调用
Person p3(p2); //拷贝构造函数调用
//注意事项1
//调用默认构造函数时，不要加（）
Person p4(); //编译器会认为这是一个函数的声明
/*****显式法*****/
Person p1;
Person p2 = Person(10);
Person p3 = Person(p2);
//Person(10) 匿名对象，特点：当前行执行结束后，系统会立即回收掉匿名对象
//注意事项2
//不要利用拷贝构造函数初始化匿名对象
Person(p3); //编译器会认为Person(p3) == Person p3;
/*****隐式构造法*****/
Person p4 = 10; //相当于 Person p4 = Person(10);
Person p5 = p4; //相当于 Person p5 = p4;
}
int main(){
test01();
system("pause");
return 0;
}
3. 拷贝构造函数调用时机
C++中拷贝构造函数调用时机通常有三种情况
- 使用一个已经创建完毕的对象来初始化一个新对象
- 值传递的方式给函数参数传值
- 以值方式返回局部对象
#include<iostream>
#include<string>
using namespace std;
class Person{
//1.1构造函数
public:
int m_age;
Person(){
cout << "默认构造函数调用" << endl;
}
Person(int age){
m_age = age;
cout << "有参构造函数调用" << endl;
}
//拷贝构造函数
Person(const Person &p){
m_age = p.m_age;
cout << "拷贝构造函数调用" << endl;
}
~Person(){
cout << "析构函数调用" << endl;
}
};
//1. 使用一个已经创建完毕的对象来初始化一个新对象
void test01(){
Person p1(20);
Person p2(p1);
cout << "p2的年龄为：" << p2.m_age << endl;
}
//2. 值传递的方式给函数参数传值
void test02(Person p){
}
//3. 值方式返回局部对象
Person doWork02(){
Person p1;
return p1;
}
void test03(){
Person p = doWork02();
}
int main(){
//Person p;
//test01();
test03();
system("pause");
return 0;
}
4. 构造函数的调用规则
默认情况下，C++编译器至少给一个类添加三个函数：
- 默认构造函数（无参，函数体为空）
- 默认析构函数（无参，函数体为空）
- 默认拷贝构造函数，对属性值进行拷贝(不是空函数体)
构造函数调用规则如下：
- 如果用户定义有参构造函数，C++不再提供无参构造，但是会提供默认拷贝
- 如果用户定义拷贝构造函数，C++不会再提供其他构造函数
#include<iostream>
#include<string>
using namespace std;
class Person{
public:
Person(){
cout << "默认构造函数调用" << endl;
}
Person(int age){
m_age = age;
cout << "有参构造函数调用" << endl;
}
//拷贝构造函数
/*Person(const Person &p){
m_age = p.m_age;
cout << "拷贝构造函数调用" << endl;
}*/
~Person(){
cout << "析构函数调用" << endl;
}
int m_age;
};
void test01(){
Person p;
p.m_age = 18;
Person p2(p);
cout << "p2的年龄为：" << p2.m_age << endl;
}
void test02(){
Person p;
}
int main(){
test01();
system("pause");
return 0;
}
5. 深拷贝与浅拷贝
深浅拷贝是面试经典问题，也是常见的一个坑
浅拷贝：简单的赋值拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作
- 浅拷贝带来的问题就是堆区的重复释放
- 解决办法是自己实现拷贝构造函数
#include<iostream>
#include<string>
using namespace std;
class Person{
public:
Person(){
cout << "默认构造函数调用" << endl;
}
Person(int age, int height){
m_age = age;
m_height = new int(height);
cout << "有参构造函数调用" << endl;
}
//自己实现拷贝构造函数，解决浅拷贝带来的问题
Person(const Person &p){
cout << "拷贝构造函数调用" << endl;
m_age = p.m_age;
//m_height = p.m_height; 编译器默认实现就是这行代码
m_height = new int(*p.m_height);
}
~Person(){
if (m_height != NULL){
delete m_height;
m_height = NULL;
}
cout << "析构函数调用" << endl;
}
int m_age;
int *m_height;
};
void test01(){
Person p1(18,160);
cout << "p1的年龄为：" << p1.m_age << " 身高为：" << *p1.m_height << endl;
Person p2(p1);
cout << "p2的年龄为：" << p2.m_age << " 身高为：" << *p2.m_height << endl;
}
int main(){
test01();
system("pause");
return 0;
}
6. 初始化列表
作用：C++提供了初始化列表语法，用来初始化属性
语法：构造函数():属性(值1)属性(值2)...{}
#include<iostream>
#include<string>
using namespace std;
class Person{
public:
/*Person(int a, int b, int c){
m_A = a;
m_B = b;
m_C = c;
}*/
//初始化列表初始化属性
Person(int a, int b, int c):m_A(a),m_B(b),m_C(c){
}
int m_A;
int m_B;
int m_C;
};
void test01(){
//Person p(10,20,30);
Person p(30,20,10);
cout << "m_A: " << p.m_A << endl;
cout << "m_B: " << p.m_B << endl;
cout << "m_C: " << p.m_C << endl;
}
int main(){
test01();
system("pause");
return 0;
}
7. 类对象作为类成员
C++类中的成员可以是另一个类的对象，我们称该成员为对象成员
例如：
class A{}
class B{
A a;
}
B类中有对象A作为成员，A为对象成员
那么当创建B对象时，A与B的构造和析构的顺序是谁先谁后呢？
- 当其他类对象作为本类成员，构造时候先构造类对象，再构造自身
- 析构的顺序与构造相反
8. 静态成员
静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员
静态成员分成：
- 静态成员变量
- 所有对象共享同一份数据
- 在编译阶段分配内存
- 类内声明，类外初始化
- 静态成员函数
- 所有对象共享一个函数
- 静态成员函数只能访问静态成员变量
示例1：
#include<iostream>
#include<string>
using namespace std;
class Person{
public:
static int m_A; //静态成员变量
//静态成员变量特点：
//1.在编译阶段分配内存
//2.类内声明，类外初始化
//3.所有对象共享同一份数据
private:
static int m_B; //静态成员变量也是有访问权限的
}；
int Person::m_A = 10;
int Person::m_B = 20;
void test01(){
//静态成员变量两种访问方式
//1.通过对象
Person p1;
p1.m_A = 100;
cout << "p1.m_A = " << p1.m_A << endl;
Person p2;
p2.m_A = 200;
cout << "p1.m_A = " << p1.m_A << endl; //共享同一份数据
cout << "p2.m_A = " << p2.m_A << endl;
//2.通过类名
cout << "m_A = " << Person::m_A << endl;
//cout << "m_B = " << Person::m_B << endl; //私有权限访问不到
}
int main(){
test01();
return 0;
}
示例2：
#include<iostream>
#include<string>
using namespace std;
class Person{
public:
static void func(){
m_A = 100;
// m_B = 200; 静态成员函数不可以访问非静态程序变量，无法区分是哪个对象的m_B属性
cout << "static void func调用" << endl;
}
static int m_A;
int m_B;
};
int Person::m_A = 0;
void test01(){
//1. 通过对象访问
Person p;
p.func();
//2. 通过类名访问
Person::func();
}
int main(){
test01();
return 0;
}
Debugging is twice as hard as writing the code in the first place. Therefore, if you write the code as cleverly as possible, you are, by definition, not smart enough to debug it.
