4

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

filename.cpp:63: 错误: 没有匹配函数调用'Manager<(Base)1u>::init(Combination<(Base)1u, (Dependent2)0u>*)'</p>

这是线路调用b.init(&combination_2)

g++ --version => 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++ 的某些已知属性/功能/约束？

4

4 回答 4

2

下面的代码为我编译，我稍微简化了你的代码，尽管它仍然做同样的事情。

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();
    }

};
于 2013-01-25T10:18:58.217 回答
0

如果您结合继承并远离常量模板参数，扩展 Combination 以提供有关其模板参数的信息，您可以获得要编译的代码，考虑到您不希望它编译：

b.init(&combination_1);

您正在努力为您的 Manager 中的 init 成员模板间接指定和修复 Combination 的类型，即使 init 模板会推断出它，因为它是函数的唯一参数，并且无论如何在 main 中定义了类型 si .

你会考虑直接用组合模板化初始化吗？

这样，除了 init() 声明之外的所有内容都保持不变，并且您的代码按照您最初想要的方式编译：

class Base
{
};

class AA
:
    public Base
{
};

class BB
: 
    public Base
{
};

class Dependent1
{
};

class PP
:
    public Dependent1
{};

class Dependent2
{};

class XX
:
    public Dependent2
{};

template<class Base>
struct DependentProperty {
};

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

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

template <class Base> 
class Combination {
 public:

     typedef Base CombinationBase;
     typedef typename DependentProperty<Base>::Dependent CombinationDependent;

     void reset() 
     {

     }

     int o;
};


template <class Base>
class Manager
{
    public:

        // Any type C
        template<class C>
        void init (C* t)
        {
            // Any type C conforming to the implicit interface holding reset()
            t->reset(); 
            // Forcing specific combination
            Base b = typename C::CombinationBase(); 
            // Forcing it again
            typename DependentProperty<Base>::Dependent d = typename C::CombinationDependent();
        }
};

int main(int argc, char** argv) {

  Combination<AA> combination_1;
  Manager<AA> a;
  a.init(&combination_1);

  Manager<BB> b;
  Combination<BB> combination_2;
  b.init(&combination_2);

  b.init(&combination_1);

  return 0;
}

在这种情况下，您可以扩展组合模板以向客户端代码提供对其模板参数的访问。当然，在这种情况下，只要您依赖它在 init 成员函数中的实现（访问存储的模板参数值等），模板 C 在这种情况下就会成为组合概念的改进。

于 2013-01-25T13:09:31.597 回答
0

您的代码是正确的，除了函数调用部分。

a.init<PP, Combination>( &combination_1 );
b.init<XX, Combination> ( &combination_2 );

这编译并和平运行。

于 2015-07-10T06:40:39.897 回答
-1

我唯一看到的是

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

你的类Combination等待值作为模板参数，但你想给他类型

我花了一些时间来修复它 - 就像那样

template <typename DependentProperty<B>::Dependent D,
          template<Base BB,
                typename DependentProperty<BB>::Dependent DD
          > class T>
void init(T<B, D>* t);

和许多其他变体，但没有成功。

请原谅我把它作为一个答案，但我无法在评论中输入这么多代码

于 2013-01-25T11:05:21.563 回答