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

时间:2022-12-19 01:44:56

模板元编程:在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语句是在运行期执行的)