C++进阶-1-单继承、多继承、虚继承

news/2024/12/23 3:16:20 标签: c++, 开发语言, visual studio, 笔记, 学习

C++单继承详解

1. 基础概念

继承是面向对象编程中的一个核心概念，允许一个类（子类或派生类）继承另一个类（父类或基类）的属性和方法。单继承意味着一个类只能直接继承一个父类。这种简单的结构在许多情况下是足够的，特别是在类层次结构较为简单的情况下。

2. 语法结构

在C++中，单继承的基本语法结构如下：

cpp

class Base {
    // 基类内容
};

class Derived : public Base {
    // 派生类内容
};
  • Base：基类，包含公共或保护成员。
  • Derived：派生类，继承自基类，可以访问基类的公共和保护成员。

3. 访问权限

C++提供了三种访问权限控制：

  • public：公共成员可以被任何地方访问，包括通过派生类访问。
  • protected：保护成员只能在基类及其派生类中访问，外部代码无法访问。
  • private：私有成员只能在基类内部访问，派生类无法直接访问。

示例代码

以下是一个详细的示例，展示了单继承的基本特性和用法。

cpp

#include <iostream>
using namespace std;

// 基类
class Animal {
protected:
    string name;

public:
    Animal(string n) : name(n) {} // 构造函数

    void speak() {
        cout << name << " says: Hello!" << endl;
    }
};

// 派生类
class Dog : public Animal {
public:
    Dog(string n) : Animal(n) {} // 调用基类构造函数

    void bark() {
        cout << name << " barks!" << endl;
    }
};

int main() {
    Dog myDog("Buddy");
    myDog.speak(); // 调用基类方法
    myDog.bark();  // 调用派生类方法
    return 0;
}

4. 构造与析构

在单继承中，子类的构造函数会调用父类的构造函数。可以使用初始化列表来实现这一点。析构函数也遵循相同的规则，派生类的析构函数会在对象销毁时自动调用基类的析构函数。

cpp

class Base {
public:
    Base() { cout << "Base Constructor" << endl; }
    ~Base() { cout << "Base Destructor" << endl; }
};

class Derived : public Base {
public:
    Derived() { cout << "Derived Constructor" << endl; }
    ~Derived() { cout << "Derived Destructor" << endl; }
};

int main() {
    Derived d; // 输出基类和派生类构造函数
    return 0;  // 输出派生类和基类析构函数
}

5. 多态性

单继承也可以实现多态性。通过基类指针或引用，可以调用派生类的重载方法。

cpp

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

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

void display(Base* b) {
    b->show(); // 调用时根据对象类型决定调用哪个方法
}

int main() {
    Base b;
    Derived d;
    display(&b); // 输出 "Base class"
    display(&d); // 输出 "Derived class"
    return 0;
}

6. 优缺点

优点

  1. 简单性：单继承结构清晰，易于理解和使用。
  2. 易于维护：代码结构简单，便于维护和扩展。
  3. 减少复杂性：避免了多重继承带来的复杂性和潜在问题，如二义性。

缺点

  1. 灵活性不足：单继承限制了类的扩展性，无法利用多重继承的灵活性。
  2. 代码重复：如果多个类需要共享相同的功能，可能需要在多个类中重复代码。

7. 单继承的设计模式

单继承在许多设计模式中被广泛应用。例如：

  • 模板方法模式：基类定义一个算法的框架，子类可以实现具体的步骤。
  • 策略模式：基类定义一个接口，子类实现不同的策略。

8. 实际应用

在实际应用中，单继承被广泛用于类的层次结构设计。例如，在图形界面编程中，可以有一个基本的窗口类，所有特定类型的窗口（如对话框、主窗口等）都可以继承自这个基本窗口类。

9. 总结

C++中的单继承是一种重要的面向对象编程特性，使得代码的组织和结构变得更加清晰。在设计类结构时，应根据项目需求和复杂性，合理选择单继承或多重继承。尽管单继承有其局限性，但在许多情况下，它仍然是实现类之间关系的有效方式。

C++多继承详解

1. 基础概念

多继承是面向对象编程中的一个特性，允许一个类同时继承多个类的属性和方法。在C++中，类可以通过多继承来组合多个基类的功能，形成更复杂的类层次结构。这种灵活性使得代码复用变得更加高效，但也引入了一些复杂性。

2. 语法结构

在C++中，使用逗号分隔多个父类来实现多继承，基本语法如下：

cpp

class Base1 {
    // 基类1的内容
};

class Base2 {
    // 基类2的内容
};

class Derived : public Base1, public Base2 {
    // 派生类的内容
};

3. 访问权限

在多继承中，访问权限可以对每个基类单独设置。例如，派生类可以使用 public、protected 或 private 来继承多个基类：

cpp

class Derived : public Base1, protected Base2 {
    // 访问权限根据需要设置
};

示例代码

以下是一个多继承的示例，展示了如何从多个基类继承功能。

cpp

#include <iostream>
using namespace std;

// 第一个基类
class Printer {
public:
    void print() {
        cout << "Printing..." << endl;
    }
};

// 第二个基类
class Scanner {
public:
    void scan() {
        cout << "Scanning..." << endl;
    }
};

// 派生类
class MultiFunctionPrinter : public Printer, public Scanner {
public:
    void copy() {
        cout << "Copying..." << endl;
    }
};

int main() {
    MultiFunctionPrinter mfp;
    mfp.print(); // 从Printer基类继承的方法
    mfp.scan();  // 从Scanner基类继承的方法
    mfp.copy();  // 自己定义的方法
    return 0;
}

4. 构造与析构

在多继承中，派生类的构造函数会依次调用每个基类的构造函数。析构函数的调用顺序是相反的，先调用派生类的析构函数，然后是基类的析构函数。

cpp

class Base1 {
public:
    Base1() { cout << "Base1 Constructor" << endl; }
    ~Base1() { cout << "Base1 Destructor" << endl; }
};

class Base2 {
public:
    Base2() { cout << "Base2 Constructor" << endl; }
    ~Base2() { cout << "Base2 Destructor" << endl; }
};

class Derived : public Base1, public Base2 {
public:
    Derived() { cout << "Derived Constructor" << endl; }
    ~Derived() { cout << "Derived Destructor" << endl; }
};

int main() {
    Derived d; // 构造顺序：Base1 -> Base2 -> Derived
    return 0;  // 析构顺序：Derived -> Base2 -> Base1
}

5. 二义性问题

多继承的一个主要问题是二义性，即如果多个基类有同名成员，派生类将无法决定使用哪个基类的成员。这种情况需要通过作用域解析运算符来解决。

cpp

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

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

class C : public A, public B {
public:
    void display() {
        A::show(); // 使用A的show
        B::show(); // 使用B的show
    }
};

int main() {
    C c;
    c.display();
    return 0;
}

6. 虚基类

为了解决多继承中的二义性问题，C++提供了虚基类的概念。虚基类确保在多重继承中只创建一个基类的实例，从而避免二义性。

cpp

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

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

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

class D : public B, public C {
public:
    void display() {
        A::show(); // 确保只调用一个A的实例
    }
};

int main() {
    D d;
    d.display();
    return 0;
}

7. 优缺点

优点

  1. 灵活性：多继承允许组合多个类的功能，增加了类的灵活性和复用性。
  2. 功能扩展：可以通过继承多个基类来扩展功能，满足复杂的需求。
  3. 代码复用：通过多继承可以重用多个基类中的代码，减少代码重复。

缺点

  1. 复杂性：多继承可能导致类层次结构变得复杂，难以理解和维护。
  2. 二义性问题：当多个基类有同名成员时，会引起二义性，增加了使用难度。
  3. 内存开销：虚基类的使用可能导致内存开销增加。

8. 实际应用

多继承常用于需要组合多个功能的场景，例如：

  • 接口组合：在设计API时，可以通过多继承组合多个接口。
  • 设备驱动：在硬件驱动开发中，可能需要同时继承多个设备的功能。
  • 游戏开发：在游戏开发中，可以通过多继承创建具有多个特性的角色或对象。

9. 设计模式中的多继承

在一些设计模式中，多继承被广泛应用，例如：

  • 适配器模式：通过多继承实现不同接口的适配。
  • 桥接模式：将抽象部分与实现部分分离，可以通过多继承实现不同的实现。

注意事项

在使用多继承时，有几个注意事项：

  1. 清晰性：确保类的设计是清晰的，避免不必要的复杂性。
  2. 避免滥用：多继承虽然强大，但不应随意使用，应根据需要合理设计。
  3. 使用虚基类：在多重继承时，如果存在共同基类，考虑使用虚基类以避免二义性。

10. 总结

C++中的多继承是面向对象编程的重要特性，允许一个类同时继承多个基类的功能。尽管多继承提供了灵活性和代码复用，但也带来了复杂性和潜在的二义性问题。在设计类层次结构时，开发者应考虑是否真的需要多继承，权衡其优缺点，以实现更高效、更可维护的代码。

C++虚继承详解

1. 基础概念

虚继承是C++中处理多重继承的一种机制，旨在解决多继承时可能出现的二义性问题。二义性问题出现在两个或多个基类继承自同一个父类时，派生类会继承多个父类的实例，导致相同成员的冲突。虚继承确保在多重继承中只创建一个基类的实例，从而有效避免这种冲突。

2. 语法结构

在C++中，使用关键字 virtual 来声明虚基类。基本语法如下：

cpp

class Base {
    // 基类内容
};

class Derived1 : virtual public Base {
    // 派生类1
};

class Derived2 : virtual public Base {
    // 派生类2
};

class FinalDerived : public Derived1, public Derived2 {
    // 最终派生类
};

3. 访问权限

与普通继承相同，虚继承也支持访问权限控制。可以为虚基类指定 public、protected 或 private，以控制派生类对基类成员的访问权限。

示例代码

以下是一个简单的虚继承示例，展示了如何使用虚继承来解决二义性问题。

cpp

#include <iostream>
using namespace std;

// 基类
class Base {
public:
    void show() {
        cout << "Base class show()" << endl;
    }
};

// 第一个派生类
class Derived1 : virtual public Base {
public:
    void show() {
        cout << "Derived1 class show()" << endl;
    }
};

// 第二个派生类
class Derived2 : virtual public Base {
public:
    void show() {
        cout << "Derived2 class show()" << endl;
    }
};

// 最终派生类
class FinalDerived : public Derived1, public Derived2 {
public:
    void display() {
        // 显示调用的基类方法
        Base::show(); // 调用Base类的方法
    }
};

int main() {
    FinalDerived fd;
    fd.display(); // 调用显示方法
    return 0;
}

5. 虚继承的工作机制

共享基类实例

虚继承的核心在于确保派生类只拥有一个基类的实例。对于上述示例中的 Base 类，Derived1 和 Derived2 都虚继承自 Base，在 FinalDerived 中只会有一个 Base 的实例。这通过在内存中使用虚表（vtable）来实现。

构造顺序

在虚继承的情况下，构造函数的调用顺序如下：

  1. 先构造虚基类的实例（即 Base）。
  2. 然后构造派生类（如 Derived1 和 Derived2）。
  3. 最后构造最终派生类（FinalDerived）。

6. 优缺点

优点

  1. 消除二义性：虚继承确保在多继承中只有一个基类实例，从而消除二义性。
  2. 代码复用：允许多个派生类共享父类的实现，减少代码重复。
  3. 清晰的层次结构：虚继承提供了更清晰的类层次结构，易于管理。

缺点

  1. 复杂性：引入虚继承可能使类的设计变得更加复杂，增加理解和维护的难度。
  2. 性能开销：使用虚继承会增加内存开销，因为需要维护虚表和指针。
  3. 构造与析构的复杂性：构造和析构顺序的特殊处理可能导致混淆。

7. 实际应用

虚继承多用于以下几种场景：

  1. 接口设计：在设计需要多个接口的类时，虚继承可以确保接口的唯一性。
  2. 多重继承：当多个类需要继承同一基类时，虚继承可以避免重复实例化，减少内存使用。
  3. 复杂系统：在复杂系统中，尤其是涉及多个模块和组件的系统，虚继承可以帮助管理类之间的关系。

注意事项

在使用虚继承时，需要注意以下几点：

  1. 合理使用：只有在确实需要解决二义性问题时，才应使用虚继承。
  2. 清晰设计：确保类的设计清晰，避免不必要的复杂性。
  3. 构造函数：理解虚基类的构造函数调用顺序，以避免潜在的错误。

示例扩展

以下是一个更复杂的示例，展示了虚继承的灵活性和强大功能。

cpp

#include <iostream>
using namespace std;

// 基类
class Vehicle {
public:
    Vehicle() { cout << "Vehicle constructed." << endl; }
    void drive() { cout << "Driving a vehicle." << endl; }
};

// 虚基类
class Car : virtual public Vehicle {
public:
    Car() { cout << "Car constructed." << endl; }
    void honk() { cout << "Car honking!" << endl; }
};

// 虚基类
class Truck : virtual public Vehicle {
public:
    Truck() { cout << "Truck constructed." << endl; }
    void load() { cout << "Loading truck." << endl; }
};

// 最终派生类
class Pickup : public Car, public Truck {
public:
    Pickup() { cout << "Pickup constructed." << endl; }
};

int main() {
    Pickup p;
    p.drive(); // 调用Vehicle类的方法
    p.honk();  // 调用Car类的方法
    p.load();  // 调用Truck类的方法
    return 0;
}

8. 设计模式中的虚继承

在一些设计模式中，虚继承的应用也相当普遍。例如：

  • 适配器模式：通过虚继承组合不同类型的接口，使得对象可以互相适配。
  • 桥接模式：将抽象部分与实现部分分离，使用虚继承可以实现不同的实现。

9. 进阶概念

虚析构函数

为了安全地删除通过基类指针指向的派生类对象，基类应使用虚析构函数。这确保在删除时会调用派生类的析构函数。

cpp

class Base {
public:
    virtual ~Base() { cout << "Base Destructor" << endl; }
};

class Derived : public Base {
public:
    ~Derived() { cout << "Derived Destructor" << endl; }
};

int main() {
    Base* b = new Derived();
    delete b; // 正确调用Derived和Base的析构函数
    return 0;
}

10. 总结

C++中的虚继承是解决多继承中二义性问题的重要机制。通过确保在多重继承中只创建一个基类的实例，虚继承提高了代码的可复用性和管理性。然而，虚继承引入的复杂性和性能开销也不容忽视。在设计类层次结构时，应合理考虑虚继承的使用，以实现更高效和可维护的代码结构。


http://www.niftyadmin.cn/n/5796263.html

相关文章

数据结构_赫夫曼树（基于例题）

数据结构_赫夫曼树（基于例题）

赫夫曼树的构建与编码 哈夫曼树类 属性有权值&#xff0c;父母值&#xff0c;左孩子值和右孩子值&#xff0c;实现的方法有构造哈夫曼树和哈夫曼编码 class HuNode { public:int weight, parent, lch, rch;void create_Tree(HuNode* HT, int n);void create_Code(HuNode* HT…
阅读更多...
linux作 samba 服务端，linux windows文件互传，免账号密码

linux作 samba 服务端，linux windows文件互传，免账号密码

一 ubuntu 安装 sudo apt install samba二 修改samba 配置文件 1 路径 ls -l /etc/samba/smb.conf2 修改文件 a&#xff1a;配置成 匿名用户&#xff0c;无需输入账号 b&#xff1a;注意配置可读写且文件可创建可删除 [global] workgroup SAMBA security user passdb back…
阅读更多...
初识面向对象晨考day09

初识面向对象晨考day09

1.类和对象什么关系 类是对象的抽象 对象是类的具体 2.什么是属性和方法 一类事物共有的特征&#xff0c;使用属性描述 一类事物共有的行为&#xff0c;使用方法描述 3.普通方法的定义格式 public 返回值类型 方法名(参数列表){} 4.什么是形参&#xff0c;什么是实参 形参是方法…
阅读更多...
解锁未来：深入探索去中心化应用程序（DApps）的潜力与挑战

解锁未来：深入探索去中心化应用程序（DApps）的潜力与挑战

引言 近年来&#xff0c;随着区块链技术的迅猛发展&#xff0c;去中心化应用程序&#xff08;DApps&#xff09;逐渐成为业界关注的焦点。那么&#xff0c;什么是DApps&#xff1f;它们如何工作&#xff1f;又能为我们的生活和工作带来哪些影响和改变&#xff1f;本文将深入探…
阅读更多...
完全二叉树的权值(蓝桥杯2019年试题G)

完全二叉树的权值(蓝桥杯2019年试题G)

给定一棵包含N个节点的完全二叉树&#xff0c;树上的每个节点都有一个权值&#xff0c;按从上到小、从左到右的顺序依次是A1、A2……An,&#xff08;1&#xff0c;2&#xff0c;n为下标。&#xff09;如下图所示。 现在&#xff0c;小明要把相同深度的节点的权值加到一起&#…
阅读更多...
详细介绍如何使用rapidjson读取json文件

详细介绍如何使用rapidjson读取json文件

本文主要详细介绍如何使用rapidjson库来实现.json文件的读取&#xff0c;分为相关基础介绍、结合简单示例进行基础介绍、结合复杂示例进行详细的函数实现介绍等三部分。 一、相关基础 1、Json文件中的{} 和 [] 在 JSON 文件中&#xff0c;{} 和 [] 分别表示不同的数据结构&…
阅读更多...
CTF学习24.12.21[隐写术进阶]

CTF学习24.12.21[隐写术进阶]

MISC08[隐写术进阶] PDF文件隐写 隐写的加密&#xff1a;wbStego4open工具的下载和使用 1.wbStego4open介绍&#xff1a; wbStego4open是一个隐写开源工具&#xff0c;它支持Windows和Linux平台&#xff0c;可以使用wbStego4open把文件隐藏到BMP、TXT、HTM和PDF文件中&#…
阅读更多...
[项目代码] YOLOv8 遥感航拍飞机和船舶识别 [目标检测]

[项目代码] YOLOv8 遥感航拍飞机和船舶识别 [目标检测]

项目代码下载链接 &#xff1c;项目代码&#xff1e;YOLO 遥感航拍飞机和船舶识别&#xff1c;目标检测&#xff1e;https://download.csdn.net/download/qq_53332949/90163939YOLOv8是一种单阶段&#xff08;one-stage&#xff09;检测算法&#xff0c;它将目标检测问题转化为…
阅读更多...
最新文章

Copyright @ 2022~2023