精华内容
参与话题
问答
  • C++ 友元函数

    万次阅读 2020-07-25 09:22:23
    在程序里,有些私有属性也想让类外特殊的一些函数或者类进行访问, 就需要用到友元的技术 友元的目的就是让一个函数或者类访问另-个类中私有成员 友元的关键字为friend I 友元的三种实现 ●全局函数友元 ●类做...

    生活中你的家有客厅(Public),有你的卧室(Private)
    客厅所有来的客人都可以进去,但是你的卧室是私有的,也就是说只有你能进去
    但是呢,你也可以允许你的好闺蜜好基友进去。
    在程序里,有些私有属性也想让类外特殊的一些函数或者类进行访问, 就需要用到友元的技术
    友元的目的就是让一个函数或者类访问另-个类中私有成员
    友元的关键字为friend I
    友元的三种实现
    ●全局函数做友元
    ●类做友元
    ●成员函数做友元

    我们先用第一种实现友元函数全局函数做友元:

    #include<iostream>
    #include<string>
    using namespace std;
    
    
    
    class Building{
    	//告诉编译器goodGay全局函数是Building类的好朋友,可以访问类中的私有内容
    	friend void goodGay(Building * building);
    public:
    	Building() {
    
    		this->m_SittingRoom = "客厅";
    		this->m_BedRoom = "卧室";
    	}
    public:
    	string m_SittingRoom; //客厅
    private:
    	string m_BedRoom; //卧室
    };
    void goodGay(Building * building) {
    	cout << "好基友正在访问:" << building->m_SittingRoom << endl;
    	cout << "好基友正在访问: "<< building->m_BedRoom << endl;
    }
    
    
    void test01(){
    	Building b;
    	goodGay(&b);
    }
    int main() {
    	test01();
    	system("pause");
    }

    类做友元:

    #include<iostream>
    #include<string>
    using namespace std;
    
    
    
    class Building;
    class goodGay{
    	public:
    		goodGay();
    		void visit();
    	private:
    	
    		Building * building;
    };
    class Building{
    	//告诉编译器goodGay类是Building美的好朋友,可以访问到Building类中私有内容
    	friend class goodGay;
    	public:
    		Building();
    	public:
    		string m_SittingRoom; //客厅
    	private:
    		string m_BedRoom;//卧室
    
    };
    
    
    Building::Building() {
    	this->m_SittingRoom = "客厅";
    	this->m_BedRoom = "卧室";
    }
    goodGay::goodGay() {
    	building = new Building;
    
    }
    void goodGay :: visit(){
    			 cout << "好基友正在访问"<< building->m_SittingRoom << endl;
    			 cout << "好基友正在访问"<< building->m_BedRoom << endl;
    }
    
    
    void test01() {
    	goodGay gg;
    	gg.visit();
    }
    
    int main() {
    	test01();
    	system("pause");
    }

    成员函数做友元:

    #include<iostream>
    #include<string>
    using namespace std;
    
    
    
    class Building {
    	//告诉编译器goodGay全 局函数是Building类的好朋友,可以访问类中的私有内容
    	friend void goodGay(Building * building);
    	public:
    		Building(){
    			this->m_SittingRoom = "客厅";
    			this->m_BedRoom = "卧室";
    		}
    
    	public:
    		string m_SittingRoom; //客厅
    	private:
    		string m_BedRoom; //卧室
    
    
    };
    
    void goodGay(Building * building) {
    	cout << "好基友正在访问:" << building-> m_SittingRoom << endl;
    	cout << "好基友正在访问:" << building->m_BedRoom << endl;
    }
    
    
    void test01() {
    	Building b;
    	goodGay(&b);
    }
    int main() {
    	test01();
    	system("pause");
    	return 0;
    }

     

    展开全文
  • C++友元函数

    2020-11-10 14:36:31
    友元函数,是为在该类中提供一个对外(除了他自己以外)访问的窗口; 友元函数不属于该类的成员函数,他是定义在类外的普通函数,只是在类中声明该函数可以直接访问类中的private或者protected成员。 friend <返回...

    友元函数,是为在该类中提供一个对外(除了他自己以外)访问的窗口;
    友元函数不属于该类的成员函数,他是定义在类外的普通函数,只是在类中声明该函数可以直接访问类中的private或者protected成员。

    friend <返回类型> <函数名> (<参数列表>);
    

    参考链接:https://blog.csdn.net/qq_26337701/article/details/53996104

    展开全文
  • c++友元函数

    2020-08-29 16:49:19
    目录概述知识点友元函数友元类友成员函数 概述        在C++中,我们使用类对数据进行了隐藏和封装,类的数据成员一般都定义为私有成员,成员函数一般都定义为公有的,以此提供类与外界的通讯...

    概述

           在C++中,我们使用类对数据进行了隐藏和封装,类的数据成员一般都定义为私有成员,成员函数一般都定义为公有的,以此提供类与外界的通讯接口。但是,有时需要定义一些函数,这些函数不是类的一部分,但又需要频繁地访问类的数据成员,这时可以将这些函数定义为该函数的友元函数。除了友元函数外,还有友元类,两者统称为友元。友元的作用是提高了程序的运行效率(即减少了类型检查和安全性检查等都需要时间开销),但它破坏了类的封装性和隐藏性,使得非成员函数可以访问类的私有成员。

    知识点

    • 友元关系不能被继承。
    • 友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。
    • 友元关系不具有传递性。若类B是类A的友元,类C是B的友元,类C不一定是类A的友元,同样要看类中是否有相应的声明
    • 如果将类的封装比喻成一堵墙的话,那么友元机制就像墙上了开了一个门,那些得到允许的类或函数允许通过这个门访问一般的类或者函数无法访问的私有属性和方法。友元机制使类的封装性得到消弱,所以使用时一定要慎重。
    • 通常对于普通函数来说,要访问类的保护成员是不可能的,如果想这么做那么必须把类的成员都声明为public(共用的),然而这做带来的问题遍是任何外部函数都可以毫无约束的访问它操作它,c++利用friend修饰符,可以让一些你设定的函数能够对这些保护数据进行操作,避免把类成员全部设置成public,最大限度的保护数据成员的安全。
    • 友元能够使得普通函数直接访问类的保护数据,避免了类成员函数的频繁调用,可以节约处理器开销,提高程序的效率,但所矛盾的是,即使是最大限度大保护,同样也破坏了类的封装特性,这即是友元的缺点,在现在cpu速度越来越快的今天我们并不推荐使用它,但它作为c++一个必要的知识点,一个完整的组成部分,我们还是需要讨论一下的。 在类里声明一个普通数学,在前面加上friend修饰,那么这个函数就成了该类的友元,可以访问该类的一切成员

    友元函数

    1. 友元函数是可以直接访问类的私有成员的非成员函数。它是定义在类外的普通函数,它不属于任何类,但需要在类的定义中加以声明
    2. 友元函数的声明可以放在类的私有部分,也可以放在公有部分,它们是没有区别的,都说明是该类的一个友元函数。
    3. 一个函数可以是多个类的友元函数,只需要在各个类中分别声明。
    4. 友元函数的调用与一般函数的调用方式和原理一致。
    class CTestA
    {
    public:
    	CTestA():m_nId(0),m_nAge(0)
    	{}
    
    	friend int Func();//定义为友元函数
    
    private:
    	int m_nId;
    	int m_nAge;
    };
    
    //全局函数
    int Func()
    {
    	CTestA a;
    	return a.m_nId;//可以调用自由成员
    }
    
    int main()
    {
    	int nId = Func();
    	std::cout << nId << std::endl;
    }
    

    友元类

    1. 友元类的所有成员函数都是另一个类的友元函数,都可以访问另一个类中的隐藏信息(包括私有成员和保护成员)。
    2. 当希望一个类可以存取另一个类的私有成员时,可以将该类声明为另一类的友元类。
    class CTestB
    {
    public:
    	friend class CTestA;//把类CTestA定义为类CTestB的友元类,这样就可以在类CTestA中访问类CTestB中的所有成员变量
    
    private:
    	int m_nId;
    	int m_nAge;
    };
    
    class CTestA
    {
    public:
    	CTestA():m_nId(0),m_nAge(0)
    	{}
    
    	void Show() const
    	{
    		//可以在类CTestA中使用CTestB的所有成员变量
    		CTestB b;
    		b.m_nId = 1;
    		b.m_nAge = 2;
    		std::cout << b.m_nId << std::endl;
    	}
    
    private:
    	int m_nId;
    	int m_nAge;
    };
    
    int main()
    {
    	CTestA a;
    	a.Show();//1
    }
    

    友成员函数

    class CTestB
    {
    public:
    	friend void CTestA::Show();//把类CTestA中的Show函数定义为类CTestB的友元函数,这样在类CTestA的Show函数中就可以访问类CTestB的所有成员
    
    private:
    	int m_nId;
    	int m_nAge;
    };
    
    class CTestA
    {
    public:
    	CTestA() :m_nId(0), m_nAge(0)
    	{}
    
    	void Show();
    
    
    private:
    	int m_nId;
    	int m_nAge;
    };
    
    void CTestA::Show()
    {
    	//可以在类CTestA中使用CTestB的所有成员变量
    	CTestB b;
    	b.m_nId = 1;
    	b.m_nAge = 2;
    	std::cout << b.m_nId << std::endl;
    }
    

    参考文章

    展开全文
  • c++ 友元函数

    2020-04-23 10:13:18
    尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。 友元可以是一个函数,该函数被称为友元函数;友元也可以是一个类,该类被称为友元类,在这种情况下,整个类及其所有成员都是友元。 如果要...

    定义

    类的友元函数是定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。

    友元可以是一个函数,该函数被称为友元函数;友元也可以是一个类,该类被称为友元类,在这种情况下,整个类及其所有成员都是友元。

    如果要声明函数为一个类的友元,需要在类定义中该函数原型前使用关键字 friend,如下所示:

    题目:

    定义Boat和Car两个类,二者都有一个weight属性,定义它们的一个友元函数totalWeight( ),计算二者的重量和。

    代码如下:

    #include <iostream>
    #include <string.h>
    #include <map>
    #include<queue>
    #include<unordered_map>
    using namespace std;
    #pragma warning(disable:4996)
    
    class Car;//先声明
    
    /*boat类*/
    class Boat {
    	int weight;
    public:
    	void setWeight(int setwei);
    	int getWeight();
    	friend int totalWeight(Boat boat, Car car);
    };
    // 成员函数定义
    void Boat::setWeight(int setwei) {
    	weight = setwei;
    }
    // 成员函数定义
    int Boat::getWeight() {
    	return weight;
    };
    
    /*car类*/
    class Car {
    	int weight;
    public:
    	void setWeight(int setwei);
    	int getWeight();
    	friend int totalWeight(Boat boat, Car car);
    };
    // 成员函数定义
    void Car::setWeight(int setwei) {
    	weight = setwei;
    }
    // 成员函数定义
    int Car:: getWeight() {
    	return weight;
    }
    
    /*计算car和boat的总重量,该函数不是任何类的成员函数*/
    int totalWeight(Boat boat,Car car) {
    	return car.weight + boat.weight;
    }
    
    int main() {
    	Boat boat;
    	Car car;
    
    	//使用成员函数设置
    	boat.setWeight(10);
    	car.setWeight(20);
    	
    	cout<<"boat的重量是:"<<boat.getWeight()<<endl;
    	cout<<"car的重量是:"<<car.getWeight()<<endl;
    	//使用友元函数输出
    	cout << "boat与car的总重量:"<<totalWeight(boat,car)<< endl;
    }
    

    结果如下:

    在这里插入图片描述

    展开全文

空空如也

1 2 3 4 5 ... 20
收藏数 5,794
精华内容 2,317
关键字:

c++友元函数

c++ 订阅