[C++] Debug Error

#include <iostream>

class complexe{
    private :
        float reel;
        float imag;
    public :
        complexe(float reel0 = 0, float imag0 = 0):
            reel(reel0),imag(imag0)
        {}

        inline const float & re() const{
            return reel;
        }

        inline const float & im() const{
            return imag;
        }

        inline complexe multiplier_r(const float & r){
            reel *= r; // reel équivaut à this->reel
            return *this;
        }

        inline complexe multiplier_c(const complexe & c){
            reel = re() * c.re() - im() * c.im();
            imag = re() * c.im() - im() * c.re();
            return *this;
        }

        inline complexe additionner_r(const float & r){
            reel += r;
            return *this;
        }

        inline complexe addionner_c(const complexe & c){
            reel = re() + c.re();
            imag = im() + c.im();
            return *this;
        }

        inline void affich() const {
            std::cout << " " << re() << " + " << im() << "i" << std::endl;
        };
};

inline complexe operator + (const complexe & c,const float & r){
    complexe res(c);
    res.additionner_r(r);
    return res;
}

inline complexe operator + (const float & r,const complexe & c){
    return c + r;
}

inline complexe operator + (const complexe & x,const complexe & y){
    complexe res(x);
    res.addionner_c(y);
    return res;
}

// idem pour *

int main(){
    complexe c(1,2), c1(2,2);
    c.addionner_c(c1);
    c.affich();
    return 0;
}

#include <iostream>
#include <ostream>

// La classe des imaginaires purs ------------------------------
// Cette classe encapsule un imaginaire pur par exemple z = 69i

class imaginaire{
    protected:
        float imag;
    public:
        imaginaire(const float & x):imag(x){}

        inline const float & im() const{
            return imag;
        }

        inline void set_im(const float & x){
            imag = x;
        }
};

// Grace à cet opérateur je peux directement écrire un imaginaire dans un flux,
// par exemple std::cout, std::cerr, ou n'importe quel std::ofstream (fichier
// ouvert en écriture)
inline std::ostream & operator << (std::ostream & out,const imaginaire & x){
    out << x.im() << 'i';
    return out;
}

// L'addition des imaginaires purs
inline imaginaire operator + (const imaginaire & x,const imaginaire & y){
    return imaginaire(x.im() + y.im());
}

// La multiplication des imaginaires purs
inline float operator * (const imaginaire & x,const imaginaire & y){
    return - (x.im() * y.im());
}

// Le produit d'un imaginaire par un réel
inline float operator * (const imaginaire & x,const float & y){
    return imaginaire(y * x.im());
}

// Pour le produit d'un réel et d'un imaginaire, je réutilise l'opérateur précédent
// Il s'agit bien d'un opérateur différent de :
// inline float operator * (const imaginaire & x,const float & y)
inline  float operator * (const float & x,const imaginaire & y){
    return y * x;
}

// La classe des complexes ------------------------------

// Comme je suis une grosse flemmarde je vais réutiliser par héritage la classe
// imaginaire que je viens de définir pour implémenter un complexe. Grosso modo
// un complexe c'est un imaginaire enrichi d'une partie réelle, donc l'héritage
// prend tout son sens. En particulier je pourrais directement utiliser les
// méthodes de la classe imaginaire sur un complexe (par exemple im())

class complexe : public imaginaire{
    private:
        float reel;
    public:

        complexe(float reel0 = 0,float imag0 = 0):
            imaginaire(imag0),
            reel(reel0)
        {}

        complexe(const imaginaire & x):
            imaginaire(x),
            reel(0)
        {}

        inline const float & re() const{
            return reel;
        }

        inline void set_re(const float & x){
            reel = x;
        }
};

// Ecriture : ici je réutilise :
// inline std::ostream & operator << (std::ostream & out,const imaginaire & x)
inline std::ostream & operator << (std::ostream & out,const complexe & x){
    out << x.re() << '+' << imaginaire(x.im());
    return out;
}

// Addition
// J'aurais pu réutiliser l'addition des imaginaires mais bon ici c'est quand même
// plus lisible comme ça...
complexe operator +(const complexe & x,const complexe & y){
    return complexe(
        x.re() + y.re(),
        x.im() + y.im()
    );
}

// Cette fonction template va permettre d'additionner
// un objet de type T  à un complexe. Il faut juste avoir un constructeur 
// convertissant un objet de type T en complexe pour que cette fonction 
// ait un sens (donc un imaginaire ou un float)
template <typename T>
complexe operator + (const complexe & x,const T & y){
    return x + complexe(y);
}

// Même chose pour additionner un objet de type T à gauche
template <typename T>
complexe operator + (const T & x,const complexe & y){
    return complexe(x) + y;
}

// Multiplication
inline complexe operator * (const complexe & x,const complexe & y){
    return complexe(
        (x.re() * y.re()) - (x.im() * y.im()),
        (x.re() * y.im()) + (x.im() * y.re())
    );
}

template <typename T>
complexe operator * (const complexe & x,const T & y){
    return x * complexe(y);
}

template <typename T>
complexe operator * (const T & x,const complexe & y){
    return complexe(x) * y;
}

// Le main ------------------------------

int main(){
    complexe x(1,2), y(2,2);
    std::cout << "x = " << x << std::endl
              << "y = " << y << std::endl
              << "x + y = " << x + y << std::endl;
    imaginaire z(7);
    std::cout << "z = " << z << std::endl
              << "x + z = " << x + z << std::endl;
    return 0;
}

x = 1+2i
y = 2+2i
x + y = 3+4i
z = 7i
x + z = 1+9i

inline const float & re() const{
            return reel;
        }

        inline const float & im() const{
            return imag;
        }

inline std::ostream & operator << (std::ostream & out,const complexe & x){
    out << x.re();
    const float x_im = x.im();
    if(x.im() < 0) out << '+';
    else out << '-';
    out << imaginaire(std::abs(x_im));
    return out;
}

template <typename T>
T abs(const T & x){
  return (x < 0 ? -x : x);
}