💖作者：小树苗渴望变成参天大树
❤️‍🩹作者宣言：认真写好每一篇博客
💨作者gitee:gitee
💞作者专栏：C语言,数据结构初阶,Linux,C++

在这里插入图片描述如果你喜欢作者的文章，就给作者点点关注吧！

文章目录

前言
一、友元（friend）
- 1.1友元函数
- 1.2友元类
二、内部类
三、匿名对象
四、拷贝对象时的一些编译器优化
五、总结

前言

今天我们再来重新认识一下友元，友元就像朋友，使用了友元，你就可以随便来我家里做客，访问类里面私有的东西，相当于开了挂，我们在来回顾一下

一、友元（friend）

1.1友元函数

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

class Date
{
public:
Date(int year, int month, int day)
     : _year(year)
     , _month(month)
     , _day(day)
 {}
// d1 << cout; -> d1.operator<<(&d1, cout); 不符合常规调用
// 因为成员函数第一个参数一定是隐藏的this，所以d1必须放在<<的左侧
ostream& operator<<(ostream& _cout)
 {
     _cout << _year << "-" << _month << "-" << _day << endl;
     return _cout;
 }
private:
int _year;
int _month;
int _day;
};

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

class Date
{
 friend ostream& operator<<(ostream& _cout, const Date& d);
 friend istream& operator>>(istream& _cin, Date& d);
public:
 Date(int year = 1900, int month = 1, int day = 1)
 : _year(year)
 , _month(month)
 , _day(day)
 {}
private:
 int _year;
 int _month;
 int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
 _cout << d._year << "-" << d._month << "-" << d._day;
 return _cout; 
}
istream& operator>>(istream& _cin, Date& d)
{
 _cin >> d._year;
 _cin >> d._month;
 _cin >> d._day;
 return _cin;
}
int main()
{
 Date d;
 cin >> d;
 cout << d << endl;
 return 0;
}

说明：

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

1.2友元类

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

友元关系是单向的，不具有交换性。
比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
友元关系不能传递
如果C是B的友元， B是A的友元，则不能说明C时A的友元。
友元关系不能继承，在继承位置再给大家详细介绍。

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;

上述在日期类中可以访问时间类的私有成员，反过来就不行，对于友元我们知道怎么用就行了，以后用的也少，接下来讲解其他知识点

二、内部类

在这C++里面用的也比较少，在Java里面用的也比较多，但是我也简单的介绍一下

内部类简单来说就是在类里面又定义一个类

class A
{
private:
 static int k;
 int h;
public:
 class B 
 {
 private:
 int m;
 int n;
 public:
 void foo(const A& a)
 {
 cout << k << endl;//OK
 cout << a.h << endl;//OK
 }
 };
};
int A::k = 1;
int main()
{
A a;
   cout<<sizeof(a)<<endl;
    
    return 0;
}

在这里插入图片描述

我们只计算了A类中h的大小，k在静态区，不属于对象
在这里插入图片描述
我们看到只有创建了内部类对象，才算外部类的大小，==我们把内部的声明当成图纸，创建了对象才当成外部类的成员变量，这样就能很好的理解了。

那我们怎么只使用B类的内容呢？？前提是共有的，私有的就访问不了

A::B b;

这样就可以了

内部类天生就是外部类的友元函数：

class A
{
private:
	static int k;
	int h;
public:
	class B // B天生就是A的友元
	{
	private:
		int m;
		int n;
	public:
		void foo(const A& a)
		{
			cout << k << endl;//OK
			cout << a.h << endl;//OK
		}
	};
	B b;
};

我们在foo函数访问到了外部类中私有的成员变量，反过来就不行了

通过内部类我们来一下上篇博客的那题：

class Solution{
private:
static int _i;
static int _ret;
public:
class Sum
{
   public:
    Sum()
    {
       _ret+=_i;
       _i++;
    }
};
    int Sum_Solution(int n) {
        Sum a[n];
        return _ret;
    }
};
int Solution::_i=1;
int Solution::_ret=0;

不需要再写一个函数来将结果返回出来，直接进行访问就行了

三、匿名对象

匿名对象再这里我就给大家讲讲用法和一些注意事项，现在用到的也不多，以后再单例的时候会用到，那个时候再细讲一下

匿名对象顾名思义就是没有名字的对象
我们来具体看看：

class A
{
public:
 A(int a = 0)
 :_a(a)
 {
 cout << "A(int a)" << endl;
 }
 ~A()
 {
 cout << "~A()" << endl;
 }
private:
 int _a;
};

A a;
A a1(1);//这都是有名的对象

我们来具体怎么使用

A ;//对于不传参的匿名对象，我们不可能写成这样，我们只有加一个括号来区分
A();


A (1);传参的匿名对象

在这里插入图片描述
匿名对象的声明周期就再当前行，即用即销毁，匿名对象出现就把他当成只有一个使用机会的对象，对象怎么去调用函数的，他就怎么去调用。

我们再来看下面的代码：
在这里插入图片描述
我们看到这样就不行了，原因是匿名对象和临时对象都有常性，加一个const就行了

在这里插入图片描述
我们此时来看这个匿名对象的生命周期是多少：

没有即用即销毁，可以这么说引用延长了匿名对象的生命周期，可以这么简单理解，之前创建了匿名对象没人使用，就即用即销毁，现在有人用了，就延长销毁时间了

这个以后再String类的时候会用到。以后再详细介绍，这个大家会使用就行了。

四、拷贝对象时的一些编译器优化

再介绍explicit关键字的时候，这个关键字是防止隐式类型转换，隐式类型转换是将一个整型先构造一个临时变量，再拷贝构造。大家要是忘记了，可以先看看这篇博客explicit

Date d1;//最多可以传一个参数的类
d1=2023;//构造+拷贝构造

这是一条语句有这种重复的操作，编译器会进行优化变成一个操作，只会进行构造。如果这两个操作不在一条语句就不会有这种优化，接下来会通过几个例子给大家展示：
在这里插入图片描述
第一个因为不在一个语句，就没有办法进行优化。第二个匿名对象也会调用构造函数，传参会调用拷贝构造，编译器进行了优化，直接构造。

在这里插入图片描述
优化不止会发现再构造和拷贝构造中，不止会发生再拷贝构造和拷贝构造之间

我写的不一定正确，大家有问题可以提出来，写这个的目的就是想让大家知道，编译器对于重复的操作会有优化，大家了解就好了，也方便大家理解怎么调用析构函数和构造函数，不然大家去打印是调用了几次构造，不知道编译器会优化的话，总会发现少一个构造，总是对不上

大家可以去测试一下这些函数：

void f1(A aa)
{}
A f2()
{
 A aa;
 return aa;
}
int main()
{
 // 传值传参
 A aa1;
 f1(aa1);
 cout << endl;
 // 传值返回
 f2();
 cout << endl;
 // 隐式类型，连续构造+拷贝构造->优化为直接构造
 f1(1);
 // 一个表达式中，连续构造+拷贝构造->优化为一个构造
 f1(A(2));
 cout << endl;
 // 一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造
 A aa2 = f2();
 cout << endl;
 // 一个表达式中，连续拷贝构造+赋值重载->无法优化
 aa1 = f2();
 cout << endl;
 return 0;
}