Как вызвать конструктор одиночных аргументов в этой программе с шаблоном класса?

Question

Это код, который я написал, чтобы начать с шаблонов классов.

#include<iostream> 
using namespace std; 
template<class T> 
class Complex 
{ 
T *real,*imag; 
public: 
    Complex(T a) 
    { 
    real=new T; 
    imag=new T; 
     *real=a; 
     *imag=0; 
    } 
    Complex(T a,T b) 
    { 
    real=new T; 
    imag=new T; 
     *real=a; 
     *imag=b; 
    } 
    Complex() 
    { 
    real=new T; 
    imag=new T; 
     *real=0; 
     *imag=0; 
    } 
template<class R>  
friend ostream& operator<<(ostream &out,Complex<R> &C); 
template<class R> 
friend istream& operator>>(istream &in,Complex<R> &C); 
template<class R> 
friend Complex<R> operator +(Complex<R> a,Complex<R> b);  
}; 
template<class R> 
ostream& operator<<(ostream &out,Complex<R> &C) 
    { 
    out<<"The number is "<<*C.real<<"+"<<*C.imag<<"i"<<endl; 
    return out; 
    } 
template<class R>  
istream& operator>>(istream &in,Complex<R> &C) 
    { 
    cout<<"Enter the number "; 
    in>>*C.real>>*C.imag; 
    return in; 
    } 
template<class R>  
Complex<R> operator +(Complex<R> a,Complex<R> b) 
{ 
Complex<R> temp; 
*temp.real=*a.real+*b.real; 
*temp.imag=*a.imag+*b.imag; 
return temp;  
}  
int main() 
{ 
Complex<float> C1,C2(4.2,6.8),C3,C4; 
C1=5; 
C3=3+C1; 
C4=C2+C3; 
cout<<C1; 
cout<<C2; 
cout<<C3; 
cout<<C4; 
} 

Этот код работает нормально, за исключением случаев, когда я пытаюсь использовать целочисленное значение типа «3 + C2», оно показывает ошибку. Если один и тот же код рассматривается без использования шаблонов для «3 + C2», вызывает оператор функции друга + (Complex a, Complex b) и 3, который копируется для объекта a, который вызывает конструктор одиночных аргументов, и 3 будет присвоен действительной части Сложный класс. Как сделать то же самое при использовании шаблонов классов? Как вызвать конструктор одиночных аргументов, когда число передается функции operator +() вместо объекта Complex при использовании шаблонов классов?

Answer 1

С чем-то вроде

template<class R> 
Complex<R> operator +(Complex<R>, Complex<R>); 

типа R выводится независимо друг от аргумента функции; оба вывода должны быть успешными, и выведенный тип должен соответствовать для этого, чтобы он мог использоваться. Поскольку 3 не является Complex, вывод невозможен, и перегрузка не учитывается.

Существует два способа решить эту проблему. Одним из них является использование друга без шаблона:

template<class T> 
class Complex { 
    // ... 
    friend Complex operator+(Complex a, Complex b) { 
     // ... 
    } 
}; 

Это инстанцирует в функцию друга нешаблонного, который с удовольствием рассмотрят неявные преобразования.

Другой подход является обеспечение дополнительных перегрузок, которые выводят только от одного аргумента:

template<class T> struct identity { using type = T; }; 
template<class T> using nondeduced_t = typename identity<T>::type; 

template<class R> 
Complex<R> operator +(nondeduced_t<Complex<R>>, Complex<R>) { /* ... */ } 

template<class R> 
Complex<R> operator +(Complex<R>, nondeduced_t<Complex<R>>) { /* ... */ } 

Это подход, std::basic_string_view.

---

Кстати, реализация, которую вы имеете, сильно сломана. Он утечки памяти, как нет завтра - и нет причин для динамического распределения T s в первую очередь.