effective c++条款总结（6）

1. 使用成员函数模板生成可接受所有兼容类型的函数。

// SmartPtr<T>拥有了拷贝构造函数，这个构造函数只有在实参适合（兼容/隐式转换）的时候才能通过编译
template<typename T>
class SmartPtr{
public:
	template<typename U>
	SmartPtr(const SmartPtr<U>& other) : heldPtr(other.get()){...}
	T* get() const { return heldPtr; }
	...
private:
	T* heldPtr;
};

TR1规范中关于tr1::shared_ptr的摘录如下：

// &auto_ptr当被复制时，其实已经改动了，所以不用const
template<class T>
class shared_ptr{
	template<class Y> explicit shared_ptr(Y* p);
	template<class Y> shared_ptr(shared_ptr<Y> const& r);
	template<class Y> explicit shared_ptr(weak_ptr<Y> const& r);
	template<class Y> explicit shared_ptr(auto_ptr<Y>& r);
	template<class Y> shared_ptr& operator=(shared_ptr<Y> const& r);
	template<class Y> shared_ptr& operator=(auto_ptr<Y> const& r);	
};

2. 当我们将一个类转换为模板类时，为了支持所有参数的隐式类型转换，将模板类内部那些函数定义为友元。

template<typename T>
class Rational{
public:
// 为了将函数类型转换发生在所有实参上，我们定义了非成员函数
// 为了将这个函数被主动实现，我们定义在class内部
// 为了使用它，我们让它成为friend
// 为了能够具体实现，我们要提供定义式（使用inline）
	friend const Rational operator*(const Rational& l, const Rational& r){
		return Rational(l.first() * r.first(), l.second() * r.second());
	}
};

3. 重载traits的实现，会以template的形式实现

template<typename IterT, typename DistT>
void advance(IterT& iter, DistT d){
	doAdvance(iter, d, typename std::iterator_traits<IterT>::iterator_category());
}

template<typename IterT, typename DistT>
void doAdvance(IterT& iter, DistT d, std::random_accessiterator_tag){
	iter += d; // random access 迭代器
}
template<typename IterT, typename DistT>
void doAdvance(IterT& iter, DistT d, std::bidirectional_iterator_tag){
	if (d >= 0){
		while(d--)
			++iter; // bidirectional 迭代器
	}; 
}
template<typename IterT, typename DistT>
void doAdvance(IterT& iter, DistT d, std::input_iterator_tag){
	if (d < 0){
		throw std::out_of_range("Negative distance");
	} 
	while (d--)
		iter++; // input 迭代器
}

4. 认识模板元编程（TMP）

// 利用TMP在编译器计算阶乘
template<unsigned n>
struct Factorial{
	enum { value = n * Factorial<n-1>::value };
}
template<>
struct Factorial<0>{
	enum { value = 1 };
}
// 测试函数
int main(){
	std::cout << Factorial<5>::value << endl;
	return 0;
}