如何在这个涉及类模板的程序中调用单参数构造函数？

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' 调用友元函数 operator+(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采取的方法。

---

顺便说一句，你的实现被严重破坏了。它会泄漏内存，就像没有明天一样 - 首先没有理由动态分配 Ts。