欢迎来到CILMY23的博客

🏆本篇主题为： 类的新成员：static成员和类的好朋友：友元

🏆个人主页：CILMY23-CSDN博客

🏆系列专栏：Python | C++ | C语言 | 数据结构与算法 | 贪心算法 | Linux

🏆感谢观看，支持的可以给个一键三连，点赞关注+收藏。

---

✨写在前头：

这么长时间，我们终于把构造函数的内容解决了，初始化列表，默认构造函数，构造函数和析构函数的顺序，全缺省的默认构造函数都值得我们细细品味，本期将接触类和对象中新的部分，static成员和类的好朋友：友元

---

static成员

1.1  static成员的引入

之前我们学过了构造函数的顺序，我们来看看以下代码：

int n = 0;

class A
{
public:
	A()
	{
		++n;
	}

	A(const A& a)
	{
		++n;
	}
private:
};

A Func()
{
	A aa;
	return aa;
}

int main()
{
	A aa1;
	A aa2;
	Func();

	cout << n << endl;
	return 0;
}

稍微分析一下我们就会发现，这是四次的创建，但是有的编译器会优化，可能就是三次，但是不影响我们这里的讨论。如果我们把int n 从全局放到类里面，我们要如何增加次数呢？于是C++里提供了static成员。 

1.2  static成员的概念

在C++中，static关键字在类的中用于声明静态成员。静态成员可以是静态成员变量（也叫静态数据成员）或静态成员函数。静态成员是类的一部分，但它们不是类的对象的一部分，属于所有对象，属于所有类。

 ◼️例如：静态成员变量如下

class A
{
public:
	A()
	{
		++n;
	}

	A(const A& a)
	{
		++n;
	}
private:
	//静态成员是类的一部分，但它们不是类的对象的一部分，属于所有对象,属于整个类
	//声明
	static int n;
};

//定义,类中的全局变量
int A::n = 0;

A Func()
{
	A aa;
	return aa;
}

int main()
{
	A aa1;
	A aa2;
	Func();
	return 0;
}

1.3  static成员变量的访问

第一种： 通过类域访问，将private改为public，放开访问权限。

 第二种：提供公有的函数GetN，用来获取私有的成员变量

1.4  static静态成员函数

在上述访问中，如果我们将成员函数GetN加上static，它就变成了静态的成员函数。

class A
{
public:
	A()
	{
		++n;
	}

	A(const A& a)
	{
		++n;
	}
	//static 成员函数没有this指针
	static int GetN()
	{
		//a++ 不能访问其他的
		return n;
	}

private:
	int a;
	static int n;
};

//定义,类中的全局变量
int A::n = 0;

A Func()
{
	A aa;
	return aa;
}

int main()
{
	A aa1;
	A aa2;
	Func();

	cout << aa1.GetN() << endl;
	cout << A::GetN() << endl;

	return 0;
}

注意：静态成员函数没有this指针 ，它也不能访问非静态成员

1.5  static静态成员的特点 

1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
3. 类静态成员即可用  类名::静态成员  或者  对象.静态成员  来访问
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

两个问题： 

1. 静态成员函数可以调用非静态成员函数吗？

答：静态成员函数不能直接调用非静态成员函数。静态成员函数是属于类的，而非静态成员函数是属于类的某个特定对象的。因为静态成员函数在调用时不依赖于类的任何特定对象，它没有this指针，所以它不能直接调用那些依赖于特定对象（即需要通过this指针访问的）的非静态成员函数。

2. 非静态成员函数可以调用类的静态成员函数吗？

 答：非静态成员函数可以调用类的静态成员函数。因为静态成员函数不依赖于类的具体实例，所以它们可以被类的任何成员函数调用，无论是静态的还是非静态的。在非静态成员函数中调用静态成员函数不需要特定的对象实例，可以直接调用。

友元 

前言：

 在前几篇中，我们就涉及过了友元，无论是在写日期计算器（链接），还是在写赋值运算符重载（链接）的时候，友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

2.1 友元概念

 友元（Friend）是C++中的一个关键概念，它允许某些特定的外部函数或类访问另一个类的私有（private）或保护（protected）成员。友元破坏了类的封装性，但在某些情况下能提供方便的访问方式。友元又分为：友元函数和友元类

1. 友元函数： 当某个函数被声明为一个类的友元时，这个函数就可以访问该类的所有成员，包括私有和保护成员。友元函数不是类的成员函数，它可以是任何普通函数，甚至可以是另一个类中的成员函数。

2. 友元类： 如果一个类被声明为另一个类的友元，那么这个友元类的所有成员函数都可以访问另一个类的私有和保护成员。这种关系在两个密切相关的类之间非常有用，例如，在实现某些设计模式时。

 2.2 友元函数

 在之前我们实现日期计算器的时候，重载operator<<，然后发现没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以要将operator<<重载成全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决，operator>>同理。

友元函数：

 

//Date.h
//用户输出
ostream& operator<<(ostream& out,const Date& d);
//用户输入
istream& operator>>(istream& in, Date& d);

//Date.cpp
ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "天" << endl;
	return out;
}

istream& operator>>(istream& in, Date& d)
{
	
	while (1)
	{
		cout << "请输入对应的年月日" << endl;
		in >> d._year
			>> d._month
			>> d._day;
		if (!d.CheckInvalid())
		{
			cout << "日期输入错误，请重新输入" << endl;
		}
		else
		{
			break;
		}
	}
 
	return in;
}

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在 类的内部声明，声明时需要加friend关键字。 

友元函数的特点：

• 友元函数可访问类的私有和保护成员，但不是类的成员函数
• 友元函数不能用const修饰
• 友元函数可以在类定义的任何地方声明，不受类访问限定符限制
• 一个函数可以是多个类的友元函数
• 友元函数的调用与普通函数的调用原理相同 

2.3 友元类 

 比较亲近的两种类，例如日期类和时间类，例如：

class Time
{
	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 = 1900, 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;
};

友元类的特点：

#️⃣友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

1️⃣友元关系是单向的，不具有交换性。
比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。

2️⃣友元关系不能传递
如果C是B的友元， B是A的友元，则不能说明C时A的友元。

3️⃣友元关系不能继承

---

💡总结

1️⃣ 静态成员是类的一部分，但它们不是类的对象的一部分，属于所有对象，属于所有类。

2️⃣ 静态成员函数没有this指针 ，它也不能访问非静态成员

3️⃣ 友元还是要慎用，因为它突破了封装，提供了一个“后门”

4️⃣友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。 

5️⃣友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

6️⃣友元关系是单向的，不具有交换性，友元关系不能传递也不能继承 

---

感谢各位同伴的支持，本期C++就讲解到这啦，如果你觉得写的不错的话，可以给个一键三连，点赞，关注+收藏，若有不足，欢迎各位在评论区讨论。