精华内容
下载资源
问答
  • 分别用全局函数、友元函数计算两者和。 #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中具体有什么全然不知。如此,那么这一个语句当然无效咯!

    展开全文
  • 我作业中的一题,我按照正常逻辑做这样 下面代码//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){}
    把这三个文件中的代码修改完即可成功运行




    展开全文
  • 另一个类的成员函数声明为友元函数的三步曲 */ /*第一步:增加前向声明,并定义一个需要实现友元函数的类*/ 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;
    }
    

     

    展开全文
  • class X{ friend int Y::g(X &) private: int i; public: X(); X(int i ); }; class X; ..."i值为:"<...为什么g函数a.i无法访问呢,另外怎么调用这个函数呢? 求助大佬
  • 我有一个类Xth,它有一个private成员 damage,现在想用另一个类 Badao的成员函数 use() 来打印这个值;其实这个问题有很简单 清晰实现方法,比如在Xth中定义一个专门用来获取damagepublic函数,等等;但是我...
    问题是这样的:
    我有一个类Xth,它有一个private成员 damage,现在想用另一个类 Badao的成员函数 use() 来打印这个值;其实这个问题有很简单
    清晰的实现方法,比如在Xth中定义一个专门用来获取damage的值的public函数,等等;但是我第一个想到的是用友元函数玩一波骚操作
    问题在与,两个类分别写在各自的头文件中,我一开始以为,两者必须要包含对方的头文件,但是这样根本无法通过编译。
    

    引用某大佬在另一个类似问题上的回答:

    • 友元函数显然是可以的,但是你说的头文件相互包含的问题是可以避免的 你在Book类里面声明Manage类的成员函数为友元函数,因此必然要包含Manage类的头文件,而且你最好使用提前声明,加一句class Manage;
      你在Manage类里面的函数(声明为友元的函数),可以用的是Book类的声明,也就是只用声明class Book,不用包含头文件,因为在头文件中不需要展开具体的函数,因此不需要包含Book类的头文件,只需要在Manage类的cpp文件中包含Book类的头文件即可。
    以下是代码
    main.cpp:
    ---------------------------------------------
    #include <iostream>
    #include "Badao.h"
    #include "Xth.h"
    using namespace std;
    
    int main()
    {
        Badao die;
        Xth one;
        die.use(one);
        cout << "Hello world!" << endl;
        return 0;
    }
    
    Xth.h
    --------------------------------------------
    #ifndef XTH_H
    #define XTH_H
    #include "Badao.h"
    class Badao;
    class Xth
    {
        friend void Badao::use(Xth &);
        public:
            Xth();
            virtual ~Xth();
    
        protected:
    
        private:
            int damage=1000;
    };
    #endif // XTH_H
    
    Xth.cpp
    ------------------------------------------
    #include "Xth.h"
    #include "Badao.h"
    
    Xth::Xth()
    {
        //ctor
    }
    
    Xth::~Xth()
    {
        //dtor
    }
    
    Badao.h
    ------------------------------------------
    #ifndef BADAO_H
    #define BADAO_H
    
    using namespace std;
    class Xth;
    class Badao
    {
        public:
            Badao();
            void use(Xth &);
            virtual ~Badao();
    
        protected:
    
        private:
    };
    
    #endif // BADAO_H
    
    Badao.cpp
    -----------------------------------------
    #include "Badao.h"
    #include <iostream>
    #include "Xth.h"
    
    Badao::Badao()
    {
        //ctor
    }
    void Badao::use(Xth &cw){
        cout<<cw.damage<<endl;
    }
    Badao::~Badao()
    {
        //dtor
    }
    
    
    展开全文
  • 友元函数 :既可以是不属于任何类的非成员函数,也可以是另一个类的成员函数,统称为友元函数友元函数不是当前类的成员函数,而是独立于类的外部函数,但它可以访问该类所有的成员,包括私有成员、保护成员和公有...
  • 友元函数 :既可以是不属于任何类的非成员函数,也可以是另一个类的成员函数,统称为友元函数友元函数不是当前类的成员函数,而是独立于类的外部函数,但它可以访问该类所有的成员,包括私有成员、保护成员和公有...
  • 可以把一个函数指定为类的友元,也可以把整个类指定为另一个类的友元。 (1)友元函数 (2)友元类,友元类的成员函数可以访问一个类的所有 成员,但是友元类的成员函数不是一个类的成员函数 2.友元函数 友元...
  • 一、友元函数介绍 ...可以把一个函数指定为类的友元,也可以把整个类指定为另一个类的友元。 二、友元函数 友元函数在类作用域外定义,但它需要在类体中进行说明,为了与该类的成员函数加以区
  • 特性:一个类的友元函数,可以访问到类中私有成员 推荐使用引用的方法取访问私有成员,更高效友元的定义写在public下和private下都正确的,不过为了直观应写在开头 2.友元成员函数 将一个类的...
  • 一、友元函数 1、友元函数 友元函数不是当前类的成员函数,但它可以访问该类所有的成员,包括私有... 友元函数既可以是非成员函数,也可以是另一个类的成员函数。 class Date { public: Date(int y, int m, in...
  • 友元友元函数

    2020-05-31 21:33:06
    友元类的所有成员函数变成另一个成员函数 友元关系单方面的,如果需要相互构成友元关系,则需要相互声明 友元关系不能传递 内部类 可以通过对象访问外部类的私有成员, 类似于友元类,外部类不可以访问内部类的...
  • 友元友元函数

    2018-01-29 09:27:55
    通过友元,一个不同函数另一个类中的成员函数可以访问类中的私有成员和保护成员。c++中的友元为封装隐藏这堵不透明的墙开了一个小孔,外界可以通过这个小孔窥视内部的秘密。 友元的正确使用能提高程序的运行效率...
  • 可以把一个函数指定为类的友元,也可以把整个类指定为另一个类的友元友元函数友元类 二、友元函数友元函数在类作用域外定义,但它需要在类体中进行说明为了与该类的成员函数加以区别,定义的方式在类中用关键字...
  • 通过将一个模块声明为另一个模块的友元,一个模块能够引用到另一个模块中本被隐藏的信息。 可以使用友元函数和友元。 为了确保数据的完整性,及数据封装与隐藏的原则,建议尽量不使用或少使用友元。 友元函数...
  • C++友元友元函数

    千次阅读 2013-04-14 23:39:16
    可以将一个类设为另一个类的友元类,比如类A设为类B的友元类;这时类A的成员函数可以访问类B所有的数据成员,包括私有部分,但是反过来则不行,因为类B并不类A的友元类;友元函数和友元类的实现方式一样 友元函数...
  • 将一个类A再另一个类B的定义中声明(声明时加friend关键字),即该类A为定义类B的友元类。该类A的所有成员函数均定义类B的友元函数(友元声明可以位于公用、私有、或者保护部分)。 例: class student { friend...
  • 友元函数和友元

    2018-02-25 22:56:00
    可以把一个函数指定为类的友元,也可以把整个类指定为另一个类的友元友元函数 友元类 二、友元函数 友元函数在类作用域外定义,但它需要在类体中进行说明 为了与该类的成员函...
  • 友元函数友元

    2017-03-24 16:18:28
    通过友元,一个不同函数另一个类中的成员函数可以访问类中的私有成员和保护成员。c++中的友元为封装隐藏这堵不透明的墙开了一个小孔,外界可以通过这个小孔窥视内部的秘密。友元的正确使用能提高程序的运行效率,...
  • 一.概述 友元关系提供了不同对类或对象的成员函数,类的成员函数与一般函数之间之间进行的数据共享机制。...友元函数是另一个类的成员函数: friend 类型名 另一个类名::函数名(参数表); 计算两点间
  • 通过友元,一个不同函数另一个类中的成员函数可以访问类中的私有成员和保护成员。c++中的友元为封装隐藏这堵不透明的墙开了一个小孔,外界可以通过这个小孔窥视内部的秘密。友元的正确使用能提高程序的运行效率,...
  • 一个类的成员函数可以是另一个类的友元函数,这样子可以直接调用那个类的数据 友元函数如果只是取数据的便利,完全可以增加一些公有的函数来处理。 #include<iostream> using namespace st

空空如也

空空如也

1 2 3 4 5 ... 19
收藏数 364
精华内容 145
关键字:

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