《Effective C++》学习笔记（条款43：学习处理模板化基类内的名称)

最近开始看《Effective C++》，为了方便以后回顾，特意做了笔记。若本人对书中的知识点理解有误的话，望请指正！！！

假设我们有一个程序，它能够传送信息到若干不同的公司去。信息要么被加密，要么就是未加密。如果在编译期间我们拥有足够的信息来决定哪一个信息传至哪家公司，就可以采用基于 template 的方法：

class CompanyA {
public:
    ...
    void sendCleartext(const std::string& msg);
    void sendEncrypted(const std::string& msg);
    ...
};
class CompanyB {
public:
    ...
    void sendCleartext(const std::string& msg);
    void sendEncrypted(const std::string& msg);
    ...
};
...                                     // CompanyC、CompanyD、...等其他公司类
    
class MsgInfo { ... };         // 保存信息的类，以备将来产生信息

template<typename Company>
class MsgSender {
public:
    ...                                // 构造、析构函数等
    void sendClear(const MsgInfo& info) {
        std::string msg;
		//在这儿，根据info产生信息
        Company c;
        c.sendCleartext(msg);
    }
    
    void sendSecret(const MsgInfo& info){
        std::string msg;
        //在这儿，根据info产生信息
        Company c;
        c.sendEncrypted(msg);
    }
};

如果我们有时想在每次发送信息时记录某些信息，派生类 可轻易实现，这似乎是合情合理的方法：

template<typename Company>
class LoggingMsgSender: public MsgSender<Company> {
public:
    ...										// 构造、析构函数等
    void sendClearMsg(const MsgInfo& msg)
    {
        // 将 发送前的信息 写到 log
        sendClear(info);					//调用基类函数；这段代码无法通过编译
        // 将 发送后的信息 写到 log
    }
    ...
};

派生类 的信息发送函数是 sendClearMsg ,与其基类的名称不同（sendClear）。这是个好设计，因为它避免遮掩“继承而得的名称”（见条款33），也避免重新定义一个继承而得的 普通成员函数 （见条款36）。但上述代码无法通过编译，因为编译器无法找到sendClear，虽然我们知道 sendClear 在其 基类 内。编译器为什么无法找到它呢？

因为编译器遇到 类模板 LoggingMsgSender 定义式时，并不知道它继承什么样的类。虽然它继承的是 MsgSender<Company> ,但其中的 Company 是个 template参数，不到最后（当 LoggingMsgSender 被实例化）都无法确切知道它是什么。而不知道 Company ，就无法知道 MsgSender<Company> 类看起来像什么，即没办法知道它是否有个 sendClear 函数。

为了让问题更具体化，假设 CompanyZ 类坚持使用加密通讯：

class CompanyZ {
public:
    ...			//这个类没有提供sendCleartext函数
    void sendEncrypted(const std::string& msg);
    ...
};

一般的 MsgSender 类模板对 CompanyZ 并不合适，因为那个 template 提供了一个 sendClear 函数（函数体内调用了类型参数 Company 的 sendCleartext 函数），所以需要为 CompanyZ 量身打造一个适合它的 MsgSender 特化版：

template<>
class MsgSender<CompanyZ>  {	//一个全特化的 MsgSender，它和一般的模板相同，差别只在于它删掉了 sendClear
public:
    ...			
    void sendSecret(const MsgInfo& info) { ... }
    ...
};

上述代码中的首行 template<> ，表示这既不是 template 也不是 标准 class，而是个特殊化版本的 MsgSender 类模板，只有在 template实参是 CompanyZ 时才被使用。

这就是 模板全特殊化：MsgSender 类模板 针对类型 CompanyZ 特殊化了，而且其特殊化是全面性的，也就是说一旦类型参数被定义为 CompanyZ ，再没有其它 template参数 可供变化。

那么我们再来看下上面的 派生类 LoggingMsgSender ：

template<typename Company>
class LoggingMsgSender: public MsgSender<Company> {
public:
    ...										// 构造、析构函数等
    void sendClearMsg(const MsgInfo& msg)
    {
        // 将 发送前的信息 写到 log
        sendClear(info);					//如果 Company == CompanyZ，这个函数不存在
        // 将 发送后的信息 写到 log
    }
    ...
};

当 基类 被指定为MsgSender<CompanyZ> 时，这段代码不合法，因为那个类并未提供 sendClear 函数。

这就是为什么C++拒绝这个调用的原因：它知道 基类模板（base class template） 有可能被特殊化，而那个特殊化版本可能不提供一般 类模板 相同的接口。因此它往往拒绝在 模板化基类（本例的 MsgSender<Company>） 内寻找继承而来的名称（本例的 sendClear ）。

那么有什么方法令C++ ”不进入 模板化基类 寻找继承而来的名称“的行为失效呢？

• 在 基类 函数调用动作之前加上 this->

  template<typename Company>
  class LoggingMsgSender: public MsgSender<Company> {
  public:
      ...										// 构造、析构函数等
      void sendClearMsg(const MsgInfo& msg)
      {
          // 将 发送前的信息 写到 log
          this->sendClear(info);					//成立，假设 sendClear 将被继承
          // 将 发送后的信息 写到 log
      }
      ...
  };
  

• 使用 using 声明式（见条款33）

  template<typename Company>
  class LoggingMsgSender: public MsgSender<Company> {
  public:
      using MsgSender<Company>::sendClear;	//告诉编译器，请它假设 sendClear 在 基类 内
      ...										// 构造、析构函数等
      void sendClearMsg(const MsgInfo& msg)
      {
          // 将 发送前的信息 写到 log
          sendClear(info);					//成立，假设 sendClear 将被继承
          // 将 发送后的信息 写到 log
      }
      ...
  };
  

  虽然 using 声明式 在这里和条款33都可以起作用，但两处解决的问题其实不相同。这里的情况并不是 基类名称 被 派生类名称 遮掩，而是编译器不进入 基类作用域 内查找，于是我们通过 using 告诉它要进去查找。

• 明白指出被调用的函数位于 基类 内

  template<typename Company>
  class LoggingMsgSender: public MsgSender<Company> {
  public:
      ...										// 构造、析构函数等
      void sendClearMsg(const MsgInfo& msg)
      {
          // 将 发送前的信息 写到 log
          MsgSender<Company>::sendClear(info);					//成立，假设 sendClear 将被继承
          // 将 发送后的信息 写到 log
      }
      ...
  };
  

  但这个办法不是很好，因为当被调用的是 虚函数 时，明确的资格修饰会关闭 ”virtual绑定行为“。

从名称可视点的角度出发，上述的解决方法做的事情都相同：对编译器承诺 基类模板（base class template）的任何特化版本都将支持一般（泛化）版本所提供的接口。这样的承诺是编译器在解析 像 LoggingMsgSender 这样的 派生类模板 时需要的。但如果这个承诺最终未被实践出来，编译器将会指出这个错误。

条款44：将与参数无关的代码抽离 templates