C++_继承_父类与子类中对象权限属性的变化

最新推荐文章于 2025-11-22 23:45:52 发布

原创最新推荐文章于 2025-11-22 23:45:52 发布 · 729 阅读

7 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #java #开发语言

C++继承中protected继承，父类的protected类型，访问权限有什么变化？

在 protected 继承下：
基类成员访问权限在派生类中的访问权限
public protected
protected protected
private 不可访问（inaccessible）

✅ 所以：父类的 protected 成员，在 protected 继承后，在派生类中仍然是 protected。

📚 详细解释

我们通过一个例子来验证：


#include <iostream>
using namespace std;

// 基类
class Base {
public:
    int pub;
protected:
    int prot;
private:
    int priv;
};

// 派生类：使用 protected 继承
class Derived : protected Base {
public:
    void access_base() {
        pub = 10;     // OK: 基类 public 成员 → 在派生类中变为 protected，可访问
        prot = 20;    // OK: 基类 protected 成员 → 在派生类中仍为 protected，可访问
        // priv = 30; // ERROR: 基类 private 成员，不可访问
        cout << "pub = " << pub << ", prot = " << prot << endl;
    }
};

// 进一步派生
class FurtherDerived : public Derived {
public:
    void access_from_grandchild() {
        pub = 100;     // OK: 因为 Derived 中 pub 是 protected
        prot = 200;    // OK: 因为 Derived 中 prot 是 protected
        cout << "Further: pub = " << pub << ", prot = " << prot << endl;
    }
};

int main() {
    Derived d;
    d.access_base();  // OK

    // d.pub = 5;     // ERROR: pub 在 Derived 中是 protected，外部不可访问
    // d.prot = 5;    // ERROR: 同上

    FurtherDerived fd;
    fd.access_from_grandchild();  // OK

    return 0;
}

🔁 访问权限变化规则（核心）

C++ 的继承会改变基类成员在派生类中的访问级别，规则是：

派生类中成员的访问权限 = min(继承方式, 原始访问权限)

这里的 min 是“更严格”的意思（private < protected < public）。
原始权限\继承方式 public protected private
public public protected private
protected protected protected private
private 不可访问不可访问不可访问

所以：

基类 protected 成员 + protected 继承 → min(protected, protected) = protected

🧠 为什么使用 protected 继承？

protected 继承的使用场景较少，但有其特定用途：

当你希望派生类可以访问基类的 public 和 protected 成员，
但又不希望这些成员在派生类的外部接口中暴露为 public。
它表达了一种 “受保护的 is-a” 关系，比 public 继承更严格。

⚠️ 注意：protected 继承后，基类的 public 成员在派生类中变成了 protected，因此外部代码无法直接访问。

✅ 总结
问题回答
protected 继承下，父类的 protected 成员权限如何变化？仍然是 protected
是否可以在派生类内部访问？ ✅ 可以
是否可以在派生类外部访问？ ❌ 不可以（因为是 protected）
是否可以在进一步的派生类中访问？ ✅ 可以（只要是派生类内部）

1、 C++中通过protected方式继承父类后，再子类里的protected属性的函数是否能够访问父类的public属性、protected属性和private属性的变量，同理子类中public属性和private属性的函数是否能够访问父类的上述三种属性的变量？

✅ 核心结论

在 C++ 中，能否访问基类成员，只取决于两点：

继承方式（public / protected / private）
基类成员的原始访问权限

而与派生类中调用它的函数的访问权限（public/protected/private）无关！

🔑 重点：只要该成员在派生类中是“可访问的”（accessible），那么派生类的任何成员函数（无论 public、protected 还是 private）都可以访问它。

📊 详细分析表

我们先看在 protected 继承下，基类成员在派生类中的“新权限”：
基类原始权限 protected 继承后在派生类中的权限
public protected
protected protected
private ❌ 不可访问

✅ 回答你的问题

🎯 关键点：只要成员在派生类中是可访问的（即不是 private 且继承方式允许），那么派生类的任何成员函数都可以访问它。

📌 代码验证示例


#include <iostream>
using namespace std;

class Base {
public:
    int pub = 100;
protected:
    int prot = 200;
private:
    int priv = 300;  // 派生类无法访问
};

// 使用 protected 继承
class Derived : protected Base {
public:
    void public_func() {
        cout << "public_func: pub=" << pub << ", prot=" << prot << endl;
        // cout << priv; // ERROR: 不可访问
    }

protected:
    void protected_func() {
        cout << "protected_func: pub=" << pub << ", prot=" << prot << endl;
    }

private:
    void private_func() {
        cout << "private_func: pub=" << pub << ", prot=" << prot << endl;
    }

public:
    void test() {
        public_func();      // OK
        protected_func();   // OK
        private_func();     // OK: 调用私有函数
    }
};

int main() {
    Derived d;
    d.test();  // 输出所有值
    // d.pub;  // ERROR: pub 在 Derived 中是 protected，外部不可访问
    return 0;
}

输出：

深色版本

public_func: pub=100, prot=200
protected_func: pub=100, prot=200
private_func: pub=100, prot=200

✅ 总结一句话

在 protected 继承下，只要父类的成员不是 private，它们在子类中都变为 protected，因此子类的任何成员函数（public、protected、private）都可以访问这些成员。private 成员始终无法访问。

2、 C++中通过public方式继承父类后，再子类里的protected属性的函数是否能够访问父类的public属性、protected属性和private属性的变量，同理子类中public属性和private属性的函数是否能够访问父类的上述三种属性的变量？

✅ 核心结论

在 C++ 中，一个成员函数能否访问基类的成员，只取决于：

继承方式
基类成员的原始访问权限

🔑 与调用它的函数自身的访问权限（public/protected/private）无关！

只要该成员在派生类中是“可访问的”（accessible），那么派生类的任何成员函数都可以访问它。
📊 public 继承下，基类成员在派生类中的权限变化
基类原始权限 public 继承后在派生类中的权限
public public
protected protected
private ❌ 不可访问

✅ 回答你的问题

🎯 关键点：在 public 继承下，只要成员不是 private，它们在派生类中保持原有权限（public 还是 public，protected 还是 protected），因此派生类的任何成员函数都可以访问这些成员。

📌 代码验证示例


#include <iostream>
using namespace std;

class Base {
public:
    int pub = 100;
protected:
    int prot = 200;
private:
    int priv = 300;  // 派生类无法访问
};

// 使用 public 继承
class Derived : public Base {
public:
    void public_func() {
        cout << "public_func: pub=" << pub << ", prot=" << prot << endl;
        // cout << priv; // ERROR: 不可访问
    }

protected:
    void protected_func() {
        cout << "protected_func: pub=" << pub << ", prot=" << prot << endl;
    }

private:
    void private_func() {
        cout << "private_func: pub=" << pub << ", prot=" << prot << endl;
    }

public:
    void test() {
        public_func();      // OK
        protected_func();   // OK
        private_func();     // OK: 调用私有函数
    }
};

int main() {
    Derived d;
    d.test();       // ✅ 可以调用 test()
    d.public_func(); // ✅ 可以从外部调用 public 函数
    // d.protected_func(); // ❌ 错误：protected 函数外部不可访问
    // d.private_func();   // ❌ 错误：private 函数外部不可访问
    return 0;
}

输出：


public_func: pub=100, prot=200
protected_func: pub=100, prot=200
private_func: pub=100, prot=200

✅ 总结一句话

在 public 继承下，只要父类的成员不是 private，它们在子类中保持原有访问权限（public 或 protected），因此子类的任何成员函数（public、protected、private）都可以访问这些成员。private 成员始终无法访问。

🧠 补充说明

外部代码（如 main()）能否调用子类的函数，取决于该函数自身的访问权限（public 可调，protected/private 不可调）。
但函数内部能否访问父类成员，只看继承后该成员是否对派生类可见。

3、C++中通过private方式继承父类后，再子类里的protected属性的函数是否能够访问父类的public属性、protected属性和private属性的变量，同理子类中public属性和private属性的函数是否能够访问父类的上述三种属性的变量？

非常好的问题！我们来深入分析 private 继承下，子类中不同访问权限的成员函数能否访问父类的成员变量。
✅ 核心结论（再次强调）

在 C++ 中，一个成员函数能否访问基类的成员，只取决于：

继承方式
基类成员的原始访问权限

🔑 与调用它的函数自身的访问权限（public/protected/private）无关！

只要该成员在派生类中是“可访问的”（accessible），那么派生类的任何成员函数都可以访问它。
📊 private 继承下，基类成员在派生类中的权限变化
基类原始权限 private 继承后在派生类中的权限
public private
protected private
private ❌ 不可访问

🎯 关键点：在 private 继承下，基类的 public 和 protected 成员在派生类中都变成 private，而 private 成员仍然不可访问。

✅ 回答你的问题

🎯 关键点：在 private 继承下，只要成员不是 private，它们在派生类中都变为 private，因此派生类的任何成员函数都可以访问这些成员。

📌 代码验证示例


#include <iostream>
using namespace std;

class Base {
public:
    int pub = 100;
protected:
    int prot = 200;
private:
    int priv = 300;  // 派生类无法访问
};

// 使用 private 继承
class Derived : private Base {
public:
    void public_func() {
        cout << "public_func: pub=" << pub << ", prot=" << prot << endl;
        // cout << priv; // ERROR: 不可访问
    }

protected:
    void protected_func() {
        cout << "protected_func: pub=" << pub << ", prot=" << prot << endl;
    }

private:
    void private_func() {
        cout << "private_func: pub=" << pub << ", prot=" << prot << endl;
    }

public:
    void test() {
        public_func();      // OK
        protected_func();   // OK
        private_func();     // OK: 调用私有函数
    }
};

int main() {
    Derived d;
    d.test();       // ✅ 可以调用 test()
    d.public_func(); // ✅ 可以从外部调用 public 函数

    // 注意：虽然 pub 和 prot 在 Derived 中是 private，
    // 但 Derived 的成员函数仍然可以访问它们。

    return 0;
}

输出：


public_func: pub=100, prot=200
protected_func: pub=100, prot=200
private_func: pub=100, prot=200

✅ 总结一句话

在 private 继承下，只要父类的成员不是 private，它们在子类中都变为 private，因此子类的任何成员函数（public、protected、private）都可以访问这些成员。private 成员始终无法访问。

🧠 补充说明：private 继承的用途

private 继承表达的是一种 “实现继承” 而非 “接口继承”。
它常用于 “组合”（Composition）的替代方案，即“is-implemented-in-terms-of”（基于……实现）。
与组合相比，private 继承可以访问基类的 protected 成员，并且可以重写虚函数。

例如：


class Stack : private vector<int> {  // Stack 基于 vector 实现
public:
    void push(int x) { emplace_back(x); }  // 可以访问 vector 的 protected 成员？
    int pop() { 
        int x = back();
        pop_back();
        return x;
    }
};