class Complex
{
private:
    ...
public:
    ...
    Complex operator+(Complex &other){...}
    Complex operator+(const double &other){...}
        ...
};

void main(void)
{
    Complex z(1,2);
    z=z+1;/* все работает */
    z=3+z;/* Нет такого глобального оператора или нет соответствующей заданным операторам конверсии*/
}

O>    z=z+1;/* все работает */
O>    z=3+z;/* Нет такого глобального оператора или нет соответствующей заданным операторам конверсии*/
O>

class Complex
{
   friend Complex operator+(int fst, const Complex &Snd);
private:
    ...
public:
    ...
    Complex operator+(Complex &other){...}
    Complex operator+(const double &other){...}
        ...
};

Complex operator+(int fst, const Complex &Snd)
{
  // тут пиши что хочешь, но не забудь вернуть объект типа Complex
}

Complex operator+( double one, const Complex& another)
{
}

class Complex
{
private:
    ...
public:
    Complex( double num )
    {
    }
        ...
};

class Complex
{
private:
    ...
public:
    Complex( double num )
    {
    }
        ...
};

Complex
{
private:
    // ...
public:
    Complex( double num ) // Для конверсии от double к Complex, например, при передаче в функцию
    {
        // ...
    }
    
    const Complex& operator=( double num )    // Можно еще присваивание добавить
    {
        // ...
    }

    Complex operator+( double a ) const
    {
        // ...
    }
}

Complex operator+( double a, const Complex& b )
{
    return b + a; // и зачем тут дружественность?
}

O>class Complex
O>{
O>private:
O>    ...
O>public:
O>    Complex( double num )
O>    {
O>    }
O>        ...
O>};
O>

O>Хм..с операторами всё отлично решилось а вот с конструкторами не очень, так можно описать только принудительную конверсию , а мне бы хотелось чтобы компилятор сам делал за меня эту грязную работу

class Complex 
{
public:
    Complex( double num )
    {
    }
}

// ...

double a = 1.234;
Complex c;

c = 123.5 + a; // Все OK, присваивание произойдет через конструирование временного объекта Complex(123.5+a), а потом оператор присваивания Complex& opearator=( const Complex& )

class Complex
{
private:
    ...
public:
    ...
    const Complex operator+(const Complex &other){...}
    const Complex operator+(const double &other){...}
        ...
};

const Complex operator + (double lhs, const Complex& rhs) { return rhs + lhs; }

class Complex
{
public:
   Complex(TYPE arg) {...}
};

class Complex 
{
public:
    Complex( double num )
    {
    }
}

// ...

double a = 1.234;
Complex c;

c = 123.5 + a; // Правая часть вычисляется получаем double который для присваивания может быть конвертирован только в Complex
c = c + a; // Все Bad, без перегрузки оператора + правая часть не сможет быть вычисленна
c = c + Complex(a); // Всё ОК, принудительная конверсия

class Complex 
{
public:
    Complex() {}
    Complex( double num )
    {
    }
const Complex operator + (const Complex& rhs) { return Complex(); }
};

int main()
{
double a = 1.234;
Complex c;

c = 123.5 + a; // Правая часть вычисляется получаем double, который затем конвертируется в Complex с 
// использоавнием констркуктора Complex::Complex (double), а затем полученный временный объект 
// присваиваивается объекту c с использованием operator=, сгенерированного компилятором
c = c + a; //Переменная a конвертируется в Complex с использоавнием констркуктора Complex::Complex (double),
// а затем вызывается Complex::operator+()
 c = c + Complex(a); // Всё ОК, принудительная конверсия
return 0;
}

Complex ooperator +  (Complex &a, Complex & b)
{
    Complex c(a.real() + b.real(), a.imag() + b.imag());
    return c;
}

Complex operator + (double a, Complex &b)
{
    Complex c(a);
    c += b;
    return c;
}
Complex operator + (Complex &a, double b)
{
    Complex c(a);
    c += Complex(b);
    return c;
}