C++的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置
构造函数和析构函数
对象的初始化和清理也是两个非常重要的安全问题
- 一个对象或者变量没有初始状态，对其使用后果是未知
- 使用完一个对象或变量，没有及时清理，也会造成一定的安全问题
C++利用构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象的初始化和清理工作，对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器提供的构造函数和析构函数将会是空实现
- 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用
- 析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作
构造函数语法：类名 () {}
- 没有返回值，也不写
void - 函数名称与类名相同
- 构造函数可以有参数，因此可以发生重载
- 程序在调用对象时会自动调用构造，无需手动调用，而且只会调用一次
析构函数语法：~类名 () {}
- 没有返回值，也不写void
- 函数名称与类名相同，在名称前加符号
~ - 析构函数不可以有参数，因此不可以发生重载
- 程序在对象销毁前会自动调用析构，无需手动调用，而且只会调用一次
class person { private: string name; public: person() { cout << "调用构造函数" << endl; name = "张三"; } ~person() { cout << "调用析构函数" << endl; } string getname() { return name; } }; int main() { person a1; cout << a1.getname() << endl; system("pause"); return 0; }
输出
调用构造函数 张三 请按任意键继续. . . 调用析构函数
构造函数分类及调用
两种分类方式：
- 按参数分为：无参构造（默认构造）和有参构造
- 按类型分为：普通构造和拷贝构造
三种调用方式：
- 括号法
- 显示法
- 隐式转换法
注意事项：
- 调用默认构造函数时，不要加
()，因为编译器会认为是一个函数声明，不会认为在创建对象 - 不要利用拷贝构造函数初始化匿名对象，编译器会认为时一个对象声明，会报重定义的错误
person(c1) = person c1;
//括号法 person a0;//调用默认构造函数时，不要加()，因为编译器会认为是一个函数声明 person a1("张三");//有参构造 person a2(a1);//拷贝构造 //显示法 person b1; person b2 = person("张三");//有参构造 person b3 = person(b2);//拷贝构造 person("张三");//匿名对象，当前行执行结束后，会被系统立即回收 //隐式转换法 person c1 = "张三";//会报错,暂时不知道原因 person c2 = c1;//编译器转换为person c2 = person(c1);
拷贝构造函数的调用时机
C++中拷贝构造函数调用时机：
- 使用一个已经创建完毕的对象来初始化一个新对象
- 值传递的方式给函数参数传值
- 以值方式返回局部对象
person test(person a) { return a; }; int main() { //使用一个已经创建完毕的对象来初始化一个新对象 person p1("张三"); person p2(p1); //值传递的方式给函数参数传值 test(p1); //以值方式返回局部对象 person p3 = test(p1); return 0; }
构造函数调用规则
默认情况下，C++编译器至少给一个类添加三个函数：
- 默认构造函数（无参，函数体为空）
- 默认析构函数（无参，函数体为空）
- 默认拷贝构造函数，对属性进行值拷贝
构造函数调用规则如下：
- 如果用户定义有参构造函数，C++不再提供默认无参构造，但是会提供默认拷贝构造
- 如果用户定义拷贝构造函数，C++不会再提供其他普通构造函数
class person { private: string name; public: person(const string a) { cout << "有参构造" << endl; name = a; } person(const person& a) { cout << "拷贝构造" << endl; name = a.name; } }; int main() { person p0;//没有合适的默认构造函数可用 person p1("张三"); person p2(p1); return 0; }
深拷贝与浅拷贝
深浅拷贝是面试经典问题
- 浅拷贝：简单的赋值拷贝工作
- 深拷贝：在堆区重新申请空间，进行拷贝操作
析构：将堆区开辟的数据做释放操作
浅拷贝问题：堆区内存重复释放
解决方法：自己实现一个拷贝函数，解决浅拷贝带来的问题
注意事项：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题
class person { private: string* name; public: person(const string a) { cout << "有参构造" << endl; name = new string(a); cout << *name << endl; } //深拷贝 person(const person& a) { cout << "拷贝构造" << endl; name = new string(*a.name); cout << *name << endl; } ~person() { cout << "调用析构函数" << endl; if (name != NULL) { delete name; name = NULL; } } }; int main() { person p1("张三"); person p2(p1); return 0; }
初始化列表
C++提供了初始化列表语法，用来初始化属性
语法：构造函数():属性1(值1),属性2(值2)...{}
注意冒号:在构造函数形参列表之后
class person { public: person(const string a, int b) :name(a), age(b) { cout << "初始化列表" << endl; } string name; int age; }; int main() { person p1("张三", 10); return 0; }
类对象作为类成员
C++类中的成员可以是另一个类的对象，我们称该成员为对象成员
当其他类对象作为本类成员，构造的时候先构造类对象，再构造自身，析构的顺序与构造相反
class Phone { public: Phone() { cout << "对象构造" << endl; } ~Phone() { cout << "对象析构" << endl; } string phone; }; class Person { public: Person() { cout << "本类构造" << endl; } ~Person() { cout << "本类析构" << endl; } string name; Phone phone; }; int main() { Person a; return 0; }
输出结果
对象构造 本类构造 本类析构 对象析构
静态成员
静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员
静态成员分为：
- 静态成员变量
- 所有对象共享同一份数据
- 在编译阶段分配内存（全局区）
- 类内声明，类外初始化
- 静态成员变量，不属于某个对象上，所有对象都共享同一份数据
- 静态成员函数
- 所有对象共享同一个函数
- 静态成员函数只能访问静态成员变量
- 可以访问静态成员变量：不属于某一个对象，是共享的
- 无法访问非静态成员变量：无法区分到底是哪个对象的属性
- 也是有访问权限的
静态成员变量有两种访问方式：
- 通过对象进行访问：
对象.成员变量 - 通过类名进行访问：
类名::成员变量
class Phone { public: //类内定义 static string phone; private: static string name;//静态成员变量也是有访问权限的 }; //类外初始化 string Phone::phone = "110";//通过类名访问 int main() { Phone a; a.phone = "119";//通过对象访问 cout << a.phone << endl; return 0; }
