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++ 的多态性。

cshape中形参和实参

在C++中的`cshape`类（假设它是一个表示形状的抽象基类）中，形参和实参通常用于函数参数。形参是函数定义时声明的变量，它们代表了函数期望传入的值。实参则是实际传递给函数的值。

例如，如果你有一个抽象的`draw()`函数：

class cshape {
public:
    virtual void draw(double size) = 0; // 形参：size，表示形状大小
};

在这个例子中，`double size`就是形参，它是一个双精度浮点数，表示绘制形状时使用的尺寸。当你创建这个类的一个子类并实例化后调用`draw()`方法时，需要提供具体的数值作为实参：

class circle : public cshape {
public:
    void draw(double radius) override { ... } // 实参：radius，表示圆的半径
};

circle my_circle(5.0); // 实例化并初始化
my_circle.draw(7.5); // 调用draw函数时，传入实参7.5