使用虚函数编写程序求球体和圆柱体的体积及表面积

### 回答1：
可以使用C++中的虚函数来编写程序求解球体和圆柱体的体积和表面积。

首先，定义一个基类Shape，包含两个纯虚函数getVolume()和getSurfaceArea()，分别用于计算体积和表面积。

然后，定义两个派生类Sphere和Cylinder，分别表示球体和圆柱体。这两个类都继承自Shape类，并实现了getVolume()和getSurfaceArea()函数。

在主函数中，可以通过创建Sphere和Cylinder对象来计算它们的体积和表面积，并输出结果。

示例代码如下：

#include <iostream>
using namespace std;

class Shape {
public:
    virtual double getVolume() = ;
    virtual double getSurfaceArea() = ;
};

class Sphere : public Shape {
private:
    double radius;
public:
    Sphere(double r) : radius(r) {}
    double getVolume() {
        return 4. / 3. * 3.14159 * radius * radius * radius;
    }
    double getSurfaceArea() {
        return 4. * 3.14159 * radius * radius;
    }
};

class Cylinder : public Shape {
private:
    double radius;
    double height;
public:
    Cylinder(double r, double h) : radius(r), height(h) {}
    double getVolume() {
        return 3.14159 * radius * radius * height;
    }
    double getSurfaceArea() {
        return 2. * 3.14159 * radius * height + 2. * 3.14159 * radius * radius;
    }
};

int main() {
    Sphere s(5);
    Cylinder c(3, 10);

    cout << "Sphere volume: " << s.getVolume() << endl;
    cout << "Sphere surface area: " << s.getSurfaceArea() << endl;
    cout << "Cylinder volume: " << c.getVolume() << endl;
    cout << "Cylinder surface area: " << c.getSurfaceArea() << endl;

    return ;
}

### 回答2：
在面向对象的编程中，虚函数是一种非常常用的技术，它允许我们在一个基类中定义一个虚函数，并在派生类中对该函数进行覆盖，从而实现多态性。在本题中，我们可以利用虚函数的特性，编写一个程序求球体和圆柱体的体积和表面积。

首先创建一个基类Shape，这个类中定义一个虚函数getArea()用于计算图形的面积，在此基础上派生出Sphere和Cylinder两个派生类，并分别实现自己的getArea()函数。在Sphere类中计算球体的表面积和体积，而在Cylinder类中计算圆柱体的表面积和体积。

具体代码如下：

#include<iostream>
#include<cmath>
using namespace std;

class Shape {
    public:
        virtual float getArea() {return 0;}
};

class Sphere: public Shape {
    private:
        float r;
    public:
        Sphere(float rr) {r = rr;}
        virtual float getArea() {
            float s = 4 * 3.14159 * r * r;
            float v = 4.0 / 3.0 * 3.14159 * r * r * r;
            cout << "球体表面积为：" << s << endl;
            cout << "球体体积为：" << v << endl;
            return 0;
        }
};

class Cylinder: public Shape {
    private:
        float r, h;
    public:
        Cylinder(float rr, float hh) {r = rr; h = hh;}
        virtual float getArea() {
            float s = 2 * 3.14159 * r * r + 2 * 3.14159 * r * h;
            float v = 3.14159 * r * r * h;
            cout << "圆柱体表面积为：" << s << endl;
            cout << "圆柱体体积为：" << v << endl;
            return 0;
        }
};

int main()
{
    Shape *p;
    Sphere s(5);
    Cylinder c(4, 10);
    p = &s;
    p->getArea();
    p = &c;
    p->getArea();
    return 0;
}

在程序中，我们定义了一个Shape基类，基类中定义了虚函数getArea()，让它返回0。基类Shape被派生成了Sphere和Cylinder两个派生类，其中Sphere类中定义了一个名为r的私有变量，该变量表示球半径。Cylinder类中定义了名为r和h的两个私有变量，分别表示圆柱的半径和高。

在Sphere类中重新实现了getArea()函数，通过r计算了球体表面积和体积，然后输出计算结果。同样地，在Cylinder类中通过r和h计算了圆柱体的表面积和体积，最后输出了计算结果。

在主函数中，我们定义了一个指向Shape基类的指针p，并通过s和c两个对象分别创建了Sphere和Cylinder的实例，然后将对象的地址赋值给指针p。接着调用了p的getArea()函数，由于getArea()是虚函数，在程序运行时将根据实际调用的对象类型而动态调用相应的函数。

最后程序会输出球体和圆柱体的体积和表面积。通过这个例子，我们可以看到使用虚函数非常方便实现多态性，而这种机制正是面向对象编程的一个重要特性。

### 回答3：
闭包环境需要进行面向对象编程，用虚函数实现求球体和圆柱体的体积及表面积。

首先，我们定义两个基类：一个球体（Sphere）和一个圆柱体（Cylinder）。每个基类都必须实现求体积（volume）和表面积（surface_area）的方法。在父类中，这些方法可以被标注为虚函数，以便在派生类中重新定义，取决于其特定实现的需要。两个基类都定义了有用的信息，例如半径和高度。在它们中间，有一个 Point 类，用于保存三维图形中的某个点。

Point类定义如下：

class Point{
private:
    double x,y,z;
public:
    Point(double ax, double ay, double az):x(ax),y(ay),z(az){};
    void setPoint(double ax, double ay, double az) {x=ax;y=ay;z=az;}
    double getX() const{return x;}
    double getY() const{return y;}
    double getZ() const{return z;}
};

下面是基类 Sphere：

class Sphere{
protected:
    Point origin;
    double radius;
public:
    Sphere(double x, double y, double z, double r);
    void move(double x, double y, double z);
    Point position() const;
    double get_radius() const{return radius;}
    virtual double volume() const = 0;
    virtual double surface_area() const = 0 ;
    virtual ~Sphere(){}
};
//构造函数
Sphere::Sphere(double x, double y, double z, double r):radius(r),origin(x,y,z){}
//移动
void Sphere::move(double x, double y, double z){
    origin.setPoint(x,y,z);
}
//获取位置
Point Sphere::position() const{
    return origin;
}

然后是 Cylinder 类:

class Cylinder{
protected:
    Point origin;
    double radius, height;
public:
    Cylinder(double x, double y, double z, double r, double h);
    void move(double x,double y,double z);
    Point position() const;
    double get_radius() const{return radius;}
    double get_height() const{return height;}
    virtual double volume() const = 0;
    virtual double surface_area() const = 0;
    virtual ~Cylinder(){}
};

//构造函数
Cylinder::Cylinder(double x,double y,double z,double r,double h):height(h),radius(r),origin(x,y,z){}
//移动
void Cylinder::move(double x,double y,double z){
    origin.setPoint(x,y,z);
}
//获取位置
Point Cylinder::position() const{
    return origin;
}

接下来是派生类，我们为 Sphere 派生子类 SimpleSphere，定义其具体实现，计算物体的体积和表面积：

class SimpleSphere : public Sphere{
public:
    SimpleSphere(double x, double y, double z, double r): Sphere(x,y,z,r){}
    virtual double surface_area() const;
    virtual double volume() const;
    virtual ~SimpleSphere(){}
};

double SimpleSphere::surface_area() const{
    return 4.0 * M_PI * radius * radius;
}

double SimpleSphere::volume() const{
    return 4 * M_PI * radius * radius * radius / 3.0;
}

同样，对于 Cylinder 派生子类 SimpleCylinder，我们也定义具体实现，计算物体的体积和表面积：

class SimpleCylinder : public Cylinder{
public:
    SimpleCylinder(double x,double y,double z,double r,double h): Cylinder(x,y,z,r,h){}
    virtual double surface_area() const;
    virtual double volume() const;
    virtual ~SimpleCylinder(){}
};

double SimpleCylinder::surface_area() const{
    return 2 * M_PI * radius * height + 2 * M_PI * radius * radius;
}

double SimpleCylinder::volume() const{
    return M_PI * radius * radius * height;
}

我们定义的四个类都继承自一些基类。 SimpleSphere 和 SimpleCylinder 都是有具体实现的。直接从这些类创建对象，可以计算一个特定球体或圆柱体的体积和表面积。

下面是 main 函数，可以生成并计算一个球体和一个圆柱体的体积和表面积：

int main()
{
    Sphere *s;
    Cylinder *c;
    s = new SimpleSphere(0, 0, 0, 5);
    c = new SimpleCylinder(0,0,0,3,10);
    cout<<"A sphere with radius "<<s->get_radius()<<endl;
    cout<<"Volume of sphere is "<< s->volume()<<endl;
    cout<<"Surface area of sphere is "<< s->surface_area()<<endl;
    cout<<"A cylinder with radius "<<c->get_radius()<<" and height "<<c->get_height()<<endl;
    cout<<"Volume of cylinder is "<< c->volume()<<endl;
    cout<<"Surface area of cylinder is "<< c->surface_area()<<endl;    
    delete s;
    delete c;
    return 0;
}

输出为：

A sphere with radius 5
Volume of sphere is 523.599
Surface area of sphere is 314.159
A cylinder with radius 3 and height 10
Volume of cylinder is 282.743
Surface area of cylinder is 113.097

这样，我们就成功使用虚函数实现了计算球体和圆柱体的体积与表面积的程序。这种方法具有相当的灵活性，因为您可以随时添加一些新的球体或圆柱体的类，只需要简单地扩展现有代码即可。