C/C++编程：需要类型转换时请为模板定义non-member 函数

Bertha 。 2023-01-20 10:54 27阅读 0赞

[C/C++编程：如果所有参数都需类型转换，请为此采用non-member函数][C_C_non-member]提出，为支持混合式算法，需要让operator\*成为一个non-member函数，以允许编译期在每一个实参上执行隐式类型转换。即只有non-member函数才有能力在“所有实参身上实施隐式类型转换”。这里我们尝试用模板改写

template<typename T>
    class Rational{
        
    public:
    	Rational(const T& numerater=0, const T& denominator  = 1);  //构造函数故意不为explicit，允许int-to-Rational隐式转换
    	const T numerator() const;
    	const T denominator() const;
    };
    
    template<typename T>
    const Rational<T> operator* (const Rational<T>& lhs, const Rational<T>& rhs ){
        }

但是发现预期的混合式运算不支持：

Rational<int> oneHalf(1, 2);
    Rational<int> result = oneHalf * 2; //无法通过编译

上面的失败给我们的启示是，模板和非模板不同，在非模板时，编译期知道我们尝试调用的是哪个函数，而这里编译期不知道我们想要调用哪个函数，取而代之的是，它们视图想出什么函数被名为opertaor*的模板具现化出来。它们知道它们应该可以具现化某个"名为operator*并接受两个Rational< T>参数"的函数。但为了完成这一具现化行动，必须先算出T是什么，问题是它们没有这个能耐。

为了推导T，它们看了看operator\*调用动作中的实参类型。本例中那些类型分别是Rational< T>(oneHalf的类型)的int(2的类型)。每个参数分开考虑。

以oneHalf进行推导：operator\*的第一参数被声明为Rational< T>, 而传递给operator \* 的第一个参数是Rational< T>，所以T是int。传递给operator `*`第二参数的类型是2，编译期如何根据这个推算出T。你也许会期盼编译器使用Rational< T>的non-explicait构造函数将2转换为Rational< T>，从而推导出T是int，但是不可能这么做。因为**在模板实参推导过程中从不将隐式类型转换函数纳入考虑**

解决方法：

template<typename T>
    class Rational{
        
    public:
    	friend const Rational operator*(const Ration& lhs, const Rational & rhs);
    	// 上面相当于
    	//friend const Rational<T> operator*(const Rational<T>& lhs, const Rational<T> & rhs);
    }
    
    template<typename T>
    friend const Rational<T> operator*(const Rational<T>& lhs, const Rational<T> & rhs)

现在混合式调用可以编译了：因为当对象OneHalf被声明一个Rational< T>, class Rational< T>于是被具现化出来，而作为过程的一部分，友元函数operator\*也就被自动声明出来。后者是一个函数而不是一个函数模板，因此编译期就可以在调用它是使用隐式转换函数。这就是混合式调用编译的原因。

但是，还有问题，虽然混合式代码可以编译但是无法连接。可以通过编译的原因是编译器知道我们要调用哪个函数，但是这个函数只被声明于Rational内，并没有被定义出来。我们想要此类外的operator\*模板提供定义，但是行不通-----解决方法是将operator`*`函数本体合并到其声明式内：

template<typename T>
    class Rational{
        
    public:
    	friend const Rational operator*(const Ration& lhs, const Rational & rhs){
        
    		return Rational(lhs.numerator() * rhs.numerator(),
    					lhs.denominator() * rhs.denominator());
    	}
    }

现在混合式运算可以成功调用了。

这项技术的一个有趣点是，虽然我们使用了friend，却与friend的传统用途”访问class的non-public成分“毫不相干。[为了让类型转换可能发生于所有实参身上，我们需要一个non-member函数][C_C_non-member]；为了让这个函数被自动具现化，我们需要将它声明在类内部；而在类内部声明non-member函数的唯一方法就是，令它成为一个friend。定义于类内部的函数都暗中成为了inline。

”Rational是个模板“意味着其辅助函数通常也是个模板。所以定义了Rational的头文件代码，应该是类似：

template<typename T> class Rational;
    
    template<typename T>
    const Rational<T> doMultiply(const Rational<T>&lhs,	const Rational<T>& rhs);
    
    template<typename T>
    class Rational{
        
    ...
    friend const Rational<T> operator*(const Rational<T>& lhs, const Rational<T> & rhs){
        
    		return doMutiply(lhs, rhs);
    	};
    };
    
    template<typename T>
    const Rational<T> doMultiply(const Rational<T>&lhs,	const Rational<T>& rhs){
        
    	return Rational(lhs.numerator() * rhs.numerator(),
    					lhs.denominator() * rhs.denominator());
    }

作为一个模板，doMultiply当然不支持混合式乘法，但它其实也不需要。它只被operator `*`调用，而operator `*`支撑了混合式操作。本质上operator `*`支持了类型转换所需的任何东西，确保两个Rational对象能够相乘，然后它将这两个对象传给一个适当的doMultiply模板具现体，完成实际的乘法操作。

总结：

*  当我们编写一个类模板时，而它所提供的”与此模板相关的“函数支持”所有参数的隐式类型转换“时，请将那些函数定义为”类内部的friend函数“

[C_C_non-member]: https://blog.csdn.net/zhizhengguan/article/details/116608557