Для каждой параболы вывести уравнение, найти эктремумы; выяснить совпадают или пересекаются эти параболы

#include <iostream>
#include <cmath>
 
using namespace std;
 
class Parabola {
    float a, b, c;
public: 
    Parabola(float ss, float dd)
    {
        cin >> a >> b >> c;
    }
    void PeresechenieParabol() // Для определния точек пересечения двух парабол
    {
        float x, d;
        //(a-d)*pow(x,2)+(b-e)*x + (c-f);
        if (a==0) {
            cout << "Не квадратное" << endl;
        }
        else {
             d = b * b - 4 * a * c;
        }
        if (d<0) {
            cout << "Не имеет действительных корней" << endl;
        }
        else if (d == 0) {
            cout << "Имеет единственный корень" << endl;
            x = b / (2*a);
            cout << x;
        }
        else {
            cout << "Имеет два корня" << endl;
            x = (-b-sqrt(d)) / (2*a);
            cout << x;
            x = (-b - sqrt(d))/(2*a);
            cout << x;
        }
    }
    void ExtreumFunction()
    {
        
    }
    bool operator||(Parabola _y1)
    { 
        float y1,y2; // совпадение парабол
        
        if (y1 == y2) 
            return true;
        return false;
    }
    };
 
int main() {
    setlocale(0,"");
    
    system("pause");
    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//1.
///////////////////////////////////////////////////////////////////////////////
//Класс: Пapaбoлa y = ax^2 + bx + c
//Члены класса: коэффициенты a, b, c
//Методы: конструктор, деструктор, методы вывода уравнения параболы,
//вычисления экстремума функции (min или max)
//Операторы перегрузки: проверка совпадения двух парабол (||),
//пересечения парабол (/)
 
//Исходные данные:
//yl =ax^2 + bx + c
//y2 =dx^2 + ex + f
 
//Результаты:
//Для каждой параболы вывести уравнение, значение экстремума функции
//с пояснением - min или max.
//Проверить, совпадают ли эти параболы или они пересекаются.
///////////////////////////////////////////////////////////////////////////////
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
///////////////////////////////////////////////////////////////////////////////
class   T_parabola
{
    //-------------------------------------------------------------------------
    typedef std::vector     < double    >   T_coeffs;
    //-------------------------------------------------------------------------
    T_coeffs    coeffs_;
    int         not_zero_coeffs_count_;
    //-------------------------------------------------------------------------
public:
    //-------------------------------------------------------------------------
    T_parabola
        (
            double  a,
            double  b,
            double  c
        )
        :
        coeffs_                 {c, b, a},
        not_zero_coeffs_count_  { !!a + !!b + !!c }
    {}
    //-------------------------------------------------------------------------
    ~T_parabola()
    {}
    //-------------------------------------------------------------------------
    T_str   to_string()                                                     const
    {
        T_str   res;
 
        if  (
                not_zero_coeffs_count_  ==  0
            )
        {
            res     +=  "0";
        }
        else
        {
            res     +=  term_str(2);
            res     +=  term_str(1);
            res     +=  term_str(0);
        }//else
 
        if  (
                res.front()     ==  '+'
            )
        {
            res.erase(0, 1);
        }
 
        return  "y = " + res;
    }
    //-------------------------------------------------------------------------
    T_str    extremum()                                                     const
    {
        T_str   res;
 
        if  (
                    a() ==  0
                &&  b() !=  0
            )
        {
            res     =   "extremum not exist";
        }
        else
        {
            res     =       (
                                a() > 0
                                    ?   "min = "
                                    :   "max = "
                            )
 
                        +   std::to_string  (
                                                a() == 0
                                                    ?   c()
                                                    :   -D() / 4 / a()
                                            );
        }//else
 
        return  res;
    }
    //-------------------------------------------------------------------------
    bool    operator||  ( T_parabola    const   &   p )                     const
    {
        return      coeffs_
                ==  p.coeffs_;
    }
    //-------------------------------------------------------------------------
    bool    operator/   ( T_parabola    const   &   p )                     const
    {
        auto    res_p   =   T_parabola
                                (
                                    a() -   p.a(),
                                    b() -   p.b(),
                                    c() -   p.c()
                                );
 
        return  res_p.has_roots();
    }
    //-------------------------------------------------------------------------
private:
    //-------------------------------------------------------------------------
    double  D()                                                             const
    {
        return  b() * b() - 4 * a() * c();
    }
    //-------------------------------------------------------------------------
    bool    has_roots()                                                     const
    {
        if  (
                a()
            )
        {
            return  D() >=  0;
        }
 
        return      b()     !=      0
                ||  c()     ==      0;
    }
    //-------------------------------------------------------------------------
    double  a()                                                             const
    {
        return  coeffs_[2];
    }
    //-------------------------------------------------------------------------
    double  b()                                                             const
    {
        return  coeffs_[1];
    }
    //-------------------------------------------------------------------------
    double  c()                                                             const
    {
        return  coeffs_[0];
    }
    //-------------------------------------------------------------------------
    T_str   term_str( int   exp_val )                                       const
    {
        T_str   res;
        auto    coeff   =   coeffs_[ exp_val ];
 
        if( coeff )
        {
            res     +=  (
                            coeff > 0
                                ?   "+"
                                :   "-"
                        );
 
            if  (
                        std::abs( coeff )   !=  1
                    ||  exp_val             ==  0
                )
            {
                res     +=  std::to_string  (
                                                std::abs( coeff )
                                            );
            }
 
            res     +=  x_with_exp_str( exp_val );
        }
 
        return  res;
    }
    //-------------------------------------------------------------------------
    static
    T_str   x_with_exp_str( int     exp_val )
    {
        switch( exp_val )
        {
        case    2   :   return  "x^2";
        case    1   :   return  "x";
        default     :   return  {};
        }
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
int     rand_coef( int  k )
{
    return  rand() % (2 * k + 1) - k;
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    for(;;)
    {
        int     t{};
        std::cout   <<  "\n\nint_param = ";
        std::cin    >>  t;
 
        T_parabola  p_1     (
                                rand_coef(t),
                                rand_coef(t),
                                rand_coef(t)
                            );
 
        T_parabola  p_2     (
                                rand_coef(t),
                                rand_coef(t),
                                rand_coef(t)
                            );
 
        std::cout   <<  std::endl
                    <<  p_1.to_string   ()  <<  std::endl
                    <<  p_1.extremum    ()  <<  std::endl
 
                    <<  p_2.to_string   ()  <<  std::endl
                    <<  p_2.extremum    ()  <<  std::endl
 
                    <<  (
                            p_1 || p_2
                                ?   "parabolas coincide"
                                :   "parabolas not coincide"
                        )
 
                    <<  std::endl
 
                     <<  (
                             p_1 / p_2
                                 ?   "parabolas intersect"
                                 :   "parabolas not intersect"
                         )
 
                     <<  std::endl;
    }//for
}