使用虚基类、虚函数实现graphic图形类

思路

1.1 调用路径

• 在graphic中提供calculate（）以及get（double &arg1,double & arg2）两个纯虚函数，这两个函数在其派生类graphic2D和graphic3D中实现，具体实现如下：

void graphic2D::calculate()
{
    cal_area();
    cal_perimeter();
}

void graphic2D::get(double &arg1, double &arg2)
{
    arg1=get_area();
    arg2=get_perimeter();
}
void graphic3D::calculate()
{
    cal_area();
    cal_volume();
}

void graphic3D::get(double &arg1, double &arg2)
{
    arg1=get_area();
    arg2=get_volume();
}

• 以graphic2D为例，其中的calculate（）中调用了cal_area（）和cal_perimeter（），而这两个函数又是graphic2D中的纯虚函数。

graphic.h

#ifndef GRAPHIC_H
#define GRAPHIC_H
#define PI 3.1415926
#include <math.h>

class graphic{
public:
    virtual bool is_illegal()=0;
    virtual void calculate()=0;
    virtual void get(double& arg1,double &arg2)=0;
    virtual ~graphic();
};

class graphic2D:public graphic {
protected:
    double area;
    double perimeter;
public:
    virtual void calculate();
    virtual void get(double& arg1,double &arg2);
    virtual void cal_area() = 0;
    virtual void cal_perimeter() = 0;
    virtual bool is_illegal();
    double get_area();
    double get_perimeter();
    graphic2D();
    virtual ~graphic2D();
};

class circle :public graphic2D {
private:
    double r;
public:
    virtual void cal_area();
    virtual void cal_perimeter();
    virtual bool is_illegal();
    circle();
    void set_size(double R);
    virtual ~circle();
};

class triangle :public graphic2D {
private:
    double a, b, c;
public:
    virtual bool is_illegal();
    virtual void cal_area();
    virtual void cal_perimeter();
    triangle();
    void  set_size(double a,double b,double c);
    virtual ~triangle();
};

class rectangle :public graphic2D {
private:
    double w, l;//w即width,l即length
public:
    virtual bool is_illegal();
    virtual void cal_area();
    virtual void cal_perimeter();
    rectangle();
    void set_size(double w, double l);
    virtual ~rectangle();
};

class graphic3D:public graphic {
protected:
    double area;
    double volume;
public:
    virtual void calculate();
    virtual void get(double& arg1,double &arg2);
    virtual bool is_illegal();
    virtual void cal_area() = 0;
    virtual void cal_volume() = 0;
    double get_area();
    double get_perimeter();
    double get_volume();
    graphic3D();
    virtual ~graphic3D();
};

class sphere :public graphic3D {
private:
    double R;
public:
    virtual bool is_illegal();
    virtual void cal_area();
    virtual void cal_volume();
    sphere();
    void set_size(double r);
    virtual ~sphere();
};

class cubic :public graphic3D {
private:
    double w, l, h;
public:
    virtual bool is_illegal();
    virtual void cal_area();
    virtual void cal_volume();
    cubic();
    void set_size(double w, double l, double h);
    virtual ~cubic();
};

class cylinder :public graphic3D {
private:
    double R;
    double h;
public:
    virtual bool is_illegal();
    virtual void cal_area();
    virtual void cal_volume();
    cylinder();
    void set_size(double r,double h);
    virtual ~cylinder();
};
#endif //!GRAPHIC_H

graphic.cpp

#include "graphic.h"

void circle::cal_area()
{
    area=PI*r*r;
}

void circle::cal_perimeter()
{
    perimeter = 2 * PI * r;
}

bool circle::is_illegal()
{
    if (r >= 0) {
        return true;
    }
    else {
        return false;
    }
}

circle::circle()
{
    r = 0;
}

void circle::set_size(double R)
{
    r = R;
}

circle::~circle()
{

}

void graphic2D::calculate()
{
    cal_area();
    cal_perimeter();
}

void graphic2D::get(double &arg1, double &arg2)
{
    arg1=get_area();
    arg2=get_perimeter();
}

bool graphic2D::is_illegal()
{
    return true;
}

double graphic2D::get_area()
{
    return area;
}

double graphic2D::get_perimeter()
{
    return perimeter;
}

graphic2D::graphic2D()
{
    area = 0;
    perimeter = 0;
}

graphic2D::~graphic2D()
{

}

bool triangle::is_illegal()
{
    {
        if ((a + b > c) && (a + c > b) && (b + c > a) && a>0 && b>0 && c>0) {
            return true;
        }
        else {
            return false;
        }
    }
}

void triangle::cal_area()
{
    double p = (a + b + c) / 2;
    area=sqrt(p * (p - a) * (p - b) * (p - c));
}

void triangle::cal_perimeter()
{
    perimeter = a + b + c;
}

triangle::triangle()
{
    a = 0;
    b = 0;
    c = 0;
}

void triangle::set_size(double a, double b, double c)
{
    this->a = a;
    this->b = b;
    this->c = c;
}

triangle::~triangle()
{

}

bool rectangle::is_illegal()
{
    if (w > 0 && l > 0) {
        return true;
    }
    else {
        return false;
    }
}

void rectangle::cal_area()
{
    area = w * l;
}

void rectangle::cal_perimeter()
{
    perimeter = 2 * (w + l);
}

rectangle::rectangle()
{
    w = 0;
    l = 0;
}

void rectangle::set_size(double w, double l)
{
    this->w = w;
    this->l = l;
}

rectangle::~rectangle()
{

}

void graphic3D::calculate()
{
    cal_area();
    cal_volume();
}

void graphic3D::get(double &arg1, double &arg2)
{
    arg1=get_area();
    arg2=get_volume();
}

bool graphic3D::is_illegal()
{
    return true;
}

double graphic3D::get_area()
{
    return area;
}

double graphic3D::get_volume()
{
    return volume;
}

graphic3D::graphic3D()
{
    area = 0;
    volume = 0;
}

graphic3D::~graphic3D()
{

}

bool sphere::is_illegal()
{
    if (R >= 0) {
        return true;
    }
    else {
        return false;
    }
}

void sphere::cal_area()
{
    area = 4 * PI * R * R;
}

void sphere::cal_volume()
{
    volume = 4.0 / 3.0 * PI * pow(R, 3);
}

sphere::sphere()
{
    R = 0;
}

void sphere::set_size(double r)
{
    R = r;
}

sphere::~sphere()
{

}

bool cubic::is_illegal()
{
    if (w > 0 && l > 0 && h > 0) {
        return true;
    }
    else {
        return false;
    }
}

void cubic::cal_area()
{
    area = 2 * (w * l + w * h + l * h);
}

void cubic::cal_volume()
{
    volume = w * l * h;
}

cubic::cubic()
{
    w = 0;
    l = 0;
    h = 0;
}

void cubic::set_size(double w, double l, double h)
{
    this->w = w;
    this->l = l;
    this->h = h;
}

cubic::~cubic()
{

}

bool cylinder::is_illegal()
{
    if (R > 0 && h > 0) {
        return true;
    }
    else {
        return false;
    }
}

void cylinder::cal_area()
{
    area = 2 * PI * pow(R, 2) + 2 * PI * R * h;
}

void cylinder::cal_volume()
{
    volume = PI * pow(R, 2) * h;
}

cylinder::cylinder()
{
    R = 0;
    h = 0;
}

void cylinder::set_size(double r, double h)
{
    this->R = r;
    this->h = h;
}

cylinder::~cylinder()
{

}

graphic::~graphic()
{

}