精华内容
下载资源
问答
  • C++中,一个类中可以有 public、protected、private 三种属性的成员,通过对象可以访问 public 成员,只有本类中的函数可以访问本类的 private 成员。现在,我们来介绍一种例外情况——友元(friend)。借助友元...

    在C++中,一个类中可以有 public、protected、private 三种属性的成员,通过对象可以访问 public 成员,只有本类中的函数可以访问本类的 private 成员。现在,我们来介绍一种例外情况——友元(friend)。借助友元(friend),可以使得其他类中的成员函数以及全局范围内的函数访问当前类的 private 成员。

    friend 的意思是朋友,或者说是好友,与好友的关系显然要比一般人亲密一些。我们会对好朋友敞开心扉,倾诉自己的秘密,而对一般人会谨言慎行,潜意识里就自我保护。在 C++ 中,这种友好关系可以用 friend 关键字指明,中文多译为“友元”,借助友元可以访问与其有好友关系的类中的私有成员。如果你对“友元”这个名词不习惯,可以按原文 friend 理解为朋友。

    友元函数

    在当前类以外定义的、不属于当前类的函数也可以在类中声明,但要在前面加 friend 关键字,这样就构成了友元函数。友元函数可以是不属于任何类的非成员函数,也可以是其他类的成员函数。

    友元函数可以访问当前类中的所有成员,包括 public、protected、private 属性的。

    1) 将非成员函数声明为友元函数。

    请大家直接看下面的例子:

    #include <iostream>
    using namespace std;
    
    class Student{
    public:
        Student(char *name, int age, float score);
    public:
        friend void show(Student *pstu);  //将show()声明为友元函数
    private:
        char *m_name;
        int m_age;
        float m_score;
    };
    
    Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }
    
    //非成员函数
    void show(Student *pstu){
        cout<<pstu->m_name<<"的年龄是 "<<pstu->m_age<<",成绩是 "<<pstu->m_score<<endl;
    }
    
    int main(){
        Student stu("小明", 15, 90.6);
        show(&stu);  //调用友元函数
        Student *pstu = new Student("李磊", 16, 80.5);
        show(pstu);  //调用友元函数
    
        return 0;
    }
    
    //运行结果:
    //小明的年龄是 15,成绩是 90.6
    //李磊的年龄是 16,成绩是 80.5

    show() 是一个全局范围内的非成员函数,它不属于任何类,它的作用是输出学生的信息。m_name、m_age、m_score 是 Student 类的 private 成员,原则上不能通过对象访问,但在 show() 函数中又必须使用这些 private 成员,所以将 show() 声明为 Student 类的友元函数。


    注意,友元函数不同于类的成员函数,在友元函数中不能直接访问类的成员,必须要借助对象。下面的写法是错误的:

    void show()
    {
        cout<<m_name<<"的年龄是 "<<m_age<<",成绩是 "<<m_score<<endl;
    }
    
    
    
    
    
    成员函数在调用时会隐式地增加 this 指针,指向调用它的对象,从而使用该对象的成员;而 show() 是非成员函数,没有 this 指针,编译器不知道使用哪个对象的成员,要想明确这一点,就必须通过参数传递对象(可以直接传递对象,也可以传递对象指针或对象引用),并在访问成员时指明对象。
    

    2) 将其他类的成员函数声明为友元函数

    friend 函数不仅可以是全局函数(非成员函数),还可以是另外一个类的成员函数。请看下面的例子:

    #include <iostream>
    using namespace std;
    
    class Address;  //提前声明Address类
    
    //声明Student类
    class Student{
    public:
        Student(char *name, int age, float score);
    public:
        void show(Address *addr);
    private:
        char *m_name;
        int m_age;
        float m_score;
    };
    
    //声明Address类
    class Address{
    private:
        char *m_province;  //省份
        char *m_city;  //城市
        char *m_district;  //区(市区)
    public:
        Address(char *province, char *city, char *district);
        //将Student类中的成员函数show()声明为友元函数
        friend void Student::show(Address *addr);
    };
    
    //实现Student类
    Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }
    void Student::show(Address *addr){
        cout<<m_name<<"的年龄是 "<<m_age<<",成绩是 "<<m_score<<endl;
        cout<<"家庭住址:"<<addr->m_province<<"省"<<addr->m_city<<"市"<<addr->m_district<<"区"<<endl;
    }
    
    //实现Address类
    Address::Address(char *province, char *city, char *district){
        m_province = province;
        m_city = city;
        m_district = district;
    }
    
    int main(){
        Student stu("小明", 16, 95.5f);
        Address addr("陕西", "西安", "雁塔");
        stu.show(&addr);
       
        Student *pstu = new Student("李磊", 16, 80.5);
        Address *paddr = new Address("河北", "衡水", "桃城");
        pstu -> show(paddr);
    
        return 0;
    }
    
    //运行结果:
    //小明的年龄是 16,成绩是 95.5
    //家庭住址:陕西省西安市雁塔区
    //李磊的年龄是 16,成绩是 80.5
    //家庭住址:河北省衡水市桃城区


    本例定义了两个类 Student 和 Address,程序第 27 行将 Student 类的成员函数 show() 声明为 Address 类的友元函数,由此,show() 就可以访问 Address 类的 private 成员变量了。

    几点注意:
    ① 程序第 对Address 类进行了提前声明,是因为在 Address 类定义之前、在 Student 类中使用到了它,如果不提前声明,编译器会报错,提示'Address' has not been declared类的提前声明和函数的提前声明是一个道理。

    ② 程序将 Student 类的声明和实现分开了,而将 Address 类的声明放在了中间,这是因为编译器从上到下编译代码,show() 函数体中用到了 Address 的成员 province、city、district,如果提前不知道 Address 的具体声明内容,就不能确定 Address 是否拥有该成员(类的声明中指明了类有哪些成员)。

    ③ 一个函数可以被多个类声明为友元函数,这样就可以访问多个类中的 private 成员。

     

    友元类

    不仅可以将一个函数声明为一个类的“朋友”,还可以将整个类声明为另一个类的“朋友”,这就是友元类。友元类中的所有成员函数都是另外一个类的友元函数。

    例如将类 B 声明为类 A 的友元类,那么类 B 中的所有成员函数都是类 A 的友元函数,可以访问类 A 的所有成员,包括 public、protected、private 属性的。

    更改上例的代码,将 Student 类声明为 Address 类的友元类:

    #include <iostream>
    using namespace std;
    
    class Address;  //提前声明Address类
    
    //声明Student类
    class Student{
    public:
        Student(char *name, int age, float score);
    public:
        void show(Address *addr);
    private:
        char *m_name;
        int m_age;
        float m_score;
    };
    
    //声明Address类
    class Address{
    public:
        Address(char *province, char *city, char *district);
    public:
        //将Student类声明为Address类的友元类
        friend class Student;
    private:
        char *m_province;  //省份
        char *m_city;  //城市
        char *m_district;  //区(市区)
    };
    
    //实现Student类
    Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }
    void Student::show(Address *addr){
        cout<<m_name<<"的年龄是 "<<m_age<<",成绩是 "<<m_score<<endl;
        cout<<"家庭住址:"<<addr->m_province<<"省"<<addr->m_city<<"市"<<addr->m_district<<"区"<<endl;
    }
    
    //实现Address类
    Address::Address(char *province, char *city, char *district){
        m_province = province;
        m_city = city;
        m_district = district;
    }
    
    int main(){
        Student stu("小明", 16, 95.5f);
        Address addr("陕西", "西安", "雁塔");
        stu.show(&addr);
       
        Student *pstu = new Student("李磊", 16, 80.5);
        Address *paddr = new Address("河北", "衡水", "桃城");
        pstu -> show(paddr);
    
        return 0;
    }

    将 Student 类声明为 Address 类的友元类,声明语句为:

    friend class Student;

    有的编译器也可以不写 class 关键字,不过为了增强兼容性还是建议写上。

    关于友元,有两点需要说明:

    • 友元的关系是单向的而不是双向的。如果声明了类 B 是类 A 的友元类,不等于类 A 是类 B 的友元类,类 A 中的成员函数不能访问类 B 中的 private 成员。
    • 友元的关系不能传递。如果类 B 是类 A 的友元类,类 C 是类 B 的友元类,不等于类 C 是类 A 的友元类。

    除非有必要,一般不建议把整个类声明为友元类,而只将某些成员函数声明为友元函数,这样更安全一些。

    展开全文
  • C++友元函数的定义和使用 <C++析构函数C++友元类> 类的封装性实现了数据隐藏,即类的私有成员在该类的作用域之外是不可见的。但有时可能需要在类的外部访问类的私有成员,为此 C++ 提供了一种允许类外的函数...

    本文参考:http://www.itxueyuan.org/view/100.html

    C++析构函数C++友元类 >

    类的封装性实现了数据隐藏,即类的私有成员在该类的作用域之外是不可见的。但有时可能需要在类的外部访问类的私有成员,为此 C++ 提供了一种允许类外的函数或其他的类访问该类的私有成员的方法,它通过关键字 friend 把其他类或函数声明为一个类的友元。

    友元的使用就好比一个独立的个人,私有成员是个人的秘密,本来对外界是保密的,但对于好朋友却没必要隐藏,这样好朋友就可以了解个人的所有秘密。在编程中,如果模拟空调和遥控器的程序,就可以使用友元关系来处理,遥控器不是空调或空调的一部分,但可以改变空调的状态。

    本节只讲解 C++ 友元函数,C++ 友元类将在下节讲解。

    友元函数是声明在类体内的一般函数,也可以是另一个类中的成员函数。友元函数并不是这个类中的函数,但它具有这个类中成员函数所具有的访问该类所有成员的功能。接下来分两种情况讨论友元函数。

    C++普通函数作为友元函数

    普通函数作为友元函数,其语法格式如下:

    friend 函数返回值类型 函数名(形式参数列表);


    接下来演示普通函数作为友元函数的用法,如例 1 所示。

    【例 1】

    #include <iostream>
    #include <cmath>
    using namespace std;
    class Point
    {
    public:
    Point(int a = 0, int b = 0)
    {
    x = a;
    y = b;
    }
    void print()
    {
    cout << "(" << x <<","<< y<< ")";
    }
    friend double Distance(Point a, Point b); //友元函数的声明
    private:
    int x, y;
    };
    double Distance(Point a, Point b) //友元函数的定义
    {
    int x = a.x - b.x;
    int y = a.y - b.y;
    return sqrt(x * x + y * y);
    }
    int main()
    {
    Point p1(3, 4), p2;
    double d = Distance(p1, p2); //友元函数的调用
    p1.print();
    p2.print();
    cout << " 距离为"<< d << endl;
    return 0;
    }

    程序执行结果为:

    (3,4)(0,0) 距离为5

    在例 1 中,Point 类中声明了一个友元函数,它是普通函数定义在类体外。友元函数中通过指定的对象访问了类中的私有数据成员,并进行了运算。

    C++类中的成员函数作为另一个类的友元函数

    类中的成员函数作为另一个类的友元函数,其语法格式如下:

    friend 类名::函数返回值类型 函数名(形式参数列表);


    接下来演示类中的成员函数作为另一个类的友元函数的用法,如例 2 所示。

    【例 2】

    #include <iostream>
    using namespace std;
    class B; //声明B类
    class A //定义A类
    {
    public:
    A(int x = 0)
    {
    a = x;
    }
    void print()
    {
    cout << "A: a = " << a << endl;
    }
    void func(B &var);
    private:
    int a;
    };
    class B //定义 B 类
    {
    public:
    B(int y = 0)
    {
    b = y;
    }
    void print()
    {
    cout << "B: b = " << b << endl;
    }
    friend void A::func(B &var); //将 A 类中的成员函数 func() 声明为 B 类的友元函数
    private:
    int b;
    };
    void A::func(B &var) //友元函数的定义
    {
    a = var.b;
    }
    int main()
    {
    A m(2);
    m.print();
    B y(3);
    y.print();
    m.func(y); //友元函数的调用
    m.print();
    return 0;
    }

    程序执行结果为:

    A: a = 2
    B: b = 3
    A: a = 3

    在例 2 中,第 3 行必须声明 B 类,因为只有 A 类完整定义过之后,才能定义友元的 B 类,而A类中又使用了“B”这个标识符,因此就需要使用类的声明。类的声明并不是对类的完整定义,它只是告诉编译器标识符的含义,一个只有声明的类是不能实例化的。

    在使用友元函数时,还需要注意以下几点:

    • 友元函数必须在类的定义中声明;
    • 友元函数的声明可以出现在类的任何地方,包括在 private 和 protected 部分;
    • C++ 不允许将某个类的构造函数、析构函数和虚函数声明为友元函数。
    • C++primer5th上250页说,不完全类型只能在以下情况使用(1)可以定义指向这种类型的指针或引用(2)可以声明(不能定义)以不完全类型作为参数或者返回类型的函数。

     

    我自己写了一个程序,证明不完全类型也可以声明指向它自己类型的引用。(估计定义指向它的指针也可以),如下:

    #include <iostream>
    #include <string>
    using namespace std;
    class Test{
    	public:
    		Test() = default;
    		Test(int k1,int k2):i(k1),j(k2){}
    		void print()const;
    		void fun(Test &t);//这里,Test还没没定义完,还是个不完全类型。结果通过编译
    	private:
    		int i;
    		int j;
    };
    void Test::print()const
    {
    cout << i << endl;
    cout << j << endl;
    }
    void Test::fun(Test &t)
    {
       if(i > 0) {cout << "first private data's sum:" << i + t.i<< endl;}
       if(j > 0) {cout <<"second private data's sum:."<< j+ t.j << endl;}
    }
    int main()
    {
    Test t1(1,2);
    Test t2(100,200);
    t1.print();
    t1.fun(t2);
    
    
    return 0;
    }

    结论,不完全类型可以声明它的引用。

    展开全文
  • } //流运算符友元函数重载 继承和派生 在C++中 代码重用通过继承机制实现 继承就是在一个已有类得基础上,建立一个新类 类可升级可维护 基类定义了公共得内容,方便统一修改 代码得可重用性:类库 添加新类,新成员...

    友元
    1.1为什么要使用友元函数
    在实现类之间数据共享时,减少系统开销,提高效率。如果类A中的函数要访问类B中的成员(例如:智能指针类的实现),那么类A中该函数要是类B的友元函数。
    具体来说:为了使其他类的成员函数直接访问该类的私有变量。即:允许外面的类或函数去访问类的私有变量和保护变量,从而使两个类共享同一函数。

    实际上具体大概有下面两种情况需要使用友元函数:(1)运算符重载的某些场合需要使用友元。(2)两个类要共享数据的时候。

    1.2使用友元函数的优缺点
    优点:能够提高效率,表达简单、清晰。

    缺点:友元函数破环了封装机制,尽量不使用成员函数,除非不得已的情况下才使用友元函数。

    B类中嵌A类对象,但是B的成员函数无法直接访问A的私有成员
    1.某类中嵌套了一个类,该类普通成员函数可以直接访问
    2.普通函数可以访问那个类中的数据
    实现:

    • 友元函数(普通函数+其他了类的成员函数)

    <1>friend <类型标识符> <友元函数名> (参数表)
    <2>friend <类型标识符> 类名 ::<友元函数名> (参数表)

    • 简单使用,普通函数
      <1>
    class cpoint
    {
    	doule x, y;
    public:
    	
    }
    

    重载运算符

    //重载+运算符
    const Integer operator+(const Integer & other) const;
    const Integer operator-(const Integer & other) const;
    const Integer operator*(const Integer & other) const;
    const Integer operator/(const Integer & other) const;
    const Integer operator%(const Integer & other) const;
    //重载赋值运算符,需要const修饰函数
    //num4.operator = (num3)
    const Integer & operator = (const Integer & other);
    //二元运算符建议采用友元得方式重载
    friend const Integer operator + (int intvalue, const Integer & other)
    //流运算符一般智能使用友元函数进行重载
    friend ostream & operator << (ostream & out , const Integer & num);
    
    
    
    //友元函数不需要使用域运算符了
    const Integer operator +( int intvalue , const Integer & other)
    {
    	return Integer(intvalue + other.m_value);
    }
    //流运算符友元函数重载
    
    

    继承和派生
    在C++中 代码重用通过继承机制实现

    • 继承就是在一个已有类得基础上,建立一个新类
    • 类可升级可维护
    • 基类定义了公共得内容,方便统一修改
    • 代码得可重用性:类库
    • 添加新类,新成员方便

    注意

    • 派生类对象包含了基类得数据成员,派生类继承了积累得实现
    • 派生类对象可以使用基类得非私有函数
    • 派生类需要自己的构造函数
    • 派生类可以添加额外的数据成员和函数

    1、公有继承

    //hero.h文件
    #ifndef HER0_H
    #define HER0_H
    #include <iostream>
    #include <string>
    using namespace std;
    /**
      *英雄基类/父类
      */
    class Hero
    {
    	private:
    		string m_NickName;
    		int m_lever;
    		int m_MaxLife;
    		int m_CurrLife
    	public:
    		Hero();
    		void Move();
    }
    class Warrior :public Hero
    {
    	//战士特有的成员和函数
    }
    class Archmage :public Hero
    {
    	//法师特有的成员和函数
    }
    #endif //HER0_H
    

    继承方式提供程序员对类进行封装的机制

    • 公有继承:(无法访问基类的私有,维持基类的访问权限)
    • 私有继承:(除了基类的私有成员,其他成员都会改为私有)
    • 受保护继承:(无法访问基类的私有,基类的共有变为受保护)

    不管使用哪种继承,派生类都不能访问基类的私有成员(除非改为共有成员)
    private:私有
    public:共有
    prtected:受保护的

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

    2021-01-06 21:13:17
    友元函数是在类中用关键字friend修饰的非成员函数。友元函数可以是一个普通的函数,也可以是其他类的成员函数,虽然它不是本类的成员函数,但是在它的函数体中可以通过对象名访问类的私有和保护成员。 #include <...

    友元函数是在类中用关键字friend修饰的非成员函数。友元函数可以是一个普通的函数,也可以是其他类的成员函数,虽然它不是本类的成员函数,但是在它的函数体中可以通过对象名访问类的私有和保护成员。

    #include <iostream>
    #include <cmath>
    
    using namespace std;
    
    class Point {
    	private:
    		int x, y;      // 私有数据成员 
    	public:
    		Point(int x = 0, int y = 0) : x(x), y(y){}
    		
    		int getX() {
    			return x;
    		}
    		
    		int getY() {
    			return y;
    		}
    		
    		friend float dist(Point &p1, Point &p2);  // 友元函数声明
    }; 
    
    float dist(Point &p1, Point &p2){
    	double x = p1.x - p2.x;
    	double y = p1.y - p2.y;
    	return static_cast<float>(sqrt(x * x + y * y));  // static_cast是一个c++运算符,功能是把一个表达式转换为float类型。
    }
    
    int main(){
    	Point *point1 = new Point(1, 1);  // 定义 Point 类的对象 
    	Point *point2 = new Point(4, 5);   // 定义 Point 类的对象 
    	
    	cout << "两点间的距离是:";
    	cout << dist(*point1, *point2) << endl;  // 计算两点间的距离 
    	
    	delete point2;
    	delete point1;
    	
    	return 0;
    }
    

    注:友元函数不仅可以是一个普通函数,也可以是另一个类的成员函数。友元成员函数的使用和一般友元函数的使用基本相同,只是要通过相应的类或对象名来访问。

    #include<iostream>
    
    using namespace std;
    
    class girl{
    	private:
    	    char name;
    	    int age;
    	    
    	public:
    	    girl(char n, int d){     //构造函数
    	        name = n;
    		    age = d;
    		}
    		
    		friend void display(girl &x);  //声明友元函数
    };
    
    void display(girl &x){    //类外定义 友元函数
        cout << "姓名:" << x. name << "\n年龄:" << x.age << endl;
        //girl类的友元函数能访问girl类对象的私有成员
    }
    
    int main(){
        girl e('z', 18);
        display(e); //调用友元函数
    	         
        return 0;
    }
    
    展开全文
  • 一、友元函数友元函数是一种特殊的函数,它需要在类体内进行说明,可以访问类的私有成员和保护成员,但又不是类的成员函数。友元函数的说明如下:friend 数据类型函数名(参数)其中,friend是说明友元函数的关键字,...
  • 1.友元函数调用类成员变量要先定义类对象,然后通过对象调用,并且可以访问任何成员,成员函数就不需要定义类对象,可以直接使用数据成员, 2.友元函数和成员函数的定义方式不同,友元函数有个friend修饰 3.定义...
  • .h文件 #ifndef SRC_STUDENT_H_ #define SRC_STUDENT_H_ class ... score 报错 Field 'score' could not be resolved 我已经声明了setscore()是类Student的友元函数为什么还是调用不了其中的私有成员变量score呢?
  • 但有时可能需要在类的外部访问类的私有成员,为此 C++ 提供了一种允许类外的函数或其他的类访问该类的私有成员的方法,它通过关键字friend把其他类或函数声明为一个类的友元友元的使用就好比一个独立的个人,私有...
  • C++友元函数与友元类

    2021-03-15 15:12:59
    友元函数是一个可以访问类的私有成员的函数,并且它不属于这个类。 友元类则是可以访问另一个类的私有成员的类。 声明友元函数/友元类,则需要这样做: 比如,我们需要生命ClassTwo是ClassOne的友元类,那么...
  • @TOC今天记录的是c++中的友元函数的主要用法,话不多说,直接看正文! 一、全局函数做友元 #include <iostream> using namespace std; #include <string> //首先定义一个Building类 class Building { ...
  • C++友元函数、友元类

    2021-02-03 14:36:40
    友元 友元是一种定义在类外部的普通函数或类,需要在类体内进行说明,为了与该类的成员函数加以区别,在说明时前面加以关键字friend。 友元提出的原因: 类具有封装和信息隐藏...友元函数不是成员函数,但是它可以访问
  • C++友元函数概述

    千次阅读 2020-12-21 16:35:10
    友元函数  类的友元函数是定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。 #include <iostream> ...
  • C++友元函数

    2021-06-15 17:08:22
    类的友元函数是定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。 友元可以是一个函数,该函数被称为友元函数...
  • 友元函数是一个不属于类成员的函数,但它可以访问该类的私有成员。换句话说,友元函数被视为好像是该类的一个成员。友元函数可以是常规的独立函数,也可以是其他类的成员。实际上,整个类都可以声明为另一个类的友元...
  • c++中对类的成员设置了保护,如private和protected是不允许外部访问的,有时候有一个外部函数就是需要访问,为了解决这个问题,c++开了个后门,就是友元函数友元函数就是将外部函数在类中进行申明,声明时前面...
  • C++虚函数和友元函数

    2021-04-13 11:50:53
    C++等面向对象程序设计语言中有虚函数、虚方法的概念。这种函数或方法可以被子类继承和覆盖,通常使用动态分派实现。虚函数这一概念是面向对象程序设计中多型的重要组成部分。虚函数可以给出目标函数的定义,但该...
  • 私有成员只能在类的成员函数内部访问,如果想在别处访问对象的私有成员,只能通过类提供的接口(成员函数)间接地进行...C++ 设计者认为, 如果有的程序员真的非常怕麻烦,就是想在类的成员函数外部直接访问对象的私有...
  • C++中的友元函数

    2021-05-13 02:49:54
    1为什么要使用友元函数在实现类之间数据共享时,减少系统开销,提高效率。如果类A中的函数要访问类B中的成员(例如:智能指针类的实现),那么类A中该函数要是类B的友元函数。具体说:为了使其他类的成员函数直接访问...
  • 但是,有时需要定义一些函数,这些函数不是类的一部分,但又需要频繁地访问类的数据成员,这时可以将这些函数定义为该函数的友元函数。除了友元函数外,还有友元类,两者统称为友元。友元的作用是提高了程序的运行...
  • c++友元类和友元函数

    2021-05-06 16:10:28
    一、友元函数 友元函数和普通函数最大的区别在于友元函数可以直接访问类的私有成员和保护成员; 友元函数不属于类的成员函数,但是友元函数必须在类内部定义; 友元函数使用friend关键词声明; 友元函数能够实现类...
  • 友元函数3. 友元类4. 友元成员函数 1. 前言 友元,一种定义在类外部的普通函数或类,但它需要在类体内进行说明,为了与该类的成员函数加以区别,在说明时前面加以关键字friend。贴一下百度百科的解释百度百科-友元...
  • #include "stdafx.h" #include "ioStream.h" #include "string.h" typedef char String[30];... CPerson(String Name,int Age)//构造函数 { strcpy(name,Name); age = Age; } friend char * GetName(CP.
  • c++友元函数

    2021-11-24 19:10:17
    ~普通友元函数 ~以另一个类的成员函数充当友元函数 ps: ~友元只是提供一个场所,赋予对象能打破类的权限限定(无视权限) ~不是说可以忽视掉原来的规则,类中的数据成员必须通过对象去调用 小知识: 无参普通...
  • c++ 友元函数

    2021-11-02 21:04:21
    友元函数 使用规则 在类(结构体)中需要定义友元函数的原型(前面加friend) friend只能在友元函数的原型加,不能在友元函数的实现部分加friend 尽管友元函数的原型在类中定义,但不能像调用类成员方法一样调用友元...
  • c++友元函数和友元类

    2021-04-19 14:19:39
    友元函数 友元函数不是本类的成员函数,而是一个外部函数 友元函数的标志就是在类内部加friend关键字来声明 友元函数声明的位置不要求,写在private或者protected或者public内都可以,反正只要有声明就行 ...

空空如也

空空如也

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

c++友元函数

c++ 订阅
友情链接: android-topeka-master.zip