C ++ equation de second degrés [Résolu]

#include <iostream>
#include <vector>

public class polynome{
   //Membres de l'objet
   double a,b,c;

   //Constructeur
   polynome(double a,double b,double c):a=0,b=0,c=0{}

   //Destructeur
   ~polynome(){}

    //Calcule delta
    double delta(){return b*b-4*a*c;}

    std::vector<double> racines(){
       std::vector v;
       double d=this.delta();
       if (d<0){
          std::cout<<"Pas de racines reelles !"<<std::endl;
          return v;
       }
       else if (d==0){
          std::cout<<"Une seule racine reelle"<<std::endl;
          v.push_back(........); //formule pour une racine
          return v;
       }else{//d>0
          std::cout<<"Deux racines reelles"<<std::endl;
          v.push_back(........); //formule pour la première racine
          v.push_back(........); //formule pour la deuxième racine
          return v;
       }
   }
};

std::ostream & 	operator<< (std::ostream &os, polynome const &p){
    std::ostream o;
    o<<a<<"x²+"<<b<<"x+"<<c;
}

int main(){
    polynome p(2,5,6);
    std::cout<<p<<std::endl;
    std::cout<<"delta="<<p.delta()<<std::endl;
    std::vector v=p.racines();
    std::cout<<"racines:"<<std::end;
    for(unsigned int i=0;i<v.size();++i) std::cout<<v[i]<<std::endl;
    return 0;
}

#include <iostream>
#include <cmath>

class polynome_t{
    protected:
        double a; // coefficient de x^2
        double b; // coefficient de x^1
        double c; // coefficient de x^0
    public:
        polynome_t(const double & a0,const double & b0,const double & c0):
            a(a0),b(b0),c(c0)
        {}

        inline double get_delta() const{
            return b*b - 4*a*c;
        }

        inline const double & get_a() const{
            return a;
        }

        inline const double & get_b() const{
            return b;
        }

        inline const double & get_c() const{
            return c;
        }

        inline std::pair<std::pair<double,double>,bool>
        get_racines() const{
            std::pair<double,double> racines;
            double delta = get_delta();
            if(delta < 0)   return std::make_pair(racines,false); // pas de racine reelle
            racines.first  = (- b - sqrt(delta))/(2*a);
            racines.second = (- b + sqrt(delta))/(2*a);
            return std::make_pair(racines,true);
        }

};

inline std::ostream & operator << (std::ostream & out,const polynome_t & p){
    const double &
        a = p.get_a(),
        b = p.get_b(),
        c = p.get_c();
    if (a)              out << a << " * x^2";
    if (a && b)         out << " + ";
    if (b)              out << b << " * x ";
    if ((a || b) && c)  out << " + " << c;
    return out;
}

int main(){
    // x^2 - 4
    polynome_t polynome(1,0,-4);
    double delta = polynome.get_delta();
    std::cout << polynome << std::endl << "delta = " << delta << std::endl;

    std::pair<std::pair<double,double>,bool> res = polynome.get_racines();
    if (res.second){
        if (delta){
            std::cout << "2 racines réelles"  << std::endl
                << res.first.first << std::endl
                << res.first.second << std::endl;
        }else{
            std::cout << "1 racine réelle"  << std::endl
                << res.first.first << std::endl;
        }
    }else{
        std::cout << "Pas de racine réelle !" << std::endl;
    }
    return 0;
}

(mando@aldur) (~) $ g++ -W -Wall -lm plop.cpp
(mando@aldur) (~) $ ./a.out
1 * x^2
delta = 16
2 racines réelles
-2
2