(C++) 类和对象 (三) 静态成员变量 静态成员函数 友元 匿名对象 内部类

承接上文：
https://blog.csdn.net/m0_71914032/article/details/136657179

# 1 静态成员

类中的成员变量与成员函数都可以有static前缀。

大体与以前一致，
只不过是受到了类的域作用限定符与访问限定符的限制，变成了这个类独有的变量与函数，
本质上还是属于全局。

# 1.1 静态成员变量

作为属于全局的变量，当然不能在每个对象中重复定义。
所以静态成员变量就是该类的所有对象公有的一个变量。

static
因为静态成员变量属于整个类，而不是某一个对象，
所以静态成员变量是不走初始化列表的，也不能在声明时给缺省值。

既然不走初始化列表，那么在哪里定义？
答案是类外，一般写在全局。
必须在类外定义，此时不需要加static，要在前面加上类名和域作用限定符。
如：

class Date 
{
public:
	Date(int year = 2024, int month = 1, int day = 1)
	{
		++count;
	}

//private:
	int _year;
	int _month;
	int _day;

	static int count;
};

int Date::count = 0;

int main()
{
	Date d1;
	cout << d1.count << endl;

	Date d2;
	cout << d2.count << endl;

	return 0;
}

从上述代码也可以看出，虽然静态成员变量不属于某一个单独的对象，但是依然可以通过取对象成员变量的方式来找到。

因为是静态的，所以静态成员变量并不会增加类类型的大小。

# 1.2 静态成员函数

我们都知道成员函数都隐含着一个this指针。
这意味着如果要调用成员函数，必须通过一个对象，这样this指针才有的接收。

如果在函数前面加上static，
让这个成员函数变成全局的，那么自然没有this指针了。
即不需要对象也可以直接调用该函数。

当然，同样可以在有对象的情况下调用，就和普通的成员函数一样。
不过由于没有this指针，这样做并没有什么意义。

# 2 友元

关键词friend
具体分为友元函数与友元类。
顾名思义，友元函数和友元类的意义在于跨过访问限定符的限制，
使得该函数，或者该类可以访问私有成员。

# 2.1 友元函数

对于定义在全局或者其他类内的函数，
若想要直接访问另一个类的私有成员变量，就得定义成友元函数，
具体操作为在类内部多加一句该函数的声明，前面再加上关键词friend。

class Date
{
public:
	Date(int year = 2024, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

private:
	int _year;
	int _month;
	int _day;

	friend void Print(Date& d1);
};

void Print(Date& d1)
{
	cout << d1._year << endl;
	cout << d1._month << endl;
	cout << d1._day << endl;
}

int main()
{
	Date d1;
	Print(d1);

	return 0;
}

Print是全局的函数，写成友元之后，就可以访问Date私有的成员。
这个含有带有friend的声明，放在私有和公有里没有区别。
不过一般是像大部分成员函数一样，放在公有里。

# 2.2 友元类

同样，如果想要A类可以访问B类的私有，
就可以把A类的声明写进B类，前面加上关键词friend。

这种关系是单向的。
即A类可以访问B类的私有，但是B类不能访问A类的私有。

友元类也不能传递。

# 3 杂项

剩下的不太好分类，也是比较零散的点，提一嘴。

# 3.1 匿名对象

一种C++支持的写法，创建一个临时的对象。
这个临时对象的生命周期只在创建的这一行，
一旦代码执行到下一行，这个临时对象就会被销毁。

class Date
{
public:
	Date(int year = 2024, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Print()
	{
		cout << _year << ' ';
		cout << _month << ' ';
		cout << _day << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	// 正常创建对象
	Date d1;
	d1.Print();

	// 创建匿名对象
	// 通过匿名对象调用函数
	Date().Print();

	return 0;
}

# 3.2 内部类

除了内置类型，类的成员变量当然也可以是类类型。

在A类内部包含B类，就把B叫做是A的内部类。

// 需注意，B作为A的内部类，定义要写在A类的上面
class B
{
public:
	B(int y = 2)
	{
		_y = y;
	}

	void Print()
	{
		cout << _y << endl;
	}
private:
	int _y;
};

class A 
{
public:
	A()
		:_x(1)
	{
		;
	}

	void Print()
	{
		cout << _x << endl;
		_b.Print();
	}
private:
	int _x;
	B _b;
};

int main()
{
	A a;
	a.Print();

	return 0;
}

虽然B类是A类的成员，
但A类的大小并不包括B。

B相当于一个外部的普通类，只是受A的类域和访问限定符限制。
同时，B天生就是A的友元。

# 3.3 优化

为了提高效率，许多编译器都会对代码进行优化，
具体不尽相同，很难一一列举。
这里提一个大部分编译器都有，针对构造与拷贝构造的简易优化。

在同一个表达式当中，如果出现如下三种情况：

a.构造+构造；
b.构造+拷贝构造；
c.拷贝构造+拷贝构造；

那么编译器会将其合二为一。
优化为：

a.一次构造
b.一次构造
c.一次拷贝构造

class A
{
public:
	A(int a = 0)
	{
		// 用于标志调用了构造函数
		cout << "构造" << endl;
	}

	A(A& a)
	{
		//用于标志调用了拷贝构造
		cout << "拷贝构造" << endl;
	}

private:
	int _a;
};

void Func(A aa)
{
	;
}

int main()
{
	// 这里是一次构造
	A a1 = 1;
	// 与一次拷贝构造
	Func(a1);
	
	// 写在同一行，就会被优化为一次构造
	Func(1);
}