наследование(класс треугольник)

#include <iostream>

using namespace std;

class point   //класс точка для записи координат
{
public:
    float x, y;
    point(float x = 0, float y = 0)
    {
        this->x = x;
        this->y = y;
    }
};

class quadr    //класс четырехугольник
{
public:
    point A;
    point B;
    point C;
    point D;
    float sr;
    quadr() {};
    quadr(point A, point B, point C, point D); //конструктор с параметрами
    float storona(point X, point Y);    //метод для вычисления сторон четырехугольника
    bool proverka(point X, point Y, point Z);    //метод для проверки существования четырехугольника
    float S(); //метод для вычисления площади четырехугольника
    float inf(); //метод для выведение информиции о четырехугольнике
};

quadr::quadr(point A, point B, point C, point D)  //конструктор с параметрами
{
    this->A = A;
    this->B = B;
    this->C = C;
    this->D = D;
}

float quadr::storona(point X, point Y)   //метод для вычисления сторон четырехугольника
{
    float st = sqrt(pow(Y.x - X.x, 2) + pow(Y.y - X.y, 2));
    return st;
}

bool quadr::proverka(point X, point Y, point Z)   //метод для проверки существования четырехугольника
{
    float nenaprX = ((Z.x - X.x) / (Y.x - X.x));   //четырехугольник существует, если три любые точки не лежат на одной прямой
    float nenaprY = ((Z.y - X.y) / (Y.y - X.y));

    float AB = storona(A, B);
    float BC = storona(B, C);
    float CD = storona(C, D);
    float AD = storona(A, D);

    float arr[4] = { AB, BC, CD, AD };
    float max = arr[0];
    for (int i = 1; i < 4; i++)
    {
        if (arr[i] > max) max = arr[i];
    }
    float sum = AB + BC + CD + AD - max;  //четырехугольник существует, если длина одной из его сторон меньше, чем сумма длин трех остальных сторон

    if (sum > max && nenaprX != nenaprY)
    {
        return true;
    }
    else return false;
}

float quadr::inf()
{
    if (proverka(A, B, C))
    {
        cout << "Четырехугольник существует" << endl;
        float AB = storona(A, B);  //стороны четырехугольника
        float BC = storona(B, C);
        float CD = storona(C, D);
        float AD = storona(A, D);
        cout << "Стороны четырехугольника:" << endl;
        cout << "AB = " << AB << "\nBC = " << BC << "\nCD = " << CD << "\nAD = " << AD << endl;

        float AC = storona(A, C);   //диагонали четырехугольника
        float BD = storona(B, D);
        cout << "Диагонали четырехугольника:" << endl;
        cout << "AC = " << AC << "\nBD = " << BD << endl;

        float perimetr = AB + BC + CD + AD;   //периметр четырехугольника
        cout << "Периметр четырехугольника:\nP = " << perimetr << endl;
    }
    else cout << "Четырехугольник не существует" << endl;
    return 0;
}

float quadr::S()
{
    if (proverka(A, B, C))
    {
        float AB = storona(A, B);
        float BC = storona(B, C);
        float CD = storona(C, D);
        float AD = storona(A, D);
        float perimetr = AB + BC + CD + AD;
        float p = perimetr / 2;  //площадь четырехугольника(примерно)
        float s = sqrt((p - AB) * (p - BC) * (p - CD) * (p - AD));
        cout << "Площадь четырехугольника (примерно)\nS = " << s << endl;
        return s;
    }
    else return 0;
}

class parallelogram :public quadr
{
public:
    parallelogram(point A, point B, point C, point D);
    bool proverka();
    float sq(point A, point B, point C, point D);
};

parallelogram::parallelogram(point A, point B, point C, point D)
{
    this->A = A;
    this->B = B;
    this->C = C;
    this->D = D;
}

bool parallelogram::proverka()
{
    float AB = storona(A, B);  //стороны параллелограмма
    float BC = storona(B, C);
    float CD = storona(C, D);
    float AD = storona(A, D);

    if (AB == CD && BC == AD)
    {
        return true;
    }
    else return false;
}

float parallelogram::sq(point X, point Y, point Z, point Q)
{
    if (proverka())
    {
        cout << "Фигура - параллелограмм" << endl;
        float ss, a, h;
        a = Y.y - X.y;
        h = Q.x - X.x;
        ss = a * h;
        cout << "Площадь параллелограмма\nS = " << ss << endl;
        return ss;
    }
    else  cout << "Фигура - не параллелограмм" << endl;
    return 0;
}

int main()
{
    setlocale(0, "RUS");

    const int k = 2;
    cout << "Количество четырехугольников - "<< k << endl;

    cout << "1" << endl;
    point A1(1, 4), B1(5, 9), C1(9, 6), D1(6, 1);
    quadr ABCD1(A1, B1, C1, D1);
    ABCD1.proverka(A1, B1, C1);
    ABCD1.inf();
    float s1 = ABCD1.S();
    cout << endl;

    cout << "2" << endl;
    point A2(1, 5), B2(6, 10), C2(9, 1), D2(5, 5);
    quadr ABCD2(A2, B2, C2, D2);
    ABCD2.proverka(A2, B2, C2);
    ABCD2.inf();
    float s2 = ABCD2.S();
    cout << endl;

    cout << "Средняя площадь четырехугольников равна " << (s1 + s2) / k << endl;

    const int p = 3;
    cout << "\nКоличество параллелограммов - " << p << endl;

    cout << "1" << endl;
    point a1(1, 2), b1(3, 5), c1(8, 5), d1(6, 2);
    parallelogram abcd1(a1, b1, c1, d1);
    abcd1.proverka();
    float ss1 = abcd1.sq(a1, b1, c1, d1);

    cout << "2" << endl;
    point a2(2, 4), b2(2, 10), c2(9, 6), d2(9, 0);
    parallelogram abcd2(a2, b2, c2, d2);
    abcd2.proverka();
    float ss2 = abcd2.sq(a2, b2, c2, d2);

    cout << "3" << endl;
    point a3(1, 6), b3(3, 8), c3(5, 3), d3(3, 1);
    parallelogram abcd3(a3, b3, c3, d3);
    abcd3.proverka();
    float ss3 = abcd3.sq(a3, b3, c3, d3);

    if (ss1 > ss2 && ss1 > ss3)
    {
        cout << "Параллелограмм 1 наибольшей площади" << endl;
    }
    else if (ss2 > ss1 && ss2 > ss3)
    {
        cout << "Параллелограмм 2 наибольшей площади" << endl;
    }
    else cout << "Параллелограмм 3 наибольшей площади" << endl;

    cout << endl;

    if (ss1 < ss2 && ss1 < ss3)
    {
        cout << "Параллелограмм 1 наименьшей площади" << endl;
    }
    else if (ss2 < ss1 && ss2 < ss3)
    {
        cout << "Параллелограмм 2 наименьшей площади" << endl;
    }
    else cout << "Параллелограмм 3 наименьшей площади" << endl;
    return 0;
}