c++多重继承的子类，其父类如果含有虚函数，那么子类如何去调用自身的非虚成员函数

子类可以通过作用域限定符来调用自身的非虚成员函数。其语法为：`子类名::函数名()`。

例如，假设有两个父类 A 和 B，均含有虚函数 func()，并且子类 C 继承了 A 和 B。子类 C 还定义了一个非虚成员函数 non_virt_func()。如果想要在子类 C 中调用 non_virt_func()，可以使用如下语法：

class C : public A, public B {
public:
    void non_virt_func() {
        // 子类自身的非虚成员函数
    }
};

int main() {
    C c;
    c.non_virt_func(); // 调用子类自身的非虚成员函数
    c.A::func(); // 调用父类 A 的虚函数
    c.B::func(); // 调用父类 B 的虚函数
    return 0;
}

在子类 C 中，可以直接调用 non_virt_func() 函数。如果需要调用父类 A 或 B 的虚函数 func()，则可以使用作用域限定符指定父类的名称。

相关问题

怎么实现C++中基类使用虚函数怎么调用多个子类

实现C++中基类使用虚函数的调用多个子类方法可以采用多态的机制，具体可以通过以下步骤实现：

1. 在基类中声明虚函数，子类可以重写这个函数。
2. 声明一个基类指针指向子类对象，通过这个指针调用虚函数实现多态。
3. 通过动态绑定机制在运行时确定调用哪个子类的虚函数。

例如：

#include <iostream>
using namespace std;

class Shape {
public:
    virtual void draw() {
        cout << "Shape::draw() called" << endl;
    }
};

class Circle : public Shape {
public:
    void draw() {
        cout << "Circle::draw() called" << endl;
    }
};

class Square : public Shape {
public:
    void draw() {
        cout << "Square::draw() called" << endl;
    }
};

int main() {
    Shape *s;
    Circle c;
    Square sq;

    s = &c;
    s -> draw();

    s = &sq;
    s -> draw();

    return 0;
}

输出：

Circle::draw() called
Square::draw() called

在这个例子中，Shape作为基类声明了虚函数draw()，然后Circle类和Square类都重写了这个函数并实现自己的逻辑。在main()函数中，我们声明了Shape类型的指针s，并用它依次指向了Circle对象和Square对象，然后通过指针s调用draw()函数。运行结果表明，程序正确地调用了Circle::draw()和Square::draw()函数，这就是多态机制的体现。

c++父类非虚函数，想在子类中实现新的功能

如果想要在子类中实现新的功能，建议使用虚函数来实现，而不是重新定义继承而来的非虚函数。虚函数可以在派生类中进行重写，从而实现新的功能，而不会影响到基类的实现。

具体实现方法如下：

1. 在父类中声明虚函数。
2. 在子类中重写虚函数，实现新的功能。
3. 在需要调用子类实现的地方，使用指向子类对象的指针或引用来调用虚函数。

示例代码如下：

#include <iostream>

using namespace std;

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

class Child : public Parent {
public:
    void print() {
        cout << "Child::print()" << endl;
    }
    
    void show() override {
        cout << "Child::show()" << endl;
    }
};

int main() {
    Parent *p = new Child;
    p->print(); // 调用父类的print函数
    p->show(); // 调用子类的show函数
    return 0;
}

输出结果为：

Parent::print()
Child::show()

可以看到，当使用指向子类对象的指针调用print函数时，调用的是父类的print函数，而使用同样的指针调用show函数时，调用的是子类的show函数。这就是虚函数的实现方式。