C++核心编程 4 类和对象-对象的初始化和清理（2）
构造函数和析构函数
对象的初始化和清理工作是两个非常重要的安全问题，一个对象或者变量没有初始状态，对其使用结果是未知的，同样，使用完一个对象或变量，没有及时清理，也会造成一定的安全问题。C++利用了构造和析构函数解决上述问题，这两个函数会被编译器自动调用，完成初始化和清理工作，对象的初始化和清理工作是编译器强制我们做的事，如果我们不提供构造和析构函数，编译器会提供，编译器提供的构造和析构函数是空实现；
构造函数：主要作用在于创建对象时为对象的成员赋值，构造函数由编译器自动调用，完成对象的初始化和清理工作。
语法：类名（）{ }
1、构造函数，没有返回值，也不写void
2、函数名和类名相同
3、构造函数可以有参数，因此可以发生重载
4、程序调用对象时会自动调用构造，无需手动调用，而且只会调用一次
析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。
语法：~ 类名（）{ }
1、构造函数，没有返回值，也不写void
2、函数名和类名相同，在名称前加~
3、构造函数不可以有参数，因此不可以发生重载
4、程序调用对象时会自动调用析构，无需手动调用，而且只会调用一次
#include<iostream> #include<string> using namespace std; //对象的初始化和清理 class Person { //1、构造函数 进行初始化操作 /* 1、构造函数，没有返回值，也不写void 2、函数名和类名相同 3、构造函数可以有参数，因此可以发生重载 4、程序调用对象时会自动调用构造，无需手动调用，而且只会调用一次 */ public: Person() { cout << "Person构造函数的调用" << endl; } //2、析构函数 进行清理的操作 /* 1、构造函数，没有返回值，也不写void 2、函数名和类名相同，在名称前加~ 3、构造函数不可以有参数，因此不可以发生重载 4、程序调用对象时会自动调用析构，无需手动调用，而且只会调用一次 */ ~Person() { cout << "Person析构函数的调用" << endl; } }; void test1() { Person p; //栈上的数据，test1执行完毕后，释放掉这个对象； } int main() { test1(); system("pause"); return 0; }
构造函数的分类和调用
两种分类方式：
按参数分：有参构造和无参构造
按类型分：普通构造和拷贝构造
三种调用方式：
括号法
显示法
隐式转换法
#include<iostream> #include<string> using namespace std; //构造函数的分类和调用 //分类 //按照参数分类 无参构造和有参构造 class Person { //构造函数 public: Person() { cout << "Person无参（默认）构造函数的调用" << endl; } Person(int a) { age = a; cout << "Person有参构造函数的调用" << endl; } //拷贝构造函数 Person( const Person &p ) { //将传入人的身上的所有属性，拷贝到我身上； age = p.age; cout << "Person拷贝构造函数的调用" << endl; } ~Person() { cout << "Person析构函数的调用" << endl; } int age; }; //调用 void test1() { //1、括号法 //Person p1; //无参（默认）构造函数的调用 //Person p2(10); //有参构造函数的调用 //Person p3(p2); //拷贝构造函数的调用 //注意事项 //调用默认构造函数是，不要加（） //因为下面这行代码，编译器会认为这是一个函数的声明，不会认为在创建对象 //Person p1 (); // ↓ ↓ ↓ //void func (); //cout << "p2年龄为：" << p2.age << endl; //cout << "p3年龄为：" << p3.age << endl; //2、显示法 //Person p1; //Person p2 = Person(10); //有参构造 //Person p3 = Person(p2); //拷贝函数 调用p2的拷贝构造函数 //Person(10); //匿名对象 特点：当前行之行结束后，系统立即回收掉匿名对象 //cout << "aaaa" << endl; //注意事项2 //不要利用拷贝构造函数 初始化匿名对象 编译器会认为Person(p3) == Person p3;会认为Person(p3)是对象的声明 //Person(p3); //3、隐式转换法 Person p4 = 10; //相当于 写了 Person p4 = Person(10) Person p5 = p4; //拷贝函数 } int main() { test1(); system("pause"); return 0; }
拷贝构造函数的调用时机
1、使用一个已经创建完毕的对象来初始化一个新对象
2、值传递的方式给函数参数传值
3、值方式返回局部对象
#include<iostream> using namespace std; //拷贝构造函数的调用时机 class Person { //构造函数 public: Person() { cout << "Person默认构造函数的调用" << endl; } Person(int age) { cout << "Person有参构造函数的调用" << endl; m_Age = age; } Person(const Person &p) { cout << "Person拷贝构造函数的调用" << endl; m_Age = p.m_Age; } ~Person() { cout << "Person析构函数调用" << endl; } int m_Age; }; //1、使用一个已经创建完毕的对象来初始化一个新对象 //调用 void test1() { Person p1(20); //p1已经创建完毕 Person p2(p1); //用p1来初始化p2 } //2、值传递的方式给函数参数传值 void dowork(Person p3) //形参Person p3 = 实参p3 形参Person p3初始化用的就是拷贝构造函数 { } void test2() { Person p3; dowork(p3); } //3、值方式返回局部对象 Person dowork2() //以值的方式返回 不会返回Person p1中的对象p1，而是按照p1拷贝一个新的对象返回给外面【test3中的Person p】 { Person p1; //默认构造调用 此处的Person p1是局部对象 cout << (int*)&p1 << endl; return p1; //以局部对象的方式返回p1， } void test3() { Person p = dowork2(); cout << (int*)&p << endl; } int main() { //test1(); //test2(); test3(); system("pause"); return 0; }
构造函数调用规则
默认情况下，C++编译器至少给一个类添加3个函数
1、默认构造函数（无参，函数体为空）
2、默认析构函数（无参，函数体为空）
3、默认拷贝构造函数，对属性进行值拷贝
构造函数调用规则如下：
如果用户自定义有参构造函数 C++不再提供默认无参构造 但是会提供默认拷贝构造
如果用户自定义拷贝构造函数 C++不会再提供其他构造函数
#include<iostream> using namespace std; //构造函数的调用规则 //1、默认情况下，C++编译器至少给一个类添加3个函数 //默认构造（空实现） //默认析构（空实现） //默认拷贝构造（值拷贝） //2、如果我们自定义了有参构造函数，编译器就不再提供默认无参构造 但是依然会提供默认拷贝构造 //如果我们自定义了拷贝构造函数 编译器就不会再提供其他构造函数 class Person { //构造函数 public: Person() { cout << "Person默认构造函数的调用" << endl; } Person(int age) { cout << "Person有参构造函数的调用" << endl; m_Age = age; } Person(const Person &p) { cout << "Person拷贝构造函数的调用" << endl; m_Age = p.m_Age; } ~Person() { cout << "Person析构函数调用" << endl; } int m_Age; }; //void test1() //{ // Person p; // p.m_Age = 18; // // Person p2(p); // // cout << "p2的年龄为：" << p2.m_Age << endl; //} void test2() { Person p(28); Person p2(p); cout << "p2的年龄为：" << p2.m_Age << endl; } int main() { //test1(); test2(); system("pause"); return 0; }
深拷贝与浅拷贝
浅拷贝：简单的赋值拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作
#include<iostream> using namespace std; //深拷贝和浅拷贝 class Person { public: Person() { cout << "Person默认构造函数的调用" << endl; } Person(int age , int height) { cout << "Person有参构造函数的调用" << endl; m_Age = age; m_Height = new int(height); //new int 返回值类型为：int * } ~Person() { //析构代码，将堆区开辟的数据释放掉 if (m_Height != NULL) { delete m_Height; m_Height = NULL; } cout << "Person析构函数调用" << endl; } int m_Age; //年龄 int* m_Height; //身高 通过指针将身高的数据开辟到堆区 }; void test1() { Person p1(19,160); cout << "p1的年龄为：" << p1.m_Age << endl; cout << "p1的身高为：" << *p1.m_Height << endl; Person p2(p1); //编译器做了一次浅拷贝 cout << "p2的年龄为：" << p2.m_Age << endl; cout << "p2的身高为：" << *p2.m_Height << endl; } int main() { test1(); system("pause"); return 0; }
以上代码执行完会出现下图中的错误 原因就是身高是指针类型。p2已经释放过了指针所存地址的数据，p1再去释放此时已经是非法操作。
栈上数据：先进后出，p2先释放，p1再释放
解决办法：利用深拷贝
#include<iostream> using namespace std; //深拷贝和浅拷贝 class Person { public: Person() { cout << "Person默认构造函数的调用" << endl; } Person(int age , int height) { cout << "Person有参构造函数的调用" << endl; m_Age = age; m_Height = new int(height); //new int 返回值类型为：int * } //自己实现拷贝构造函数 解决浅拷贝带来的问题 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 << "Person析构函数调用" << endl; } int m_Age; //年龄 int* m_Height; //身高 通过指针将身高的数据开辟到堆区 }; void test1() { Person p1(19,160); cout << "p1的年龄为：" << p1.m_Age << endl; cout << "p1的身高为：" << *p1.m_Height << endl; Person p2(p1); //编译器做了一次浅拷贝 cout << "p2的年龄为：" << p2.m_Age << endl; cout << "p2的身高为：" << *p2.m_Height << endl; } int main() { test1(); system("pause"); return 0; }
初始化列表
作用：用来初始化属性
语法： 构造函数（）：属性1（值1），属性2（值2）... { }
#include <iostream> using namespace std; //初始化列表 class Person { public: ////传统初始化操作 //Person(int a, int b, int c) //{ // m_A = a; // m_B = b; // m_C = c; //} //初始化列表初始化属性 //Person() :m_A(10), m_B(20), m_C(30) //这样就写死了，只能赋值10，20，30，于是更推荐下面这种 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; 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; }
类对象作为类成员
C++类中的成员可以是另一个类的对象，我们称该成员位 对象成员
例如：
class A {} class B { A a; }
B类中有对象A作为成员，A为对象成员
当其他类对象作为本类成员，构造时候先构造类对象，再构造自身，析构的顺序与构造相反
静态成员
静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员
静态成员分为：
静态成员变量：1、所有对象共享同一份数据（eg : a=10;b=20;a=b;）；2、在编译阶段分配内存；3、类内声明，类外初始化；
//静态成员变量
class person { public: //1 所有对象共享同一份数据 //2 编译阶段就分配内存 //3 类内声明，类外初始化 eg：类外的 int person::m_a = 100; int person::m_b = 100; static int m_a; //静态成员变量也是有访问权限的 private: static int m_b; //类外访问不到 }; int person::m_a = 100; int person::m_b = 200; void test1() { person p; //100 cout << p.m_a << endl; person p2; p2.m_a = 200; //100 ? 200 cout << p.m_a << endl; //答案：200 } void test2() { //静态成员变量 不属于某个对象上，所有对象都共享同一份数据 //因此 静态成员变量有两种访问方式 //1 通过对象进行访问 // person p; // cout << p.m_a << endl; //2 通过类名进行访问 cout << person::m_a << endl; //cout << person::m_b << endl; //b在私有作用域下 在类外访问不到私有静态成员变量 故报错 } int main() { //test1(); test2(); return 0; }
静态成员函数：1、所有对象共享同一个函数；2、静态成员函数只能访问静态成员变量；
//静态成员函数
class person { public: //1 所有对象共享同一个函数 //2 静态成员函数只能访问静态成员变量 static void func() { m_a = 100; //静态成员函数可以访问静态成员变量 //m_b = 200; //静态成员函数 不可以访问 非静态成员变量，无法区分到底是哪个对象的m_b属性 cout << "static void func 的调用" << endl; } static int m_a;//静态成员变量 int m_b;//非静态成员变量 //静态成员函数也是有访问权限的 private: static void func2() { cout << "static void func2 的调用" << endl; } }; int person::m_a = 0; void test1() { //1 通过对象进行访问 person p; p.func(); //2 通过类名进行访问 person::func(); //person::func2(); //类外访问不到私有静态成员函数 } int main() { test1(); return 0; }
浙公网安备 33010602011771号