C++ - 继承与访问控制

直接上代码：

    // 访问控制与继承
    class Base {
    public:
        void pubMem() {}

        void memfcn(Base &b) { b = *this; }

    protected:
        int protMem() { return 0; }

    private:
        char privMem() { return 'a'; }
    };

    class PubDerv : public Base {
    public:
        int f() { return protMem(); } // 正确，派生类能访问基类 protected 成员

        // char g() { return privMem(); } // 错误，派生类不能访问基类的 private 成员

        void memfcn(Base &b) { b = *this; }
    };

    class DerivedFromPublic : public PubDerv {
    public:
        int useBase() { return protMem(); } // 正确，protMem 在派生类 PubDerv 中仍然是 protected

        void memfcn(Base &b) { b = *this; }
    };

    class ProtDerv : protected Base {
    public:
        // protected 继承不影响派生类本身（派生类自己成员）的访问权限，但是所有从基类继承的成员均变为 protected 类型
        int f() { return protMem(); } // 正确，派生类能访问基类 protected 成员

        // char g() { return privMem(); } // 错误，派生类不能访问基类的 private 成员

        void memfcn(Base &b) { b = *this; }
    };

    class DerivedFromProtected : public ProtDerv {
    public:
        int useBase() { return protMem(); } // 正确，protMem 在派生类 ProtDerv 中仍然是 protected

        void memfcn(Base &b) { b = *this; }
    };

    class PrivDerv : private Base {
    public:
        // private 继承不影响派生类本身（派生类自己成员）的访问权限，但是所有从基类继承的成员均变为 private 类型
        int f() { return protMem(); } // 正确，派生类能访问基类 protected 成员

        // char g() { return privMem(); } // 错误，派生类不能访问基类的 private 成员

        // using Base::protMem; // 可以通过添加 using 声明改变成员的可访问性，添加到何种访问控制符后即是何种访问权限，例为public

        void memfcn(Base &b) { b = *this; }
    };

    class DerivedFromPrivated : public PrivDerv {
    public:
        // int useBase() { return protMem(); } // 错误，protMem 在派生类 PrivDerv 中是 privated

        // void memfcn(Base &b) { b = *this; } // 错误
    };

测试代码：

    void AccessControlTest() {
        // 访问控制与继承
        MyQuoteSpace::PubDerv d1;
        MyQuoteSpace::PrivDerv d2;
        MyQuoteSpace::ProtDerv d3;
        d1.pubMem();  // pubMem 在PubDerv中是public的
        // d2.pubMem();  // 错误，pubMem 在PrivDerv中是private的

        MyQuoteSpace::DerivedFromPublic dd1;
        MyQuoteSpace::DerivedFromPrivated dd2;
        MyQuoteSpace::DerivedFromProtected dd3;

        MyQuoteSpace::Base *p = &d1;
        // p = &d2; // 错误
        // p = &d3; // 错误
        p = &dd1;
        // p = &dd2; // 错误
        // p = &dd3; // 错误

        return;
    }

友元和继承：不能继承友元关系，每个类负责控制各自成员的访问权限

  // 友元和继承，不能继承友元关系，每个类负责控制各自成员的访问权限
    class Base1 {
        friend class Pal;

    protected:
        int protMem;
    };

    class Sneaky : public Base1 {
    private:
        // 正确，clobber能访问 Sneaky 对象的 private 和 protected成员
        friend void clobber(Sneaky &s) { s.j = s.protMem = 0; }

        // 错误，clobber不能访问 Base 对象的 protected 成员
        // friend void clobber(Base1 &b) { b.protMem = 0; }

        int j;
    };

    class Pal {
        int f1(Base1 b) { return b.protMem; } // 正确，Pal 是 Base1 的友元
        // int f2(Sneaky s) { return s.j; } // 错误，Pal 不是 Sneaky 的友元
        int f3(Sneaky s) { return s.protMem; } // 正确，Pal 是 Base1 的友元 ？？？
    };

参考 C++ Primer 第五版 第15章

最后

以上就是多情小懒虫为你收集整理的C++ - 继承与访问控制的全部内容，希望文章能够帮你解决C++ - 继承与访问控制所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。