2．根据父类，编写子类，求圆型的面积。要求至少包括构造函数、圆形面积的成员函数。const double PI = 3.1415926;用C++编程

以下是圆形面积的类的实现：

const double PI = 3.1415926;

class Circle {
public:
    Circle(double r) : m_radius(r) {} // 构造函数
    double area() const { return PI * m_radius * m_radius; } // 求圆形面积的成员函数
private:
    double m_radius; // 半径
};

在这个类中，我们使用了一个常量 `PI`，并定义了一个构造函数，它接受一个半径参数并将其存储在类的私有成员变量 `m_radius` 中。我们还实现了一个成员函数 `area()`，它计算并返回圆形的面积。

使用示例：

Circle c(10.0);
double area = c.area();
cout << "The area of the circle is: " << area << endl;

输出：

The area of the circle is: 314.159

相关问题

定义 GetPerim（）函数计算对象的周长，通过重载来求矩形 Rectangle 和圆形 Circle 的周长，并编写测试 main（）函数。

在面向对象编程中，`GetPerim()`函数是一个通用的方法，用于计算形状的周长。为了实现多态，我们可以创建两个类，Rectangle（矩形）和Circle（圆），它们都包含一个共同的父类Shape或者接口IShape，这个父类或接口声明了计算周长的方法。

首先，让我们定义基础的Shape类以及GetPerim()方法：

class IShape {
public:
    virtual double GetPerim() const = 0; // 纯虚函数，所有子类都需要实现此方法
};

class Shape {
protected:
    double _perimeter;
public:
    // 构造函数等...
    virtual ~Shape() {}
    double GetPerim() override { return _perimeter; } // 父类实现基本版本
};

然后，我们为Rectangle和Circle这两个具体的形状类重载GetPerim()方法：

class Rectangle : public Shape {
private:
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    double GetPerim() const override {
        return 2 * (width + height);
    }
};

class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}
    double GetPerim() const override {
        return 2 * M_PI * radius;
    }
};

最后，在main函数中，我们可以创建不同类型的对象并调用GetPerim()，由于多态性，系统会自动选择正确的实现：

int main() {
    Rectangle rect(5, 7);
    Circle circle(4.5);

    cout << "Rectangle perimeter: " << rect.GetPerim() << endl;
    cout << "Circle perimeter: " << circle.GetPerim() << endl;

    return 0;
}

C++ 定义形状类并派生圆类和矩形类 定义点类为圆类和矩形类定义合适的属性,然后定义成员函数计算面积

在C++中，我们可以首先定义一个基础形状类Shape，接着定义两个派生类Circle（圆形）和Rectangle（矩形），以及一个Point（点）类。这里是一个简单的例子：

// Shape 类
class Shape {
protected:
    Point center; // 点类实例作为基类属性

public:
    // 构造函数和析构函数
    Shape(Point c) : center(c) {}
    virtual ~Shape() {}

    // 计算面积的纯虚函数，子类需要覆盖
    virtual double getArea() const = 0;
};

// Circle 类，从 Shape 派生
class Circle : public Shape {
private:
    double radius;

public:
    Circle(Point c, double r) : Shape(c), radius(r) {}
    double getArea() const override { return M_PI * radius * radius; }
};

// Rectangle 类，从 Shape 派生
class Rectangle : public Shape {
private:
    double width, height;

public:
    Rectangle(Point c, double w, double h) : Shape(c), width(w), height(h) {}
    double getArea() const override { return width * height; }
};

// Point 类
class Point {
private:
    double x, y;

public:
    Point(double x, double y) : x(x), y(y) {}
    // 提供访问x和y坐标的方法...
};

在这个例子中，`getArea`函数是Shape类的一个纯虚函数，每个派生类都必须提供自己的实现。这样，无论我们创建的是Circle还是Rectangle对象，只要它们都是Shape类型的，就可以通过Shape指针调用getArea方法，并得到相应的面积值。