[英]Function template overloading - partial specialization
我有两个遵循类似模式的类:
oo
// header guard here
class Foo {
public:
Foo() = delete;
static foo1& getFoo1( Param a, Param b, Param c ) {
// code...
}
static foo2& getFoo2( Param a, Param b, Param c ) {
// code...
}
// generic function to return appropriate Foo Type based on template argument
template<class FooType>
static FooType& getFoo( Param a, Param b, Param c );
};
#endif
Foo.cpp
#include <Foo.h>
// specializations of getFoo() for each type
template<>
foo1& Foo::getFoo( Param a, Param b, Param c ) {
return getFoo1( a, b, c );
}
template<>
foo2& Foo::getFoo( Param a, Param b, Param c ) {
return getFoo2( a, b, c );
}
上面的Foo编译就好了。 另一方面, Bar
具有与上面的Foo
类似的结构或样式; 唯一的区别是它是静态的getBar1()
, getBar2()
等不只是普通的函数; 它们是功能模板。
Bar.h
// header guard
class Bar {
public:
Bar() = delete;
template<class IntType = int>
static bar1<IntType>& getBar1( IntType a, IntType b ) {
// code...
}
template<class RealType = double>
static bar2<RealType>& getBar2( RealType a, RealType b ) {
// code...
}
template<class IntType = int>
static bar3<IntType>& getBar3( IntType a ) {
// code...
}
template<class RealType = double>
static bar4<RealType>& getBar4( RealType a ) {
// code...
}
// ...
template<class RealType = double>
static bar12<RealType>& getBar12() {
// code...
}
template<class RealType = double, class A, class B>
static bar12&<RealType>& getBar12( A a1, A a2, B b1 ) {
// code...
}
template<class RealType = double, class X>
static bar12&<RealType>& getBar12( std::initialize_list<double> list, X x ) {
// code...
}
template<class RealType = double, class X>
static bar12&<RealType>& getBar12( std::size_t size, RealType a, RealType b, X x ) {
// code..
}
// Here is where I start to get into problems:
// I'm trying to do something similar to what I've done above in Foo for a generic function template.
template<typename Type, template<typename> class BarType, class... FuncParams>
static BarType<Type>& getBar( FuncParams... params );
};
#endif
Bar.cpp
#include "Bar.h"
// specializations of getBar() for each type
template<typename Type, class... FuncParams>
bar1<Type>& Bar::getBar( FuncParams... params ) {
return getBar1( params... );
}
template<typename Type, class... FuncParms>
bar2<Type>& Bar::getBar( FuncParams... params ) {
return getBar2( params... );
}
为什么当我开始添加作为类模板的类类型时为什么? 一切似乎都坏了。 上面的第一个类编译并返回适当的Foo
。 但是,在第二个类Bar
我不断收到函数定义与现有声明不匹配的编译器错误。
这个问题与这里的问题有关: 使用可变参数参数化和/或重载成员函数模板
这个问题专门针对为何一个人编译而另一个人不编译的问题。
上面的第一个类编译并返回适当的
Foo
是的,因为
template<>
foo1& Foo::getFoo( Param a, Param b, Param c ) {
return getFoo1( a, b, c );
}
这是模板方法getFoo()
的完全专业化
template<class FooType>
static FooType& getFoo( Param a, Param b, Param c );
FooType
类型固定为foo1
。
您可以对模板功能(或方法)进行完全专业化。
但是,在第二个类
Bar
我不断收到函数定义与现有声明不匹配的编译器错误。
当然。
因为您正在尝试部分专门化模板方法getBar()
template<typename Type, template<typename> class BarType, class... FuncParams>
static BarType<Type>& getBar( FuncParams... params );
将BarType
固定到bar1
template<typename Type, class... FuncParams>
bar1<Type>& Bar::getBar( FuncParams... params ) {
return {};//getBar1( params... );
}
但是您不能部分专门化模板功能/方法。 该语言禁止使用。
如果您想要类似的东西,则必须通过结构(或类)的部分专业化。
-编辑-
OP问
您说过:“您必须经历struct(或类)的部分专业化。” 好的; 因此,有一个解决方法:您能否提供一个小的基本示例?
有很多方法可以使用结构(类)的部分专业化来绕过函数/方法的非部分专业化限制。
在下面的基本示例中,我提出了带有模板func()
方法的模板foo
结构。 foo
的单个模板参数是func()
返回的类型; func()
的可变参数模板类型列表是参数类型的列表。
但是您可以以不同模式玩此游戏。
#include <iostream>
template <typename>
struct bar1
{ template <typename ... Args> bar1 (Args && ...) { } };
template <typename>
struct bar2
{ template <typename ... Args> bar2 (Args && ...) { } };
template <typename>
struct foo;
template <typename T>
struct foo<bar1<T>>
{
template <typename ... Args>
static bar1<T> func (Args && ... as)
{ return { std::forward<Args>(as)... }; }
};
template <typename T>
struct foo<bar2<T>>
{
template <typename ... Args>
static bar2<T> func (Args && ... as)
{ return { std::forward<Args>(as)... }; }
};
int main()
{
foo<bar1<int>>::func(1, "two", 3.0);
foo<bar2<long>>::func(4.0f, "five", 6L);
}
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.