友元提供了一种突破封装的方式,有时提供了便利。但是友元会增加耦合度,破坏了封装,所以友元不易多用 友元分为:友元函数 和 友元类。 友元关键字 :friend 可以理解为我把他看做朋友,所以他可以使用我的东西。这就是友元做到的事情是类似的,通过设置友元,在一个类中可以访问类外的函数与变量。
我们现在来实现日期类Date的流输出<<重载,那么我们来看:
class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
//这里 参数有两个 (Date* this , ostream& out )
//左右操作数不一致。
ostream& operator<<(ostream& out) {
out << _year << '-' << _month << '-' << _day << endl;
return out;
}
private:
int _year;
int _month;
int _day;
};
int main(){
Date a1(2024,2,24);
cout << a1;
return 0;
}
这样必然会出现问题,因为在成员函数中第一个参数默认为(Date* this)所以在使用<<时就会出现参数不匹配环节。
所以要想改变默认参数的顺序,就要把operator<<重载为全局函数,但是这样无法访问Date的私有变量,此时就可以通过友元来解决这个问题。来看修改后的代码
class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
friend ostream& operator<<(ostream& out, Date& d);
private:
int _year;
int _month;
int _day;
};
ostream& operator<<(ostream& out, Date& d) {
out << d._year << '-' << d._month << '-' << d._day << endl;
return out;
}
int main() {
Date a1(2024, 2, 24);
cout << a1;
return 0;
}
现在就可以顺利的使用<<重载了。
总结一下: 友元函数可以直接访问类的私有成员,它是定义在类外部的普通函数,不属于任何类,但需要在 类的内部声明,声明时需要加friend关键字。 友元声明只能出现在类定义的内部,但是类内出现的具体位置不限。友元不是类的成员也不受它所在区域访问控制级别的约束。一般来说,最好在类定义开始或结束区域集中声明友元。
注意:
友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类的非公用成员。
下面给出时间类Time 与 日期类Date 的示例,来帮助我们更好理解友元。
Time类中声明友元即可成功:
class Time
{
// 声明日期类为时间类的友元类,
//则在日期类中就直接访问Time类中的私有成员变量
friend class Date;
public:
Time(int hour = 0, int minute = 0, int second = 0)
: _hour(hour)
, _minute(minute)
, _second(second)
{}
private:
int _hour;
int _minute;
int _second;
};
如果一个类定义在另一个类的内部,这个内部类就叫做内部类。 内部类是一个独立的类,它不属于外部类,更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
注意: 内部类就是外部类友元类,内部类可以通过外部类的对象参数来访问外部类的所有成员,但是外部类不是内部类的友元。
可以把友元实现的打印日期形成内部类,也可以做到相同效果。
#include<cstdio>
#include<iostream>
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;
}
定义内部类
class Time
{
friend class Date; // 声明日期类为时间类的友元类,则在日期类中就直接访问Time类
中的私有成员变量
public:
Time(int hour = 0, int minute = 0, int second = 0)
: _hour(hour)
, _minute(minute)
, _second(second)
{}
void show(Date& d){
printf("时间是 %d年%d月%d日%d时%d分%d秒", d._year, d._month, d._day,
_hour,_minute,_second);
}
private:
int _hour;
int _minute;
int _second;
};
private:
int _year;
int _month;
int _day;
Time _t;
};
int main() {
Date d1(2024, 2, 26);
Date::Time t1(11, 26, 30);
t1.show(d1);
}
来看效果:非常好!!!
匿名对象可以帮助我们优化语句:
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
class Solution {
public:
int Sum_Solution(int n) {
//...
return n;
}
};
int main()
{
A aa1;
// 不能这么定义对象,因为编译器无法识别下面是一个函数声明,还是对象定义
//A aa1();
// 但是我们可以这么定义匿名对象,匿名对象的特点不用取名字,
// 但是他的生命周期只有这一行,我们可以看到下一行他就会自动调用析构函数
A();
A aa2(2);
// 匿名对象在这样场景下就很好用,当然还有一些其他使用场景,这个我们以后遇到了再说
Solution().Sum_Solution(10);
return 0;
}