class Base2
{
    friend class Pal;
public:
    void pub_mem() {}
protected:
    int prot_mem;
private:
    char priv_mem;
};

struct Pub_Derv : public Base2
{
    int f() {return prot_mem;}
//    char g() {return priv_mem;} error:这个是private的无法访问
};

struct Priv_Derv : private Base2
{
    //私有继承不影响派生类中的访问，只是Base对于Priv_Derv来说都是private的
    int f() const {return prot_mem;}
};

void fun1()
{
    Pub_Derv d1;
    Priv_Derv d2;
    d1.pub_mem();
//    d2.pub_mem();   error:这里是私有继承，对于Priv_Derv来说Base2里面的类都是private类型的
}

struct Derived_from_public : public Pub_Derv
{
    int use_base(){return prot_mem;}    //ok:protected in pub_Derv
};

struct Derived_from_private : public Priv_Derv
{
    int use_base(){return prot_mem;}    error:这里prot_mem是private类型
};

Friendship and Inheritance

class Base
{
    friend class Pal;
};

class Sneaky2 : public Base2
{
    int j;  //默认private类型
};


class Pal
{
public:
    int f(Base2 b) {return b.prot_mem;}
//    int f2(Sneaky s) {return s.j;}  error:Pal 不是Sneaky的友元
    int f3(Sneaky2 s2) {return s2.prot_mem;}    //不要惊讶，这是对的
};

class D2 : public Pal
{
public:
//    int mem(Base2 b){return b.prot_mem;}    error: 友元是无法继承的！！！

};

class Base3
{
    friend class Pal;
public:
    size_t size() const {return n;}
    void pub_mem() {}
protected:
    size_t n;
    int prot_mem;
private:
    char priv_mem;
};

class Derved : private Base3
{
public:
    using Base3::size;  //用using改变访问权限
protected:
    using Base3::n;
};

/**
* 功能:访问控制和继承
* 时间:2014年7月21日17:22:50
* 作者:cutter_point
*/

#include<iostream>
#include<algorithm>

using namespace std;
/*
public: 公有类型
private: 私有类型
protected: 保护类型
当一个类的成员定义为public，就能够在类外访问，包括它的派生类。
当一个成员定义为private，它仅能在类内访问，不能被它的派生类访问。
当一个成员定义为proteced，它仅能在类内访问，但是能被它的派生类访问。
当一个成员没有指定访问说明符时，默认为private。
*/

/*
派生类成员或友元可以访问受保护的成员
但只有只有通过派生类对象来访问。
*/
class Base
{
protected:
    int prot_mem;
};

class Sneaky : public Base
{
    friend void clobber(Sneaky&);   //这个可以访问prot_mem
    friend void clobber(Base&);     //不能访问prot_mem,这个不是Base的友元
    int j;  //默认private类型
};

void clobber(Sneaky &s) {s.j=s.prot_mem=0; cout<<"通过Sneaky友元调用Base的prot_mem"<<endl;}

//void clobber(Base &b) {b.prot_mem=0;}   //error,prot_mem是保护的外面无法访问

/**
public, private, and protected 继承
*/
class Base2
{
    friend class Pal;
public:
    void pub_mem() {}
protected:
    int prot_mem;
private:
    char priv_mem;
};

struct Pub_Derv : public Base2
{
    int f() {return prot_mem;}
//    char g() {return priv_mem;} error:这个是private的无法访问
};

struct Priv_Derv : private Base2
{
    //私有继承不影响派生类中的访问，只是Base对于Priv_Derv来说都是private的
    int f() const {return prot_mem;}
};

void fun1()
{
    Pub_Derv d1;
    Priv_Derv d2;
    d1.pub_mem();
//    d2.pub_mem();   error:这里是私有继承，对于Priv_Derv来说Base2里面的类都是private类型的
}

struct Derived_from_public : public Pub_Derv
{
    int use_base(){return prot_mem;}    //ok:protected in pub_Derv
};

/*
struct Derived_from_private : public Priv_Derv
{
    int use_base(){return prot_mem;}    error:这里prot_mem是private类型
};
*/

/**
Friendship and Inheritance
*/
/*
友元函数可以访问该类的所有成员，但是没有访问该类派生类所有成员的权利
友元函数对于派生类来说就是在类的外部
*/
/*
class Base
{
    friend class Pal;
};
*/

class Sneaky2 : public Base2
{
    int j;  //默认private类型
};


class Pal
{
public:
    int f(Base2 b) {return b.prot_mem;}
//    int f2(Sneaky s) {return s.j;}  error:Pal 不是Sneaky的友元
    int f3(Sneaky2 s2) {return s2.prot_mem;}    //不要惊讶，这是对的
};

class D2 : public Pal
{
public:
//    int mem(Base2 b){return b.prot_mem;}    error: 友元是无法继承的！！！

};

/*
友元不是继承，每个类控制访问其成员
*/

/**
Exempting Individual Members
*/
class Base3
{
    friend class Pal;
public:
    size_t size() const {return n;}
    void pub_mem() {}
protected:
    size_t n;
    int prot_mem;
private:
    char priv_mem;
};

class Derved : private Base3
{
public:
    using Base3::size;  //用using改变访问权限
protected:
    using Base3::n;
};

/*
用using 调整这些成员的访问权限
*/

/**
Default Inheritance Protection Levels(默认继承保护级别)
*/

/*
一个私人的派生类应明确指定私人而不是依靠
默认。明确表明私有继承的目的是
不要疏忽
*/

int main()
{

    system("pause");
    return 0;
}