【effective c++】模板与泛型编程

模板元编程：在c++编译器内执行并于编译完成时停止执行

1.了解隐式接口和编译期多态

面向对象编程总是以显式接口（由函数名称、参数类型和返回类型构成）和运行期多态（虚函数）解决问题

模板及泛型编程：对template参数而言，接口是隐式的，基于有效表达式的约束，而多态则是通过模板实例化和函数重载解析发生于编译期。

隐式接口和显式接口两者都在编译期完成检查。

隐式接口：

template<typename T>
void doProcessing(T &w) {
    // 隐式接口，对模板参数类型T的约束
    if (w.size() > 10 && w != someNastyWidget) {
        // ...
    }
}

2.了解typename的双重意义

当我们声明template类型参数，class和typename的意义完全相同

template内出现的名称如果相依于某个template参数，称之为从属名称，如果从属名称在class内呈嵌套状，称之为嵌套从属名称。c++规定：如果解析器在template中遭遇一个嵌套从属名称，它便假设这名称不是个类型，除非你告诉它是。

任何时候当你想要在template中指涉一个嵌套从属类型名称，就必须在紧邻它的前一个位置放上关键字typename，typename只被用来验明嵌套从属类型名称，其他名称不该有它存在

template <typename C>
void f(const  C& container,        //不允许使用typename
    typename C::iterator iter); //一定要使用typename

typename必须作为嵌套从属类型名称的前缀词这一规则的例外是，typename不可以出现在base class list内的嵌套从属类型名称之前，也不可在成员初始化列表中作为base class修饰符

template <typename T>
class Derived :public Base<T>::Nested  // 不允许typename
{
public:
    explicit Derived(int x)
        :Base<T>::Nested(x)  // 不允许typename
    {
        typename Base<T>::Nested temp;
    }
};

std::iterator_traits<IterT>::value_type  //类型为IterT之对象所指之物的类型

真实程序中使用typename的例子：

std::iterator_traits<IterT>::value_type 表示IterT类型对象指向的对象的类型，比如IterT是vector<int>::iterator,则value_type为int （类型萃取）

template <typename IterT>
void workWithIterator(IterT iter)
{
    typename std::iterator_traits<IterT>::value_type  temp(*iter); // value_type是嵌套从属类型名称
}

3.学习处理模板化基类内的名称

base class template有可能被特化，而那个特化版本可能不提供和一般性template相同的接口，故c++往往拒绝在模板化基类内寻找继承而来的名称。假如基类的派生类实例化的模板参数是基类的特化版本对应的参数，即该派生类实际继承自特化版本，然后调用了泛化版本中才有的函数，这样就会出错

解决方案：对编译器承诺base class template的任何特化版本都将支持其一般(泛化)版本所提供的接口

1)在base class函数调用动作之前加上"this ->"

2)使用using声明式

3)明确指出被调用的函数位于base class内即用基类名称去调用该函数，这样会失去多态性

class MsgInfo{};

template<typename Company>
class MsgSender {
public:
    void sendClear(const MsgInfo &info) {
        string msg;
        Company c;
        c.sendCleartext(msg);
    }
};

template<typename Company>
class LoggingMsgSender: public MsgSender<Company> {
    using MsgSender<Company>::sendClear; // ok，此时sendClearMsg中可以直接调用sendClear
    void sendClearMsg(const MsgInfo &info) {
        // logging
        sendClear(info); // 无法通过编译，因为基类的特化版本中可能没有该接口
        this->sendClear(info); // ok
        MsgSender<Company>::sendClear(info); // ok,但如果sendClear是虚函数,失去多态性
        // logging
    }
}

4.将与参数无关的代码抽离template

使用template可能会导致代码(object code)膨胀,template生成多个class和多个函数（实例化模板时的模板参数不同，导致生成不同的class,导致目标码很大），因为非类型模板参数而造成的代码膨胀，往往可消除，做法是以函数参数或class成员变量替换template参数。

// size_t n为非类型模板参数
template<typename T, size_t n>
class SquareMatrix {
public:
    void invert();
};

// 调用的invert是两个不同的函数，引发代码膨胀
SquareMatrix<double, 5> sm1;
sm1.invert(); // 调用SquareMatrix<double, 5>::invert

SquareMatrix<double, 10> sm2;
sm2.invert(); // 调用SquareMatrix<double, 10>::invert

template<typename T>
class SquareMatrixBase {
protected:
    void invert(size_t matrix_size);
};

// 对于给定类型T,SquareMatrix对象共享同一个基类以及invert方法
template<typename T, size_t n>
class SquareMatrix: private SquareMatrixBase<T> {
private:
    // 避免隐藏基类的invert方法
    using SquareMatrixBase<T>::invert;
public:
    void invert() {
        this->invert(n);
    }
};

5.运用成员函数模板接受所有兼容类型

同一个template的不同实例化之间并不存在什么固有关系，如果以带有base-derived关系的B、D两类型分别具现化某个template，产生出来的两个具现体并不带有base-derived关系

真实指针支持隐式转换，派生类指针可以隐式转换为基类指针，指向non-const对象的指针可以转换为指向const对象的指针，而智能指针比如shared_ptr都是模板类，若想支持隐式转换，可通过成员函数模板实现（是不是还得实现泛化拷贝复制运算？）

template<typename T>
class SmartPtr
{
public:
    // member function template
    template<typename U>
    // 对任何类型T和任何类型U，可以根据SmartPtr<U>生成一个SmartPtr<T>,泛化copy构造函数
    SmartPtr(const SmartPtr<U>& other);
};

 注意:在class内声明泛化copy构造函数(member template)并不会阻止编译器生成它们自己的copy构造函数（non-template）,所以如果你想要控制copy控制的方方面面，你必须同时声明泛化copy构造函数和“正常形式的”copy构造函数，相同规则也适用于赋值操作。

6.需要类型转换时请为模板定义非成员函数

当我们编写一个class template，而它所提供的与此template相关的函数支持所有参数可以隐式类型转换时，请将那些函数定义为class template内部的friend函数(参考条款24)

template<typename T>
class Rational {
public:
    Rational(const T& numerator = 0, const T& denominator =1);
    const T numerator() const;
    const T denominator() const;
};

template<typename T>
const Rational<T> operator* (const Rational<T> &lhs, const Rational<T> &rhs) {
    return Rational<T>(lhs.getNumerator() * rhs.getNumerator(), lhs.getDenominator() * rhs.getDenominator());
}

/*
编译器通过operator*调用动作中的实参类型推导模板类型参数T,由oneHalf可推出operator *的第一个参数中T为int,
因为在template参数推导过程中从不将隐式类型转换函数纳入考虑，也就是说2不能隐式转换为Rational<int>类型，这样
operator*的第二个参数中T无法推导出来
*/
Rational<int> oneHalf(1, 2);
Rational<int> result = oneHalf * 2; // 编译出错

为了让类型转换可以发生于所有实参身上，我们需要一个non-member函数(条款24)，为了令这个函数被自动具现化，我们需要将它声明在class内部(类模板并不依赖模板实参推导，后者只施行于函数模板身上，此时会隐式调用Rational的构造函数)，而在class内部声明non-member函数的唯一方法就是声明它为friend，同时需要在声明的同时提供定义。

template<typename T>
class Rational {
public:
    Rational(const T& numerator = 0, const T& denominator =1){
        // 如果不加this，成员变量的作用域大于形参的作用域，即下面的两个
        // numerator、denominator都被视为形参这个变量
        this->numerator = numerator;
        this->denominator = denominator;
    }
    const T getNumerator() const {
        return numerator;
    }
    const T getDenominator() const {
        return denominator;
    }
    // 定义于class内的函数都暗自成为inline，包括像operator *这样的friend函数
    friend const Rational<T> operator*(const Rational &lhs, const Rational &rhs) {
        return Rational<T>(lhs.getNumerator() * rhs.getNumerator(), lhs.getDenominator() * rhs.getDenominator());
    }
private:
    T numerator;
    T denominator;
};

int main()
{
    Rational<int> oneHalf(1, 2);
    cout << "oneHalf.numerator: " << oneHalf.getNumerator() << endl;
    cout << "oneHalf.denominator: " << oneHalf.getDenominator() << endl;
    Rational<int> result = oneHalf * 2;
    cout << "result.numerator: " << result.getNumerator() << endl;
    cout << "result.denominator: " << result.getDenominator() << endl;
    return 0;
}

7.请使用traits classes表现类型信息

traits并不是c++关键字或一个预先定义好的构件，它是一种技术，也是每一个c++程序员共同遵守的协议，允许你在编译期取得某些类型信息，traits总是被实现为struct，iterator_traits是针对迭代器的traits

iterator_traits的运作方式是，针对每一个类型IterT,在struct iterator_traits<IterT>内一定声明某个typedef名为iterator_category,这个typedef用来确定IterT的迭代器分类。(下面代码中的类中类的成员的访问方式？)。首先它要求每一个用户自定义的迭代器类型必须嵌套一个typedef，名为iterator_category,然后iterator_traits响应iterator class的嵌套式typedef。

// deque为用户自定义类型
template<typename T>
class deque {
public:
    class iterator { // 这里没有必要定义一个内部类，直接在deque中声明一个typedef就可以了
    public:
        typedef random_access_iterator_tag iterator_category;
    };
};

template<typename IterT>
struct iterator_traits {
    typedef typename IterT::iterator_category iterator_category;
};

iterator_traits特别针对指针类型提供一个偏特化版本（指针类型不能像用户自定义类型那样嵌套一个typedef）：

template<typename IterT>
struct iterator_traits(IterT*)
{
    typedef random_access_iterator_tag iterator_category;
};

总结：

1)traits classes使得类型相关信息在编译器可用，它们以templates和templates特化完成实现

2)整合函数重载技术后，traits classes有可能在编译期对类型执行if...else测试（if语句是在运行期执行的）