C++友元的简单分析

//C++友元，包括友元函数和友元类
//C++友元函数




//C++友元类
/*
当某个类A，声明另外一个类B为其友元类的时候，那么在B中可以访问A的private内容
*/


#include <iostream>
using namespace std;
class A
{
    private:
        friend class B;
        friend class C;
        friend void friend_func(A & a);
        friend void friend_func_pointer(A *a);
        int i;
    public:
        A(int ii):i(ii)
        {
            cout<<"constructor A"<<endl;
        }
        ~A()
        {
            cout<<"deconstructor A"<<endl;
        }
        void func()
        {
            cout<<"A.i == "<<this->i<<endl;
        }
        void set(int ii)
        {
            this->i = ii;
            cout<<"set A.i = "<<this->i<<endl;
        }
};

class B
{
    public:
        B()
        {
            cout<<"constructor B"<<endl;
        }
        ~B()
        {
            cout<<"deconstructor B"<<endl;
        }
        void func(A& a)
        {
            cout<<"friend of A is B, something is done in B, A.i = "<<a.i<<endl;
            return;
        }
};


//在这里我们准备搞一些邪恶的事情，假如C类即使A的派生类，又是A的friend class会怎么样呢?
//let‘s have a try
//我们知道即使C是A的派生类，在C里面也不能访问其基类的private成员，
//那么如果一个类既是它的派生类，又是它的friend class的话，会发生什么有意思的事情呢?
class C : public A
{
    private:
        int j;
    public:
        C(int ii, int jj):A(ii), j(jj)
        {
            cout<<"constructor C"<<endl;
        }
        ~C()
        {
            cout<<"deconstructor C"<<endl;
        }
        void func(A& a)
        {
            cout<<"do something with out telling A. A.i"<<a.i<<endl;
        }
};



//我们定义一个友元函数
void friend_func(A& a)
{
    cout<<"I am a friend func of A, A.i = "<<a.i<<endl;
    return;
}


void friend_func_pointer(A *a)
{
    cout<<"I am a friend func of A, which receives of pointer of A, A.i = "<<a->i<<endl;
}


int main(int argc, char** argv)
{
    B b;
    A a(1);
    cout<<"sizeof(B) = "<<sizeof(B)<<endl;//这里输出的B的大小是1个字节，是不是很奇怪?鬼知道C++想干什么
    cout<<"sizeof(A) = "<<sizeof(A)<<endl;//这里输出仍然是4个字节，即一个int的大小，说明在A里面申明一个友元并不会导致A的体积变大
    cout<<"sizoef(C) = "<<sizeof(C)<<endl;
    b.func(a);

    C c(1,2);
    c.func(a);
    //c.func();//这里将发生name hiding，我们之前讲过的，会导致编译失败

    friend_func(a);//我们在A里面申明friend_func是A的友元函数，那么这个函数就可以访问A中的private成员

    //让我们干点刺激的东西吧，当友元遇到up_cast会怎样? 让我们试一试 = =!
    friend_func(c);//完全没有问题，我们访问到了C里面的东西。实际上从概念上说，我们还是访问对的是A里面的东西

    //如果遇到指针的up_cast会发生什么呢?试一试便知道 + +
    friend_func_pointer(&a);

    friend_func_pointer((A*)&c);//也完全没有问题
    
    return 0;
}


/*
关于友元有一些需要注意的概念
(1) 友元关系不能被继承。 B是A的友元class，C是A的子类，但是B不是C的友元。
    这一点也很好理解。从封装性的角度考虑，友元class B可以访问A的private内容，但是不应该看到
    其子类的private东西。连A都看不到，更别说它的友元class B了。
(2) 友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。
    这个更好理解了，A说:B，你是我的友元，我的所有东西都可以给你看，
    但是B说:好啊，你一厢情愿，我也没有办法。但是我的东西还是不能给你看。
(3) 友元关系不具有传递性。
    这一点也比较好理解，假如B是A的friend class， A又是D的友元。
    那么B可以看到A的private，A有可以看见D的private，但是B不应该直接看到D的private。
    简单的例子就是，我朋友的朋友不一定认识我嘛。
*/

//友元函数，是指定义在类的外部，但是可以直接访问类的private成员的函数
//我们还是来上面代码里面的例子吧


/*
总结:
1.一个字，乱
2.个人认为friend class和friend function破坏了oop语言的封装特性。
3.从上面的例子里面可以看到，当friend function遇到了up_cast的时候，friend function破坏了
  派生类的内容。
4.any way，我觉得还是不到万不得已的情况下，不要用friend class和friend function吧。
  毕竟在别人不感知的情况下擅自动别人的底裤是一种不文明的现象。
*/