【C++航海王：追寻罗杰的编程之路】类与对象你学会了吗？(下)

02-26 1034阅读

1 -> 再谈构造函数
- 1.1 -> 构造函数体赋值
- 1.2 -> 初始化列表
- 1.3 -> explicit关键字
- 2 -> static成员
- - 2.1 -> 概念
  - 2.2 -> 特性
  - 3 -> 友元
  - - 3.1 -> 友元函数
    - 3.2 -> 友元类
    - 4 -> 内部类
    - 5 -> 匿名对象
    - 6 -> 拷贝对象时的一些编译器优化
      
      1 -> 再谈构造函数
      
      1.1 -> 构造函数体赋值
      
      在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。
```
#include 
using namespace std;
class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
```
      虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。
      
      1.2 -> 初始化列表
      
      初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。
```
#include 
using namespace std;
class Date
{
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};
```
      【注意】
      1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)；
      2. 类中包含以下成员，必须放在初始化列表位置进行初始化：
        引用成员变量；
        const成员变量；
        自定义类型成员(且该类没有默认构造函数时)。
```
#include 
using namespace std;
class A
{
public:
	A(int a)
		:_a(a)
	{}
private:
	int _a;
};
class B
{
public:
	B(int a, int ref)
		:_aobj(a)
		, _ref(ref)
		, _n(10)
	{}
private:
	A _aobj;
	int& _ref;
	const int _n; 
};
```
      1. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化；
```
#include 
using namespace std;
class Time
{
public:
	Time(int hour = 0)
		:_hour(hour)
	{
		cout 
public:
	Date(int day)
	{}
private:
	int _day;
	Time _t;
};
int main()
{
	Date d(1);
	return 0;
}

public:
	// 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
 // explicit修饰构造函数，禁止类型转换——explicit去掉之后，代码可以通过编译
	explicit Date(int year)
		:_year(year)
	{}
	/*
	// 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具有类型转换作用
	// explicit修饰构造函数，禁止类型转换
	explicit Date(int year, int month = 1, int day = 1)
	: _year(year)
	, _month(month)
	, _day(day)
	{}
	*/
	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};
void Test()
{
	Date d1(2022);
	// 用一个整形变量给日期类型对象赋值
	// 实际编译器背后会用2023构造一个无名对象，最后用无名对象给d1对象进行赋值
	d1 = 2023;
	// 将1屏蔽掉，2放开时则编译失败，因为explicit修饰构造函数，禁止了单参构造函数类型转换的作用
}
```
      p上述代码可读性不是很好，用explicit修饰构造函数，将会禁止构造函数的隐式转换。/p h22 -> static成员
      2.1 -> 概念
      
      声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化。
      
      2.2 -> 特性
      1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区；
      2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明；
      3. 类静态成员即可用类名::静态成员或者对象.静态成员来访问；
      4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员；
      5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制。
      3 -> 友元
      
      友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。
      
      友元分为：友元函数和友元类。
      
      3.1 -> 友元函数
      
      现在尝试去重载operator public: Date(int year, int month, int day) : _year(year) , _month(month) , _day(day) {} // d1 _cout friend ostream& operator} private: int _year; int _month; int _day; }; ostream& operator _cout _cin d._year; _cin d._month; _cin d._day; return _cin; } int main() { Date d; cin d; cout friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量 public: Time(int hour = 0, int minute = 0, int second = 0) : _hour(hour) , _minute(minute) , _second(second) {} private: int _hour; int _minute; int _second; }; class Date { public: Date(int year = 2024, int month = 1, int day = 1) : _year(year) , _month(month) , _day(day) {} void SetTimeOfDate(int hour, int minute, int second) { // 直接访问时间类私有的成员变量 _t._hour = hour; _t._minute = minute; _t._second = second; } private: int _year; int _month; int _day; Time _t; }; private: static int k; int h; public: class B // B天生就是A的友元 { public: void foo(const A& a) { cout A::B b; b.foo(A()); return 0; } public: A(int a = 0) :_a(a) { cout cout public: int Sum_Solution(int n) { return n; } }; int main() { A aa1; // 不能这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义 // A aa1(); // 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字， // 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数 A(); A aa2(2); // 匿名对象在这样场景下就很好用，当然还有一些其他使用场景 Solution().Sum_Solution(10); return 0; } public: A(int a = 0) :_a(a) { cout cout cout _a = aa._a; } return *this; } ~A() { cout } A f2() { A aa; return aa; } int main() { // 传值传参 A aa1; f1(aa1); cout