c++ 形参是子类的引用，实参却是父类对象

在 C++ 中，当形参是子类类型的引用，并且函数接受的是父类类型的指针或引用作为实参时，这被称为“隐式转换”或“上下文依赖类型”。这是由于 C++ 的动态绑定特性，也称为晚期绑定或运行时多态。

例如：

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

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

void function(Base& baseRef) {
    // 实参是一个 Derived 对象
    Derived derived;
    // 虽然形参是 Base 类型的引用，但因为是通过 derived 引用传递，会调用 Derived 类的 print 方法
    baseRef.print(); // 输出 "Derived"
}

int main() {
    Derived derived;
    function(derived); // 隐式转换，不会引发错误，运行时调用的是 Derived 的 print 方法
    return 0;
}

相关问题

c++ 形参是父类的引用，实参却是子类对象

在 C++ 中，当形参是父类的引用，而实参是子类的对象时，这种情况称为“向下转型”或“隐式转换”。这是因为尽管函数声明中使用的形参是父类类型的，但在实际调用时，如果传入的是子类的对象，编译器会自动将子类对象转换为父类类型的指针或引用。

例如，假设有一个基类 `Shape` 和两个派生类 `Circle` 和 `Square`：

class Shape {
public:
    virtual void draw() const { cout << "Drawing a shape." << endl; }
};

class Circle : public Shape {
public:
    void draw() const override { cout << "Drawing a circle." << endl; }
};

class Square : public Shape {
public:
    void draw() const override { cout << "Drawing a square." << endl; }
};

void printShape(const Shape& s) {
    s.draw();
}

int main() {
    Circle circle;
    Square square;

    // 尽管printShape接受的是Shape的引用，但circle和square都是其子类对象
    printShape(circle); // 输出: Drawing a circle.
    printShape(square); // 输出: Drawing a square.

    return 0;
}

这里，`printShape` 函数可以接受任何 `Shape` 类型的引用，而当我们传入 `Circle` 或 `Square` 对象时，它们的 `draw` 方法会被正确地调用，体现了 C++ 的多态性。

形参是父类，实参是子类，传递过程有啥问题

在这种情况下，传递子类对象作为父类形参是完全可行的，因为子类是父类的一种特殊情况，拥有与父类相同的属性和方法，同时还可以有自己独特的属性和方法。这种传递方式被称为多态，是面向对象编程中的一种重要概念。

但是需要注意的是，如果在方法中对形参进行了类型转换，将其转换为其子类类型，那么可能会导致类型转换异常，因为实参可能并不是父类的子类。此外，在对形参进行操作时，如果使用了子类特有的方法或属性，那么在运行时可能会出现错误。因此，应该确保在对形参进行操作时，只使用父类中已定义的方法和属性。