Множественное наследование: прямоугольник, квадрат, ромб, параллелограмм

class Parallelogram{
protected:
vec2 centre;
float a;
float b;
float angle
public:
Parallelogram(vec2 position, float sidea, float sideb, float ang);
virtual float get_area(){return a*b*sin(angle);}
 
};
class romboid: public Parallelogram{
public:
romboid(vec2 position, float side, float ang):Parallelogram(position, side, side, ang){};
Circle get_inner_circle(){float rad=sin(angle/2.0)*a*cos(angle/2.0); Circle result(centre, rad); return result;}
}
class rectangle: public Parallelogram{
public:
rectangle(vec2 position, float sidea, float sideb):Parallelogram(position, sidea, sideb, 90.0){};
Circle get_outer_circle(){float rad=sqrt(a*a+b*b)/2.0; Circle result(centre, rad); return result;}
virtual float get_area(){return a*b;}
}
class square:public Parallelogram{
public:
square(vec2 position, float side):rectangle(position, side, side);
virtual float get_area(){return a*a;}
}

#include <cassert>
 
 
struct rectangle {
    rectangle(int width_, int height_) : width(width_), height(height_) {}
 
    int width;
    int height;
};
 
 
struct square : rectangle {
    square(int width) : rectangle(width, width) {}
};
 
 
void change_width(rectangle & rect, int width) {
    rect.width = width;
}
 
 
int main() {
    square sq(4);
    assert(sq.width == sq.height);
    
    change_width(sq, 5);
    assert(sq.width == sq.height);    // fail
}

#include <cmath>
 
class Parallelogram
{
public:
    static double const PI;
    Parallelogram(double a, double b, double ang)
    {
        if (a <= 0) throw invalid_argument("side A must be a positive number");
        if (b <= 0) throw invalid_argument("side B must be a positive number");
        if (ang <= 0 || ang >=  PI) throw invalid_argument("Angle must be lesss than PI");
        sideA = a; sideB = b; angle = ang;
    }
    
    double area() const
    {
        return (sideA * sideB) * sin(angle);
    }
 
private:
    double sideA;
    double sideB;
    double angle;
};
 
double const Parallelogram::PI = 3.14159;
 
class Metall
{
public:
    Metall(double den)
    {
        if (den <= 0)   throw invalid_argument("density be a positive number");
        density = den;
    }
    double get_density() const
    {
        return density;
    }
private:
    double density;
};
 
class MetallicParallelogram : public Parallelogram, public Metall
{
public:
    static enum COLOR {GOLD, SILVER, BRONZE};
    MetallicParallelogram(COLOR c, double a, double b, double ang, double den) : Parallelogram(a, b, ang), Metall(den), color(c) {};
    double weight() const
    {
        return area() * get_density();
    }
private:
    COLOR color;
};

#include <cassert>
 
 
struct rectangle {
    rectangle(int width, int height) : width_(width), height_(height) {}
 
    int get_width() const {
        return width_;
    }
    virtual void set_width(int width) {
        width_ = width;
    }
    
    int get_height() const {
        return height_;
    }
    virtual void set_height(int height) {
        height_ = height;
    }
    
    virtual ~rectangle() {}
    
private:
    int width_;
    int height_;
};
 
 
struct square : rectangle {
    square(int width) : rectangle(width, width) {}
    
    virtual void set_width(int width) {
        rectangle::set_width(width);
        rectangle::set_height(width);
    }
    
    virtual void set_height(int height) {
        rectangle::set_width(height);
        rectangle::set_height(height);
    }
};
 
 
void change_width(rectangle & rect, int width) {
    rect.set_width(width);
}
 
 
int main() {
    square sq(4);
    assert(sq.get_width() == sq.get_height());
    
    change_width(sq, 5);
    assert(sq.get_width() == sq.get_height());    
}

bool isRomb() const
    {
        return sideA == sideB;
    }
 
    bool isRectangle() const
    {
        return angle == PI / 2;
    }
 
    bool isSquare() const
    {
        return isRomb() && isRectangle();
    }