C++三种继承方式

提示信息

流年梦

10月09日发表在 c++编程语言阅读 262 评论 20 | 免费使用 “AI大模型GPT4.0” 提问

C++中有三种继承方式：

公有继承（public inheritance）：使用public关键字声明。在公有继承中，基类中的public成员在派生类中保持不变，派生类可以直接访问基类的公有成员。

示例代码：

class Base {  
public:  
    void foo() {  
        // 公有成员函数  
    }  
    int x; // 公有成员变量  
};  
class Derived : public Base {  
public:  
    void bar() {  
        foo(); // 可以直接调用基类中的公有函数  
        x = 10; // 可以直接访问基类中的公有成员变量  
    }  
};

私有继承（private inheritance）：使用private关键字声明。在私有继承中，基类中的public和protected成员在派生类中变为私有的，只能通过派生类的成员函数访问。

示例代码：

class Base {  
public:  
    void foo() {  
        // 公有成员函数  
    }  
protected:  
    int x; // 保护成员变量  
};  
class Derived : private Base {  
public:  
    void bar() {  
        foo(); // 无法直接调用基类中的公有函数，会导致编译错误  
        x = 10; // 无法直接访问基类中的保护成员变量，会导致编译错误  
    }  
    void baz() {  
        Base::foo(); // 可以通过派生类的成员函数间接调用基类中的公有函数  
        Base::x = 10; // 可以通过派生类的成员函数间接访问基类中的保护成员变量  
    }  
};

保护继承（protected inheritance）：使用protected关键字声明。在保护继承中，基类中的public和protected成员在派生类中变为保护的，只能通过派生类的成员函数访问。

示例代码：

class Base {  
public:  
    void foo() {  
        // 公有成员函数  
    }  
protected:  
    int x; // 保护成员变量  
};  
class Derived : protected Base {  
public:  
    void bar() {  
        foo(); // 无法直接调用基类中的公有函数，会导致编译错误  
        x = 10; // 无法直接访问基类中的保护成员变量，会导致编译错误  
    }  
    void baz() {  
        Base::foo(); // 可以通过派生类的成员函数间接调用基类中的公有函数  
        Base::x = 10; // 可以通过派生类的成员函数间接访问基类中的保护成员变量  
    }  
};

遇到难题？ "AI大模型GPT4.0、GPT" 是你的私人解答专家！点击按钮去提问......

流年梦赞 | 0

最近一次登录：2024-11-20 03:46:21

暂时还没有签名，请关注我或评论我的文章

20条评论

按时间正序按时间倒序按喜欢排序

局外人

10月13日

对于C++中的继承方式，确实需要掌握。这三种继承方式在OOP中是非常基本而又重要的概念。

赞 0 回复举报

海怪： @局外人

在C++中，理解三种继承方式（公有继承、保护继承和私有继承）确实是面向对象编程的基础。不同的继承方式会影响子类与父类成员的可访问性，这在设计复杂系统时尤为重要。

公有继承是最常用的方式，子类可以自由访问父类的公有成员。例如：

class Base {
public:
    void display() { std::cout << "Base class display function called." << std::endl; }
};

class Derived : public Base {
public:
    void show() { display(); }  // 可以访问父类的公有成员
};

保护继承则相对少见，通常用于限制访问。在这种方式下，父类的公有和保护成员在子类中变成保护成员：

class Base {
protected:
    void display() { std::cout << "Base class display function called." << std::endl; }
};

class Derived : protected Base {
public:
    void show() { display(); }  // 仍然可以访问，但外部无法访问
};

私有继承又是一个较为特殊的用法，它使得父类的公有和保护成员在子类中都变成私有成员，适用性较小，但在某些设计模式中却非常有效。这种方式可以用于指示“实现依赖”：

class Base {
public:
    void display() { std::cout << "Base class display function called." << std::endl; }
};

class Derived : private Base {
public:
    void show() { display(); }  // 只能在Derived内部调用
};

对于想深入了解的开发者，可以参考 C++继承与多态以获取更详细的信息和示例。这不仅有助于理解基本概念，还有助于在实际项目中巧妙运用这三种继承方式。

11月13日回复举报

添加新评论

不知不觉

10月25日

示例代码提供了很好的理解方式，尤其是关于protected继承的解释，在实际项目中应用较为广泛。

赞 0 回复举报

韦晗： @不知不觉

对于protected继承的讨论，确实值得深入探讨。它的使用场景不仅限于实现接口的封装，还能够在一定程度上控制访问权限，确保子类能够访问基类的成员，同时又防止其他类的不当访问。

例如，假设有一个基类Base，我们希望子类能够访问一些敏感成员，但又不希望这些成员被外部代码直接访问。使用protected继承可以很好地实现这个目的：

class Base {
protected:
    int protectedValue;
public:
    Base() : protectedValue(10) {}
};

class Derived : protected Base {
public:
    void showValue() {
        std::cout << "Protected value: " << protectedValue << std::endl;
    }
};

int main() {
    Derived d;
    d.showValue();  // 输出 Protected value: 10
    // d.protectedValue; // 错误: 'protectedValue' is protected within this context
    return 0;
}

在这个例子中，Derived 类可以访问 Base 的 protectedValue 成员，但外部代码无法直接访问它。这使得 protected 继承在某些设计中变得非常有用。

建议可以进一步了解C++的访问控制以及设计模式，特别是封装与继承的组合使用。参考网址：C++ Inheritance and Access Control。通过更深入的了解，可以更有效地利用继承方式以实现更加清晰和安全的代码结构。

6天前回复举报

添加新评论

忘记

10月29日

公有继承是最常见的继承方式，适合需要直接公开接口的场景，这篇文章对此的描述很清晰。

赞 0 回复举报

无边雨丝： @忘记

公有继承确实在许多场景下是非常合适的，比如在设计类库时，基类的接口需要被派生类直接继承和使用。例如，在实现一个简单的图形系统时，可以定义一个基类 Shape，然后通过公有继承创建不同的形状类，如 Circle 和 Rectangle。

class Shape {
public:
    virtual void draw() = 0; // 纯虚函数
};

class Circle : public Shape {
public:
    void draw() override {
        // 画圆的逻辑
    }
};

class Rectangle : public Shape {
public:
    void draw() override {
        // 画矩形的逻辑
    }
};

在这个例子中，Circle 和 Rectangle 继承自 Shape，使得可以通过指向基类的指针来调用派生类的 draw 方法，提供了灵活性和可扩展性。

同时，值得一提的是，私有继承和保护继承在不同的场景下也有其独特的应用价值。私有继承可以帮助封装实现细节，防止外部直接访问，而保护继承则为子类提供了一定的访问权限。

若想深入理解不同继承方式的应用场景，可以参考以下链接：C++ Inheritance Types。

11月13日回复举报

添加新评论

趋势主人

11月09日

文章对私有继承有误解，实际无法直接调用基类公有函数，应理解为私有继承影响访问控制。示例可优化。

赞 0 回复举报

凌草： @趋势主人

私有继承确实在访问控制上有一些特殊之处。私有继承使基类的公共和保护成员在派生类中变为私有，外部代码无法通过派生类直接访问基类的公共成员。以下是一个简单的示例，展示了私有继承对访问控制的影响：

class Base {
public:
    void show() {
        std::cout << "Base show" << std::endl;
    }
};

class Derived : private Base {
public:
    void test() {
        show(); // 可以调用基类的公共方法
    }
};

int main() {
    Derived d;
    d.test(); // 可以调用Derived的测试方法
    // d.show(); // 这里会报错，因为show是私有继承的
    return 0;
}

在这个例子中，Derived类可以调用Base类的show方法，但外部代码却无法直接调用它。如果想要友好地访问基类的功能，可以提供公有方法在派生类中进行桥接。

了解这些特性后，在设计时选择合适的继承方式显得至关重要。可以参考更多关于C++继承的文献，比如 C++ Programming Language 等，深入学习继承机制和设计原则。

11月14日回复举报

添加新评论

雾涩九月

11月11日

使用protected继承是一些设计模式中常见的技巧，比如template method。理解这些细节对于C++进阶开发者很关键。

赞 0 回复举报

城南： @雾涩九月

使用protected继承的确在某些设计模式中扮演着重要角色，尤其是在模板方法模式中，这样的做法可以让子类享有父类的保护成员，同时限制其他外部访问。这样一来，子类可以更灵活地重写或扩展父类的行为。

例如，考虑下面的一个简单示例，演示了如何利用protected继承来实现模板方法模式：

#include <iostream>

class Base {
protected:
    void templateMethod() {
        step1();
        step2();
    }

    virtual void step1() {
        std::cout << "Base step 1\n";
    }

    virtual void step2() {
        std::cout << "Base step 2\n";
    }
};

class Derived : protected Base {
public:
    void run() {
        templateMethod(); // 可以访问
    }

protected:
    void step1() override {
        std::cout << "Derived step 1\n";
    }

    void step2() override {
        std::cout << "Derived step 2\n";
    }
};

int main() {
    Derived derived;
    derived.run(); // 输出 Derived step 1 和 Derived step 2
    return 0;
}

在这个例子中，Base类定义了一个模板方法templateMethod，它会调用两个步骤，而这些步骤在Derived类中被重写。由于使用了protected继承，Derived类的run方法能够安全地调用templateMethod，而外部代码却不能直接访问基类的成员。这种方式在设计框架时，能够有效地管理访问权限，同时保持灵活性。

在深入研究C++的设计理念时，可以考虑参考一些资料，比如《Design Patterns: Elements of Reusable Object-Oriented Software》，也许会得到更多启发。

3天前回复举报

添加新评论

蔓层生

11月23日

代码示例还可以更丰富些，比如加入多重继承的案例，以便展示多种继承方式的复杂情况。

赞 0 回复举报

出鞘的利剑： @蔓层生

在讨论C++的继承方式时，多重继承的例子确实可以展示其复杂性和灵活性。可以考虑以下简单的示例，以便更好地理解多重继承的应用场景：

#include <iostream>
using namespace std;

class A {
public:
    void show() {
        cout << "Class A" << endl;
    }
};

class B {
public:
    void display() {
        cout << "Class B" << endl;
    }
};

class C : public A, public B {
public:
    void print() {
        cout << "Class C" << endl;
    }
};

int main() {
    C obj;
    obj.show();    // 从类 A 继承
    obj.display(); // 从类 B 继承
    obj.print();   // 类 C 自有的方法
    return 0;
}

在上述示例中，类 C 同时继承了类 A 和类 B，可以调用两者的方法。这展示了多重继承的典型使用场景，但也需要注意潜在的复杂性，比如命名冲突和菱形继承等问题。

对于想进一步探索多重继承的同学，可以参考 GeeksforGeeks关于多重继承的文章，这提供了一些更深入的解释和代码示例，帮助理解这些概念。

11月12日回复举报

添加新评论

岚风殇

11月26日

在处理大型项目时，选择合适的继承方式对代码可维护性的提升很有帮助。学习这些是优秀C++开发者的基本功。

赞 0 回复举报

黑丝： @岚风殇

在选择继承方式时，确实需要考虑代码的可维护性和扩展性。在C++中，公共继承、保护继承和私有继承的应用场景是非常不同的。

举个例子，在公共继承中，可以通过基类定义一个接口，子类实现这个接口，这种方式特别适合角色间有“is-a”关系的情况。像下面的示例：

class Shape {
public:
    virtual void draw() = 0; // 纯虚函数
};

class Circle : public Shape {
public:
    void draw() override {
        // 绘制圆形的代码
    }
};

class Square : public Shape {
public:
    void draw() override {
        // 绘制方形的代码
    }
};

这样可以确保所有形状都实现了draw方法，提高了代码的一致性和可读性。

而在使用私有继承时，通常体现的是“has-a”的关系，适合需要组合和数据隐藏的场景。例如：

class Engine {
public:
    void start() {}
};

class Car : private Engine {
public:
    void startCar() {
        // 调用私有继承的Engine的方法
        start();
    }
};

这种方式可以有效保护Engine的实现细节，不让外部直接访问。

关于更多关于C++继承的内容，可以参考这篇文章：C++ Inheritance ，里面对不同继承方式的优劣进行了详细的讨论。

适当的继承方式不仅能提高代码的可读性，还能减少潜在的错误，正如你所提到的，特别是在大型项目中，可维护性是至关重要的。

11月14日回复举报

添加新评论

光阴

12月06日

虽然代码解释得很好，但应该强调继承的缺点如易导致紧耦合，建议搭配组合使用。

赞 0 回复举报

违心少年： @光阴

对于继承在设计中的应用，确实需要谨慎处理，特别是当多个类紧密耦合时。相比于单一依赖于继承，组合可以提升代码的灵活性和可维护性。例如，可以考虑使用组合模式来替代继承：

class Engine {
public:
    void start() {
        std::cout << "Engine started" << std::endl;
    }
};

class Car {
private:
    Engine engine; // 组合：Car 拥有一个 Engine
public:
    void start() {
        engine.start();
        std::cout << "Car is ready to go!" << std::endl;
    }
};

以上代码展示了用组合来实现Car类，而不是直接继承自Engine。这样的设计使得Car与Engine之间的耦合度降低，可以灵活地替换或扩展Engine的实现而不影响Car的继承层次。

针对继承的缺点，比如容易引入复杂性与紧耦合，建议在设计中适当使用接口和抽象类来加强代码的灵活性。同时，也可以参考一些设计模式，例如策略模式和装饰模式，来替代传统的继承关系，从而提高系统的可扩展性。

关于进一步读物，可以参考这篇文章：Design Patterns in C++ 来深入理解如何更好地使用类和对象的组合。

11月11日回复举报

添加新评论

心有翅膀

12月17日

继承是个老生常谈的话题，而如何安全有效地使用这三种继承需要开发者深思熟虑。

赞 0 回复举报

铭记心： @心有翅膀

继承的使用确实需要谨慎考虑，特别是在不同继承方式之间的选择。C++ 中的三种继承方式——公有继承、保护继承和私有继承，适合不同的场景，但需要理解其影响。

例如，如果我们使用公有继承，可以通过基类指针或引用来访问派生类的函数，像这样：

class Base {
public:
    void show() { std::cout << "Base class show function called." << std::endl; }
};

class Derived : public Base {
public:
    void display() { std::cout << "Derived class display function called." << std::endl; }
};

int main() {
    Derived obj;
    obj.show(); // 允许，公有继承
    obj.display();
    Base* basePtr = &obj;
    basePtr->show(); // 也允许
    // basePtr->display(); // 不允许，基类不能访问派生类特有的函数
}

而保护继承和私有继承则在控制访问权限上更为严格，这在设计类层次结构时会带来不同的灵活性和封装性。

在实际开发中，对各类继承方式的运用应结合具体需求，参考一些经典书籍如《C++ Primer》或《Effective C++》都很有益。此外，可以查阅 cppreference 以获取最新和详细的 C++ 继承相关内容。通过深入理解这些原则，开发者可以有效地设计出结构良好的类层次，以提高代码的可维护性与可读性。

4天前回复举报

添加新评论

尘封

12月21日

更深入的理解可以查阅Bjarne Stroustrup的《C++程序设计语言》，在那里有较为全面深入的讲解。

赞 0 回复举报

旧夏天： @尘封

对于C++的继承方式，深入了解确实可以帮助开发者更好地掌握面向对象编程的精髓。在讨论继承时，除了类的基础结构外，关注其访问控制和多态性的实现是非常重要的。

例如，在使用公有继承时，基类的公有成员会成为派生类的公有成员，而私有成员则无法直接访问。深入了解这些机制可以避免在设计类时出现潜在的错误。

以下是一个简单的代码示例，展示了公有继承的用法：

class Base {
public:
    void show() {
        std::cout << "Base class method." << std::endl;
    }
};

class Derived : public Base {
public:
    void showDerived() {
        std::cout << "Derived class method." << std::endl;
    }
};

int main() {
    Derived obj;
    obj.show();          // 可以访问基类的方法
    obj.showDerived();   // 可以访问派生类的方法
    return 0;
}

另一个值得注意的点是虚继承。在复杂的多重继承中，虚继承的使用可以有效避免“菱形继承”问题，使得基类的共享更加明确。

对于希望深入掌握C++的开发者，可以查阅更多相关资料，例如在 cplusplus.com 上，找到关于继承和多态的内容，将有助于更好地理解这些高级特性。

11月14日回复举报

添加新评论

免费图表工具，画流程图、架构图

C++三种继承方式

举报评论

删除

删除后，将不可回复，确认要删除？

提示

复制代码，请先登录