https://www.bilibili.com/video/BV1et411b73Z?p=106&spm_id_from=333.1007.top_right_bar_window_history.content.clickhttps://www.bilibili.com/video/BV1et411b73Z?p=106&spm_id_from=333.1007.top_right_bar_window_history.content.click
目录
1.构造函数与析构函数
构造函数：
2.构造函数的分类及调用
3.拷贝构造函数的调用时机
4.构造函数调用规则
5.深拷贝与浅拷贝
6.初始化列表
7.类对象作为类成员
8.静态成员
9.成员变量和成员函数分开存储
10.this指针
11.空指针访问成员函数
12.const修饰成员函数
对象的初始化和清理
·生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用时也会删除一些自己信息数据保证安全
·C++中的面向对象来源于生活，每个对象也都会有初始化设置以及对象销毁前的的清理数据的设置
1.构造函数与析构函数
对象的初始化和清理也是两个非常重要的安全问题
一个对象或者变量没有初始状态，对其使用后果是未知
同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题
C++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作，对象的初始化和清理工作是编译器强制要求我们要做的事，因此我们如果不提供构造和析构，编译器会提供
编译器提供的构造函数和析构函数是空实现
构造函数：
主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用
语法： 类名(){}
1.构造函数，没有返回值也不写void
2.函数名称与类名相同
3.构造函数可以有参数，因此可以发生重载
4.程序在调用对象时会自动调用构造，无需手动调用，而且只会调用一次
析构函数：
主要作用在于对象销毁前系统自动的调用，执行一些清理工作
语法：~类名(){}
1.析构函数，没有返回值也不写void
2.函数名称与类名相同，在类名前加上“~”符号
3.析构函数不可以有参数，因此不可以发生重载
4.程序在对象销毁前会自动调用析构，无需手动调用，而且只会调用一次
#includeusing namespace std; //对象的初始化和清理 //1、构造函数 进行初始化 class Person { public: //1.1构造函数 //没有返回值 不用写void //函数名 与类名相同 //构造函数可以有参数，可以发生重载 //创建对象的时候，构造函数会自动调用，而且只调用一次 Person() { cout << "Person 函数的调用" << endl; } //2.析构函数 进行清理的操作 //没有返回值 不写void //函数名与类名相同 在名称前加~ //析构函数不可以有参数，不可以发生重载 //对象在销毁前会自动调用析构函数，而且只会调用一次 ~Person() { cout << "Person 析构函数的调用" << endl; } }; //构造和析构都是必须有的实现，如果我们自己不实现，编译器会提供一个空实现的构造和析构 void test01() { Person p;//栈上的数据，test01执行完毕后，释放这个对象 } //析构函数 进行清理的操作 int main() { test01(); //Person p; system("pause"); return 0; }
2.构造函数的分类及调用
两种分类方式：
按参数分为：有参构造和无参构造
按类型分为：普通构造和拷贝构造
三种调用方式：
括号法
显示法
隐式转换法
#includeusing namespace std; //构造函数的分类及调用 //分类 // 按照参数分类 无参构造(默认构造) 和 有参构造 // 按照类型分类 普通构造函数 拷贝构造函数 class Person { public: //构造函数 Person() { cout << "Person的无参构造函数调用" << endl; } Person(int a) { age = a; cout << "Person的有参构造函数调用" << endl; } //拷贝构造 Person(const Person& p) { //将传入的人(p)身上的所有的属性，拷贝到我(class)的身上 age = p.age; cout << "Person的拷贝构造函数调用" << endl; } ~Person() { cout << "Person的析构函数调用" << endl; } int age; }; //调用 void test01() { //1、括号法 Person p1;//默认构造函数调用 Person p2(10);//有参构造函数 Person p3(p2);//拷贝构造函数 //注意事项1 //调用默认构造函数时不要加() //Person p4(); 因为这行代码编译器认为是一个函数声明，不会认为在创造对象 //2、显示法 Person p1; Person p2 = Person(10);//有参构造 Person p3 = Person(p2);//拷贝构造 //Person(10);//匿名对象 特点：当前行执行结束后，系统会立即回收掉匿名对象 //cout << "aaa" << endl; //注意事项2 //不要利用拷贝构造函数 来初始化匿名对象 编译器会认为 Person(p3)===Person p3; //编译器会认为是对象的声明而 重定义 //Person(p3); //3、隐式转换法 Person p4 = 10;//相当于 写了 Person p4 = Person(10); Person p5 = p4;//相当于 写了 Person p5 = Person(p4); } int main() { test01(); return 0; }
3.拷贝构造函数的调用时机
C++中拷贝构造函数的调用时机有三种：
1.使用一个已经创建完毕的对象来初始化一个新对象
2.值传递的方式给函数参数传值
3.以值方式返回局部对象
#includeusing namespace std; class Person { public: Person() { cout << "Person 默认构造函数调用" << endl; } Person(int age) { m_Age = age; cout<< "Person 有参构造函数调用" << endl; } Person(const Person& p) { m_Age = p.m_Age; cout<< "Person 拷贝构造函数调用" << endl; } ~Person() { cout<< "Person 析构函数调用" << endl; } int m_Age; }; //拷贝构造函数调用时机 //1、使用一个已经创建完毕的对象来初始化一个新对象 void test01() { Person p1(20); Person p2(p1); cout << "p2.age = " << p2.m_Age << endl; } //2、值传递的方式给函数传值 void doWork(Person p) { } void test02() { Person p; doWork(p);//值传递的方式，拷贝一个新的p，不会改变原来的 } //3、以值方式返回局部对象 Person doWork2() { Person p1; cout << (int*)&p1 << endl; return p1;//返回的不是p1本身，而是根据p1创建一个新的对象返回 } void test03() { Person p = doWork2(); cout << (int*)&p << endl; } int main() { //test01(); //test02(); test03(); return 0; }
4.构造函数调用规则
默认情况下，C++编译器至少给一个类添加3个函数
1.默认构造函数（无参，函数体为空）
2.默认析构函数（无参，函数体为空）
3.默认拷贝构造函数，对属性进行值拷贝
构造函数调用规则如下：
·如果用户定义有参构造函数，C++不再提供默认无参构造，但是会提供默认拷贝构造
·如果用户定义拷贝构造函数，C++不再提供其他构造函数
#includeusing namespace std; //默认情况下，C++编译器至少给一个类添加3个函数 //1、默认构造函数(无参，函数体为空) 空实现 //2、默认析构函数(无参，函数体为空) 空实现 //3、默认拷贝构造函数，对其属性进行拷贝 值拷贝 //构造函数调用规则如下： //·如果用户定义有参构造函数，C++不在提供默认无参构造，但是会提供默认拷贝构造 //·如果用户定义拷贝构造函数，C++不再提供其他构造函数 class Person { public: Person(int age) { m_Age = age; cout << "Person 有参构造函数调用" << endl; } ~Person() { cout << "Person 析构函数调用" << endl; } int m_Age; }; //void test01() //{ // Person p; // p.m_Age = 18; // // Person p2(p); // // cout << "p2.age = " << p2.m_Age << endl; //} void test02() { Person p(28); Person p2(p); cout << "p2.age = " << p2.m_Age << endl; } int main() { //test01(); test02(); return 0; }
举一个例子：
假如我们只写了有参函数构造，编译器就不再提供默认函数构造，此时如果再无参构造的话就会报错
如果我们只写了拷贝构造函数，编译器就不再提供其他普通构造函数，此时再写无参构造或有参构造的话就会报错
5.深拷贝与浅拷贝
深拷贝与浅拷贝是面试经典问题，也是常见的一个坑
浅拷贝：简单的复制拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作
需要创建新的内存处new int（*某括号内的对象成员地址）
#includeusing namespace std; //深拷贝和浅拷贝 //如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题 class Person { public: Person() { cout << "Person 默认构造函数调用" << endl; } Person(int age,int height) { m_Age = age; m_Height = new int(height); cout << "Person 有参构造函数调用" << endl; } //自己实现拷贝构造函数 解决浅拷贝带来的问题 Person(const Person& p) { cout << "Person 拷贝构造函数调用" << endl; m_Age = p.m_Age; m_Height = new int(*p.m_Height);//深拷贝 } ~Person() { //析构代码，将堆区开辟的数据做释放操作 cout << "Person 析构函数调用" << endl; } int m_Age; int* m_Height; }; void test01() { Person p1(18, 180); cout << "p1的年龄为：" << p1.m_Age << " 身高为：" << *p1.m_Height << endl; Person p2(p1); cout << "p2的年龄为：" << p2.m_Age << " 身高为：" << *p2.m_Height << endl; } int main() { test01(); return 0; }
6.初始化列表
作用：
C++提供了初始化列表，用来初始化属性
语法：
构造函数(): 属性1(值1) , 属性2(值2) , 属性3(值3)...{}
#includeusing namespace std; //初始化列表 //初始化属性 //语法： 构造函数():属性1(值1),属性2(值2),...{} 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(); return 0; }
传统的赋值初始化是相当于----先声明类，在做赋值操作
初始化列表相当于----直接声明一个有初始值的类型，省略了赋值操作
在大型项目中，class类中的成员变量极多的情况下，初始化列表效率极高
7.类对象作为类成员
C++中类的成员也可以是另一个类的对象
例如：
class A{};
class B
{
A a;
};
B类中有对象A作为成员，A为对象成员
那么当创建对象B时，A与B的构造和析构顺序是什么？
#include#include using namespace std; //类对象作为类成员 //C++类中的成员可以是另一个类的对象，我们称该成员为对象成员 //当其他类对象作为本类成员，构造时先构造类对象，在构造自身，析构的顺序？ //析构的顺序与构造的顺序相反 class Phone { public: Phone(string pName) { m_PName = pName; cout << "Phone的构造函数调用" << endl; } ~Phone() { cout << "Phone的构造函数调用" << endl; } string m_PName; }; class Person { public: //Phone m_Phone = pName 隐式转换法 Person(string name,string pName):m_Name(name),m_Phone(pName) { cout << "Person的构造函数调用" << endl; } ~Person() { cout<< "Person的析构函数调用" << endl; } //姓名 string m_Name; //手机 Phone m_Phone; }; void test01() { Person p("zhangsan", "iPhone 13 Pro Max"); cout << p.m_Name << " use " << p.m_Phone.m_PName << endl; } int main() { test01(); return 0; }
8.静态成员
静态成员就是在成员变量或成员函数前加上关键字 static，称为静态成员
静态成员分为：
·静态成员变量
所有对象共享同一份数据
在编译阶段分配内存
类内声明，类外初始化
·静态成员函数
所有对象共享同一个函数
静态成员函数只能访问静态成员变量
#includeusing namespace std; //静态成员变量 class Person { public: //所有对象都共享同一份数据 //编译阶段就分配内存 //类内声明，类外初始化操作 static int m_A;//类内声明 //静态成员变量也有访问权限 private: static int m_B; }; int Person::m_A = 100; int Person::m_B = 300; void test01() { Person p; cout << p.m_A << endl; Person p2; p2.m_A = 200; cout << p2.m_A << endl; cout << p.m_A << endl; } void test02() { //静态成员变量 不属于某个对象上 所有对象都共享同一份数据 //因此静态成员变量有两种访问方式 //1、通过对象进行访问 Person p; cout << p.m_A << endl; //2、通过类名进行访问 cout << Person::m_A << endl; //cout << Person::m_B; << endl;类外访问不到私有的静态变量 } int main() { //test01(); test02(); return 0; }
#includeusing namespace std; //静态成员函数 //所有对象共享一个函数 //静态成员函数只能访问静态成员变量 class Person { public: static void func() { m_A = 100;//静态成员函数可以访问 静态成员变量 //m_B = 200;//静态成员变量 不可以访问 非静态成员变量 cout << "static void func调用" << endl; } static int m_A;//静态成员变量 int m_B;//非静态成员变量 private: static void func2() { cout << "static func2()的调用 " << endl; } }; int Person::m_A = 0; void test01() { //1、通过对象来访问 Person p; p.func(); //2、通过类名来进行访问 Person::func(); //Person::func2();类外访问不到私有静态函数 } int main() { test01(); return 0; }
9.成员变量和成员函数分开存储
在C++中，类内的成员变量和成员函数分开存储
只有非静态成员变量才属于类的对象上
#includeusing namespace std; //成员变量和成员函数分开存储 //在C++中，类内的成员变量和成员函数分开存储 //只有非静态成员变量才属于类的对象上 class Person { int m_A;//非静态成员变量 static int m_B; //静态成员变量 不属于类的对象上 void func(){} //非静态成员函数 不属于类的对象上 static void func(){} //静态成员函数 不属于类的对象上 }; int Person::m_B = 0; void test01() { Person p; //空对象占用内存空间为：1 //C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置 //每个空对象也应该有一个独一无二的内存地址 cout << "size of p = " << sizeof(p) << endl; } void test02() { Person p; cout << "size of p = " << sizeof(p) << endl; } int main() { //test01(); test02(); return 0; }
10.this指针
通过上一节的学习我们知道了成员变量和成员函数是分开存储的
每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一段代码
那么问题是：这一块代码是如何区分是哪个对象调用它的呢？
C++通过提供特殊的对象指针，this指针，解决上述问题
this指针指向被调用的成员函数所属的对象
this指针是隐含在每一个非静态成员函数内的一种指针
this指针不需要定义，直接使用即可
this指针的用途：
1.当形参变量与成员变量重名时，可以用this指针区分
2.在类的非静态成员函数中返回对象本身，可以用 return * this
#includeusing namespace std; class Person { public: Person(int age) { //this 指针指向被调用的成员函数的所属的对象 this->age = age; } //用引用的方式返回，返回类型为Person&，即返回对象本体 Person& PersonAddAge(Person& p)//链式调用 { this->age += p.age; //this指向的是p2的指针，*this指向的是p2这个本体 return *this; } int age; }; //1、解决名称冲突问题 void test01() { Person p1(18); cout << "p1 age = " << p1.age << endl; } //2、返回对象本身用*this void test02() { Person p1(10); Person p2(10); //链式编程思想 p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1); cout << "p2.age = " << p2.age << endl; } int main() { test02(); return 0; } //this指针指向被调用的成员函数所属的对象 //this指针式隐含在每一个非静态成员函数内的一种指针 //this指针不需要定义，直接使用即可 //用途： //·当形参和成员变量同名时，可以用this 指针区分 //·在类的非静态成员函数中返回对象本身，可使用return*this、以引用的方式返回
11.空指针访问成员函数
C++中空指针也可以访问成员函数，但是要注意有没有用到this指针
如果用到this指针，需要加以判断保证代码的健壮性
#includeusing namespace std; //空指针调用成员函数 class Person { public: void showClassName() { cout << "This is Person class" << endl; } void showPersonAge() { //报错的原因是传入的指针为NULL if (this == NULL)return;//加这一行代码防止出错 cout << "age = " << m_Age << endl; } int m_Age; }; void test01() { Person* p = NULL; //p->showClassName(); p->showPersonAge(); } int main() { test01(); return 0; }
12.const修饰成员函数
常函数：
成员函数后加const后我们称这个函数为常函数
常函数内不可修饰成员属性
成员属性声明时加关键字mutable后，在常函数中依然可以修改
常对象：
声明对象时加const称该对象为常对象
常对象只能调用常函数
#includeusing namespace std; //常函数 class Person { public: //this指针的本质 是指针常量 指针的指向是不可以修改的 //Person * const this; //在成员函数后面加const ，修饰的是this 指向 让指针指向的值也不可以修改 //const Person * const this void showPerson() const { //his->m_A = 1000; this->m_B = 1000; //this->NULL; } void func() { } int m_A; mutable int m_B;//特殊变量，即使在常函数中，也可以修改这个值 }; void test01() { Person p; p.showPerson(); } //常对象 void test02() { const Person p;//在对象前加const，变为常对象 //p.m_A = 100;error p.m_B = 1000;//mutable 在常对象里也可以修改 //常对象只能调用常函数 p.showPerson(); //p.func(); }
