template <class XTag, class YTag> struct PromoteTags;

template <> struct PromoteTags<ComplexTag, RealTag> { typedef ComplexTag type; };
template <> struct PromoteTags<IntegerTag, RealTag> { typedef RealTag type; };
...

template <class XType, class YType> struct PromoteReals;

template <> struct PromoteReals<double, float> { typedef double type; };
template <> struct PromoteReals<float, long double> { typedef long double type; };
...

template <class Tag, class Underlying> struct MakeClassFromTag;
template <class Underlying> struct MakeClassFromTag<ComplexTag, Underlying> { typedef Complex<Underlying> type; };
...

template <class Numeric1, class Numeric2>
struct Promote
{
    typedef typename MakeClassFromTag<
        typename PromoteTags<typename Numeric1::Tag, typename Numeric2::Tag>::type,
        typename PromoteReals<typename Numeric1::Underlying, typename Numeric2::Underlying>::type
    >::type type;
};

template <class Numeric1, class Numeric2>
typename Promote<Numeric1, Numeric2>::type someFunc(Numeric1 x, Numeric2 y);

// Base class for the numbers
class Complex
{
...
public:
    // operators
    Complex& operator+ (Complex& cmplx){...};
    Complex& operator- (Complex& cmplx);
    Complex& operator* (Complex& cmplx);
    Complex& operator/ (Complex& cmplx);

...

protected:
    // Complex fields
    float real;
    float imag;
...

};



// Real numbers class
class Real : public Complex
{
...
public:
     Real& operator+(Real& value){...};
...

};

Complex с(1,2);
Real r(2);
Complex a = c+r;

Complex с(1,2);
Real r(2);
Complex a = r+с;

L>// Base class for the numbers
L>class Complex
L>{
L>...
L>public:
L>    // operators
L>    virtual Complex/* & */ operator+ (const Complex& cmplx){ return Complex( real + cmplx.real, imag + cmplx.imag ) };
L>    virtual Complex/* & */ operator- (const Complex& cmplx);
L>    virtual Complex/* & */ operator* (const Complex& cmplx);
L>    virtual Complex/* & */ operator/ (const Complex& cmplx);

L>...

L>protected:
L>    // Complex fields
L>    float real;
L>    float imag;
L>...

L>};



L>// Real numbers class
L>class Real : public Complex
L>{
L>...
L>public:
L>     using complex::operator+;
L>     Real/* & */ operator+(const Real& value){...};
L>...

L>};
L>

Complex c1( 1.0f, 2.0f );
Real r1( 3.0f ), r2(4.0f);

Real r3 = r1 + r2;
Complex c2 = c1 + r2;

class Complex
{
public :
    Complex( float r_, float i_ ) : r( r_ ), i( i_ ) {}

    friend Complex operator + ( const Complex& lhs, const Complex& rhs );

protected :
    float r, i;
};

class Real : public Complex
{
public :
    Real( float val ) : Complex( val, 0.0f ) {}

    friend Real operator + ( const Real& lhs, const Real& rhs );
};

Complex operator + ( const Complex& lhs, const Complex& rhs )
{
    return Complex( lhs.r + rhs.r, lhs.i + rhs.i );
}

Real operator + ( const Real& lhs, const Real& rhs )
{
    return Real( lhs.r + rhs.r );
}

RO>...

Many binary operators that expect operands of arithmetic or enumeration type cause conversions and yield result types in a similar way. The purpose is to yield a common type, which is also the type of the result. This pattern is called theusual arithmetic conversions, which are defined as follows:

• If either operand is of type long double, the other shall be converted to long double.
  
• Otherwise, if either operand is double, the other shall be converted to double.
  
• Otherwise, the integral promotions (4.5) shall be performed on both operands.
  
• Then, if either operand is unsigned long the other shall be converted to unsigned long.
  
• Otherwise, if one operand is a long int and the other unsigned int, then if a long int can represent all the values of an unsigned int, the unsigned int shall be converted to a long int; otherwise both operands shall be converted tounsigned long int.
  
• Otherwise, if either operand is long, the other shall be converted to long.
  
• Otherwise, if either operand is unsigned, the other shall be converted to unsigned.

template < typename ValType >
class complex
{
public :
    typedef ValType value_type;

        template < typename T >
    struct rebind
    {
        typedef complex< T > value;
    };

    complex( ValType r_, ValType i_ ) : r( r_ ), i( i_ ) {}

    //...
protected :
    ValType r, i;
};

template < typename ValType >
class real
{
public :
    typedef ValType value_type;

    template < typename T >
    struct rebind
    {
        typedef real< T > value;
    };

    real( ValType val ) : r( val ) {}

    //...
protected :
    ValType r;
};

template < 
    typename T1, 
    typename T2, 
    bool enable_first = ((sizeof( T1 ) > sizeof( T2 )) || (!std::numeric_limits<T1>::is_integer && std::numeric_limits<T2>::is_integer))
> struct enable
{
    typedef T2 value;
};

template < typename T1, typename T2 > 
struct enable< T1, T2, true >
{
    typedef T1 value;
};

template < typename T1, typename T2 >
struct promote
{
    typedef typename enable< 
        typename T1::value_type, 
        typename T2::value_type 
    >::value max_value_type;

    typedef typename enable<
        typename T1::rebind< max_value_type >::value,
        typename T2::rebind< max_value_type >::value
    >::value value;
};

typedef promote< complex< float >, real< double > >::value type;// тут будет complex< double >
typedef promote< real< float >, real< double > >::value type;// тут будет real< double >