[C++] 友元

最新推荐文章于 2024-07-17 22:45:00 发布
最新推荐文章于 2024-07-17 22:45:00 发布
阅读量770 收藏 5
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37474728/article/details/85998618
版权

友元是一种定义在类外部的普通函数或类，但它需要在类体内进行说明，为了与该类的成员函数加以区别，在说明时前面加以关键字friend。友元不是成员函数，但是它可以访问类中的私有成员。（百度百科）

一、友元函数

如果某函数是某个类的友元函数，则可以在该函数中访问到该类的所有成员。

例：func()是类A的友元函数，则在func()中可以访问到类A的所有成员（包括私有成员和保护成员）。

/*code block 1*/
class A {
    friend int getAInfo(A a);
    friend int getAValue(A a);
    friend void doAShow(A a);
private:
    int info;

    void show() {
        cout << "info: " << info << ", value: " << value << endl;
    }
protected:
    int value;

public:
    A(int _info, int _value) : info(_info), value(_value) {
    }

    ~A() {
    }
};

//访问了类A的私有成员info
int getAInfo(A a) {
    return a.info;
}

//访问了类A的保护成员value
int getAValue(A a) {
    return a.value;
}

//调用了类A的私有成员函数show()
void doAShow(A a) {
    a.show();
}

int main() {
    A a1(45, 13);
    A a2(23, 3);

    cout << getAInfo(a1) << endl;
    cout << getAInfo(a2) << endl;
    cout << "-------------------" << endl;
    cout << getAValue(a1) << endl;
    cout << getAValue(a2) << endl;
    cout << "-------------------" << endl;
    doAShow(a1);
    doAShow(a2);

    return 0;
}

代码块1的运行结果如下：

上面说到了所有成员，那么静态成员呢？试试吧。

/*code block 2*/
class A {
    friend int getStaticMember();
    friend void doStaticFunction();
private:
    static int objectCount;
    static void show() {
        cout << "A::show()" << endl;
    }
public:
    A() {
        ++objectCount;
    }

    ~A() {
    }
};

int A::objectCount = 0;

//访问了类A的静态私有成员objectCount
int getStaticMember() {
    return A::objectCount;
}

//调用了类A的静态私有成员函数show()
void doStaticFunction() {
    A::show();
}

int main() {
    A a1;
    cout << "objectCount: " << getStaticMember() << endl;
    doStaticFunction();
    A a2;
    cout << "objectCount: " << getStaticMember() << endl;
    doStaticFunction();
    A a3;
    cout << "objectCount: " << getStaticMember() << endl;
    doStaticFunction();

    return 0;
}

代码块2的运行结果如下：

代码块1和2证明了类的友元函数可以访问类的所有成员。

二、友元类

若类A是类B的友元类，则类B中所有的成员都能在类A中访问到，称“类A中的所有成员都为类B的友元函数”（搞清楚这个关系）。简单来说就是，你是我的朋友，那么我的很多东西你都可以使用（C++里这种朋友更加无私，可以分享一切供朋友使用）。

看看下面的例子：

/*code block 3*/
class A {
    friend class B;

private:
    int info;

    static int objectCount;
protected:
    int value;

public:
    A(int _info, int _value) : info(_info), value(_value) {
        ++objectCount;
    }

    ~A() {
    }
};

int A::objectCount = 0;

class B {
public:
    //访问了类A的私有成员info
    void showAInfo(A a) {
        cout << "info: " << a.info << endl;
    }

    //访问了类A的保护成员info
    void showAValue(A a) {
        cout << "value: " << a.value << endl;
    }

    //访问了类A的静态私有成员objectCount
    void showAObjectCount() {
        cout << "objectCount: " << A::objectCount << endl;
    }
};

int main() {
    B b;
    A a1(13, 98);

    b.showAInfo(a1);
    b.showAValue(a1);
    b.showAObjectCount();
    A a2(4, 65);
    b.showAInfo(a2);
    b.showAValue(a2);
    b.showAObjectCount();

    return 0;
}

代码块3的运行结果如下：

这里要注意：就像那句话说的“我把你当兄弟，你却把我当父亲”，C++中类的友元关系也是单向的，不具有交换性。如果类A是类B的友元类，那么类A的所有成员函数都是类B的友元函数，反之不然。

下面，给出一个错误示例：

/*code blocks 4*/
class A {
    friend class B;
private:
    int info;

protected:
    int value;

public:
    A(int _info, int _value) : info(_info), value(_value) {
    }

    ~A() {
    }

    //访问类B的私有成员info和保护成员value
    void visitBMembers(B b) {
        cout << "B::info: " << b.info << ", B::value: " << b.value << endl;
    }
};

class B {
public:
    B(int _info, int _value) : info(_info), value(_value) {
    }

    ~B() {
    }

    //访问类A的私有成员info和保护成员value
    void visitAMembers(A a) {
        cout << "A::info: " << a.info << ", A::value: " << a.value << endl;
    }

private:
    int info;

protected:
    int value;
};

编译出错，报错内容如下：

上图中说“B has not been declared”，错误位置是在void A::visitBMembers(int)中，说明在类A中不能访问类B的私有成员和保护成员。也印证了上文中的说法，友元类的关系是单向的，不具有交换性。

那么，友元关系能不能够传递呢？再试试。（C是B的朋友，B是A的朋友，那C和A是什么关系）

/*code block 5*/
class A {
    friend class B;
private:
    int info;

public:
    A(int _info) : info(_info) {
    }

    ~A() {
    }
};

class B {
    friend class C;
private:
    int info;

public:
    B(int _info) : info(_info) {
    }

    ~B() {
    }

    //访问类A的私有成员info
    void visitAInfo(A a) {
        cout << "A::info: " << a.info << endl;
    }
};

class C {
public:
    //访问类B的私有成员info
    void visitBInfo(B b) {
        cout << "B::info: " << b.info << endl;
    }
};

int main() {
    A a(23);
    B b(34);
    C c;

    c.visitBInfo(b);
    b.visitAInfo(a);

    return 0;
}

代码块5的运行结果如下：

将代码块5的代码稍作修改如下（类A和类B的代码以及主函数不变）：

/*code block 6*/
class C {
public:
    //访问类B的私有成员info
    void visitBInfo(B b) {
        cout << "B::info: " << b.info << endl;
    }

    //访问类A的私有成员info
    void visitAInfo(A a) {
        cout << "A::info: " << a.info << endl;
    }
};

编译出错，报错内容如下：

说明类C不能直接访问类A的私有成员和保护成员，因此类C不是类A的友元类，即友元关系不具有传递性。

接下来，验证一下友元关系是否能继承。

/*code blocks 7*/
class A {
    friend class B;
private:
    int info;

public:
    A(int _info) : info(_info) {
    }

    ~A() {
    }
};

class B {
public:
    //访问A的私有成员info
    void BVisitAInfo(A a) {
        cout << "BVisitAInfo():A::info: " << a.info << endl;
    }
};

class C : public B {
public:
    //访问A的私有成员info
    void CVisitAInfo(A a) {
        cout << "CVisitAInfo():A::info: " << a.info << endl;
    }
};

编译出错，报错内容如下：

代码块7中，类B是类A的友元类，类C是类B的派生类。但从报错内容中可以看出，类A的私有成员info对类C是不可见的，所以友元关系也不能被继承。

三、类的成员函数作为另一个类的友元函数

若类A的某个成员函数是类B的友元函数，则可以通过该成员函数访问到类B的所有成员。

若类A是类B的友元类，则可以通过类A的所有成员函数访问到类B的所有成员。

这两者的差别其实就在于“所有”这两个字，友元类的开放范围更大，而成员函数作为另一个类的友元函数，开放的入口只有一个函数。

/*code blocks 8*/
//类B的前向声明
class B;

class A {
public:
    void visitBInfo(B b);
};

class B {
    friend void A::visitBInfo(B b);

private:
    int info;

public:
    B(int _info) : info(_info) {
    }

    ~B() {
    }
};

//访问类B的私有成员info
void A::visitBInfo(B b) {
    cout << "B::info: " << b.info << endl;
}

int main() {
    B b(87);
    A a;

    a.visitBInfo(b);

    return 0;
}

代码块8的运行结果如下：

/*code blocks 9*/
class B;

class A {
public:
    void visitBInfo(B b);
    void visitBInfoWithOutFriend(B b);
};

class B {
    friend void A::visitBInfo(B b);

private:
    int info;

public:
    B(int _info) : info(_info) {
    }

    ~B() {
    }
};

//访问B的私有成员info
void A::visitBInfo(B b) {
    cout << "B::info: " << b.info << endl;
}

//访问B的私有成员info
void A::visitBInfoWithOutFriend(B b) {
    cout << "B::info: " << b.info << endl;
}

编译出错，报错内容如下：

通过报错内容可以看到，未将void A::visitBInfoWithOutFriend(B)声明为类B的友元函数，是无法通过该函数访问到类B的私有成员和保护成员的。

 

基本上，到这里，关系就清楚了。

总结几点：

1、友元关系不具有交换性。

2、友元关系不具有传递性。

3、友元关系不可被继承。

4、若将类A作为类B的友元类，则类A中的所有成员函数都是类B的友元函数。

5、在某类外，只能通过被声明为该类的友元函数的函数访问该类的私有成员和保护成员。

大概，就这么多吧。欢迎补充。

RaydeLee
关注
c++友元
希望我的博客，能帮上你解决学习中工作中所遇到的问题
10-15 306
1友元函数 例如 class A1 { public: A1() { a1 = 100; a2 = 200; } int getA1() { return this->a1; } //声明一个友元函数 friend void setA1(A1 *p, int a1); //这个函数是这个类的好朋友 protected: private: int a1; int a2; }; void setA1(A1 *p, int a1) { p->a1 = a1; } void main() { A1
c++ 友元
weixin_33728268的博客
06-29 57
利用工作之余， 看了一天的友元居然都不理解， 第二天中午睡觉醒来后， 奇迹般的懂了， 把代码记录下来以防以后不懂    作用及特点 作用及特点   友元提供了不同类的成员函数之间、类的成员函数与一般函数之间进行数据共享的机制。通过友元，一个不同函数或另一个类中的成员函数可以访问类中的私有成员和保护成员。c++中的友元为封装隐藏这堵不透明的墙开了一个小孔，外界可以通过这个小孔窥视内部的秘密...
C++ :友元类
最新发布
qq_43441284的博客
07-17 415
有元函数是单向的两个类可以互为有元类、可以相互拥有有元方法C++编译器在寻找运算符函数时，找的自己内部的函数，有就用显示实现的函数，没有的话就使用默认实现的，有元函数是外部函数，就不太编译器寻找范围内。
C++ 友元
Knash的博客
06-08 1766
介绍C++ 中的 成员函数作友元，类作友元，全局函数作友元
C++-知识点6-友元
lusics的博客
04-02 407
友元https://www.cnblogs.com/zhuguanhao/p/6286145.html 友元函数、友元类和友元成员函数 想访问类种的私有成员，就用友元。public：friend声明只要在类内，位置不限。友元定义可以在类外任意位置。 有些情况下，允许特定的非成员函数访问一个类的私有成员，同时仍阻止一般的访问，这是很方便做到的。例如被重载的操作符，如输入或输出操作符，经常需要...
C++友元
weixin_34194087的博客
01-28 73
本文地址：http://www.cnblogs.com/archimedes/p/cpp-friend.html，转载请注明源地址 类的提前声明 回忆函数的原型声明 #include &lt;iostream&gt; using std::cout; using std::endl; void test(); int main() { test(); ret...
C++友元习题.pdf
01-24
"C++友元习题.pdf" 本摘要信息涵盖了C++语言中友元函数的使用方法和应用场景，通过三个实例程序，详细说明了友元函数的声明、定义和使用。 知识点1：友元函数的声明和定义 在C++中，友元函数是指在类外部定义的...
C++友元函数及友元类全总结
04-28
### C++友元函数及友元类全总结 #### 一、引言 在C++编程语言中，封装性是一个非常重要的概念。封装使得对象的数据成员（尤其是私有成员）和成员函数得以隐藏，从而提高了代码的安全性和可维护性。然而，在某些...
c++友元函数与友元类的深入解析
09-05
C++中的友元机制是为了突破封装的限制，允许非成员函数或类访问类的私有和保护成员。这种机制在特定场景下能提高程序的效率和灵活性，但也可能带来安全性和封装性的损失。 友元函数是类外定义的普通函数，但它在类...
关于C++友元函数的实现讲解
01-21
友元函数是一种特殊的函数，它必须要在类中进行声明，但其本身并不是类的成员函数，但友元函数可以访问类的私有成员变量。 友元函数的好处： 1、实现类之间的数据共享 2、提高程序运行效率，方便编程 友元函数的坏处...
c++中的友元
封茗世香
04-15 720
友元的概念： 友元分为友元函数和友元类 友元提供了一种突破封装的方式，但是这种方式会破坏类的封装性，所以我们要尽可能少用 友元函数： 友元函数的定义 #include<iostream> using namespace std; class Date { friend void print(const Date& d); //声明一下这个友元类 public: Date(int year = 1, int month = 1, int day ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值