C++

版权声明：本文为博主原创文章。未经博主同意不得转载。 https://blog.csdn.net/u012515223/article/details/24357301

模板函数须要类型转换时使用友元(friend)模板函数

本文地址: http://blog.csdn.net/caroline_wendy/article/details/24357301

非模板函数參考: http://blog.csdn.net/caroline_wendy/article/details/24309293

模板函数的隐式(implicit)类型转换, 涉及到模板參数(typename)的确定问题. 

从int或double类型, 无法隐式转换为模板类(template class)的类型, 由于无法确定模板參数类型(typename), 就无法确定构造函数的參数.

所以须要使模板函数, 与模板类拥有同样的參数类型(typename), 则须要成为模板类的友元(friend).

模板类的友元, 会随着类的參数实例化, 而实例化參数类型, 从一个函数模板, 生成定制的函数, 即能够通过隐式类型转换.

由于生成了定制的函数, 所以无法找到外部的模板类定义, 能够通过:

1. 直接在友元函数内部, 实现代码(inline);

2. 在友元函数内部, 实现一个模板函数, 在把模板函数在外部实现.

代码例如以下:

/*
 * test.cpp
 *
 *  Created on: 2014.04.22
 *      Author: Spike
 */

/*eclipse cdt, gcc 4.8.1*/

#include <iostream>

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 Rational<T>(lhs.numerator()*rhs.numerator(),
				lhs.denominator()*rhs.denominator());
	} //方法1*/
	friend const Rational<T> operator* (const Rational<T>& lhs,
		const Rational<T>& rhs) {
		return doMultiply(lhs, rhs);
	} //方法2
public:
	Rational(const T& numerator = 0, const T& denominator = 1) :
		m_n(numerator), m_d(denominator) {}
	const T numerator() const {return m_n;};
	const T denominator() const {return m_d;};
	const T value() {return (m_n/m_d);}
private:
	T m_n;
	T m_d;
};

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

int main(void) {
	Rational<double> oneFourth(1, 4);
	Rational<double> result;
	result = oneFourth * 3.5;
	result = 3.5 * oneFourth;
	std::cout << "result = " << result.value() << std::endl;

	return 0;
}

输出:

result = 0.875