shape_poly.cpp

#include <iostream>
#include <cmath>
#include <cstdlib>
#include <cstdio>
#include <cstring>

using namespace std;

const double PI = 3.14159265358979323846;

struct Shape;

struct ShapeVtable
{
    double (*GetArea)(Shape *);
    void (*PrintInfo)(Shape *);
};

struct Shape
{
    ShapeVtable *vtable;
};

double GetArea(Shape *shape)
{
    return shape->vtable->GetArea(shape);
}

void PrintInfo(Shape *shape)
{
    shape->vtable->PrintInfo(shape);
}

// ==========================================
// Circle 
// ==========================================
struct Circle
{
    Shape parent;
    double radius;
};

double CircleGetArea(Circle *c)
{
    return PI * c->radius * c->radius;
}

void CirclePrintInfo(Circle *c)
{
    cout << "Circle with radius " << c->radius << endl;
}

// Global VTable for Circle
ShapeVtable circle_vtable = {
    (double (*)(Shape *))CircleGetArea,
    (void (*)(Shape *))CirclePrintInfo};

void CircleInitialize(Circle *c, double r)
{
    c->parent.vtable = &circle_vtable; // Link the vtable
    c->radius = r;
}

// ==========================================
// Rectangle 
// ==========================================
struct Rectangle
{
    Shape parent;
    double width;
    double height;
};

double RectangleGetArea(Rectangle *r)
{
    return r->width * r->height;
}

void RectanglePrintInfo(Rectangle *r)
{
    cout << "Rectangle with width " << r->width << " and height " << r->height << endl;
}

ShapeVtable rectangle_vtable =
    {
        (double (*)(Shape *))RectangleGetArea,
        (void (*)(Shape *))RectanglePrintInfo};

void RectangleInitialize(Rectangle *r, double w, double h)
{
    r->parent.vtable = &rectangle_vtable;
    r->width = w;
    r->height = h;
}

// ==========================================
// Ellipse
// ==========================================
struct Ellipse
{
    Shape parent;
    double radius1;
    double radius2;
};

double EllipseGetArea(Ellipse *e)
{
    return PI * e->radius1 * e->radius2;
}

void EllipsePrintInfo(Ellipse *e)
{
    cout << "Ellipse with radius " << e->radius1 << ", " << e->radius2 << endl;
}

ShapeVtable ellipse_vtable =
    {
        (double (*)(Shape *))EllipseGetArea,
        (void (*)(Shape *))EllipsePrintInfo};

void EllipseInitialize(Ellipse *e, double r1, double r2)
{
    e->parent.vtable = &ellipse_vtable;
    e->radius1 = r1;
    e->radius2 = r2;
}

// ==========================================
// Square
// ==========================================
struct Square
{
    Shape parent;
    double side;
};

double SquareGetArea(Square *s)
{
    return s->side * s->side;
}

void SquarePrintInfo(Square *s)
{
    cout << "Square with side-length " << s->side << endl;
}

ShapeVtable square_vtable = {
    (double (*)(Shape *))SquareGetArea,
    (void (*)(Shape *))SquarePrintInfo};

void SquareInitialize(Square *s, double side)
{
    s->parent.vtable = &square_vtable;
    s->side = side;
}

int main()
{
    Circle circle;
    CircleInitialize(&circle, 10);

    Rectangle rectangle;
    RectangleInitialize(&rectangle, 3, 5);

    Ellipse ellipse;
    EllipseInitialize(&ellipse, 10, 12);

    Square square;
    SquareInitialize(&square, 7);

    Shape *shapes[4];
    shapes[0] = (Shape *)&circle;
    shapes[1] = (Shape *)&rectangle;
    shapes[2] = (Shape *)&ellipse;
    shapes[3] = (Shape *)&square;

    double total_area = 0;

    int i;
    for (i = 0; i < 4; i++)
    {
        double d = GetArea(shapes[i]);
        total_area += d;
        PrintInfo(shapes[i]);
    }

    cout << total_area << endl;

    return 0;
}