精华内容
下载资源
问答
  • C++ 友元

    2021-10-31 10:07:31
    C++ 友元1. 何为友元2. 同类对象之间无隐私3.异类对象之间有友元3.1 友元函数3.1.1 全局函数作友元函数3.1.2 类成员函数作友元函数3.2 友元类4. 小结4.1 声明位置4.2 友元利弊4.3 注意事项 1. 何为友元 采用类的机制...

    1. 何为友元

    采用类的机制后实现了数据的隐藏与封装,类的数据成员一般定义为私有成员,成员函数一般定义为公有的,依此提供类与外界间的通信接口。但是,有时需要定义一些函数,这些函数不是类的一部分,但又需要频繁地访问类的数据成员,这时可以将这些函数定义为该类的友元函数。除了友元函数外,还有友元类,两者统称为友元。友元的作用是提高了程序的运行效率(即减少了类型和安全性检查及调用的时间开销),但它破坏了类的封装性和隐藏性,使得非成员函数可以访问类的私有成员。
    友元可以是一个函数,该函数被称为友元函数;友元也可以是一个类,该类被称为友元类。

    2. 同类对象之间无隐私

    MyString::MyString(const MyString & other)
    {
    	int len = strlen(other._str);
    	this->_str = new char[len+1];
    	strcpy(this->_str,other._str);
    }
    

    3.异类对象之间有友元

    友元目的本质,是让其它不属于本类的成员(全局函数,其它类的成员函数),成为类的成员而具备了本类成员的属性。

    3.1 友元函数

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

    friend 类型 函数名(形式参数);
    

    一个函数可以是多个类的友元函数,只需要在各个类中分别声明。

    3.1.1 全局函数作友元函数

    #include<iostream>
    #include<cmath>
    using namespace std;
    class Point
    {
    public:
        Point(double xx, double yy)
        {
            x = xx;
            y = yy;
        }
        void Getxy();
    friend double Distance(Point &a, Point &b);
    private:
        double x, y;
    };
    void Point::Getxy()
    {
        cout << "(" << x << "," << y << ")" << endl;
    }
    double Distance(Point &a, Point &b)
    {
        double dx = a.x - b.x;
        double dy = a.y - b.y;
        return sqrt(dx*dx + dy*dy);
    }
    int main(void)
    {
        Point p1(3.0, 4.0), p2(6.0, 8.0);
        p1.Getxy();
        p2.Getxy();
        double d = Distance(p1, p2);
        cout << "Distance is" << d << endl;
        return 0;
    }
    

    输出结果

    3.1.2 类成员函数作友元函数

    #include<iostream>
    #include<cmath>
    using namespace std;
    class Point;
    class ManagerPoint
    {
    public:
        double Distance(Point &a, Point &b);
    };
    class Point
    {
    public:
        Point(double xx, double yy)
        {
            x = xx;
            y = yy;
        }
        void Getxy();
    friend double ManagerPoint::Distance(Point &a, Point &b);
    private:
        double x, y;
    };
    void Point::Getxy()
    {
        cout << "(" << x << "," << y << ")" << endl;
    }
    double ManagerPoint::Distance(Point &a, Point &b)
    {
        double dx = a.x - b.x;
        double dy = a.y - b.y;
        return sqrt(dx*dx + dy*dy);
    }
    int main(void)
    {
        Point p1(3.0, 4.0), p2(6.0, 8.0);
        p1.Getxy();
        p2.Getxy();
        ManagerPoint mp;
        float d = mp.Distance(p1,p2);
        cout << "Distance is" << d<< endl;
        return 0;
    }
    

    输出结果

    3.2 友元类

    友元类的所有成员函数都是另一个类的友元函数,都可以访问另一个类中的隐藏信息(包括私有成员和保护成员)。
    当希望一个类可以存取另一个类的私有成员时,可以将该类声明为另一类的友元类。定义友元类的语句格式如下:

    friend class 类名;
    其中:friendclass 是关键字,类名必须是程序中的一个已定义过的类。
    例如,以下语句说明类 B 是类 A 的友元类:
    class A
    {public:
    	friend class B;};
    

    经过以上说明后,类 B 的所有成员函数都是类 A 的友元函数,能存取类 A 的私有成员和保护成员。

    4. 小结

    4.1 声明位置

    友元声明以关键字 friend 开始,它只能出现在类定义中。因为友元不是授权类的成员,所以它不受其所在类的声明区域 public private 和 protected 的影响。通常我们选择把所有友元声明组织在一起并放在类头之后。

    4.2 友元利弊

    友元不是类成员,但是它可以访问类中的私有成员。友元的作用在于提高程序的运行效率,但是,它破坏了类的封装性和隐藏性,使得非成员函数可以访问类的私有成员。不过,类的访问权限确实在某些应用场合显得有些呆板,从而容忍了友元这一特别语法现象。

    4.3 注意事项

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

    展开全文
  • } //流运算符友元函数重载 继承和派生 在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++友元函数的定义和使用 <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++友元以及访问权限

    2021-08-29 11:45:53
    文章目录访问权限友元 访问权限 权限从大到小是public>protected>private public 可以被该类中的函数,子类的函数,其友元函数访问,也可以由,该类的对象访问 protected 可以被该类中的函数,子类的函数,其友元...

    文章目录

    访问权限

    权限从大到小是public>protected>private

    public
    

    可以被该类中的函数,子类的函数,其友元函数访问,也可以由,该类的对象访问

    protected
    

    可以被该类中的函数,子类的函数,其友元函数访问,但不能被该类的对象访问。

    private
    

    只能由该类中的函数,其友元函数访问,不能被其他访问,该类的对象也不能访问。

    友元

    友元顾名思义是作为朋友的一个成员,他的访问权限比较大,友元可以分为友元类,友元函数,他们可以访问类中的被private修饰的私有成员,友元的修饰符是用friend修饰。

    友元全局函数
    
    #include <iostream>
    using namespace std;
    class person{
            friend void visit();只需要在类中声明时添加一个friend修饰符
            public:
                    person(int age){
                            m_age=age;
                    }
            private:
            int m_age;
    };
    void visit(){
            person p1(52);
            cout<<"年龄是:"<<p1.m_age<<endl;
    }
    int main(){
            visit();
            return 0;
    }
    
    

    请添加图片描述

    友元类
    
    #include <iostream>
    using namespace std;
    class person{
         		 friend class student;
            public:
                    person(){
                            m_age=20;
                    }
            private:
            int m_age;
    
    };
     class student{
            public:
                    void visit(){
                            cout<<m_p.m_age<<endl;
                    }
            person m_p;
    };
    int main(){
            student s;
            s.visit();
            return 0;
    }
    
    
    友元成员函数
    
    #include <iostream>
    #include <string>
    using namespace std;
    class person;
     class student{
            public:
                    void visit();
            person *m_p;
    };
    class person{
            friend void student::visit();
            public:
                    person(){
                            m_age=20;
                    }
            private:
            int m_age;
    };
            void student::visit(){
                    m_p=new person;
                    cout<<m_p->m_age<<endl;
    }
    int main(){
            student s;
            s.visit();
            return 0;
    }
    
    

    请添加图片描述

    展开全文
  • c++友元

    2021-04-19 20:31:19
    在程序里,有些私有属性 也想让类外特殊的一些函数或者类进行访问,就需要用到友元的技术 友元的目的就是让一个函数或者类 访问另一个类中私有成员 友元的关键字为 friend 友元的三种实现 全局函数做友元 类做友元 ...
  • C++友元

    2021-01-25 22:17:25
    友元的目的就是让一个函数或者类访问另一个类中私有成员 友元的关键字:friend 友元的三种实现: 1.全局函数做友元 2.类做友元 3.成员函数做友元 一.全局函数做友元 #include <iostream> using namespace std;...
  • c++友元类和友元函数

    2021-05-06 16:10:28
    一、友元函数 友元函数和普通函数最大的区别在于友元函数可以直接访问类的私有成员和保护成员; 友元函数不属于类的成员函数,但是友元函数必须在类内部定义; 友元函数使用friend关键词声明; 友元函数能够实现类...
  • C++中,一个类中可以有 public、protected、private 三种属性的成员,通过对象可以访问 public 成员,只有本类中的函数可以访问本类的 private 成员。现在,我们来介绍一种例外情况——友元(friend)。借助友元...
  • c++友元模板单例模式

    2021-06-30 19:51:08
    } 4、使用友元 以上这种方式还是可以直接创建util_tool 类的,我们换一种方式 #include #include using namespace std; template <typename T> struct singleton { //static T& Instance(); static T* v_ins_ptr;...
  • 友元破环了对象的封装特性,分为外部函数友元、成员函数友元以及类友元。 一、外部函数友元 若外部函数想访问私有成员,把它设置成友元函数。示例如下: class Int { private: int value; public: Int(int x =...
  • .h文件 #ifndef SRC_STUDENT_H_ #define SRC_STUDENT_H_ class ... score 报错 Field 'score' could not be resolved 我已经声明了setscore()是类Student的友元函数为什么还是调用不了其中的私有成员变量score呢?
  • C++友元和继承

    2021-01-13 09:49:46
    友元函数 原则上,不能从声明它们的同一类外部访问该类的私有成员和受保护成员。但是,此规则不适用于“朋友”。 友元是用friend关键字声明的函数或类。 如果非成员函数被声明为该类的朋友,则该非成员函数可以访问...
  • 前言:在C++中,我们使用类对数据进行了隐藏和封装,类的数据成员一般都定义为私有成员,成员函数一般都定义为公有的,以此提供类与外界的通讯接口。但是,有时需要定义一些函数,这些函数不是类的一...
  • C++ 友元函数

    2021-03-27 19:49:27
    友元也可以是一个类,该类被称为友元类,在这种情况下,整个类及其所有成员都是友元。 如果要声明函数为一个类的友元,需要在类定义中该函数原型前使用关键字 friend,如下所示: #include <iostream> using ...
  • 一、友元函数友元函数是一种特殊的函数,它需要在类体内进行说明,可以访问类的私有成员和保护成员,但又不是类的成员函数。友元函数的说明如下:friend 数据类型函数名(参数)其中,friend是说明友元函数的关键字,...
  • 1、成员函数做友元 #include<iostream> using namespace std; class Info { friend void test();//利用关键字声明全局函数,可以访问私有的属性 public: void public_info() { cout << "公开信息...
  • 1.友元函数调用类成员变量要先定义类对象,然后通过对象调用,并且可以访问任何成员,成员函数就不需要定义类对象,可以直接使用数据成员, 2.友元函数和成员函数的定义方式不同,友元函数有个friend修饰 3.定义...
  • C++ 友元关系

    2021-11-29 21:08:45
    友元关系 友元关系是类之间的一种特殊关系, 这种关系不仅允许友元类访问对方的 public 方法和属性, 还允许友元访问对方的 protected 和 private 方法和属性。 声明一个友元关系的语法很简单,只要在类声明...
  • c++友元(笔记)

    2021-03-14 10:31:36
    在程序里,有些私有属性,想让类外特殊的一些函数或类进行访问,这就需要用到友元的技术 友元的目的就是让一个函数或者类访问另一个类中私有成员 友元关键字:friend 友元的三种实现 全局函数做友元 类做友元 成员...
  • c++友元函数和友元类

    2021-04-19 14:19:39
    友元函数 友元函数不是本类的成员函数,而是一个外部函数 友元函数的标志就是在类内部加friend关键字来声明 友元函数声明的位置不要求,写在private或者protected或者public内都可以,反正只要有声明就行 ...
  • #include "stdafx.h" #include "ioStream.h" #include "string.h" typedef char String[30]; class CPerson { private: String name;... CPerson(String Name,int Age)//构造函数 ... friend char * GetName(CP.
  • @TOC今天记录的是c++中的友元函数的主要用法,话不多说,直接看正文! 一、全局函数做友元 #include <iostream> using namespace std; #include <string> //首先定义一个Building类 class Building { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 41,122
精华内容 16,448
关键字:

c++友元

c++ 订阅
友情链接: w2vexp.rar