模板类的模板成员函数

Question

我有一个模板化的C++类，它也有一个模板化的成员函数。这个成员函数的模板参数以特定的方式依赖于类的模板参数（请参阅下面的代码）。我正在为其模板参数的两个不同值实例化（而不是专门化）该类。一切都在这一点上进行。但是，如果我调用模板化的成员函数，对第一个实例化对象的调用只会编译，而不会编译第二个。似乎编译器没有为模板类的第二次实例化实例化模板化成员函数。我正在使用“g++filename.cpp”编译下面的代码，并得到以下错误：

filename.cpp:63:错误：调用“Manager<(Base)1u>::Init(combinite<(Base)1u,(Dependent2)0u>*)”时没有匹配的函数

这是调用b.init(&combination_2)的行

G++--版本=>G++(Ubuntu/Linaro 4.4.7-1Ubuntu2)4.4.7

uname-a=>Linux 3.2.0-25-generic-pae#40-Ubuntu SMP i686 i686 i386 GNU/Linux

enum Base {
  AA,
  BB,
  CC
};

enum Dependent1 {
  PP,
  QQ,
  RR
};

enum Dependent2 {
  XX,
  YY,
  ZZ
};

template<Base B>
struct DependentProperty {
};

template<>
struct DependentProperty<AA> {
  typedef Dependent1 Dependent;
};

template<>
struct DependentProperty<BB> {
  typedef Dependent2 Dependent;
};

template <Base B, typename DependentProperty<B>::Dependent D>
class Combination {
 public:
  void reset() {}
  int o;
};

template <Base B>
class Manager {
 public:
  template <typename DependentProperty<B>::Dependent D,
            template<Base,
                    typename DependentProperty<B>::Dependent> class T>
  void init(T<B, D>* t);
};

template <Base B>
template <typename DependentProperty<B>::Dependent D,
          template<Base,
                  typename DependentProperty<B>::Dependent> class T>
void Manager<B>::init(T<B, D>* t) {
  t->reset();
}

int main(int argc, char** argv) {
  Manager<AA> a;
  Manager<BB> b;
  Combination<AA, PP> combination_1;
  Combination<BB, XX> combination_2;
  a.init(&combination_1);
  b.init(&combination_2);
  return 0;
}

在我们的实际项目中，从我的示例代码中修改与Base、Dependent或Combination相对应的类是不可行的。我真正想知道的是，我定义Manager：：init（）的语法是错误的，还是C++或G++的某些已知属性/特性/约束不允许使用此代码？

Answer 1

下面的代码是为我编译的，我把你的代码简化了一点，虽然它还是做同样的事情。

template <Base B>
class Manager {
 public:
typedef typename DependentProperty<B>::Dependent D;  // if ever you need it
    template <typename TCombinaison>
    void init(TCombinaison* t)
    {
        t->reset();
    }

};

int main(int argc, char** argv) 
{
    typedef Combination<AA, PP> CombinaisonA;
    typedef Combination<BB, XX> CombinaisonB;

    typedef DependentProperty<AA> DependencyPropertyA;
    typedef DependentProperty<BB> DependencyPropertyB;

  CombinaisonA combination_1;
  CombinaisonB combination_2;

  Manager<AA> a;
  Manager<BB> b;

  a.init(&combination_1);
  b.init<&combination_2);

  return 0;
}

编辑：第二个解决方案，以禁止在经理中混合使用组合，正如OP在下面的评论中注意到的。现在我使用std::is_same来检查“概念”合同。

template <Base B, typename DependentProperty<B>::Dependent D>
class Combination {
 public:
    typedef typename DependentProperty<B>::Dependent DependencyType;
  void reset() {}
  int o;
};

template <Base B>
class Manager {
 public:
    typedef typename DependentProperty<B>::Dependent DependencyType; 
    template <typename TCombinaison>
    void init(TCombinaison* t)
    {
        static_assert(std::is_same<TCombinaison::DependencyType, Manager::DependencyType>);
        t->reset();
    }

};