Effective C++学习笔记（第七章）

条款41：了解隐式接口和编译器多态

• 对于class而言，接口是显式的，动态通过virtual函数实现，发生于运行期间。
• 对于template而言，接口是隐式的，通过模板实例化和函数重载解析实现，发生于编译期。

条款42：了解typename的双重意义

• 声明template参数时，typename和class可以互换。
• 需要使用typename关键字表示嵌套从属类型名称，如下示例代码：

#include 
#include 
template 
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 

template 
class B {
public:
    void Foo() {std::cout << "B::Foo" << std::endl;}
};

template 
class D : public B {
public:
    void Test() {B::Foo();} // 这里必须在Foo()名称前显式指明使用基类名称B
};
int main()
{
    D obj;

    obj.Test();
    return 0;
}

继承一个模板基类时，如果在子类的成员函数中调用基类中的函数，则必须使用“this->”或者“基类名称::”，显式的指定函数是来自基类的，否则编译器不知道该函数来自哪里，相当于显式的触发基类模板的实例化。

条款44：与参数无关的代码抽离出template

主要作用是防止模板实例化后代码膨胀问题。

• template代码不应该与某个造成膨胀的template参数产生相依关系。
• 可以使用函数参数或者类成员变量替换template参数。

条款45：成员函数模板接受所有兼容类型

比如C++11中的智能共享指针，在实现基类和子类对应的智能指针转换时即是这种情况，如下所示：

#include 
#include 

template 
class SmartPtr {
public:
    SmartPtr(T* p) : ptr(p) {}

    template 
    SmartPtr(const SmartPtr& 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 sp(new D());

    SmartPtr sp1 = sp;

    return 0;
}

对于“SmartPtr sp1 = sp;”，它调用的是SmartPtr的拷贝构造函数，参数是SmartPtr类型。

条款46：需要类型转换时请为模板定义非成员函数

参考以下示例代码：

• 版本1：在模板类内定义operator成员

#include 

template 
class R {
public:
    R(T x) : val_(x) {}

    R operator*(const R& rhs) {
        int value = this->val_ * rhs.val_;
        return R(value);
    }

    void Print() {std::cout << val_ << std::endl;}

public:
    T val_;
};

int main()
{
    R r1(10), r2(12);
    R res1 = r1 * r2;
    res1.Print(); // 编译OK

    R res2 = r1 * 2;
    res2.Print(); // 编译OK

    R res3 = 2 * r2;
    res3.Print(); // 编译不通过

    return 0;
}

在这个版本中我们定义了一个模板类内的operator，可以看到当编译"2 * r2"这条语句时，编译不通过。因为编译器遇到2这个常量时，它无法知道将它转换为一个R实例对象。所以，必须定义一个非成员函数。

• 版本2：在类模板外定义一个非成员operator。

#include 

template 
class R {
public:
    R(T x) : val_(x) {}
    void Print() {std::cout << val_ << std::endl;}
public:
    T val_;
};

template 
R operator*(const R& lhs, const R& rhs)
{
    return R(lhs.val_ * rhs.val_);
}

int main()
{
    R r1(10), r2(12);
    R res1 = r1 * r2;
    res1.Print(); // 编译OK

    R res2 = r1 * 2; 
    res2.Print();  // 编译不通过

    R res3 = 2 * r2;
    res3.Print(); // 编译不通过

    return 0;
}

可以看到这次r1 * 2也编译不通过了，这是因为模板函数不接受任何隐式的转换。

• 版本3：在模板类内定义一个friend函数

#include 

template 
class R {
public:
    R(T x) : val_(x) {}
    void Print() {std::cout << val_ << std::endl;}

    friend R operator*(const R& lhs, const R& rhs)
    {
        return R(lhs.val_ * rhs.val_);
    }
public:
    T val_;
};

int main()
{
    R r1(10), r2(12);
    R res1 = r1 * r2;
    res1.Print(); // 编译OK

    R res2 = r1 * 2;
    res2.Print();  // 编译OK

    R res3 = 2 * r2;
    res3.Print(); // 编译OK

    return 0;
}

条款47：请使用traits class表现类型信息

一句话总结：traits class是“type of type”，我们常用的std::is_pod就是这类class，它是编译器执行的。

#include 
#include 

int main()
{
    int a;
    std::cout << std::is_pod::value << std::endl;
    return 0;
}

条款48：认识template元编程

• 模板元编程（TMP）可以将工作由运行期移至编译期，可以得到更高的执行效率。