C++ 子类调用父类方法

在C++中，子类调用父类方法的过程叫做方法重置（Virtual Method Call）。当一个子类对象引用父类类型的指针或引用，并通过这个指针或引用调用父类中的虚函数时，实际会执行子类中重写（overridden）的那个版本的方法。这是多态的一个关键特性。

为了实现子类对父类方法的重写，需要在父类声明该方法为虚函数（virtual），然后在子类中使用`override`关键字提供自己的实现。例如：

class Parent {
public:
    virtual void someFunction() { /* 父类方法 */ }
};

class Child : public Parent {
public:
    // 使用 override 关键字重写父类方法
    void someFunction() override { /* 子类方法 */ }
};

当你创建一个`Child`对象并将其赋值给`Parent`类型的指针时，可以像下面这样调用`someFunction()`，实际上执行的是`Child`类的方法：

Parent* ptr = new Child();
ptr->someFunction();  // 这里执行的是Child类的someFunction实现

相关问题

还有其他方法c++子类调用父类方法时，知道是哪个子类调用的

可以使用虚函数来实现子类调用父类方法时知道是哪个子类调用的。

具体实现方法是，在父类中声明一个虚函数，然后在每个子类中重写这个虚函数并添加标识子类的信息。例如：

class Animal {
public:
    virtual void speak() {
        std::cout << "I am an animal." << std::endl;
    }
};

class Cat : public Animal {
public:
    void speak() override {
        std::cout << "I am a cat." << std::endl;
    }
};

class Dog : public Animal {
public:
    void speak() override {
        std::cout << "I am a dog." << std::endl;
    }
};

在这个例子中，Animal 类中声明了一个虚函数 speak()，Cat 和 Dog 类都重写了这个虚函数并添加了标识信息。当子类调用 speak() 方法时，父类中的 speak() 方法将被调用，但实际执行的是子类中重写的方法，因此可以知道是哪个子类调用了该方法。

int main() {
    Animal* cat = new Cat();
    Animal* dog = new Dog();

    cat->speak(); // 输出 "I am a cat."
    dog->speak(); // 输出 "I am a dog."

    delete cat;
    delete dog;

    return 0;
}

在这个例子中，我们创建了一个指向 Cat 对象和一个指向 Dog 对象的 Animal 指针，然后分别调用了它们的 speak() 方法。由于 speak() 方法是虚函数，因此实际执行的是子类中重写的方法，并输出了相应的标识信息。

c++子类调用父类方法时，如何知道是哪个子类调用的

在 C++ 中，子类调用父类方法时，可以通过将子类的对象指针传递给父类方法来区分不同的子类对象。这样，父类方法就可以根据传递的子类对象指针来进行相应的处理。

例如，假设有一个父类 Animal，它有一个方法 eat()，现在有两个子类 Dog 和 Cat，它们都继承自 Animal，并且都重写了 eat() 方法。如果在某个地方需要调用 eat() 方法，可以这样做：

void function(Animal* animal) {
    animal->eat();
}

Dog dog;
Cat cat;
function(&dog); // 调用 Dog 的 eat() 方法
function(&cat); // 调用 Cat 的 eat() 方法

在上面的示例中，通过将子类的对象指针传递给函数 function()，就可以调用相应的子类方法。在父类方法 eat() 中，可以通过 this 指针来获取当前对象的类型，从而区分不同的子类对象。例如，在 Animal 类中可以这样实现 eat() 方法：

class Animal {
public:
    virtual void eat() {
        if (typeid(*this) == typeid(Dog)) {
            std::cout << "Dog is eating" << std::endl;
        } else if (typeid(*this) == typeid(Cat)) {
            std::cout << "Cat is eating" << std::endl;
        } else {
            std::cout << "Unknown animal is eating" << std::endl;
        }
    }
};

class Dog : public Animal {
public:
    void eat() {
        std::cout << "Dog is eating" << std::endl;
    }
};

class Cat : public Animal {
public:
    void eat() {
        std::cout << "Cat is eating" << std::endl;
    }
};

在上面的示例中，Animal 类中的 eat() 方法通过 typeid(*this) 获取当前对象的类型，并根据类型进行相应的处理。由于 Dog 和 Cat 类都重写了 eat() 方法，因此在调用 function() 函数时，会根据对象的实际类型来调用相应的 eat() 方法。