#include<iostream> using namespace std; class Shape { public: double calArea() { return 0; } }; class Rectangle :public Shape { private: double wide, high; public: Rectangle(double a, double b) { wide = a; high = b; } double calArea() { return wide * high; } }; class Circle :public Shape { private: double R; public: Circle(double a) { R = a; } double calArea() { return 3.1415926 * R * R; } }; int main() { double a, b, c; cin >> a >> b >> c; Rectangle A(a, b); Circle B(c); cout << "通过Rectangle类对象调用calArea()：" << A.Rectangle::calArea() << endl; cout << "通过Circle类对象调用calArea()：" << B.Circle::calArea() << endl; Shape* p1, * p2; p1 = &A; p2 = &B; cout << "基类指针指向Rectangle类对象，调用calArea()：" << p1->Shape::calArea() << endl; cout << "基类指针指向Circle类对象，调用calArea()：" << p2->Shape::calArea() << endl; Shape& r1 = A; cout << "Rectangle类对象初始化基类对象引用r，r调用calArea()：" << r1.Shape::calArea() << endl; Shape& r = B; cout << "Circle类对象初始化基类对象引用r，r调用calArea()：" << r.Shape::calArea() << endl; return 0; }其中calArea函数不纯在二义性吗

在这个程序中，calArea函数不存在二义性。这是因为该程序中的Rectangle类和Circle类都是Shape类的派生类，并且在这两个派生类中，都重写了Shape类中的calArea函数。因此，通过Rectangle类对象调用calArea函数时，会调用Rectangle类中的calArea函数；通过Circle类对象调用calArea函数时，会调用Circle类中的calArea函数。而通过基类指针或基类引用调用calArea函数时，由于指针或引用指向的是具体的派生类对象，因此也会调用相应的派生类中的calArea函数。因此，calArea函数不存在二义性。

相关问题

定义一个基类 Shape ，有成员函数： calArea ()，但什么都不做，返回0。在此基础上公有派生出 Rectangle （矩形）类和 Circle 类，添加相应的数据成员（成员均为 double 型），重新定义 calArea (）计算对象的面积。

下面是实现该题目的 C++ 代码：

#include <iostream>
using namespace std;

class Shape {
public:
    virtual double calArea() {
        return 0;
    }
};

class Rectangle : public Shape {
public:
    double width;
    double height;
    virtual double calArea() {
        return width * height;
    }
};

class Circle : public Shape {
public:
    double radius;
    virtual double calArea() {
        return 3.14 * radius * radius;
    }
};

int main() {
    Shape* shape1 = new Rectangle();
    Shape* shape2 = new Circle();

    ((Rectangle*)shape1)->width = 10;
    ((Rectangle*)shape1)->height = 20;
    cout << "Rectangle area: " << shape1->calArea() << endl;

    ((Circle*)shape2)->radius = 5;
    cout << "Circle area: " << shape2->calArea() << endl;

    delete shape1;
    delete shape2;
    return 0;
}

在上面的代码中，我们定义了一个基类 Shape ，其中有一个虚函数 calArea() ，但它什么也不做，返回值为 0 。然后我们通过 public 继承的方式定义了 Rectangle 和 Circle 两个派生类，并分别添加了对应的数据成员和重新定义了 calArea() 函数，用来计算对象的面积。

在主函数中，我们通过 Shape* 的指针分别创建了 Rectangle 和 Circle 的对象，并进行了相应的赋值。最后输出了这两个对象的面积。需要注意的是，在使用指针访问派生类的成员时，必须进行类型转换，否则编译器会提示错误。

定义一个基类Shape，有成员函数：calArea()，但什么都不做，返回0。在此基础上公有派生出Rectangle（矩形）类和Circle类，添加相应的数据成员（成员均为double型），重新定义calArea()计算对象的面积。 主函数中，分别定义一个Rectangle和Circle类对象，初始值由键盘输入。（1）通过对象调用相应的calArea()，输出结果；（2）定义Shape类对象指针，分别赋以Rectangle和Circle类的对象地址，通过指针调用calArea()，输出结果；（3）定义Shape类对象引用r，以Rectangle和Circle类的对象初始化r，通过引用r调用calArea()，输出结果。

#include <iostream>
using namespace std;

class Shape {
public:
    virtual double calArea() {
        return 0;
    }
};

class Rectangle : public Shape {
private:
    double length, width;
public:
    Rectangle(double l, double w) {
        length = l;
        width = w;
    }
    virtual double calArea() {
        return length * width;
    }
};

class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r) {
        radius = r;
    }
    virtual double calArea() {
        return 3.14 * radius * radius;
    }
};

int main() {
    double l, w, r;
    cout << "请输入矩形的长和宽：";
    cin >> l >> w;
    Rectangle rect(l, w);
    cout << "矩形的面积为：" << rect.calArea() << endl;

    cout << "请输入圆的半径：";
    cin >> r;
    Circle cir(r);
    cout << "圆的面积为：" << cir.calArea() << endl;

    Shape* sp1 = &rect;
    Shape* sp2 = &cir;
    cout << "通过指针调用矩形的面积为：" << sp1->calArea() << endl;
    cout << "通过指针调用圆的面积为：" << sp2->calArea() << endl;

    Shape& sr = rect;
    Shape& sc = cir;
    cout << "通过引用调用矩形的面积为：" << sr.calArea() << endl;
    cout << "通过引用调用圆的面积为：" << sc.calArea() << endl;

    return 0;
}

输出示例：

请输入矩形的长和宽：3 4
矩形的面积为：12
请输入圆的半径：2
圆的面积为：12.56
通过指针调用矩形的面积为：12
通过指针调用圆的面积为：12.56
通过引用调用矩形的面积为：12
通过引用调用圆的面积为：12.56