IT评测·应用市场-qidao123.com

标题: c++ 类和对象 —— 下 【复习总结】 [打印本页]
作者: 惊落一身雪    时间: 2025-3-19 06:19
标题: c++ 类和对象 —— 下 【复习总结】
1. 深入构造函数

1.1 函数体赋值

前文我们提到，创建对象时，编译器会调用构造函数给成员变量赋值。但这并不能称为对对象中成员变量的初始化。由于初始化只能初始化一次，但构造函数体内可以多次赋值。构造函数体中语句只能称为赋初值
那么，成员变量初始化的地方在那里？我们不得不引入一个知识：初始化列表
1.2 初始化列表

初始化列表：冒号开始，接着是逗号分隔的成员列表，每个“成员变量”后跟一个放括号中的初始值或表达式
  1. class Date
  2. {
  3. private:
  4.         int _year;
  5.         int _month;
  6.         int _day;
  8. public:
  9.         Date(int year, int month, int day)
  10.                 //初始列表
  11.                 :_year(year)
  12.                 ,_month(month)
  13.                 ,_day(day)
  15.            //函数体赋值
  16.            {}
  17. };
复制代码
留意事项：
1. 每个成员变量在初始化列表最多出现一次（即只能初始化一次）
2. 类中包罗：a.引用成员变量 b.const成员变量 c. 自界说成员函数（且该类没有默认构造函数）
（a 和 b 是由于要求在界说时必须初始化；c 是由于会主动调用它的默认构造函数）
3. 只管使用初始化列表初始化，对于自界说类型成员变量，一定会先使用初始化列表初始化
4. 成员变量在类中声明次序是其在初始化列表中的初始化次序，和它在初始化列表的先后次序无关
  1. class A
  2. {
  3. private:
  4.         int _a;
  5. public:
  6.         A(int a)
  7.                 : _a(a)
  8.         {}
  9. };
  11. class B
  12. {
  13. private:
  14.         A _ao;   //没有默认构造函数
  15.         int& _ret; //引用
  16.         const int _n; //const
  17. public:
  18.         B(int a, int ret)
  19.                 :_ao(a)
  20.                 ,_ret(ret)
  21.                 ,_n(10)
  22.         {}
  23. };
复制代码
1.3 explicit关键字

对于担当单个参数的构造函数，还有类型转换的作用。
担当单个参数的构造函数：
1. 构造函数只有一个参数
2. 构造函数有多个参数，除第一个参数没默认值，其他参数都有默认值
3 .全缺省构造函数
但用explicit修饰构造函数，会克制构造函数的隐式转换
  1. class Date
  2. {
  3. private:
  4.         int _year;
  5.         int _month;
  6.         int _day;
  7. public:
  8.         //单参数构造函数，有类型转换的作用
  9.         //用explicit修饰，禁止类型转换
  10.         explicit Date(int year)
  11.                 :_year(year)
  12.         {}
  14.         //有两个缺省参数，相当于单个参数
  15.         explicit Date(int year, int month=1, int day=1)
  16.                 :_year(year)
  17.                 ,_month(month)
  18.                 ,_day(day)
  19.                 {}
  20. };
复制代码
2. static成员

声明为static的类成员为类的静态成员，修饰成员变量称为静态成员变量；修饰成员函数称为静态成员函数。静态成员变量必须在类外初始化
特性：
1. 静态成员为所有类对象共享，存放在静态区
2. 静态成员变量必须在类外界说，类中只是声明，界说不加static关键字
3. 静态成员用 类名：：静态成员 或者 对象.静态成员 访问
4. 静态成员函数没有隐蔽的this指针，不能访问任何非静态成员
5.静态成员也是类的成员，受到访问限定符的限制
3. 友元

友元可以突破类封装的限制。但友元会增长耦合度，粉碎封装，不宜多用
友元：友元函数和友元类
3.1 友元函数

友元函数可以直接访问类的私有成员，它是界说在类外部的普通函数，需要在类的内部声明，声明时要加friend关键字
留意事项：
1. 友元函数不是类的成员函数，只是可以访问类的私有和掩护成员
2. 友元函数不能用const修饰
3. 友元函数可以在类界说的任何位置声明，不受访问限定符的限制
4. 一个函数可以是多个函数的友元函数
5. 友元函数的调用和普通函数调用相同
实用场景：
  1. //如果想重载operator<<，但无法重载为类成员函数。
  2. //this指针默认是第一个参数也就是左操作数了。
  3. //但是实际使用中cout需要是第一个形参对象，所以要将operator << 重载成全局函数。
  4. // 但类外没办法访问成员，此时就需要友元来解决。operator >> 同理
  5. class Date
  6. {
  7.     friend ostream& operator<<(ostream& _cout, const Date& d);
  8.     friend istream& operator>>(istream& _cin, Date& d);
  9. public:
  10.     Date(int year = 2025, int month = 1, int day = 1)
  11.         : _year(year)
  12.         , _month(month)
  13.         , _day(day)
  14.     {}
  16. private:
  17.     int _year;
  18.     int _month;
  19.     int _day;
  20. };
  21. ostream& operator<<(ostream& _cout, const Date& d)
  22. {
  23.     _cout << d._year << "-" << d._month << "-" << d._day;
  24.     return _cout;
  25. }
  26. istream& operator>>(istream& _cin, Date& d)
  27. {
  28.     _cin >> d._year;
  29.     _cin >> d._month;
  30.     _cin >> d._day;
  31.     return _cin;
  32. }
复制代码
3.2 友元类

友元类的所有成员函数都可以是另一个类的友元函数，可以访问另一个类的成员
留意事项：
1. 友元关系单向，不具有交互性
2. 友元关系不能转达
3. 友元关系不能继承
  1. class Time
  2. {
  3. //声明日期类为时间类的友元类，在日期类中可以直接访问Time类的私有成员变量
  4. friend class Date;
  5. public:
  6.     Time(int hour = 0, int minute = 0, int second = 0)
  7.         : _hour(hour)
  8.         , _minute(minute)
  9.         , _second(second)
  10.     {}
  12. private:
  13.     int _hour;
  14.     int _minute;
  15.     int _second;
  16. };
  18. class Date
  19. {
  20. public:
  21.     Date(int year = 2025, int month = 1, int day = 1)
  22.         :_year(year)
  23.         , _month(month)
  24.         , _day(day)
  25.     {}
  27.     void SetTimeOfDate(int hour, int minute, int second)
  28.     {
  29.         // 直接访问时间类私有的成员变量
  30.         _t._hour = hour;
  31.         _t._minute = minute;
  32.         _t._second = second;
  33.     }
  35. private:
  36.     int _year;
  37.     int _month;
  38.     int _day;
  40.     Time _t;
  41. };
复制代码
4. 内部类

一个类界说在另一个类的内部，这个内部的类就叫内部类。
它不属于外部类，不能通过外部类的对象去访问内部类的成员（外部类对内部类没有任何超越的访问权限），但内部类是外部类的友元类，内部类可以通过外部类对象参数访问外部类中所有成员。
留意事项：
1. 内部类可以界说在外部类的任意地方（犹如友元）
2. 内部类可以直接访问外部类的static成员，不需要外部类的对象/类名
3. sizeof（外部类）= 外部类，相当于内部类不存储在外部类
  1. class A
  2. {
  3. private:
  4.         static int a;
  5.         int b;
  6. public:
  7.         // B是A的友元
  8.         class B
  9.         {
  10.         public:
  11.                 void fun(const A& i)
  12.                 {
  13.                         //不用外部类的对象
  14.                         cout << a << endl;
  15.                         cout << i.b << endl;
  16.                 }
  17.         };
  18. };
  19. int A::a = 1;
复制代码


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 IT评测·应用市场-qidao123.com (https://dis.qidao123.com/) Powered by Discuz! X3.4