讲一讲友元类,友元类跟派生(继承)其实还是有点像的,但是对于权限问题就有偏差了。先讲友元类吧,友元类顾名思义,也就是好朋友意思,那我好朋友之间是可以分享秘密啊什么的,所以友元类可以起到一个访问私有属性的,当然也可以访问protect属性, 在一般情况下私有属性只能被类本身自己访问的,但是为了程序的灵活啊我们就来个好朋友把它秘密给问出来!
友元类的关键字:friend
友元类分三种使用方式!
第一种:全局函数做友元类
第二种:类做友元
第三种:成员函数做友元
看图!大概的结构!
来 直接上代码!
直接对比看一下就行 思路就在图上
有个注意点! 如果不是友元但是访问了私有属性是会报错的!所以我在这里给上了批注!自己去测试一下就行了。
#include<iostream>
using namespace std;
class MyHome
{
friend void Goodfriend2(MyHome* H);
public:
MyHome()//我在这里直接赋值构造函数!
{
Bedroom = "卧室";
Kouhong = "YSL口红";
}
string Desk="坐椅子";//公有属性的成员变量!
private:
string Bedroom;//卧室
string Kouhong;//口红
};
//注意!这里的MyHome*G G也是对象!
void Goodfriend1(MyHome* G)//这是没有用友元类的时候!
{
//因为是指针,当然引用也一样,都是用-> 这个符号去访问!
cout << "好朋友1号在" << G->Desk << endl;
/*cout << "好朋友1号去了" << G->Bedroom << endl; //当没有用友元类的时候他们是不可以访问私有属性的!
cout << "好朋友1号用了我的" << G->Kouhong << endl;*/
}
//利用了友元函数!
void Goodfriend2(MyHome* H)
{
cout << "好朋友2号在" << H->Desk << endl;
cout << "好朋友2号去了" << H->Bedroom << endl;
cout << "好朋友2号用了我的" << H->Kouhong << endl;
}
int main()
{
MyHome Good;//创建对象!
//这里用引用的原因是因为参数是指针!当然可以把参数改成引用
//如果参数是引用 就可以直接Goodfrien1(Good);
Goodfriend1(&Good);
cout << "==================" << endl;
Goodfriend2(&Good);
return 0;
}
好 接下来讲下一个用法!
类做友元!
老规矩 看图!
看一下大致的结构
好 我们直接上代码对比对比!
这里唯一要讲的点就是那给实例化对象!也就是MyHome M;*
用它创建了对象但未被初始化!在这里我们需要对它初始化也就是开辟内存空间
也就是M=new MyHome; M原本是MyHome类型 new就返回MyHome类型
#include<iostream>
using namespace std;
class MyHome;
class GoodFriend1
{
public:
MyHome* M;
GoodFriend1();
void visit();
private:
string Gifts;
};
class MyHome
{
friend class GoodFriend1;
public:
MyHome()
{
Bedroom = "卧室";
Kouhong = "YSL口红";
}
string Sittingrom="客厅";//公有属性的成员变量!
private:
string Bedroom;
string Kouhong;
};
//也可在类内实现 我放到类外来单独讲
GoodFriend1::GoodFriend1()
{
//这给M是我GoodFriend里用Myhome这给类写的对象 但还没初始化现在给它初始化!
M = new MyHome;
}
void GoodFriend1::visit()
{
this->Gifts = "水果拼盘";
cout << "好朋友1号带了" << Gifts << "来造访" << endl;
cout << "好朋友1号来到" << M->Sittingrom << endl;
cout << "好朋友1号来到我的" << M->Bedroom << endl;
cout << "好朋友1号用了我的" << M->Kouhong << endl;
}
class GoodFriend2 {
public:
MyHome* H;
GoodFriend2()
{
H = new MyHome;
};
void VisitGiftss()
{
this->Giftss = "大菠萝";
cout << "好朋友2号带了" << Giftss << "来造访" << endl;
}
void visit()
{
cout << "好朋友2号来到" << H->Sittingrom << endl;
//下面是没有用友元类的我上了批注!
/*cout << "好朋友2号来到我的" << H->Bedroom << endl;
cout << "好朋友2号用了我的" << H->Kouhong << endl;*/
}
private:
string Giftss;
};
void test01()
{
GoodFriend1 G1;//创建对象!
G1.visit();//对象做的行为用点给点出来
}
void test02()
{
GoodFriend2 G2;//创建对象!
G2.VisitGiftss();//对象做的行为用点点出来
G2.visit();
}
int main()
{
cout << "用了友元类!" << endl;
test01();//调用函数!
cout << "====================================" << endl;
cout << "没有用友元类!" << endl;
test02();//调用函数!
return 0;
}
好 我们来讲最后一个!
成员函数作友元
上图直接看大概结构!
好 我们直接上代码来详细看看
这里我让visit1();给它作为友元成员函数
visit2();不作为友元成员函数来进行对比
#include<iostream>
using namespace std;
class MyHome;
class GoodFriend
{
public:
GoodFriend();
MyHome* M;
void visit1();//我让他作业友元类成员函数
void visit2();//这个不作为友元类成员函数
private:
string Gifts;
};
class MyHome
{
friend void GoodFriend::visit1();//构造友元类成员函数!跟全局函数类似
//但是!这里要特定指明是哪给类的作用域下的函数!
public:
MyHome()
{
this->Bedroom = "卧室";
this->Kouhong = "YSL口红";
}
string Sittingroom = "客厅";//共有属性下的成员变量
private:
string Bedroom;
string Kouhong;
};
GoodFriend::GoodFriend()
{
M = new MyHome;//初始化对象!
}
void GoodFriend::visit1()
{
this->Gifts = "水果拼盘";
cout << "好朋友1号带了" << Gifts << "来造访" << endl;
cout << "好朋友1号来到" << M->Sittingroom << endl;
cout << "好朋友1号来到" << M->Bedroom << endl;
cout << "好朋友1用了我的" << M->Kouhong << endl;
}
void GoodFriend::visit2()
{
this->Gifts = "大芒果";
cout << "好朋友2号带了" << Gifts << "来造访" << endl;
cout << "好朋友2号来到" << M->Sittingroom << endl;
//cout << "好朋友2号来到" << M->Bedroom << endl;
//cout << "好朋友2用了我的" << M->Kouhong << endl;
}
int main()
{
GoodFriend G;//创建对象!
cout << "用了友元类的函数!" << endl;
G.visit1();
cout << "==================================" << endl;
cout << "没用友元类函数!" << endl;
G.visit2();
return 0;
}