EffectiveC++-条款43：学习处理模板化基类内的名称

一. 内容

1. 我们从一个例子入手，假设我们要设计游戏中人物的相关列表，比如 buff 列表，物品列表等等，一个显而易见的设计是：

   class Buff {
   public:
       virtual ~Buff() = default;
       virtual void Start() =0;
       virtual void End() =0;
       virtual void OnTick() =0;
   };
   
   class RedBuff : public Buff {
   public:
       virtual void Start() override {}
       virtual void End() override {}
       virtual void OnTick() override {}
   };
   
   class BlueBuff : public Buff {
   public:
       virtual void Start() override {}
       virtual void End() override {}
       virtual void OnTick() override {}
   };
   
   template <typename T>
   class Container {
   public:
       void Add(T Item) {
           std::cout << "Add" << "\n";
           Data.insert(Item);
       }
   
       void Clear() {
           std::cout << "Clear" << "\n";
           Data.clear();
       }
   
       size_t Size() {
           return Data.size();
       }
   
   private:
       std::set<T> Data;
   };
   
   template <typename T>
   class PlayerContainer : public Container<T> {
   public:
       void RemoveAll() {
          //Clear();   在此无法访问 Clear 函数
       }
   
       void ShowAll() {
           //...
       }
   };
   
   inline void TryWithBuff() {
       PlayerContainer<Buff*> PlayerBuffContainer;
       PlayerBuffContainer.Clear();
   
       RedBuff* RedBuffOne = new RedBuff;
       BlueBuff* BlueBuffOne = new BlueBuff;
       PlayerBuffContainer.Add(RedBuffOne);
       PlayerBuffContainer.Add(BlueBuffOne);
   
       std::cout << PlayerBuffContainer.Size() << "\n";
   }
   

2. 注意 PlayerContainer 中的 RemoveAll 函数并不能访问来自Container的 Clear 函数。当去掉注释时，编译器会抱怨 Clear 并不存在，为什么？

   问题在于，当编辑器遭遇 class template PlayerContainer 时，其实并不知道它究竟继承哪个 class。当然它继承的是 Container<T> ，但其中的 T 是一个 template 参数，不到后来的具现化，是无法确切知道它是什么。而如果不知道 T 是什么，就没有办法知道它是否有个 Clear 函数。 与之对比的是，在 TryWithBuff 函数中，PlayerContainer 被具现化，所有 template 参数明晰，自然也就知道存在 Clear 函数。参数明晰也可以是模板特化，比如下面的例子：

   template<>
   class Container<Buff*> {
   public:
       void Special() {
           //...
       }
   };
   //等价于
   template<typename T=Buff*>
   class Container<T> {
   public:
      void Special() {
      	 //...
      }
   };
   

   该版本的 Container template 类被特化，由于编译器会优先考虑特化版本，意味着 Container 使用 Buff 具现化时类中只存在 Special 函数，并未提供 Clear 函数。这正是前面所说，为什么 C++ 拒绝在 PlayerContainer 访问 Clear 函数的原因：它知道 base classes templates 有可能被特化，而那个特化版本可能不提供和一般性 template 相同的接口。因此它往往拒绝在 base classes templates 寻找继承而来的名称。

3. 不过默认的行为可以被改变，我们可以主动让 C++ 寻找继承而来的名称：

   • 在 base class template 函数调用动作之前加上 this->。this->Clear(); this 指针可以访问所有成员函数。
   • 使用 using 声明式。using Container<T>::Clear;可以告诉编译器进入 base class 作用域寻找函数。
   • 明确指出被调用函数位于 base class 内。Container<T>::Clear();，这种方式会强制使用该作用域的函数，会导致 virtual 属性不再生效。

     ---

   从名称可视点的角度来看，上述每一个解法做的事情都相同：对编译器承诺 base class template 的任何特化版本都支持其泛化版本所提供的接口。如果承诺未被保证，编译器仍然会报错。

二. 总结

1. 可在 derived class templates 内通过 this-> 指涉 base class templates 内的成员名称，或藉由一个明白写出的 base class 资格修饰符完成。