CPP复习 杂项

虚继承（Virtual Inheritance）是C++中的一种技术，用于解决多重继承中的菱形继承问题（Diamond Problem）。菱形继承问题通常发生在多重继承中，当一个派生类通过多个路径继承自同一个基类时，导致基类的成员存在多个拷贝。

菱形继承问题示例

考虑以下示例，展示了菱形继承问题：

#include <iostream>

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

class Derived1 : public Base {
};

class Derived2 : public Base {
};

class Final : public Derived1, public Derived2 {
};

int main() {
    Final obj;
    // obj.show(); // Error: ambiguous
    return 0;
}

在上述例子中，Final 类通过 Derived1 和 Derived2 两条路径继承自 Base 类，导致 Base 类的两个副本存在于 Final 类中。如果尝试通过 Final 类对象调用 Base 类的方法，会产生歧义。

解决菱形继承问题的虚继承

通过虚继承，可以确保无论多少派生类从一个基类继承，基类成员只有一个副本。可以使用关键字 virtual 来实现虚继承。

#include <iostream>

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

class Derived1 : virtual public Base {
};

class Derived2 : virtual public Base {
};

class Final : public Derived1, public Derived2 {
};

int main() {
    Final obj;
    obj.show(); // This works without ambiguity
    return 0;
}

在此例子中，Derived1 和 Derived2 类通过 virtual 关键字虚继承自 Base 类。这样，Final 类中只有一个 Base 类的实例，消除了歧义。

虚继承的关键点

1. 虚基类：使用 virtual 关键字指定继承关系，确保基类在最终派生类中只有一个实例。
2. 构造函数顺序：在构造派生类对象时，虚基类会在其他基类之前被初始化。

构造函数顺序示例

虚继承改变了构造函数的调用顺序。虚基类的构造函数在所有派生类构造函数之前被调用。

#include <iostream>

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

class Derived1 : virtual public Base {
public:
    Derived1() {
        std::cout << "Derived1 class constructor" << std::endl;
    }
};

class Derived2 : virtual public Base {
public:
    Derived2() {
        std::cout << "Derived2 class constructor" << std::endl;
    }
};

class Final : public Derived1, public Derived2 {
public:
    Final() {
        std::cout << "Final class constructor" << std::endl;
    }
};

int main() {
    Final obj;
    return 0;
}

输出：

Base class constructor
Derived1 class constructor
Derived2 class constructor
Final class constructor

从输出中可以看到，Base 类的构造函数首先被调用，接着是 Derived1 和 Derived2 类的构造函数，最后是 Final 类的构造函数。

总结

虚继承是C++中解决多重继承菱形继承问题的强大工具。它确保基类的成员在派生类中只有一个副本，消除了歧义和潜在的错误。掌握虚继承的概念和使用方法对编写复杂的继承层次结构非常重要。

在C++中，编译时多态性（compile-time polymorphism）是指在编译期间决定的多态行为。主要包括函数重载（function overloading）、运算符重载（operator overloading）和模板（templates）等机制。以下是对这些机制的详细介绍：

1. 函数重载（Function Overloading）

函数重载是指在同一个作用域中可以有多个同名函数，但这些函数具有不同的参数列表（参数的数量或类型不同）。编译器会根据调用函数时传递的参数类型和数量来选择匹配的函数。

示例

#include <iostream>

// 重载函数
void print(int i) {
 std::cout << "Printing int: " << i << std::endl;
}

void print(double f) {
 std::cout << "Printing double: " << f << std::endl;
}

void print(const std::string& s) {
 std::cout << "Printing string: " << s << std::endl;
}

int main() {
 print(10);          // 调用 print(int)
 print(3.14);        // 调用 print(double)
 print("Hello");     // 调用 print(const std::string&)
 return 0;
}

2. 运算符重载（Operator Overloading）

运算符重载允许开发者为用户定义的类型重新定义C++内置运算符的行为。这使得用户定义的类型可以像内置类型一样进行运算。

示例

#include <iostream>

class Complex {
private:
 double real;
 double imag;

public:
 Complex(double r, double i) : real(r), imag(i) {}

 // 重载 + 运算符
 Complex operator + (const Complex& other) const {
     return Complex(real + other.real, imag + other.imag);
 }

 void display() const {
     std::cout << "(" << real << ", " << imag << ")" << std::endl;
 }
};

int main() {
 Complex c1(1.0, 2.0);
 Complex c2(3.0, 4.0);
 Complex c3 = c1 + c2;  // 使用重载的 + 运算符
 c3.display();          // 输出: (4.0, 6.0)
 return 0;
}

3. 模板（Templates）

模板是C++中实现泛型编程的一种机制。它允许函数或类的定义中使用类型参数，使得函数或类可以处理多种不同类型的数据，而不必重复编写代码。

函数模板示例

#include <iostream>

// 函数模板
template <typename T>
T add(T a, T b) {
 return a + b;
}

int main() {
 std::cout << add(5, 3) << std::endl;        // 输出: 8 (int)
 std::cout << add(2.5, 1.5) << std::endl;    // 输出: 4.0 (double)
 return 0;
}

类模板示例

#include <iostream>

// 类模板
template <typename T>
class Box {
private:
 T value;

public:
 Box(T v) : value(v) {}
 T getValue() const {
     return value;
 }
};

int main() {
 Box<int> intBox(123);
 Box<std::string> stringBox("Template");

 std::cout << intBox.getValue() << std::endl;       // 输出: 123
 std::cout << stringBox.getValue() << std::endl;    // 输出: Template
 return 0;
}

编译时多态性的优势

1. 类型安全：模板在编译时进行类型检查，减少了运行时错误。
2. 性能：编译时多态性避免了运行时开销（如虚函数的调用开销），通常比运行时多态性更高效。
3. 代码复用：模板允许编写泛型代码，可以处理多种数据类型，从而提高代码的复用性。

总结

编译时多态性是C++语言的一个强大特性，通过函数重载、运算符重载和模板，开发者可以编写高效、类型安全且复用性高的代码。理解和熟练运用这些特性是C++编程的重要技能之一。

#include <iostream>
using namespace std;
template<class T>
T func(T a,T b)
{
 return a+b;
}
int main() {
 double a=1.1;
 int b=10;
 a=func(a,b);
 cout<<a;
}

在你的示例代码中，你使用了一个模板函数 func 来进行加法运算。然而，C++模板要求模板参数类型必须相同，而在你的 main 函数中，你传递了一个 double 类型的参数 a 和一个 int 类型的参数 b 给模板函数 func，这会导致类型不匹配的问题。

解决方案

为了使代码能够编译并运行，有两种主要的解决方案：

1. 类型转换：将参数类型转换为相同的类型。
2. 重载函数模板：使用不同类型的参数。

方案一：类型转换

你可以在调用模板函数时显式地将 int 类型的参数转换为 double 类型：

#include <iostream>
using namespace std;

template<class T>
T func(T a, T b) {
    return a + b;
}

int main() {
    double a = 1.1;
    int b = 10;
    a = func(a, static_cast<double>(b));  // 将 b 转换为 double 类型
    cout << a;  // 输出: 11.1
    return 0;
}

这样，模板函数 func 会被实例化为处理 double 类型的参数，避免了类型不匹配的问题。

方案二：重载函数模板

你可以为模板函数 func 提供一个专门处理不同类型参数的重载版本：

#include <iostream>
using namespace std;

template<class T>
T func(T a, T b) {
    return a + b;
}

// 重载版本，处理不同类型的参数
template<class T1, class T2>
auto func(T1 a, T2 b) -> decltype(a + b) {
    return a + b;
}

int main() {
    double a = 1.1;
    int b = 10;
    a = func(a, b);  // 使用重载版本
    cout << a;  // 输出: 11.1
    return 0;
}

在这里，重载版本的 func 使用了 decltype 来推断返回类型，该返回类型是两个参数相加的结果类型。这样，你就可以直接传递不同类型的参数。

解释

• 类型转换：static_cast<double>(b) 将 b 转换为 double 类型，使得两个参数类型一致，从而可以调用模板函数。
• 函数模板重载：使用模板重载和 decltype 关键字来自动推断返回类型，允许传递不同类型的参数。

选择一种方案取决于你的具体需求和代码设计。对于简单的类型转换，显式转换参数类型可能更直接和清晰；对于需要处理多种类型组合的情况，使用模板重载可能更灵活和强大。

const_cast运算符

const_cast 是 C++ 中的一个类型转换运算符，用于移除对象的常量性（constness）或 volatile 修饰符。它可以将指向常量对象的指针或引用转换为指向非常量对象的指针或引用。

用法

const_cast<new_type>(expression)

• new_type：要转换成的类型。
• expression：要转换的表达式。

示例

#include <iostream>

int main() {
    const int x = 10;
    const int* ptr = &x;

    // 错误：试图通过指向常量的指针修改常量对象
    // *ptr = 20;

    // 使用 const_cast 移除常量性，修改对象的值
    int* non_const_ptr = const_cast<int*>(ptr);
    *non_const_ptr = 20;

    std::cout << "Modified value of x: " << x << std::endl;  // 输出: 20

    return 0;
}

在这个例子中，x 是一个常量整数，通过 const_cast 将指向 x 的指针 ptr 转换为指向非常量整数的指针 non_const_ptr。然后，可以使用 non_const_ptr 修改 x 的值。需要注意的是，修改一个常量对象的值是未定义行为（undefined behavior），因此应该谨慎使用 const_cast。

注意事项

1. const_cast 只能用于移除常量性或 volatile 修饰符，不能用于移除对象的指针或引用的底层 const。
2. 修改一个常量对象的值是未定义行为，可能会导致程序崩溃或产生其他不可预测的结果。
3. 使用 const_cast 应该尽可能避免，因为它通常会破坏程序的类型安全性和约束。

应用场景

• 在需要修改由常量指针或引用指向的对象值时，可以使用 const_cast。
• 例如，在调用接受非常量参数的函数时，需要将指向常量对象的指针传递给该函数，然后在函数内部修改对象的值。

void modify(int* ptr) {
    *ptr = 100;
}

int main() {
    const int x = 10;
    const int* ptr = &x;

    // 错误：试图通过指向常量的指针修改常量对象
    // modify(ptr);

    // 使用 const_cast 移除常量性，调用 modify 函数
    modify(const_cast<int*>(ptr));

    std::cout << "Modified value of x: " << x << std::endl;  // 输出: 100

    return 0;
}

总的来说，const_cast 应该谨慎使用，因为它可能会导致代码的不可预测行为。通常情况下，修改常量对象的值是不推荐的做法，应该避免使用 const_cast。

mutable 是 C++ 中的一个关键字，用于修饰类的成员变量，表示该成员变量可以在 const 成员函数中被修改。通常情况下，如果一个成员函数被声明为 const，那么它不能修改类的成员变量。但是，如果一个成员变量被声明为 mutable，则即使在 const 成员函数中也可以修改它的值。

用法示例

#include <iostream>

class Example {
private:
 mutable int mutableVar;

public:
 Example(int value) : mutableVar(value) {}

 void modifyMutableVar() const {
     mutableVar = 100;  // 在 const 成员函数中修改 mutable 变量的值
 }

 void displayMutableVar() const {
     std::cout << "Mutable variable: " << mutableVar << std::endl;
 }
};

int main() {
 Example obj(50);
 obj.displayMutableVar();     // 输出: Mutable variable: 50
 obj.modifyMutableVar();      // 调用 const 成员函数修改 mutable 变量的值
 obj.displayMutableVar();     // 输出: Mutable variable: 100
 return 0;
}

在这个示例中，mutableVar 被声明为 mutable，所以即使在 modifyMutableVar 这个 const 成员函数中也可以修改它的值。

适用场景

• 当某个类的成员变量需要在 const 成员函数中被修改时，可以将该成员变量声明为 mutable。
• 通常情况下，应该避免在 const 成员函数中修改类的状态，但有些情况下，比如在缓存的更新或日志记录等情况下，可能需要使用 mutable 关键字。
• 举例：一个已经排好序的链表，可以通过记录最后一次成功找到的位置继续进行查找，这样可以提高效率，这就需要在负责查找的const成员函数中修改数据（记录最后一次成功找到的位置的变量A）。对A声明为multable，这样就可以在const成员函数中修改数据。

命名空间（Namespace）是 C++ 中一种用来组织代码的机制，可以将全局作用域中的标识符划分为不同的区域，避免命名冲突，并提高代码的可读性和可维护性。

用法示例

#include <iostream>

// 声明命名空间
namespace MyNamespace {
 int x = 10;

 void printX() {
     std::cout << "x = " << x << std::endl;
 }
}

int main() {
 // 使用命名空间中的变量和函数
 MyNamespace::printX();  // 输出: x = 10
 return 0;
}

在这个示例中，MyNamespace 是一个命名空间，它包含一个整型变量 x 和一个函数 printX。通过 MyNamespace:: 作用域解析运算符，可以访问命名空间中的成员。

命名空间嵌套

命名空间可以嵌套定义，形成多层次的命名空间结构，有助于组织更复杂的代码。

#include <iostream>

namespace OuterNamespace {
 namespace InnerNamespace {
     int y = 20;

     void printY() {
         std::cout << "y = " << y << std::endl;
     }
 }
}

int main() {
 OuterNamespace::InnerNamespace::printY();  // 输出: y = 20
 return 0;
}

命名空间别名

可以为命名空间定义别名，使得命名空间更易读或更短。

#include <iostream>

namespace MyNamespace = OuterNamespace::InnerNamespace;

int main() {
 MyNamespace::printY();  // 输出: y = 20
 return 0;
}

使用 using 指令

可以使用 using 指令简化对命名空间成员的访问。

#include <iostream>

// 引入命名空间中的指定成员
using OuterNamespace::InnerNamespace::y;
using OuterNamespace::InnerNamespace::printY;

int main() {
 printY();  // 输出: y = 20
 std::cout << "y = " << y << std::endl;  // 输出: y = 20
 return 0;
}

命名空间的作用

1. 避免命名冲突：命名空间可以将相似的标识符隔离开来，防止命名冲突。
2. 提高可读性：命名空间提供了代码组织的结构，使得代码更易于理解和维护。
3. 限制作用域：命名空间中的标识符仅在命名空间内可见，可以控制标识符的可见性，降低了全局作用域的污染。
4. 组织代码：通过命名空间，可以将相关联的函数、类和变量组织到一个逻辑单元中，提高代码的模块化和组织性。

总的来说，命名空间是 C++ 中一种重要的组织代码的机制，可以有效地避免命名冲突，并提高代码的可读性和可维护性。

在C++中，指向类成员的指针是一种特殊的指针，用于指向类的非静态成员。这些指针可以用来访问和操作类的成员变量和成员函数。以下是指向类成员的指针的基本语法和用法：

定义指向类成员的指针

class MyClass {
public:
 int data;
 void memberFunction() {
     // 成员函数体
 }
};

int main() {
 int MyClass::*ptrData = &MyClass::data; // 指向成员变量的指针
 void (MyClass::*ptrMemberFunction)() = &MyClass::memberFunction; // 指向成员函数的指针
 return 0;
}

访问成员变量

MyClass obj;
obj.data = 10; // 直接访问成员变量
obj.*ptrData = 20; // 通过指向成员变量的指针访问

调用成员函数

MyClass obj;
obj.memberFunction(); // 直接调用成员函数
(obj.*ptrMemberFunction)(); // 通过指向成员函数的指针调用

指向类成员的指针数组

int MyClass::*ptrs[] = { &MyClass::data, &MyClass::data2 }; // 指向成员变量的指针数组
void (MyClass::*ptrsFunc[])() = { &MyClass::memberFunction1, &MyClass::memberFunction2 }; // 指向成员函数的指针数组

指向类成员的指针的语法如上所示。需要注意的是，指向非静态成员变量的指针需要指定类名、成员变量名和类作用域解析运算符 ::，而指向非静态成员函数的指针需要指定返回类型、类名、成员函数名和参数列表，并使用成员函数指针运算符 .* 来调用。

这种技术在一些场景下很有用，比如回调函数，设计模式中的策略模式等。然而，它需要小心使用，因为它可以绕过访问控制（private、protected、public）和动态多态性（虚函数）的限制，可能导致代码的可读性和安全性问题。

使用auto关键字简化

可以使用 auto 关键字来简化指向成员函数的指针的类型声明。下面是一个示例：

#include <iostream>

class MyClass {
public:
 void memberFunction(int x) {
     std::cout << "Member function called with argument: " << x << std::endl;
 }
};

int main() {
 MyClass obj;

 // 使用 auto 关键字声明指向成员函数的指针
 auto ptr = &MyClass::memberFunction;

 (obj.*ptr)(10); // 调用成员函数

 return 0;
}

在这个示例中，auto 关键字根据初始化表达式的类型推断了 ptr 的类型，使得代码更简洁。

.* 和 ->* 是 C++ 中用于访问指向成员的指针的成员函数和成员变量的操作符。

.* 操作符

.* 操作符用于通过指向类成员的指针来访问成员函数或成员变量。它的语法如下：

(obj.*ptrToMember)(args); // 调用成员函数
value = obj.*ptrToMember; // 访问成员变量

• obj 是类对象；
• ptrToMember 是指向成员函数或成员变量的指针；
• args 是传递给成员函数的参数列表；
• value 是成员变量的值。

->* 操作符

->* 操作符用于通过指向类的指针来访问成员函数或成员变量。它的语法如下：

(objPtr->*ptrToMember)(args); // 调用成员函数
value = objPtr->*ptrToMember; // 访问成员变量

• objPtr 是指向类对象的指针；
• ptrToMember 是指向成员函数或成员变量的指针；
• args 是传递给成员函数的参数列表；
• value 是成员变量的值。

示例

#include <iostream>

class MyClass {
public:
    int data;
    void memberFunction(int x) {
        std::cout << "Member function called with argument: " << x << std::endl;
    }
};

int main() {
    MyClass obj;
    obj.data = 10;

    auto ptrToMemberFunc = &MyClass::memberFunction;
    auto ptrToMemberData = &MyClass::data;

    (obj.*ptrToMemberFunc)(5); // 调用成员函数
    std::cout << "Data value: " << obj.*ptrToMemberData << std::endl; // 访问成员变量

    MyClass* objPtr = &obj;

    (objPtr->*ptrToMemberFunc)(8); // 通过指针调用成员函数
    std::cout << "Data value: " << objPtr->*ptrToMemberData << std::endl; // 通过指针访问成员变量

    return 0;
}

总结

.* 和 ->* 操作符提供了一种在运行时通过指针来访问成员函数和成员变量的方法。它们在处理通过指针调用成员函数和访问成员变量时非常有用。

让我们通过一个更具体的示例来解释 .* 和 ->* 操作符的用法。假设有一个简单的事件处理系统，其中有一个 EventHandler 类负责处理事件，并且我们希望能够注册回调函数来处理特定类型的事件。

首先，我们定义一个 EventHandler 类，其中包含一个处理事件的成员函数 handleEvent：

#include <iostream>

class EventHandler {
public:
 void handleEvent(int eventId) {
     std::cout << "Handling event with ID: " << eventId << std::endl;
 }
};

现在，假设我们有一个需要在事件发生时调用的回调函数。为了能够通用地处理不同类的事件处理器对象，我们希望将回调函数设计为接受事件处理器对象的指针和事件ID作为参数。

void callbackFunction(void (EventHandler::*ptrToMember)(int), EventHandler* obj, int eventId) {
 (obj->*ptrToMember)(eventId);
}

在这个回调函数中，ptrToMember 是一个指向成员函数的指针，它指向 EventHandler 类的 handleEvent 成员函数。obj 是一个指向 EventHandler 对象的指针，它表示事件处理器对象。eventId 是事件的标识符。

现在，我们可以在主函数中创建 EventHandler 对象和回调函数，并注册回调函数来处理事件：

int main() {
 EventHandler handler;

 // 注册回调函数来处理事件
 callbackFunction(&EventHandler::handleEvent, &handler, 123);

 return 0;
}

在这个示例中，我们首先创建了一个 EventHandler 对象 handler。然后，我们使用 callbackFunction 函数注册了一个回调函数来处理事件。在注册时，我们传递了成员函数指针 &EventHandler::handleEvent，这表示我们希望在事件发生时调用 EventHandler 类的 handleEvent 成员函数。我们还传递了 handler 对象的指针和事件ID 123。

回调函数 callbackFunction 使用 .* 操作符来调用成员函数指针指向的成员函数。(obj->*ptrToMember)(eventId) 这行代码实际上调用了 obj 指向的对象的 handleEvent 成员函数，并传递了事件ID作为参数。

这样，我们就可以实现一个通用的回调函数，它能够处理不同类的事件处理器对象，并在事件发生时调用指定的成员函数。

回调函数是一种在编程中常见的技术，它允许你将一个函数作为参数传递给另一个函数，以便在需要时由另一个函数调用。换句话说，回调函数是一个由用户定义的函数，它用作另一个函数的参数，以便在特定事件发生时被调用。

回调函数通常用于以下几种情况：

1. 事件处理：当某个特定事件发生时，调用者需要执行某些操作，但具体的操作在调用时可能未知。通过传递一个回调函数作为参数，调用者可以在事件发生时调用该回调函数来执行所需的操作。

2. 异步编程：在多线程或异步编程中，经常需要在某个任务完成时执行特定的回调操作。通过传递一个回调函数，可以在任务完成后通知调用者并执行所需的后续操作。

3. 事件驱动编程：在图形用户界面（GUI）开发中，经常需要在用户与界面交互时执行相应的操作。通过将回调函数与特定的用户操作或界面事件关联起来，可以实现用户界面的响应性和交互性。

下面是一个简单的示例，演示了如何使用回调函数来实现事件处理：

#include <iostream>

// 回调函数类型
typedef void (*CallbackFunction)(int);

// 注册回调函数
void registerCallback(CallbackFunction callback) {
    std::cout << "Callback registered!" << std::endl;
    // 模拟事件发生
    int eventId = 123;
    // 调用回调函数
    callback(eventId);
}

// 回调函数
void eventHandler(int eventId) {
    std::cout << "Event handled with ID: " << eventId << std::endl;
}

int main() {
    // 注册回调函数
    registerCallback(eventHandler);

    return 0;
}

在这个示例中，我们定义了一个 registerCallback 函数，它接受一个指向回调函数的指针作为参数。然后，我们定义了一个名为 eventHandler 的回调函数，它用于处理事件。在 main 函数中，我们调用 registerCallback 函数，并将 eventHandler 函数的指针作为参数传递给它。当 registerCallback 函数被调用时，它会打印一条消息表示回调函数已注册，并模拟一个事件发生，然后调用传递的回调函数来处理事件。

回调函数是一种灵活且强大的技术，它可以使代码更具模块化和可重用性，同时也提高了程序的可扩展性和灵活性。

多重继承是一种面向对象编程的特性，允许一个类从多个基类派生。在 C++ 中，一个派生类可以同时继承多个基类的成员和方法。这样的继承关系形成了一个继承图，其中一个派生类可能有多个直接或间接的基类。

各个基类的构造函数的调用顺序由多重继承时指定的顺序，如果在成员初始化器没有显式地调用基类的构造函数，还是会隐式地调用它们的默认构造函数

语法

class Base1 {
 // Base1 类的成员和方法
};

class Base2 {
 // Base2 类的成员和方法
};

class Derived : public Base1, public Base2 {
 // Derived 类的成员和方法
};

在这个例子中，Derived 类从 Base1 和 Base2 两个基类派生，它继承了这两个基类的成员和方法。

优点

1. 代码重用：多重继承允许派生类从多个基类继承成员和方法，从而可以更方便地重用已有的代码。

2. 组合：通过从多个基类继承，派生类可以将不同的功能组合在一起，形成更复杂的类。

注意事项

1. 命名冲突：多重继承可能导致命名冲突，当多个基类拥有相同名称的成员或方法时，派生类必须明确指定要使用的成员或方法。

2. 虚继承：多重继承中可能出现菱形继承问题（Diamond Inheritance Problem），为了解决这个问题，可以使用虚继承（virtual inheritance）。

3. 设计复杂性：过度使用多重继承可能导致设计变得复杂，增加代码的理解和维护难度。在设计时需要权衡复杂性和灵活性。

示例

#include <iostream>

// 基类 Base1
class Base1 {
public:
    void displayBase1() {
        std::cout << "Base1" << std::endl;
    }
};

// 基类 Base2
class Base2 {
public:
    void displayBase2() {
        std::cout << "Base2" << std::endl;
    }
};

// 派生类 Derived
class Derived : public Base1, public Base2 {
public:
    void displayDerived() {
        std::cout << "Derived" << std::endl;
    }
};

int main() {
    Derived obj;
    obj.displayBase1(); // 调用来自 Base1 的成员函数
    obj.displayBase2(); // 调用来自 Base2 的成员函数
    obj.displayDerived(); // 调用来自 Derived 的成员函数
    return 0;
}

在这个示例中，Derived 类从 Base1 和 Base2 两个基类派生，它继承了这两个基类的成员函数。在 main 函数中，我们创建了 Derived 类的对象，并调用了来自各个基类和派生类的成员函数。