精华内容
下载资源
问答
  • 关键字const 1、加类型前面加 const 2、如果不想改变一个变量值,也就是向作为只读一个类型,就可以声明在前面添加 const ,如果改了编译器就会报错提醒 ...3、同样还有友元类,和友元函数道理是一样 ...

    关键字const

    1、加类型前面加 const
    在这里插入图片描述
    2、如果不想改变一个变量的值,也就是向作为只读的一个类型,就可以声明在前面添加 const ,如果改了编译器就会报错提醒

    友元函数 friend

    1. 给类交朋友,朋友就可以访问该类的私有成员,这个编译器级别做的事情。
      在这里插入图片描述
      3、同样还有友元类,和友元函数道理是一样的

    在这里插入图片描述

    展开全文
  • 一、友元函数  1、友元函数允许在类外访问该类中任何成员,使用关键字friend说明... 友元函数不属于该类成员函数,它是定义在类外普通函数,只是在类中通过friend关键字声明,从而使该函数可以访问类中pr...

    一、友元函数

      1、友元函数允许在类外访问该类中的任何成员,使用关键字friend说明。通过友元一个普通函数或类的成员函数可以访问封装于另一个类中的数据。从一定程度上讲,友元是对数据隐藏和封装的破坏,但是为了数据共享和提高程序的效率与可读性,小的破坏是必要的。

        友元函数不属于该类的成员函数,它是定义在类外的普通函数,只是在类中通过friend关键字声明,从而使该函数可以访问类中的private与protected成员

      2.友元函数的声明一般形式:

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

      3.使用友元函数注意的要点

    • 1---类中通过使用关键字friend来说明友元函数,但该函数并不是类的成员函数,其声明可以放在类的私有部分也可以放在类的公有部分。友元函数的定义在类体外实现,不需要加类限定。
    • 2---一个类的成员函数可以是另一个类的友元函数,而且一个函数可以是多个类的友元函数。
    • 3---友元函数可以访问类的私有成员和数据,但是可以访问但不能直接使用数据成员需要通过对对象进行引用使用数据成员
    • 4---友元函数在调用上同一般函数一样,不必通过对对象进行引用

    对于1、2、4、的使用解释详见下面代码:

    • class persion{
      public:
            persion(char *pn);
              //友元函数;
            friend void setweigth(persion &p,int h);//注意,参数列表中一般会有一个引用类型的形参,原因参考上面的使用要点3和4;
            void disp(); //类成员函数
      private:
            char name[20];
            int weigth,age;      
      };
      
      persion::persion(char *pn)   //构造函数
      {
         strcpy(name,pn);
         weigth=0;
      }
      void persion::disp()
      {
      cout<<name<<"--"<<weigth<<endl;
      }
      //友元函数的具体实现:这里没有类限定例如 (perion::setweigth)这种形式,这里可以与上面的disp()做个对比,一个属于类的成员,有限定,一个不属于类的成员函数,没有加限定。
      void setweigth(persion &pn,int w)
      {
      pn.weigth=w;       //私有成员数据赋值
      }
      void  main()
      {
        persion p("zhansan");
        setweigth(p,60);//调用实现setweigth(),与一般函数调用一致。
        p.disp();  //调用类的成员函数。
      }

      对于第2点的使用详见下边的代码:一个类的成员函数可以是另一个类的友元函数

    •  1 class wheel;
       2 class car{
       3 public:
       4     car(char *pn);
       5     void run(wheel &w);    //成员函数,做成wheel类中友元函数实现
       6 private:
       7     char name[20];
       8 
       9 };
      10 car::car(char *pn)
      11 {
      12 strcpy(name,pn);
      13 }
      14 
      15 class wheel{
      16 public:
      17     wheel(int s);
      18     friend void car::run(wheel &w);   //这里把car类的成员函数做了友元函数。
      19 private:
      20     int speed;
      21 };
      22 wheel::wheel(int s)
      23 {
      24   speed=s;
      25 }
      26 
      27 void car::run(wheel &w)   //car类成员函数的实现
      28 {
      29     cout<<"the car is running"<<endl;
      30     cout<<"name: "<<name<<" speed :"<<w.speed<<endl;
      31 }
      32 
      33 int  main(int argc, char const *argv[])
      34 {
      35     wheel w(60);
      36     car c("New car");
      37     c.run(w);   //通过car的成员函数作为友元函数访问类wheel类中的数据成员
      38     return 0;
      39 }

    • 使用友元函数计算两点之间的距离:代码示例如下
      •  1 #include <iostream>
         2 #include <cmath>
         3 using namespace std;
         4 //使用友元函数计算两点之间的距离
         5 class Point{
         6 public:
         7     Point(int xx = 0, int yy = 0) { X = xx; Y = yy;}
         8     int GetX() {return X;}
         9     int GetY() {return Y;}
        10     friend float fDist( Point &a, Point &b );
        11 private:
        12     int X, Y;
        13 };
        14  
        15 float fDist(Point &p1, Point &p2){
        16     double x = double(p1.X - p2.X);//通过对象访问私有数据成员,而不是必须使用Getx()函数
        17     double y = double(p1.Y - p2.Y);
        18     return float(sqrt(x*x + y*y));
        19 }
        20 int main(){
        21     Point p1(1, 1), p2(4, 5);
        22     cout << "the distance is:";
        23     cout << fDist(p1, p2) << endl;//计算两点之间的距离
        24     return 0;
        25 }

         友元函数直接使用了对象名访问了私有数据成员X,Y,而不是通过类的成员函数Getx(),Gety(),函数。




     

    二、友元类

      1、和友元函数一样,一个类也可以声明为另一个类的友元类。声明为友元的类可以访问该类的私有数据成员,该类的成员函数都是该友元类的成员函数

    • 友元类的应用详见下边代码:
    •  1 class A{
       2 public:
       3     int GetX() { return x; }
       4     friend class B;//B类是A类的友元类
       5     //其它成员略
       6 private:
       7     int x;
       8 };
       9 class B{
      10 public:
      11     void set(int i);
      12     //其他成员略
      13 private:
      14     A a;
      15 };
      16 void B :: set(int i){
      17     a.x = i;//由于B类是A类的友元类,所以在B的成员函数中可以访问A类对象的私有成员
      18 }

       

       

     

    转载于:https://www.cnblogs.com/southcyy/p/10260092.html

    展开全文
  • 友元函数

    2019-04-27 22:56:39
       友元函数是C++中,成员函数或者类外函数访问类里的私有数据成员用的比较方便的函数,友元函数的关键字是friend,我们暂时把它理解成“友好关系”的意思。    我们用两个类来比喻这种关系吧。 二.友元函数...

    一.关于友元函数

       友元函数是C++中,成员函数或者类外函数访问类里的私有数据成员用的比较方便的函数,友元函数的关键字是friend,我们暂时把它理解成“友好关系”的意思。
       我们用两个类来比喻这种关系吧。
    在这里插入图片描述
    由图可得知:
      1.Time类可以通过友元函数访问Date类的私有数据
      2.Date类可以通过友元函数访问Time类的私有数据
      3.友元函数能同时访问类TimeDate的私有数据,并建立联系。

    二.友元函数例题

      要求输出时分秒和年月日。要求用两个类,一个Date,一个Time。
    Time类的私有数据为hour ,minute ,second。
    Date类的私有数据为year ,day ,month。

    1.对于友元函数我们首先应该学会声明。声明如下:

    friend void display(Time &);//声明一个Time的友元函数
    friend void display(Date &);//声明一个Date的友元函数
    

    将此声明函数放到TimeDate类中。
    2.友元函数的的定义。定义如下:

    void display(Date &d)
    {
    	cout << d.month << "/" << d.day << "/" << d.year << endl;
    	
    }
    void display(Time &t)
    {
    	cout << t.hour << ":" << t.minute << ":" << t.second << endl;
    }
    

    我们定义了两个输出函数,形参分别为&d&t

    #include<iostream>
    using namespace std;
    class Date;
    class Time
    {
    public:
    	Time(int, int, int);//声明构造函数
    	friend void display(Time &);//声明一个友元函数
    private:
    	int hour;
    	int minute;
    	int second;
    };
    class Date
    {
    public:
    	Date(int, int, int);//声明构造函数
    	friend void display(Date &);
    private:
    	int year;
    	int month;
    	int day;
    };
    Time::Time(int h, int m, int s)
    {
    	hour = h;
    	minute = m;
    	second = s;
    }
    void display(Date &d)
    {
    	cout << d.month << "/" << d.day << "/" << d.year << endl;
    	
    }
    void display(Time &t)
    {
    	cout << t.hour << ":" << t.minute << ":" << t.second << endl;
    }
    Date::Date(int y, int m, int d)
    {
    	year = y;
    	month = m;
    	day = d;
    }
    int main()
    {
    	Time t1(10, 13, 56);
    	Date d1(12, 25, 2004);
    	display(t1);
    	display(d1);
    	return 0;
    }
    

    三.总结

    友元函数的使用主要是为了保护数据的安全。

    展开全文
  • 友元函数和友元类

    2019-10-05 12:00:39
    其中,friend是说明友元函数的关键字,友元声明可以出现在类中的任何地方。通常,将友元声明成组地放在类定义的开始或结尾是个好主意。归纳起来,友元函数是一种能够访问类中私有成员的非类成员函数,友元函数在定义...

    关键字 friend

    友元函数是一种特殊的函数,它需要在类体内进行说明,可以访问类的私有成员和保护成员,但又不是类的成员函数。

    其中,friend是说明友元函数的关键字,友元声明可以出现在类中的任何地方。通常,将友元声明成组地放在类定义的开始或结尾是个好主意。归纳起来,友元函数是一种能够访问类中私有成员的非类成员函数,友元函数在定义上和调用上与普通函数一样

    友元的作用在于提高程序的运行效率,但是,它破坏了类的封装性和隐藏性,使得非成员函数可以访问类的私有成员。因此,只有在十分需要的时候才使用友元函数。

    转载于:https://www.cnblogs.com/zhousong918/p/10418251.html

    展开全文
  • 类中,声明友元函数的关键字为friend,声明的位置和public或private 无关。具体示例代码如下。 2.示例代码 #include "iostream" using namespace std; class A { public: friend void modifyA(A *pA,int _a);//...
  • 在一个类中,可以利用关键字friend将其他函数或类声明为友元,如果友元是一般函数或者类成员函数,称为友元函数,如果友元是一个类,则成为友元类,友元类所有成员函数都自动成为友元函数友元函数友元...
  • C++友元函数

    2019-03-20 21:32:33
    友元函数是可以直接访问类的私有或被保护的成员的...定义友元函数的关键字是friend 全局函数: #include<iostream> using namespace std; class Time { friend void printTime(Time &t); public: Ti...
  • 我在以下代码中有两个关于朋友声明的问题 .... (2)如果可能的话,我想声明与拥有非成员函数的模板类函数的友谊 . 我试图与 class 宣布朋友船,但失败了 . 请给我解决方案或建议 . 非常感谢你 .#include temp...
  • 主要介绍了剖析C++编程中friend关键字所修饰的友元函数和友元类,友元了以后在外部就可以访问到正常情况下无法访问到私有属性和方法,需要朋友可以参考下
  •    友元函数是C++中,成员函数或者类外函数访问类里的私有数据成员用的比较方便的函数,友元函数的关键字是friend,我们暂时把它理解成“友好关系”的意思。    我们用两个类来比喻这种关系吧。 由图可得知:...
  • 一、友元(friend)概念:通过友元,打破了类封装性,可以访问类内所有成员分类:友元函数、友元类二、友元函数 概念:友元函数是一个普通函数,不属于类,但需要在类内表明友元关系 友元函数可访问类内所有成员,...
  • 友元函数3.友元函数注意事项4.友元类5.友元类注意事项 1.友元介绍 友元是一种允许非类成员函数访问类非公有成员一种机制。 可以把一个函数指定为类友元,也可以把整个类指定为另一个类友元。 (1)友元函数...
  • 3.8 友元:友元函数和友元类 友元函数 :既可以是不属于任何类非成员函数,也可以是另一个类成员...在类中声明友元函数时,需在其函数名前加上关键字friend,此声明可以放在公有部分、也可以放在保护和私有部分...
  • 一般情况下,使用一个函数需要先声明,或者定义在前,但是声明一个全局函数为友元函数的时候,可以理解为只是声明,而非调用,因此不用先在类的前面声明该全局函数。另外,如果要在类的前面声明该友元函数,需要用到...
  • 如:客人可以访问客厅,但一般客人不可以去主人卧室,关系较好的朋友才能访问私有的卧室,这时就要用到友元友元的关键字为friend 示例 #include <iostream> #include <string> using namespace std; ...
  • 友元函数是可以直接访问类私有成员非成员函数。它是定义在类外普通函数,它不属于任何类,但需要在类定义中加以声明,声明时只需在友元名称前加上关键字friend。我们已知道类具有封装和信息隐藏特性。...
  • C++—友元函数

    2017-03-07 15:15:31
    在C++中友元函数允许在类外访问该类中任何成员,就象成员函数一样,友元函数关键字friend说明。 那么问题来了,为什么会需要友元函数和友元类呢?? 类具有封装和信息隐藏特性。只有类成员函数才能访问...
  • 友元函数的作用就是为了访问类的私有数据,而成员函数可以直接访问) 类的成员函数属于类,调用时其内部数据会通过this指针进行调用 友元函数不具备this指针 友元函数可以直接访问类的私有成员,它是定义在类外部...
  • 友元函数的简单认识

    2021-04-10 11:46:07
    友元函数的简单认识 类的友元函数是定义在类的外部,但是有权访问类的所有私有(private)成员和保护(protect)成员。 尽管友元函数的原型在类的定义中出现过,但是友元函数不是成员函数。 友元函数是一个函数,该...
  • 友元函数的说明

    2015-06-25 19:28:03
    1)必须在类的说明中说明友元函数,说明时以关键字friend开头,后跟友元函数的函数原型,友元函数的说明可以出现在类的任何地方,包括在private和public部分; 2)注意友元函数不是类的成员函数,所以友元函数的
  • 二、友元函数友元函数在类作用域外定义,但它需要在类体中进行说明为了与该类成员函数加以区别,定义方式是在类中用关键字friend说明该函数,格式如下: friend 类型 友元函数名(参数表);友元作用在于提高...
  • 友元函数 友元类 友元成员函数

    千次阅读 2018-05-07 22:34:40
    一般来说,类内私有数据是对外不可见,但在有些情况下,我们需要在类外对该类私有数据进行访问,这就需要用到一种新技术——友元(friend),即在声明前添加关键字friend。 友元关系是单向,即如果A是B...

空空如也

空空如也

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

友元函数的关键字