派生类-访问同名的成员如何做？

基类和派生类有同名的成员

在C++类的继承中，如果基类和派生类有同名的成员，派生类会隐藏基类中所有相同名称的成员。这意味着，如果在派生类中直接访问该名称的成员，将会默认访问派生类自己的成员，而不是基类中的同名成员。
如果需要在派生类中访问被隐藏的基类成员，可以使用作用域解析运算符 :: 来指定要访问的成员所属的类。这样就可以访问到基类中被同名成员隐藏的成员。
下面是一个简单的例子：

#include <iostream>
// 基类
class Base {
public:
    int value;
    void show() {
        std::cout << "Base::show() called, value = " << value << std::endl;
    }
};
// 派生类
class Derived : public Base {
public:
    int value;
    // 派生类的构造函数
    Derived(int baseValue, int derivedValue) : Base(), value(derivedValue) {
        Base::value = baseValue; // 使用作用域解析运算符设置基类的value
    }
    // 派生类中的同名函数
    void show() {
        std::cout << "Derived::show() called, Base::value = " << Base::value << ", Derived::value = " << value << std::endl;
    }
};
int main() {
    Derived obj(10, 20);
    obj.show(); // 调用派生类的show()
    // 访问派生类的成员
    std::cout << "Derived::value = " << obj.value << std::endl;
    // 使用作用域解析运算符访问基类的成员
    std::cout << "Base::value = " << obj.Base::value << std::endl;
    return 0;
}

在这个例子中，Derived 类继承了 Base 类，并且它们都有一个名为 value 的成员和一个名为 show 的成员函数。在 Derived 类的 show 函数中，我们通过 Base::value 来访问基类中的 value 成员，通过 value 来访问派生类自己的 value 成员。在 main 函数中，我们创建了 Derived 类的对象 obj，并演示了如何通过作用域解析运算符 :: 来访问基类和派生类中同名的成员。

问：如果两个基类的同名成员呢？

如果在C++中一个派生类继承了两个或多个基类，而这些基类中包含了同名的成员，那么在派生类中直接访问这个成员会导致编译器无法确定到底应该访问哪一个基类的成员，从而产生编译错误。为了避免这种歧义，你需要使用作用域解析运算符 :: 来明确指定你想要访问的成员所属的基类。
下面是一个简单的例子，展示了如何处理这种情况：

#include <iostream>
// 第一个基类
class Base1 {
public:
    void show() {
        std::cout << "Base1::show() called" << std::endl;
    }
};
// 第二个基类
class Base2 {
public:
    void show() {
        std::cout << "Base2::show() called" << std::endl;
    }
};
// 派生类，继承了两个基类
class Derived : public Base1, public Base2 {
public:
    // 派生类的构造函数
    Derived() {}
    // 使用作用域解析运算符调用基类的show函数
    void callShows() {
        Base1::show(); // 调用Base1的show
        Base2::show(); // 调用Base2的show
    }
};
int main() {
    Derived obj;
    obj.callShows(); // 调用派生类的callShows，进而调用两个基类的show
    //或者下面方式
    obj.Base1::show();
    obj.Base2::show();
    return 0;
}

在这个例子中，Derived 类继承了 Base1 和 Base2 两个类，它们都有一个名为 show 的成员函数。在 Derived 类的 callShows 函数中，我们通过 Base1::show() 和 Base2::show() 来分别调用两个基类中的 show 函数。这样，我们就避免了编译器的歧义错误，并且可以明确地访问到我们想要访问的基类成员。

在类继承中，同名的静态成员如何处理?

在C++类继承中，静态成员函数和静态成员变量属于类本身，而不是类的某个具体对象。如果一个派生类继承了多个基类，而这些基类中包含同名的静态成员，那么这些静态成员在继承体系中仍然保持其唯一性。即使派生类中有同名的静态成员，它们也不会隐藏基类中的静态成员，因为静态成员是通过类名直接访问的，而不是通过对象。
下面是一个简单的例子，展示了如何处理继承中同名的静态成员：

#include <iostream>
// 第一个基类
class Base1 {
public:
    static void show() {
        std::cout << "Base1::show() called" << std::endl;
    }
};
// 第二个基类
class Base2 {
public:
    static void show() {
        std::cout << "Base2::show() called" << std::endl;
    }
};
// 派生类，继承了两个基类
class Derived : public Base1, public Base2 {
public:
    // 派生类的静态成员函数
    static void show() {
        std::cout << "Derived::show() called" << std::endl;
    }
};
int main() {
    Derived::show(); // 调用派生类的show
    Base1::show();  // 调用Base1的show
    Base2::show();  // 调用Base2的show

	/*这段内容，通过对象访问也可以，上面方法和下面这个都可以
	在C++中，当您创建派生类的对象时，该对象包含所有基类的成员。
	因此，您可以通过派生类的对象来调用基类的成员函数，包括静态成员函数。
	不过，需要注意的是，静态成员函数并不是与对象相关的，它们是与类本身相关的。
	因此，即使是通过对象调用，实际上也是调用的类的静态成员函数，而不是对象实例的。
	Base1 base1;
    base1.show();
    Derived derived;
    derived.show();
    derived.Base1::show();
    */
    return 0;
}

在这个例子中，Derived 类继承了 Base1 和 Base2 两个类，它们都有一个名为 show 的静态成员函数。Derived 类自己也定义了一个同名的静态成员函数 show。由于静态成员是通过类名直接访问的，因此我们可以分别通过 Derived::show()、Base1::show() 和 Base2::show() 来调用这三个不同的 show 函数。
需要注意的是，如果派生类中没有定义同名的静态成员，那么直接通过派生类名访问该成员时，编译器会根据继承的顺序来确定使用哪个基类的静态成员。例如，如果 Derived 类没有定义 show 函数，那么 Derived::show() 将会调用 Base1::show()，因为它是最先继承的基类。如果想要调用 Base2::show()，则需要使用作用域解析运算符 :: 明确指定基类名，即 Base2::show()。