如何解决了解简单？C ++部分模板专门化
|| 注意：这似乎是一个问题的转贴：C ++-重载了模板化的类方法，并且对该方法进行了部分规范化 我将C ++模板专业化遇到的问题归结为一个简单的案例。 它由一个简单的2参数模板类ѭ0组成，我想专门介绍ѭ1来表示B=int
#include <cstdio>
//
// A 3-parameter template class.
//
template <class A,class B>
class Thing
{
public:
Thing(A a,B b) : a_(a),b_(b) {}
B doSomething();
private:
A a_;
B b_;
};
//
// The generic case works as expected.
//
template <class A,class B>
B Thing<A,B>::doSomething()
{
return b_;
}
//
// This specialization does not work!
//
template <class A>
int Thing<A,int>::doSomething()
{
return b_+1;
}
int main( int argc,char** argv )
{
// Setup our thing.
Thing<double,int> thing(1.0,2);
// This doesn\'t compile - but works with the generic case.
printf(\"Expecting 3,and getting %i\\n\",thing.doSomething());
// Clean up.
return 0;
}
g++
partial_specialization.cpp:30: error: invalid use of incomplete type ‘class Thing<A,int>’
partial_specialization.cpp:8: error: declaration of ‘class Thing<A,int>’
clang++
partial_specialization.cpp:30:19: error: nested name specifier \'Thing<A,int>::\' for declaration does not
refer into a class,class template or class template partial specialization
int Thing<A,int>::doSomething()
~~~~~~~~~~~~~~^
partial_specialization.cpp:32:12: error: use of undeclared identifier \'b_\'
return b_+1;
^
2 errors generated.
Thing
template< class T >
inline T foo( T const & v ) { return v; }
template<>
inline int foo( int const & v ) { return v+1; }
//
// The generic case works as expected.
//
template <class A,B>::doSomething()
{
return foo(b_);
}
解决方法
标准不允许对功能模板进行部分专业化，无论是成员功能模板还是独立功能模板：
template<typename T,typename U> void f() {} //okay - primary template
template<typename T> void f<T,int>() {} //error - partial specialization
template<> void f<unsigned char,int>() {} //okay - full specialization
template <class A>
class Thing<A,int> //partial specialization of the class template
{
//..
int doSomething();
};
template <class A>
int Thing<A,int>::doSomething() { /* do whatever you want to do here */ }
template <class A>
int Thing<A,double>::doSomething(); //error
template <class B>
B doTheActualSomething(B & b) { return b; }
template <>
int doTheActualSomething<int>(int & b) { return b + 1; }
doSomething()
template <class A,class B>
B Thing<A,B>::doSomething() { return doTheActualSomething<B>(b_); }
doTheActualSomething
b_
B
int
doTheActualSomething
template<typename A,typename B>
struct Worker
{
B doTheActualSomething(Thing<A,B> *thing)
{
return thing->b_;
}
};
//partial specialization of the class template itself,for B = int
template<typename A>
struct Worker<A,int>
{
int doTheActualSomething(Thing<A,int> *thing)
{
return thing->b_ + 1;
}
};
thing
Thing
//forward class template declaration
template<typename T,typename U> struct Worker
template <class A,class B>
class Thing
{
template<typename T,typename U> friend struct Worker; //make it friend
//...
};
template <class A,B>::doSomething()
{
return Worker<A,B>::doTheActualSomething(this); //delegate work
}
this
Thing<A,B>
Worker<T,U>
Worker
Thing
template <class A,class B>
class Thing
{
friend struct Worker<A,B>; //make it friend
//...
};
Worker
Thing
Worker<A,B>
Thing<A,B>
Worker<A,B>
Thing<A,C>
template<typename A,typename B>
struct TwoTypes { };
template<typename A,typename B>
struct X {
/* forwards ... */
void f() { fImpl(TwoTypes<A,B>()); }
/* special overload for <A,int> */
template<typename A1>
void fImpl(TwoTypes<A1,int>) {
/* ... */
}
/* generic */
template<typename A1,typename B1>
void fImpl(TwoTypes<A1,B1>) {
/* ... */
}
};
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。