Pour convertir un nombre en virgule flottante en un nombre complexe, il faut définir de nouveaux constructeurs qui vont prendre un seul argument qui aura pour type le type d'un nombre à virgule flottante.

Sachant que dans le cas présent, nous souhaitons pouvoir transformer automatiquement un nombre à virgule flottante x en un nombre complexe si un nombre complexe est attendu, le constructeur ne doit pas être déclarée comme explicit.

De fait, il est nécessaire d'ajouter les constructeurs suivant pour les types float et double.

class Complex
{
private:
... 
public:
    Complex(double aReal) : mRealPart(aReal), mImaginaryPart(0.0) {}
    Complex(float aReal) : mRealPart(aReal), mImaginaryPart(0.0) {}
... 
};

Il n'est nullement souhaitable de se limiter aux nombres à virgule flottante, nous pouvons ajouter des opérations de conversions identiques pour les nombres entiers :

class Complex
{
private:
... 
public:
    Complex(double aReal) : mRealPart(aReal), mImaginaryPart(0.0) {}
    Complex(float aReal) : mRealPart(aReal), mImaginaryPart(0.0) {}
    Complex(int aReal) : mRealPart((double)aReal), mImaginaryPart(0.0) {}
    Complex(unsigned in aReal) : mRealPart((double)aReal), mImaginaryPart(0.0) {}
... 
};

Nous pouvons ajouter une fonction simple qui affiche le résultat sur la console. Cette fonction affiche la représentation minimale du nombre complexe.

class Complex
{
private:
...
public:
    void print() const
    {
        if(mRealPart != 0.0)
        {
            std:cout << mRealPart;
            if(mImaginaryPart != 0.0)
                std::cout << " + " << mImaginaryPart << " I";
        }
        else if(mImaginaryPart != 0.0)
            std::cout << " + " << mImaginaryPart << " I";
        else
            std::cout << "0.0";       
    }
...
};    

La difficulté, c'est qu'un nombre complexe admet deux représentations canoniques, une représentation sous la forme d'une partie réelle et une partie imaginaire ou au contraire une représentation sous la forme de coordonnées polaire.

Si nous souhaitons définir un constructeur pour construire un nombre complexe à partir de ses parties réelles et imaginaires, nous allons nous retrouver avec un constructeur ayant comme signature, la signature suivante :

    Complex(double theRealPart, double theImaginaryPart);    

Le constructeur qui construit un nombre complex à partie des coordonnées polaires aura la signature suivante :

    Complex(double rho, double theta);    

c'est à dire que les deux constructeurs auront la même signature Complex(double, double) et le compilateur se retrouvera avec deux définitions différentes du même constructeur, d'où une erreur au moment de la compilation.

Alors il existe plusieurs