C++【类和对象】（友元、内部类与匿名对象）
1.友元
- 友元提供了⼀种突破类访问限定符封装的方式，友元分为：友元函数和友元类，在函数声明或者类声明的前面加friend，并且把友元声明放到⼀个类的里面。
- 外部友元函数可访问类的私有和保护成员，友元函数仅仅是⼀种声明，他不是类的成员函数。
- 友元函数可以在类定义的任何地方声明，不受类访问限定符限制。
- ⼀个函数可以是多个类的友元函数。
#include<iostream>
using namespace std;
//编译器有个原则，用任何的类型/变量，都是要向上找
// 所以必须要前置声明，否则A的友元函数声明时编译器不认识B
class B;
class A
{
// 友元声明
friend void func(const A& aa, const B& bb);
private:
int _a1 = 1;
int _a2 = 2;
};
class B
{
// 友元声明
friend void func(const A& aa, const B& bb);
private:
int _b1 = 3;
int _b2 = 4;
};
void func(const A& aa, const B& bb)
{
cout << aa._a1 << ' ' << aa._a2 << endl;
cout << bb._b1 << ' ' << bb._b2 << endl;
}
int main()
{
A aa;
B bb;
func(aa, bb);
return 0;
}
- 友元类中的成员函数都可以是另⼀个类的友元函数，都可以访问另⼀个类中的私有和保护成员。
#include<iostream>
using namespace std;
class A
{
friend class B;
private:
int _a1 = 1;
int _a2 = 2;
};
class B
{
public:
void func1(const A& aa)
{
cout << aa._a1 << endl;
cout << _b1 << endl;
}
void func2(const A& aa)
{
cout << aa._a2 << endl;
cout << _b2 << endl;
}
private:
int _b1 = 3;
int _b2 = 4;
};
int main()
{
A aa;
B bb;
bb.func1(aa);
bb.func1(aa);
return 0;
}
-
友元类的关系是单向的，不具有交换性，比如A类是B类的友元，但是B类不是A类的友元。
-
友元类关系不能传递，如果A是B的友元，B是C的友元，但是A不是C的友元。
-
有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。
2.内部类
- 如果⼀个类定义在另⼀个类的内部，这个类就叫做内部类。内部类是⼀个独立的类，跟定义在全局相比，他只是受外部类类域限制和访问限定符限制，所以外部类定义的对象中不包含内部类。
#include<iostream>
using namespace std;
class A
{
//如果是私有限定符，那么就无法在类外定义类B
public:
//class B 并不是A的成员
class B
{
public:
void func()
{
cout << _b1 << ' ' << _b2 << endl;
}
private:
int _b1 = 1;
int _b2 = 2;
};
};
}
- 内部类默认是外部类的友元类。
#include<iostream>
using namespace std;
class A
{
static int _k;
int _a1 = 3;
//如果是私有限定符，那么就无法在类外定义类B
public:
class B
{
public:
void func(const A& aa) // B默认就是A的友元
{
cout << _k << endl;
cout << aa._a1 << endl;
}
private:
int _b1 = 1;
int _b2 = 2;
};
};
int A::_k = 0;
- 内部类本质也是⼀种封装，当A类跟B类紧密关联，A类实现出来主要就是给B类使用，那么可以考虑把A类设计为B的内部类，如果放到private/protected位置，那么A类就是B类的专属内部类，其他地方都用不了。
3.匿名对象
- 用类型(实参)定义出来的对象叫做匿名对象，相比之前我们定义的类型对象名(实参)定义出来的叫有名对象
- 匿名对象生命周期只在当前一行，一般临时定义一个对象当前用一下即可，就可以定义匿名对象。
#include<iostream>
using namespace std;
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(1);
A aa2(2);
// 匿名对象在这样场景下就很好⽤，当然还有⼀些其他使⽤场景，这个我们以后遇到了再说
Solution().Sum_Solution(10);
return 0;
}
结语
这次的分享就到这里结束了~
最后感谢您能阅读完此片文章~
如果您认为这篇文章对你有帮助的话，可以用你们的手点一个免费的赞并收藏起来哟~
如果有任何建议或纠正欢迎在评论区留言~
也可以前往我的主页看更多好文哦(点击此处跳转到主页)。
原文地址：https://blog.csdn.net/2301_80216111/article/details/142703813
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！