类模板继承中成员可见性的两种解决方案对比

以下代码无法通过编译：尽管是公有继承链，DerivedFoo中仍然无法直接访问HasFlag()方法：

class BasicFoo {
    public:  bool HasFlag() const { return m_flag; }
    private: bool m_flag = false;
};

template <typename T>
class Foo : public BasicFoo {
    public:  bool Test() const { return HasFlag(); }
};

template <typename T>
class DerivedFoo : public Foo<T> {
    public:
        // HasFlag is not visible here.
        bool Test2() const { return HasFlag(); }
};

针对这个问题，有两种常见的解决方案，下面对比它们的差异：

方案1：从直接基类引入作用域 #

// Option 1:  Explicitly pull it into scope from immediate base.
using Foo<T>::HasFlag;
bool Test2() const { return HasFlag(); }

方案2：从根类引入作用域 #

// Option 2:  Explicitly pull it from the root class.
using BasicFoo::HasFlag;
bool Test2() const { return HasFlag(); }

差异与效率分析 #

1. 作用域与依赖关系差异

   • 方案1依赖直接基类Foo<T>的继承结构，如果后续Foo<T>修改了继承逻辑（比如不再继承BasicFoo，或者重定义了HasFlag），DerivedFoo的行为会直接受影响。
   • 方案2直接绑定到根类BasicFoo，绕过了中间层Foo<T>：即使Foo<T>的继承逻辑变化，只要BasicFoo的HasFlag存在，DerivedFoo就能正常工作；但如果Foo<T>重写了HasFlag，方案2会直接忽略子类的重写，调用根类版本，这可能不符合预期。

2. 效率与代码生成差异
   担心“DerivedFoo<T>实例化多个T时生成多个相同的Foo<T>::HasFlag”是多余的：

   • 首先，HasFlag()是简单的内联成员函数，编译器会直接将其展开到调用处，不会生成冗余的函数实例。
   • 其次，即使是非内联函数，只要HasFlag()的实现不依赖模板参数T，编译器的优化机制（如COMDAT折叠）会自动合并相同的函数实例，不会产生冗余代码。
   • 两种方案在效率上没有本质区别，最终生成的汇编代码几乎一致。

内容的提问来源于stack exchange，提问作者Adrian McCarthy