条款41：了解隐式接口和编译器多态
- 对于class而言，接口是显式的，动态通过virtual函数实现，发生于运行期间。
- 对于template而言，接口是隐式的，通过模板实例化和函数重载解析实现，发生于编译期。
条款42：了解typename的双重意义
- 声明template参数时，typename和class可以互换。
- 需要使用typename关键字表示嵌套从属类型名称，如下示例代码：
#include <iostream>
#include <vector>
template <typename T>
void Print2nd(const T& container)
{
if (container.size() >= 2) {
typename T::const_iterator iter(container.begin()); //这里必须加typename表示T::const_iterator是一个名称
iter++;
int value = *iter;
std::cout << value << std::endl;
}
}
其中T::const_iterator就是嵌套从属类型，必须使用typename关键字。
条款43：学习处理模板化基类内的名称
考察以下示例代码：
#include <iostream>
template <typename T>
class B {
public:
void Foo() {std::cout << "B::Foo" << std::endl;}
};
template <typename T>
class D : public B<T> {
public:
void Test() {B<T>::Foo();} // 这里必须在Foo()名称前显式指明使用基类名称B<T>
};
int main()
{
D<int> obj;
obj.Test();
return 0;
}
继承一个模板基类时，如果在子类的成员函数中调用基类中的函数，则必须使用“this->”或者“基类名称::”，显式的指定函数是来自基类的，否则编译器不知道该函数来自哪里，相当于显式的触发基类模板的实例化。
条款44：与参数无关的代码抽离出template
主要作用是防止模板实例化后代码膨胀问题。
- template代码不应该与某个造成膨胀的template参数产生相依关系。
- 可以使用函数参数或者类成员变量替换template参数。
条款45：成员函数模板接受所有兼容类型
比如C++11中的智能共享指针，在实现基类和子类对应的智能指针转换时即是这种情况，如下所示：
#include <iostream>
#include <memory>
template <typename T>
class SmartPtr {
public:
SmartPtr<T>(T* p) : ptr(p) {}
template <typename C>
SmartPtr<T>(const SmartPtr<C>& other) {ptr = (T*)(other.get());}
T* get() const {return ptr;}
private:
T* ptr;
};
class B {
public:
virtual ~B() {}
};
class D : public B {
};
int main()
{
SmartPtr<D> sp(new D());
SmartPtr<B> sp1 = sp;
return 0;
}
对于“SmartPtr<B> sp1 = sp;”，它调用的是SmartPtr<B>的拷贝构造函数，参数是SmartPtr<D>类型。
条款46：需要类型转换时请为模板定义非成员函数
参考以下示例代码：
- 版本1：在模板类内定义operator成员
#include <iostream>
template <typename T>
class R {
public:
R(T x) : val_(x) {}
R<T> operator*(const R<T>& rhs) {
int value = this->val_ * rhs.val_;
return R(value);
}
void Print() {std::cout << val_ << std::endl;}
public:
T val_;
};
int main()
{
R<int> r1(10), r2(12);
R<int> res1 = r1 * r2;
res1.Print(); // 编译OK
R<int> res2 = r1 * 2;
res2.Print(); // 编译OK
R<int> res3 = 2 * r2;
res3.Print(); // 编译不通过
return 0;
}
在这个版本中我们定义了一个模板类内的operator，可以看到当编译"2 * r2"这条语句时，编译不通过。因为编译器遇到2这个常量时，它无法知道将它转换为一个R实例对象。所以，必须定义一个非成员函数。
- 版本2：在类模板外定义一个非成员operator。
#include <iostream>
template <typename T>
class R {
public:
R(T x) : val_(x) {}
void Print() {std::cout << val_ << std::endl;}
public:
T val_;
};
template <typename T>
R<T> operator*(const R<T>& lhs, const R<T>& rhs)
{
return R<T>(lhs.val_ * rhs.val_);
}
int main()
{
R<int> r1(10), r2(12);
R<int> res1 = r1 * r2;
res1.Print(); // 编译OK
R<int> res2 = r1 * 2;
res2.Print(); // 编译不通过
R<int> res3 = 2 * r2;
res3.Print(); // 编译不通过
return 0;
}
可以看到这次r1 * 2也编译不通过了，这是因为模板函数不接受任何隐式的转换。
- 版本3：在模板类内定义一个friend函数
#include <iostream>
template <typename T>
class R {
public:
R(T x) : val_(x) {}
void Print() {std::cout << val_ << std::endl;}
friend R<T> operator*(const R<T>& lhs, const R<T>& rhs)
{
return R<T>(lhs.val_ * rhs.val_);
}
public:
T val_;
};
int main()
{
R<int> r1(10), r2(12);
R<int> res1 = r1 * r2;
res1.Print(); // 编译OK
R<int> res2 = r1 * 2;
res2.Print(); // 编译OK
R<int> res3 = 2 * r2;
res3.Print(); // 编译OK
return 0;
}
条款47：请使用traits class表现类型信息
一句话总结：traits class是“type of type”，我们常用的std::is_pod就是这类class，它是编译器执行的。
#include <iostream>
#include <type_traits>
int main()
{
int a;
std::cout << std::is_pod<decltype(a)>::value << std::endl;
return 0;
}
条款48：认识template元编程
- 模板元编程（TMP）可以将工作由运行期移至编译期，可以得到更高的执行效率。
