C++ 三种继承方式及好处示例详解

目录
  • C++继承
    • 公有继承
    • 保护继承
    • 私有继承
  • 继承带来的好处
  • 总结

C++继承

C++继承是面向对象编程中非常常见的一个概念，它提供了一种将一个类的特性引入另一个类的机制。在继承中，被继承的类称为基类或父类，继承它的类称为派生类或子类。

在C++中，继承通过关键字“public”、“protected”、“private”来实现不同层次的继承，其中“public”表示公有继承，“protected”表示保护继承，“private”表示私有继承。以下是C++中三种继承方式的示例：

公有继承

公有继承的示例代码如下：

class Base {
public:
    void foo() { cout << "Base foo" << endl; }
};
class Derived : public Base {
public:
    void bar() { cout << "Derived bar" << endl; }
};
int main() {
    Derived d;
    d.foo(); // Base foo
    d.bar(); // Derived bar
    return 0;
}

在这个示例中，我们定义了一个基类Base和一个派生类Derived。在Derived中使用“public”关键字继承了Base，这意味着Derived拥有了Base的所有属性和方法。可以看到，Derived类可以调用它的父类Base的foo()方法并输出“Base foo”，同时调用它自己的bar()方法并输出“Derived bar”。

保护继承

保护继承的示例代码如下：

class Base {
protected:
    void foo() { cout << "Base foo" << endl; }
};
class Derived : protected Base {
public:
    void bar() { foo(); cout << "Derived bar" << endl; }
};
int main() {
    Derived d;
    d.bar(); // Base foo\nDerived bar
    return 0;
}

在这个示例中，我们定义了一个基类Base和一个派生类Derived。在Derived中使用“protected”关键字继承了Base，这意味着Derived可以访问Base的所有protected属性和方法，而Base的public属性和方法对Derived是不可见的。可以看到，Derived在它的bar()方法中调用了它从Base中继承的foo()方法，并输出“Base foo”和“Derived bar”。

私有继承

私有继承的示例代码如下：

class Base {
private:
    void foo() { cout << "Base foo" << endl; }
};
class Derived : private Base {
public:
    void bar() { foo(); cout << "Derived bar" << endl; }
};
int main() {
    Derived d;
    d.bar(); // 'Base::foo': cannot access private member declared in class 'Base'
    return 0;
}

在这个示例中，我们定义了一个基类Base和一个派生类Derived。在Derived中使用“private”关键字继承了Base，这意味着Derived可以访问Base的所有private属性和方法，但是Base的protected和public属性和方法对Derived是不可见的。可以看到，在Derived中尝试调用继承自Base的foo()方法时编译会出错，因为该方法是一个private方法。

继承带来的好处

继承作为面向对象编程中最基础的概念之一，可以为代码带来以下好处：

  • 避免冗余代码

在很多情况下，多个类之间有一些共同的属性和方法。如果没有继承机制，开发人员们将不得不为每个类都重复定义这些属性和方法，这显然会带来很多冗余代码。通过继承，开发人员可以定义一个基类，将所有共同的属性和方法都定义在其中，然后让各个子类去继承这个基类，这样可以有效地避免冗余代码。

  • 提高代码的复用性

继承可以使类之间产生“父子”关系，子类可以调用父类的方法和属性，这样可以极大地提高代码的复用性。开发人员在编写代码时，可以首先考虑是否可以通过继承实现代码的复用，这可以减少开发时间和代码的复杂性。

  • 支持多态

多态是指同一个函数可以被不同的对象调用，并且可以以不同的方式解释和执行。

继承是多态的基础之一，它允许开发人员通过父类指针或引用来调用子类对象的方法，并且在运行时根据实际类型进行调用，在这个过程中自然地实现了多态。这为代码的扩展和维护提供了极大的灵活性和方便性。

  • 使代码更加面向对象

继承是面向对象编程的重要特征之一，它可以帮助开发人员更好地组织代码，使其更加易于理解和维护。通过继承，开发人员可以将代码分为一个个独立的类，并且实现这些类之间的关系，从而使整个系统更加模块化和可扩展。

尽管继承带来了很多好处，但是我们也要注意一些细节和潜在的问题。例如，继承可能会引入不必要的复杂性，而且过度使用继承可能会导致类之间紧密耦合，从而使代码难以维护和扩展。因此，在使用继承时，我们应该慎重考虑，优雅地设计继承层次结构，避免过度使用继承导致代码的不必要复杂性。

总结

继承是C++中的一个重要特征，它通过“public”、“protected”和“private”关键字提供了三种不同的继承方式，并且带来了很多好处，例如避免冗余代码、提高复用性、支持多态以及使代码更加面向对象。在使用继承时，我们需要慎重考虑，优雅地设计继承层次结构，以免过度使用继承导致代码的不必要复杂性。

以上就是C++ 三种继承方式及好处示例详解的详细内容，更多关于C++继承好处方式的资料请关注我们其它相关文章！

赞 (0)

相关推荐

  • c++中ref的作用示例解析

    目录 正文 示例1: 输出: 输出: 总结 正文 C++11 中引入 std::ref 用于取某个变量的引用,这个引入是为了解决一些传参问题. 我们知道 C++ 中本来就有引用的存在,为何 C++11 中还要引入一个 std::ref 了?主要是考虑函数式编程(如 std::bind)在使用时,是对参数直接拷贝,而不是引用.下面通过例子说明 示例1: #include <functional> #include <iostream> void f(int& n1, int&

  • C++函数模板学习示例教程指南

    目录 C++函数模板学习指南 1. 函数模板的定义 2. 函数模板的使用 3. 函数模板的特化 4. 函数模板的偏特化 6. 非类型模板参数 7. 函数模板的局限性 总结 C++函数模板学习指南 C++函数模板是一种高效的代码复用机制,它允许我们定义一种可以用于多种类型的函数,而不必为每种类型都编写一个函数.本篇文章将介绍C++函数模板的基本使用.我们将逐步讨论函数模板的定义.使用.特化和偏特化. 1. 函数模板的定义 函数模板的定义基本语法如下: template <typename T>

  • C++预定义的流对象基本示例详解

    目录 C++预定义的流对象 示例说明 总结: C++预定义的流对象 C++预定义的流对象是可用于输入和输出的数据流向对象.它们是在C++语言中内置的,可以使用标准库的iostream头文件来调用这些流对象. 在这篇文章中,我们将介绍C++预定义的流对象,并提供一些示例说明. 示例说明 cin: cin是标准输入流对象,用于从控制台读取输入. 示例: int num; cout << "Enter a number: "; cin >> num; cout <

  • 解析C++11的std::ref、std::cref源码

    1.源码准备 本文是基于gcc-4.9.0的源代码进行分析,std::ref和std::cref是C++11才加入标准的,所以低版本的gcc源码是没有这两个的,建议选择4.9.0或更新的版本去学习,不同版本的gcc源码差异应该不小,但是原理和设计思想的一样的,下面给出源码下载地址 http://ftp.gnu.org/gnu/gcc 2.std::ref和std::cref的作用 C++本身就有引用(&),那为什么C++11又引入了std::ref(或者std::cref)呢? 主要是考虑函数式

  • C++类与对象及构造函数析构函数基础详解

    目录 C++类与对象 类的定义 对象的创建 构造函数和析构函数 访问修饰符 继承 多态 成员变量与成员方法 总结 C++类与对象 C++是一门面向对象的编程语言.在C++中,我们可以利用类来创建对象,并在编程时实现抽象.封装.继承和多态等面向对象的特性.下面是关于C++类和对象的学习内容及示例. 类的定义 在C++中,我们可以通过定义类来描述某种对象的属性和行为.类的定义可以分为两部分:声明和实现. 声明部分:类的声明部分通常包含类名.类成员(属性和方法)的声明.访问权限的修饰符等.下面是一个简

  • C++20中的结构化绑定类型示例详解

    目录 C++20中新增了一个非常有用的特性 结构化绑定概念 结构化绑定类型 数组 Pair 结构体 实现一个可以被结构化绑定的类元组类型 C++20中新增了一个非常有用的特性 结构化绑定(Structured Binding).它可以让我们方便地从一个容器类型中取出元素并绑定到对应的变量中,使得代码更加简洁.易读.接下来,本文将分别介绍结构化绑定的概念.类型以及如何实现一个可以被结构化绑定的类元组类型. 结构化绑定概念 结构化绑定是C++20中的一个语言特性,允许将一个结构体或者其他类似类型的容

  • C++标准之(ravalue reference) 右值引用介绍

    C++标准之(ravalue reference) 右值引用介绍

    1.右值引用引入的背景 临时对象的产生和拷贝所带来的效率折损,一直是C++所为人诟病的问题.但是C++标准允许编译器对于临时对象的产生具有完全的自由度,从而发展出了CopyElision.RVO(包括NRVO)等编译器优化技术,它们可以防止某些情况下临时对象产生和拷贝.下面简单地介绍一下CopyElision.RVO,对此不感兴趣的可以直接跳过: (1)CopyElision CopyElision技术是为了防止某些不必要的临时对象产生和拷贝,例如: 复制代码 代码如下: structA{ A(

  • C++获取多浏览器上网历史记录示例代码(支持获取IE/Chrome/FireFox)

    C++获取多浏览器上网历史记录示例代码(支持获取IE/Chrome/FireFox)

    复制代码 代码如下: // FileName: BrowsHistory.h // ------------------------------------------------------------------------------------------------------------------------// Remarks://   BrowsHistory对象应该设置成全局,或者静态:防止还没有获取完网址,对象就析构了:// ------------------------

  • java数组的三种扩容方式以及程序实现详解

    因为数组是在内存中连续的一段存储空间,所以数组一旦被创建,空间就固定了,长度是不能扩增的. 数组的长度是固定的,如果需要扩充**,必须创建新数组,原数组的长度要复制到新数组中 .** java中,数组类型的变量传值的时候,事实上传递的是数组的地址 . Java数组扩容的原理 1)Java数组对象的大小是固定不变的,数组对象是不可扩容的. 2)利用数组复制方法可以变通的实现数组扩容. 3)System.arraycopy()可以复制数组. 4)Arrays.copyOf()可以简便的创建数组副本.

  • 浅谈js中的三种继承方式及其优缺点

    第一种,prototype的方式: //父类 function person(){ this.hair = 'black'; this.eye = 'black'; this.skin = 'yellow'; this.view = function(){ return this.hair + ',' + this.eye + ',' + this.skin; } } //子类 function man(){ this.feature = ['beard','strong']; } man.pr

  • C++ 的三种访问权限与三种继承方式

    三种访问权限 我们知道C++中的类,有三种访问权限(也称作访问控制),它们分别是public.protected.private.要理解它们其实也很容易,看下面了一个例子. 父类: class Person { public: Person(const string& name, int age) : m_name(name), m_age(age) { } void ShowInfo() { cout << "姓名:" << m_name <&l

  • 详解C++ 中的三种继承方式

    public 方式继承 基类成员对派生类的可见性对派生类来说,基类的公有成员和保护成员可见,基类的公有成员和保护成员作为派生类的成员时,它们都保持原有的状态;基类的私有成员不可见,基类的私有成员仍然是私有的,派生类不可访问基类中的私有成员. 基类成员对派生类对象的可见性对派生类对象来说,基类的公有成员是可见的,其他成员是不可见的. 所以,在公有继承时,派生类的对象可以访问基类中的公有成员,派生类的成员函数可以访问基类中的公有成员和保护成员. 简单来说,派生类能访问基类的public, prote

  • js的三种继承方式详解

    1.js原型(prototype)实现继承 代码如下 <body> <script type="text/javascript"> function Parent(name,age){ this.name=name; this.age=age; this.sayHi=function(){ alert("Hi, my name is "+this.name+", my age is "+this.age); } } //C

  • Java中四种线程池的使用示例详解

    在什么情况下使用线程池? 1.单个任务处理的时间比较短 2.将需处理的任务的数量大 使用线程池的好处: 1.减少在创建和销毁线程上所花的时间以及系统资源的开销 2.如不使用线程池,有可能造成系统创建大量线程而导致消耗完系统内存以及"过度切换". 本文详细的给大家介绍了关于Java中四种线程池的使用,分享出来供大家参考学习,下面话不多说了,来一起看看详细的介绍: FixedThreadPool 由Executors的newFixedThreadPool方法创建.它是一种线程数量固定的线程

  • C++中的三种继承public,protected,private详细解析

    三种访问权限 public:可以被任意实体访问 protected:只允许子类及本类的成员函数访问 private:只允许本类的成员函数访问 三种继承方式 public 继承 protect 继承 private 继承 组合结果 基类中 继承方式 子类中 public & public继承 => public public & protected继承 => protected public & private继承 = > private protected &am

  • node运行js获得输出的三种方式示例详解

    一.通过console.log输出(我最喜欢的) 1.js脚本 1.js var arguments = process.argv.splice(2); //获得入参 var a= arguments[0]; 取第一个 console.log(a) //输出 2.python脚本 test_1.py import os print(os.popen('node 1.js fuck').read()) #打印结果fuck 二.通过文件读写获取 1.js脚本 1.js //npm环境别忘了装了 va

  • springAOP的三种实现方式示例代码

    这篇文章给大家介绍了springAOP的实现方式,三种分别是纯XML方式,XML+注解,纯注解方式. Spring 实现AOP思想使⽤的是动态代理技术 默认情况下, Spring会根据被代理对象是否实现接⼝来选择使⽤JDK还是CGLIB.当被代理对象没有实现 任何接⼝时, Spring会选择CGLIB.当被代理对象实现了接⼝, Spring会选择JDK官⽅的代理技术,不过 我们可以通过配置的⽅式,让Spring强制使⽤CGLIB. 接下来我们开始实现aop, 需求是:横切逻辑代码是打印⽇志,希望

  • C#多态的三种实现方式(小结)

    C#实现多态主要有3种方法,虚方法,抽象类,接口 1 虚方法 在父类的方法前面加关键字virtual, 子类重写该方法时在方法名前面加上override关键字,例如下面的Person类的SayHello方法 class Person { public Person(string name) { this.Name = name; } string _name; public string Name { get => _name; set => _name = value; } //父类方法加v

随机推荐