精华内容
下载资源
问答
  • C++一个类成员函数作为另一个类友元函数

    千次阅读 多人点赞 2019-04-27 18:17:07
    分别用全局函数、友元函数计算两者的和。 #include<iostream> using namespace std; class B; class A; // 此行可不加,这里加此行是因为下面举例子有用 class A { public: A(int n = 0): num...

    先上一段代码。定义了两个类,都有私有变量num。分别用全局函数、友元函数计算两者的和。

    #include<iostream>  
    using namespace std;  
      
    class B;
    class A;	// 此行可不加,这里加此行是因为下面举例子有用  
    class A {  
    public:  
        A(int n = 0): num(n) {} // 构造函数  
        friend void sum_1(A &a, B &b);  // 全局函数 sum_1  
        void sum_2(B &b);               // 成员函数 sum_2  
    private:  
        int num;  
    };  
      
    class B {  
    public:  
        B(int n = 0) : num(n) {}    // 构造函数  
        friend void sum_1(A &a, B &b);  // 全局函数 sum_1  
        friend void A::sum_2(B &b);     // 友元函数 A::sum_2  
    private:  
        int num;  
    };  
    // 全局函数  
    void sum_1(A &a, B &b) {  
        int sum = a.num + b.num;    // 访问了两个对象的私有变量  
        cout << a.num << " + " << b.num << " = " << sum << endl;  
    }  
    // 友元函数  
    void A::sum_2(B &b) {  
        int sum = num + b.num;  // 访问了参数对象的私有变量  
        cout << num << " + " << b.num << " = " << sum << endl;  
    }  
      
    int main() {  
        A a(1);  
        B b;  
        sum_1(a, b);  	// 调用全局函数
        a.sum_2(b);  	// 调用a的成员函数
        system("PAUSE");  
        return 0;  
    }  
    

    1. 提前声明要使用的类

    若注释掉此行

    class B;
    

    编译器会报错:error C2061: 语法错误: 标识符“B”

    本例中,先对类 B 进行了声明,但是没有定义。因为在类 A 的定义中,出现的函数 sum_1 和 sum_2 均要用到类B 名,所以必须事先声明“B”是一个类名,这样编译器才不会因为不知道”B“是什么而报错。

    2. 必须将先定义的类的成员函数作为后定义类的友元函数,调换顺序会出现语法错误

    本例中,若将 A、B 类的定义顺序调换,其余均不变,则出现语法错误

    #include<iostream>  
    using namespace std;  
      
    class B;
    class A;	// 此行可不加,这里加此行是因为下面举例子有用 
    class B {  	// A、B类的定义顺序变了
    .../*中间的语句不变*/   
    }; 
    class A {  
    .../*中间的语句不变*/  
    };  
      
    .../*后面的语句不变*/
    

    在友元函数的实现中,会出现在这里插入图片描述
    这说明B类中没有成功的把A类的成员函数sum_2声明为自己的友元函数。
    道理很很简单,和第1点很相似。若先定义B类,那么我们观察一下B类定义中的如下语句

    friend void A::sum_2(B &b);		// 友元函数 A::sum_2
    

    该语句通过类名加域运算符,将A类的成员函数sum_2声明为友元函数。等等,是不是发现了什么,这是A类根本还没有定义,编译器只知道A是一个类名,A中具体有什么全然不知。如此,那么这一个语句当然无效咯!

    展开全文
  • 通过友元一个不同函数另一个类中的成员函数可以访问中的私有成员和保护成员。c++中的友元为封装隐藏这堵不透明的墙开了一个小孔,外界可以通过这个小孔窥视内部的秘密。 友元的正确使用能提高程序的运行...
    友元提供了不同类的成员函数之间、类的成员函数与一般函数之间进行数据共享的机制。通过友元,一个不同函数或另一个类中的成员函数可以访问类中的私有成员和保护成员。c++中的友元为封装隐藏这堵不透明的墙开了一个小孔,外界可以通过这个小孔窥视内部的秘密。
    

    友元的正确使用能提高程序的运行效率,但同时也破坏了类的封装性和数据的隐藏性,导致程序可维护性变差。

    友元提供了不同类的成员函数之间、类的成员函数与一般函数之间进行数据共享的机制。通过友元,一个不同函数或另一个类中的成员函数可以访问类中的私有成员和保护成员。c++中的友元为封装隐藏这堵不透明的墙开了一个小孔,外界可以通过这个小孔窥视内部的秘密。

    友元的正确使用能提高程序的运行效率,但同时也破坏了类的封装性和数据的隐藏性,导致程序可维护性变差。

    友元函数 :

    友元函数是可以直接访问类的私有成员的非成员函数。它是定义在类外的普通函数,它不属于任何类,但需要在类的定义中加以声明,声明时只需在友元的名称前加上关键字friend,其格式如下:

    friend 类型 函数名(形式参数);
    友元函数的声明可以放在类的私有部分,也可以放在公有部分,它们是没有区别的,都说明是该类的一个友元函数。
    一个函数可以是多个类的友元函数,只需要在各个类中分别声明。
    友元函数的调用与一般函数的调用方式和原理一致。


    友元类 :
    友元类的所有成员函数都是另一个类的友元函数,都可以访问另一个类中的隐藏信息(包括私有成员和保护成员)。
    当希望一个类可以存取另一个类的私有成员时,可以将该类声明为另一类的友元类。定义友元类的语句格式如下:
    friend class 类名;
    其中:friend和class是关键字,类名必须是程序中的一个已定义过的类。

    1: #include <iostream>
    2: using namespace std;
    3:
    4: class Radius
    5: {
    6: friend class Circle; //声明Circle为Radius的友元类
    7: friend void Show_r(Radius &n); //声明Show_r为友元函数
    8: public:
    9: Radius(int x)
    10: {
    11: r = x;
    12: }
    13: ~Radius()
    14: {
    15: }
    16:
    17: private:
    18: int r;
    19: };
    20:
    21: void Show_r(Radius &n)
    22: {
    23: cout<<"圆的半径为: "<<n.r<<endl; //调用Radius对象的私有成员变量r
    24: }
    25:
    26: class Circle
    27: {
    28: public:
    29: Circle() {}
    30: ~Circle(){}
    31: double area(Radius a)
    32: {
    33: s = a.r * a.r * 3.1415926; //调用Radius对象的私有成员变量r
    34: return s;
    35: }
    36: private:
    37: double s;
    38: };
    39:
    40: int main(int argc, char *argv[])
    41: {
    42: Radius objRadius(9);
    43: Circle objCircle;
    44:
    45: Show_r( objRadius );
    46: cout<<"面积为:"<<objCircle.area(objRadius)<<endl;
    47:
    48: return 0;
    49: }
    被声明两个类的友元声明

    如果我们决定一个函数必须被声明为两个类的友元则友元声明如下

    1: class Window; // 只声明
    2:
    3: class Screen
    4:
    5: {
    6:
    7: friend bool is_equal( Screen &, Window & );
    8:
    9: // ...
    10:
    11: };
    12:
    13: class Window
    14:
    15: {
    16:
    17: friend bool is_equal( Screen &, Window & );
    18:
    19: // ...
    20:
    21: };
    作为一个类的函数又是另一个类的友元

    如果我们决定该函数必须作为一个类的成员函数并又是另一个类的友元,则成员函数声明和友元声明如下:

    1: class Window;
    2:
    3: class Screen
    4:
    5: {
    6:
    7: public:
    8:
    9: // copy 是类 Screen 的成员
    10:
    11: Screen& copy( Window & );
    12:
    13: // ...
    14:
    15: };
    16:
    17: class Window
    18:
    19: {
    20:
    21: // copy 是类 Window 的一个友元
    22:
    23: friend Screen& Screen::copy( Window & );
    24:
    25: // ...
    26:
    27: };
    只有当一个类的定义已经被看到时它的成员函数才能被声明为另一个类的友元。这并不总是能够做到的。

    例如如果Screen 类必须把Window 类的成员函数声明为友元,而Window类必须把Screen 类的成员函数声明为友元。该怎么办呢?在这种情况下可以把整个Window类声明为Screen 类的友元。

    例如:



    1: class Window;
    2:
    3: class Screen
    4:
    5: {
    6:
    7: friend class Window;
    8:
    9: // ...
    10:
    11: };
    Screen 类的非公有成员现在可以被Window 的每个成员函数访问。

    使用友元类时注意:
    (1) 友元关系不能被继承。
    (2) 友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。
    (3) 友元关系不具有传递性。若类B是类A的友元,类C是B的友元,类C不一定是类A的友元,同样要看类中是否有相应的申明友元函数 :

    友元函数是可以直接访问类的私有成员的非成员函数。它是定义在类外的普通函数,它不属于任何类,但需要在类的定义中加以声明,声明时只需在友元的名称前加上关键字friend,其格式如下:

    friend 类型 函数名(形式参数);
    友元函数的声明可以放在类的私有部分,也可以放在公有部分,它们是没有区别的,都说明是该类的一个友元函数。
    一个函数可以是多个类的友元函数,只需要在各个类中分别声明。
    友元函数的调用与一般函数的调用方式和原理一致。


    友元类 :
    友元类的所有成员函数都是另一个类的友元函数,都可以访问另一个类中的隐藏信息(包括私有成员和保护成员)。
    当希望一个类可以存取另一个类的私有成员时,可以将该类声明为另一类的友元类。定义友元类的语句格式如下:
    friend class 类名;
    其中:friend和class是关键字,类名必须是程序中的一个已定义过的类。

    1: #include <iostream>
    2: using namespace std;
    3:
    4: class Radius
    5: {
    6: friend class Circle; //声明Circle为Radius的友元类
    7: friend void Show_r(Radius &n); //声明Show_r为友元函数
    8: public:
    9: Radius(int x)
    10: {
    11: r = x;
    12: }
    13: ~Radius()
    14: {
    15: }
    16:
    17: private:
    18: int r;
    19: };
    20:
    21: void Show_r(Radius &n)
    22: {
    23: cout<<"圆的半径为: "<<n.r<<endl; //调用Radius对象的私有成员变量r
    24: }
    25:
    26: class Circle
    27: {
    28: public:
    29: Circle() {}
    30: ~Circle(){}
    31: double area(Radius a)
    32: {
    33: s = a.r * a.r * 3.1415926; //调用Radius对象的私有成员变量r
    34: return s;
    35: }
    36: private:
    37: double s;
    38: };
    39:
    40: int main(int argc, char *argv[])
    41: {
    42: Radius objRadius(9);
    43: Circle objCircle;
    44:
    45: Show_r( objRadius );
    46: cout<<"面积为:"<<objCircle.area(objRadius)<<endl;
    47:
    48: return 0;
    49: }
    被声明两个类的友元声明

    如果我们决定一个函数必须被声明为两个类的友元则友元声明如下

    1: class Window; // 只声明
    2:
    3: class Screen
    4:
    5: {
    6:
    7: friend bool is_equal( Screen &, Window & );
    8:
    9: // ...
    10:
    11: };
    12:
    13: class Window
    14:
    15: {
    16:
    17: friend bool is_equal( Screen &, Window & );
    18:
    19: // ...
    20:
    21: };
    作为一个类的函数又是另一个类的友元

    如果我们决定该函数必须作为一个类的成员函数并又是另一个类的友元,则成员函数声明和友元声明如下:

    1: class Window;
    2:
    3: class Screen
    4:
    5: {
    6:
    7: public:
    8:
    9: // copy 是类 Screen 的成员
    10:
    11: Screen& copy( Window & );
    12:
    13: // ...
    14:
    15: };
    16:
    17: class Window
    18:
    19: {
    20:
    21: // copy 是类 Window 的一个友元
    22:
    23: friend Screen& Screen::copy( Window & );
    24:
    25: // ...
    26:
    27: };
    只有当一个类的定义已经被看到时它的成员函数才能被声明为另一个类的友元。这并不总是能够做到的。

    例如如果Screen 类必须把Window 类的成员函数声明为友元,而Window类必须把Screen 类的成员函数声明为友元。该怎么办呢?在这种情况下可以把整个Window类声明为Screen 类的友元。

    例如:



    1: class Window;
    2:
    3: class Screen
    4:
    5: {
    6:
    7: friend class Window;
    8:
    9: // ...
    10:
    11: };
    Screen 类的非公有成员现在可以被Window 的每个成员函数访问。

    使用友元类时注意:
    (1) 友元关系不能被继承。
    (2) 友元关系是单向的,不具有交换性。若类B是类A的友元,类A不一定是类B的友元,要看在类中是否有相应的声明。
    (3) 友元关系不具有传递性。若类B是类A的友元,类C是B的友元,类C不一定是类A的友元,同样要看类中是否
    展开全文
  • 以下是对C++运算符重载 成员函数与友元函数进行了介绍,需要的朋友可以过来参考下
  • 另一个类中的成员函数声明为友元函数的三步曲 */ /*第一步:增加前向声明,并定义一个需要实现友元函数*/ class TV;//前向声明 class Remote { private: public: void setCh(TV&,int);//前向声明是...

    废话少说,直接上代码。

    #include <iostream>
    using namespace std;
    /*
    将另一个类中的成员函数声明为友元函数的三步曲
    */
    
    /*第一步:增加前向声明,并定义一个需要实现友元函数的类*/
    
    class TV;//前向声明
    class Remote {
    private:
    
    public:
    	void setCh(TV&,int);//前向声明是为了这里使用类名
    };
    
    /*第二步:定义另一个声明友元函数的类*/
    
    class TV {
    private:
    	string name;
    	int channel;
    	int volume;
    public:
    	TV(string n,int c, int v) {
    		channel = c; volume = v; name = n;
    	}
    	friend void Remote::setCh(TV&,int);//Remote类定义在前是为了告诉编译器友元函数的原型
    };
    
    /*第三步:实现第一个类中的成员函数,即第二个类中的友元函数*/
    
    void Remote::setCh(TV& tv,int n) {//最后实现友元函数是为了使用tv对象
    	if (tv.name == "创维")
    		tv.channel = n;
    	else
    		tv.channel = 100;
    	cout << tv.name << ":当前处于" << tv.channel << "频道。\n";
    }
    
    //声音控制函数自己体会,在此省略。
    
    int main()
    {
    	TV tv1("创维", 5, 10);
    	TV tv2("杂牌", 8, 6);
    	Remote remote;
    	remote.setCh(tv1,5);
    	remote.setCh(tv2,5);
    	return 0;
    }
    

     

    展开全文
  • 这是我作业中的题,我按照正常的逻辑做是这样 下面是我的代码//main.cpp #include"CTime.h" #include"CDate.h" #include void main() { CTime t1(10, 13, 56); CDate d1(2004, 15, 12); CTime *p1 = &t1; t1....

    这是我作业中的一题,我按照正常的逻辑做是这样

    下面是我的代码

    //main.cpp
    #include"CTime.h"
    #include"CDate.h"
    #include<stdlib.h>
    void main() {
    	CTime t1(10, 13, 56);
    	CDate d1(2004, 15, 12);
    	CTime *p1 = &t1;
    	t1.ShowValue(&d1);
    	system("pause");
    }
    //CTime.h
    class CTime {
    private:
    	int hour;
    	int minute;
    	int second;
    public:
    	void SetValue();
    	void ShowValue(CDate *);
    	CTime(int, int, int);
    };
    //CDate.h
    class CDate {
    private:
    	int year;
    	int month;
    	int day;
    public:
    	CDate(int, int, int);
            friend void CTime::ShowValue(CDate *);
    };
    //CTime.cpp
    #include<iostream>
    #include"CTime.h"
    void CTime::SetValue() {
    	std::cin >> hour >> minute >> second;
    }
    void CTime::ShowValue(CDate *d1) {
    	std::cout << d1->day << "/" << d1->month << "/" << d1->year << std::endl;
    	std::cout << hour << ":" << minute << ":" << second << std::endl;
    }
    CTime::CTime(int h,int m,int s):hour(h),minute(m),second(s){}
    //CDate.cpp
    #include"CDate.h"
    CDate::CDate(int y,int m,int d):year(y),month(m),day(d){}
    
    这样写发现,VS2015会出现编译错误

    于是我查找资料说在CTime.h要声明class CDate,在CDate.h中要申明class CTime

    但是我发现还是编译无法通过

    然后我在CDate中把CTime申明为友元类
    然后在CTime.cpp中把CDate.h引用进去

    发现即可运行成功。

    代码如下

    //CTime.h
    class CDate;	//后来添加的声明
    class CTime {
    private:
    	int hour;
    	int minute;
    	int second;
    public:
    	void SetValue();
    	void ShowValue(CDate *);
    	CTime(int, int, int);
    };
    //CDate.h
    class CTime;	//后来添加的声明
    class CDate {
    private:
    	int year;
    	int month;
    	int day;
    public:
    	CDate(int, int, int);
    	friend class CTime;	//把CTime声明为友元类
    };
    //CTime.cpp
    #include<iostream>
    #include"CTime.h"
    #include"CDate.h"	//一定要引用进来
    void CTime::SetValue() {
    	std::cin >> hour >> minute >> second;
    }
    void CTime::ShowValue(CDate *d1) {
    	std::cout << d1->day << "/" << d1->month << "/" << d1->year << std::endl;
    	std::cout << hour << ":" << minute << ":" << second << std::endl;
    }
    CTime::CTime(int h,int m,int s):hour(h),minute(m),second(s){}
    把这三个文件中的代码修改完即可成功运行




    展开全文
  • 一个成员函数为另一个类友元函数 注意点:必须先声明B,再定义A;若调换顺序会发生语法错误 //先声明B //原因就是A中的形参需要用到B中的对象 class B; //再定义A class A { public: void know(B mm); ...
  • 友元函数 友元 友元成员函数

    千次阅读 2018-05-07 22:34:40
    友元 一般来说,内的私有数据是对外不可见的,但在有些情况下,我们需要在外对该的私有数据进行访问,这就需要用到种新技术——友元(friend),即在声明前...友元函数是指某些非类成员函数,但可以访问...
  • #include <iostream>using namespace std;class Date;class Time{public:Time(int,int,int);void display(const Date&);private:int hour;int minute;int sec;...class Date{public:Date(int,int...
  • 普通成员函数作为一个类友元函数,以及一个类作为另一个类的友元,都好
  • 在使用友元函数之前需要先明白声明和定义的区别。 从编译原理上来说,声明是仅仅告诉编译器,有某类型的变量会被使用,但是编译器并不会为它分配任何内存。而定义就是分配了内存。 2、 (1)classA.h //#...
  • 搬运自:... ... 友元包括友元函数、友元 友元函数: 个人理解为在中声明的可以外部访问的内部成员变量的一个函数,这个函数并不是成员函数,只是在中声明,而定义在外。换...
  • 可以把一个函数指定为的友元,也可以把整个指定为另一个类的友元。 友元函数友元 二、友元函数友元函数作用域外定义,但它需要在体中进行说明为了与该成员函数加以区别,定义的方式是在中用关键字...
  • 友元(frend)机制允许一个类将对其非公有成员的访问权授予指定的函数或者友元的声明以friend开始,它只能出现在定义的内部,友元声明可以出现在中的任何地方:友元不是授予友元关系的那个成员,所以它们...
  • 一个类中,可以利用关键字friend将其他的函数或声明为友元,如果友元是一般函数或者成员函数,称为友元函数,如果友元是一个类,则成为友元,友元的所有成员函数都自动成为友元函数友元函数友元...
  • 错误 C2248 “Screen::contents”: 无法访问 private 成员(在“Screen”中声明) test0 c:\users\administrator\documents\visual studio 2015\projects\test0\test0\window_mgr.cpp 11 严重性 代码 说明 项目 文件...
  • xxx xxxxx 目 录 页 C++语言程序设计 绪 论 大连理工大学出版社 地址大连市软件园路80号 E-mail : dutp@ URLhttp://www.dutp,cn 友元函数和友元 友元函数和友元 具有封装性和隐藏性只有成员函数才能访问该...
  • 当声明了友元函数或者友元之后,该函数或者可以访问的所有成员,包括private成员,当然访问过程需要通过的对象进行。例如声明一个友元函数,有两种情况: ①该函数是普通的全局函数 一般情况下,使用一个...
  • 友元函数 :既可以是不属于任何的非成员函数,也可以是另一个类成员函数,统称为友元函数友元函数不是当前成员函数,而是独立于的外部函数,但它可以访问该所有的成员,包括私有成员、保护成员和公有...
  • 我有一个类Xth,它有一个private成员 damage,现在想用另一个类 Badao的成员函数 use() 来打印这个值;其实这个问题有很简单 清晰的实现方法,比如在Xth中定义一个专门用来获取damage的值的public函数,等等;但是我...
  • 写的很好的c++PPT
  • 现在先说说赋值运算符“=”的重载C++规定赋值运算符“=”只能重载为的非静态成员函数,而不可以重载为友元函数。不能重载为的静态成员应该比较容易理解,因为静态成员函数是属于整个的,不是属于某个对象...
  • C++ friend 友元函数,友元,友元成员函数看这里友元函数友元友元成员函数 友元函数 友元函数:是函数。 三种访问权限:public,protected,private。 把函数成为友元函数,函数就能访问的所有成员...
  • 在继承之外,在C++中一个类成员函数调用另一个类成员的方法主要有:的组合,友元类的前向声明,单例模式等,下面主要讲讲这4种方法的实现 方法1:利用的组合 组合通俗来讲就是B有A的属性,如声明一个...
  •  一个类的私有数据成员通常只能由函数成员来访问,而友元函数可以访问的私有数据成员,也能访问其保护成员 2. 友元函数的用处体现在哪里?  2.1 使用友元函数可提高性能,如:用友元函数重载操作符和生成迭代...
  • 3.11 友元函数和友元 3.11.1 友元关系介绍 在前面章节讲过,里面可以定义public、protected、private三种属性的成员,通过对象可以访问public成员,只有本中的函数可以访问本的private成员。 在C++里有种...
  • C++----类成员函数做友元函数

    千次阅读 2018-12-13 21:21:40
    //成员函数做友元函数: //只让visit1做building的好朋友(只有visit1能访问building的私有属性) class Building; class goodGay { public: goodGay(); void visit1(); void visit2(); private: Building * ...
  • 友元(友元函数、友元和友元成员函数) C++ 有些情况下,允许特定的非成员函数访问一个类的私有成员,同时仍阻止一般的访问,这是很方便做到的。例如被重载的操作符,如输入或输出操作符,经常需要访问的私有数据...
  • 友元函数不是这个中的成员函数,只是一个普通的小可爱:在体外声明、在体外实现,跟普通的函数完全一样,不过需要在体内“登记”一下,表示这个函数有权限访问体内的所有成员。登记的格式是: friend 函数...
  • 友元函数和友元的需要:具有封装和信息隐藏的特性。只有成员函数才能访问的私有成员,程序中的其他函数是无法访问私有成员的。非成员函数可以访问中的公有成员,但是如果将数据成员都定义为公有的,这又...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,886
精华内容 15,554
关键字:

一个类的友元函数是另一个类成员