精华内容
下载资源
问答
  • C++中的友元函数

    2018-02-25 23:04:48
    C++中的友元函数友元函数可以访问类中的私有变量,类似静态函数,友元函数不受public private protected等修饰符的限制,可以放在类中的任意位置。如果在类的声明中定义友元函数(即友元函数的声明和定义放在一处,都...

    C++中的友元函数

    友元函数可以访问类中的私有变量,类似静态函数,友元函数不受public private protected等修饰符的限制,可以放在类中的任意位置。

    如果在类的声明中定义友元函数(即友元函数的声明和定义放在一处,都在类内部),则此友元函数为内联函数,即使没有使用inline关键字,且此友元函数的作用域为文件范围,而非类范围,调用此友元函数时也无需带“类名::”,虽然此友元函数的定义声明都在类内部。只要包含这个类所在的头文件,就可以调用友元函数,另外友元函数定义和声明分开时,只需在类内部声明一次即可,无需在类外部再次声明。

    下面我们使用普通友元函数,内联友元函数,和静态成员函数,来实现打印Student类中的私有成员变量的功能

    test2.h文件

    #ifndef _TEST2_H_
    #define _TEST2_H_
    
    #include <string>
    
    using namespace std;
    
    class Student
    {
    private:
        string name;
        int stu_nu;
        //此处已经算是友元函数的声明,无需在类外部再次声明,且不受private修饰符限制
        friend void show(const Student & stu);
    public:
        Student(string name, int stu_nu);
        //print函数为内联函数,虽然没有使用inline关键字
        friend void print(const Student & stu)
        {   
            cout << "name is" << stu.name << endl;
            cout << "stu number is " << stu.stu_nu << endl;
        }   
        //使用类的静态成员函数实现同样的功能
        static void print_static (const Student &stu)
        {   
            cout << "name is" << stu.name << endl;
            cout << "stu number is " << stu.stu_nu << endl;
        }   
    };
    
    #endif
    

    show.cpp文件

    #include <iostream>
    #include "test2.h"
    
    using namespace std;
    
    void show(const Student & stu)
    {
        cout << "name is " << stu.name << endl;
        cout << "stu number is" << stu.stu_nu << endl;
    }

    我们可以看到show函数这个友元函数无需再次声明,只需在test2.cpp文件中包含test2.h文件即可在main函数中调用show函数,show函数定义会自动链接到main函数。

    但其实也存在一种特殊情况,在文章最后说明。

    test2.cpp文件

    #include <iostream>
    #include "test2.h"
    
    using namespace std;
    
    
    int main()
    {
        class Student st1("xiaoming", 100001);
        show(st1);
        print(st1);
        Student::print_static(st1);
    }
    
    Student::Student(string name, int nu) 
    {
        this->name = name;
        stu_nu = nu; 
    }
    
    

    结果为:

    name is xiaoming
    stu number is100001
    name isxiaoming
    stu number is 100001
    name isxiaoming
    stu number is 100001

    输出结果表明,三种方法都可以访问到类中的私有成员。


    友元函数需要二次声明的特殊情况(类内部和外部都要声明):

    类模板中,非运算符重载的友元函数如果将定义和声明分开写的话,需要在模板类声明之前加上友元函数的声明,运算符重载友元函数除外。但着我们要尽量避免使用这种情况,尽量遵循一个原则:即除了'>>' '<<'运算符外,尽量避免使用友元函数,即尽量使用非运算符重载的友元函数。

    详见:

    http://blog.csdn.net/xiaoyink/article/details/79372725

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

    2019-07-20 22:37:03
    回答:在类A定义一个友元函数B。 二 代码举例: #include<iostream> #include<windows.h> class Player{ private : int m_id; int m_cardnumber; friend void change_cardnumb...

    一:如何在一个全局函数B中访问一个类A中的私有成员?

          回答:在类A中定义一个友元函数B。

    二  代码举例:

    #include<iostream>
    #include<windows.h>
    class Player{
    private :
    	 int m_id;
    	 int m_cardnumber;
    	 friend void change_cardnumber(Player * player, int cardnumber);//定义友元函数函数:change_cardnumber(也可以定义成public成员)
    public :
    	Player (int id , int cardnumber){
    		m_id = id;
    		m_cardnumber = cardnumber;
    	}
    	void show_cardnubmer(){
    	 std::cout<<m_cardnumber<<"\n";
    	}
    };
    
    void change_cardnumber(Player * player, int cardnumber){
    	player->m_cardnumber = cardnumber; //在友元函数change_cardnumber中可以访问类Player中的私有成员m_cardnumber
    }
    void main(){
        Player * player = new Player(101,10);
    	player->show_cardnubmer();
    	change_cardnumber(player,20);
    	player->show_cardnubmer();
    
    	delete player;
    	system("pause");
    
    }

     

    展开全文
  • 以下是对C++中的友元函数进行了详细的总结介绍,需要的朋友可以过来参考下
  • C++中的友元函数和友元类 在C++中类具有封装的隐蔽性,由于语言特性,只有成员函数才能访问私有成员,非成员函数只能访问类中的公有成员,可是有时候我们需要非成员函数调用私有成员,这个时候要是将私有成员定义为...

    C++中的友元函数和友元类

    在C++中类具有封装的隐蔽性,由于语言特性,只有成员函数才能访问私有成员,非成员函数只能访问类中的公有成员,可是有时候我们需要非成员函数调用私有成员,这个时候要是将私有成员定义为公有的又会破坏C++的封装,为了解决上述问题,我们提出了友元的概念
    友元分为友元函数和友元类,友元函数就是非成员函数可是当我们声明成友元函数的时候也可以访问类中的私有成员,友元类就是可以访问另一个类中所有私有成员,用关键字friend声明。可是我们需要注意的是友元一定意义上破坏了C++中的封装,所以我们很少用友元,只在恰当的地方谨慎使用。
    这里举例一个日期类来演示友元函数

    #include<iostream>
    using namespace std;
    class date
    {
    public:
     date(int year, int month, int day)
      :_year(year),
      _month(month),
      _day(day)
     {}
     date(const date& d)
     {
      _year = d._year;
      _month = d._month;
      _day = d._day;
     }
     friend void display(const date& d);
     friend void operator<<(ostream& out, const date& d);
     friend void operator>>(istream& in, date& d);
    private:
     int _year;
     int _month;
     int _day;
    };
    void display(const date& d)
    {
     cout << d._year << "_" << d._month << "_" << d._day << endl;
    }
    void operator<<(ostream& out, const date& d)
    {
     out << d._year << "_" << d._month << "_" << d._day << endl;
    }
    void operator>>(istream& in, date& d)
    {
     in >> d._year;
     in >> d._month;
     in >> d._day;
    }
    

    将一个类定义为另一个类的友元类后这个类可以访问友元类的所有成员,不过一定程度上破坏了封装。

    #include<iostream>
    #include<windows.h>
    using namespace std;
    class time
    {
    public:
     friend class date;
     time(int hour = 12, int minute = 59, int second = 59)
      :_hour(hour),
      _minute(minute),
      _second(second)
     {}
    private:
     int _hour;
     int _minute;
     int _second;
    };
    class date
    {
    public:
     date(int year = 2018, int month = 1, int day = 1)
      :_year(year),
      _month(month),
      _day(day)
     {}
     void display(time& t)
     {
      cout << _year << "年" << _month<<"月"<<_day <<"日"<< endl;
      cout << t._hour << "点" << t._minute << "分" << t._second << "秒" << endl;
     }
    private:
     int _year;
     int _month;
     int _day;
     time t;
    };
    int main()
    {
     time t;
     date d;
     d.display(t);
     system("pause");
     return 0;
    }
    
    展开全文
  • C++中的友元函数friend

    2019-03-31 22:03:43
    1.C++中的友元函数 类的友元函数是定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。友元可以是一个函数,该...

    1.C++中的友元函数

    • 类的友元函数是定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。友元可以是一个函数,该函数被称为友元函数;友元也可以是一个类,该类被称为友元类,在这种情况下,整个类及其所有成员都是友元
    • 如果要声明函数为一个类的友元,需要在类定义中该函数原型前使用关键字friend,如下所示:
          class Box{
          double width;  // 默认是private
          public:
              double length;
              friend void printWidth(Box box);  // 友元函数声明
              void setWidth(double wid);
          };
      
    • 声明类 ClassTwo 的所有成员函数作为类 ClassOne 的友元,需要在类 ClassOne 的定义中放置如下声明:
          friend class classTwo;  // 在classOne类中进行此友元类的声明!!!
      
    • 完整友元函数的实例如下:
          #include "iostream"
      
          using namespace std;
      
      
          class Box{
              double width;  // 默认是private
              public:
                  double length;
                  friend void printWidth(Box box);  // 友元函数声明
                  void setWidth(double wid);
          };
      
          // 成员函数的定义
          void Box::setWidth(double wid){
              width = wid;
          }
          // 友元函数的定义
          // 请注意:printWidth() 不是任何类的成员函数!!!
          void printWidth(Box box){
              cout << "Width of Box: " << box.width << endl;
          }
      
          int main(){
              Box box;
              // 使用成员函数设置宽度
              box.setWidth(10.0);
              // 使用友元函数输出宽度
              printWidth(box); // 调用友元函数!
              cout << "-------------------------------------\n";
              return 0;
          }
      

    2.友元函数的使用

    • 可以直接调用友元函数,不需要通过对象或指针;此外,友元函数没有this指针,则参数要有三种情况:
      • 要访问非static成员时,需要对象做参数;
      • 要访问static成员或全局变量时,则不需要对象做参数;
      • 如果做参数的对象是全局对象,则不需要对象做参数.
          class INT{
              friend void Print(const INT& obj);  // 声明友元函数
          };
          // 友元函数的定义
          void Print(const INT& obj){
              cout << "我是INT类的友元函数,我骄傲!\n";
          }
          INT obj;
          Print(obj);  // 直接调用友元函数,不需要使用对象或者指针!
      
    • 下面实例是友元类的使用,详细见下面的实例:
          class Box{
              double width;  // 默认是private
              public:
                  double length;
                  friend void printWidth(Box box);  // 友元函数声明
                  friend class BigBox;  // 友元类的声明
                  void setWidth(double wid);
          };
      
          // 成员函数的定义
          void Box::setWidth(double wid){
              width = wid;
          }
          // 友元函数的定义
          // 请注意:printWidth() 不是任何类的成员函数!!!
          void printWidth(Box box){
              /* 因为printWidth()是Box的友元函数,它可以直接访问该类的任何成员 */
              cout << "Width of Box: " << box.width << endl;
          }
      
          // 友元类的使用
          class BigBox{
              public:
                  void Print(int width, Box &box){
                      // BigBox是Box类的友元类,它可以直接访问Box类的任何成员
                      box.setWidth(width);
                      cout << "Width of Box: " << box.width << endl;
                  }
          };
      
          int main(){
              Box box;
              BigBox big;
              // 使用成员函数设置宽度
              box.setWidth(10.0);
              // 使用友元函数输出宽度
              printWidth(box); // 调用友元函数!
              cout << "-------------------------------------\n";
              // 使用友元类中的方法设置宽度
              big.Print(20, box);
              return 0;
          }
      
    展开全文
  • C++中的友元函数主要应用于以下场景: 友元函数 第一种场景 代码中有一个全局函数,该函数想要去访问某个类的成员变量(该类的成员变量是private的,且该类并未提供任何获取获取私有成员变量的public方法),这时候...
  • C++ 中的友元函数

    千次阅读 2013-09-14 13:23:45
    C++中,一个全局方法或者一个类,或者一个类的成会员方法被在另一个类中声明为友元,那么这个方法或类就可以访问另一个类中的私有成员. 1,一个全局方法被一个类声明为友元. #include using namespace std; //...
  • 关于C++中的友元函数的总结 1.友元函数的简单介绍 1.1为什么要使用友元函数 在实现类之间数据共享时,减少系统开销,提高效率。如果类A中的函数要访问类B中的成员(例如:智能指针类的实现),那么类A中该...
  • 关于C++中的友元函数的总结 1.友元函数的简单介绍 1.1为什么要使用友元函数 在实现类之间数据共享时,减少系统开销,提高效率。如果类A中的函数要访问类B中的成员(例如:智能指针类的实现),那么类A中该函数要是...
  • 关于C++中的友元函数的总结 1.友元函数的简单介绍 1.1为什么要使用友元函数 在实现类之间数据共享时,减少系统开销,提高效率。如果类A中的函数要访问类B中的成员(例如:智能指针类的实现),那么类A中该...
  • 详细介绍C++中的友元函数和友元类 2011-07-15 13:49 佚名 互联网 我要评论(1) 字号:T | T 本文介绍的是C++中的友元函数和友元类,希望对你有帮助,一起来看。 AD:2013大数据全球技术峰会低价...
  • 友元函数和友元类 友元提供了不同类的成员函数之间、类的成员函数与一般函数之间进行数据共享的机制。...c++中的友元为封装隐藏这堵不透明的墙开了一个小孔,外界可以通过这个小孔窥视内部的秘密。 友元的正确

空空如也

空空如也

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

c++中的友元函数

c++ 订阅