代码之家 › 专栏 › 技术社区 › bjskishore123

显式模板专门化问题

c++

bjskishore123 · 技术社区 · 14 年前

template <class T>
class Test
{
public:
    template<class U> void f(); //generic function

    template<> void f<char>(); //Specialization for char.
};

template <class T>
template<class U> 
void Test<T>::f()   //Definition of generic function
{
}

template<>
template<> void Test<char>::f<char>(){}  //Definition of specialization.

int main()
{
    Test<char> ob1;
    ob1.f<char>(); //Works fine.

    Test<int> ob2;
    ob2.f<char>();  //Produces linker error.
}

error LNK2019: unresolved external symbol "public: void __thiscall
Test<int>::f<char>(void)"

我的要求是:我应该能够将任何类型传递给测试类,并将任何类型传递给函数f()。我应该能够使用所有类型的组合,如下所示。

  Test   f()
  --------------
  int    char
  char   int
  int    int

template<>
template<> void Test<int>::f<char>(){}

但是,将测试类作为模板有什么用呢?如何使其适用于所有组合?

3 回复 | 直到 14 年前

vitaut 14 年前

C++ 03,〈7.7.3/2〉:

显式专门化应在其命名空间中声明模板是一个成员,或者对于成员模板,在其命名空间中封闭类或封闭类模板是成员。成员函数、成员类或静态数据的显式专门化类模板是成员。

因此,您应该在类之外声明您的专业化,例如:

template <class T>
class Test
{
public:
    template<class U> void f(); //generic function
};

template <class T>
template <class U> 
void Test<T>::f() {}  //Definition of generic function

template<>
template<>
void Test<char>::f<char>(){}  //Specialization.

int main()
{
    Test<char> ob1;
    ob1.f<char>();

    Test<int> ob2;
    ob2.f<char>();
}

David Rodríguez - dribeas 14 年前

你面临的问题是你已经宣布 f char 在 Test 模板,这是不正确的。编译器没有检测到错误,但它会变得混乱,并解释您希望提供 f型 对于 烧焦 全部的 模板实例化:

template <typename T>
struct Test {
   template <typename U> void f();
   template <> void f<char>();       // <- Incorrect
};

Test<int> 编译器实例化模板,并(错误地)接受它,并中断 f型 烧焦 在里面 测试<int>

只要删除这一行,就可以编译代码了。它将使用专门化仅用于 Test<char>::f<char>() ,我不确定这是否是你想要的。

如果你想专攻 f型 烧焦 具有 全部的

template <typename T>
struct Test {
   template <typename U> void f( U );
   void f( char );
};

不参数)。此外,在您的情况下,必须显式调用模板以区分,显式请求模板的代码不会拾取重载:

int main() {
   Test<int> t;
   t.f<char>(); // will call template, not "void f(char)"!!
}

如果没有更多关于你真正想要实现什么的细节,我就无法思考这个问题的其他潜在解决方案。

Prasoon Saurav 14 年前

我的要求是:我应该能够将任何类型传递给测试类,并将任何类型传递给函数f()。我应该能够使用所有类型的组合,如下所示。

为什么需要明确的专业化?为什么不必要地要使代码复杂化?

以下适用于列出的所有组合。

template <class T>
class Test
{
public:
    template<class U> void f(); 
};

template <class T>
template<class U>
void Test<T>::f(){}   

int main()
{
    Test<char> ob1;
    ob1.f<char>(); //Works fine. T = char, U = char

    Test<int> ob2;
    ob2.f<char>();  //Works fine T = int, U = char
}