C++ 在类模板中调用模板函子

有没有办法调用类模板

Foo

的functor

operator（）（int）

，如下所示（）

模板
结构Foo
{
模板
void运算符（）（int）
{
}
};
int main（int argc，char*argv[]）
{
富富,；
傅(42),；
}

我在gcc 4.9.3中得到了错误消息

error: expected primary-expression before ‘bool’
  foo<bool>( 42 );

错误：“bool”之前应为主表达式
傅(42),；

如果成员函数不是一个函子，并且前缀是

：

，

，或者

->

，我会在函子前面加上

模板。如果没有一些帮助，编译器就不知道如何解析这个表达式；作为functor或类型为
foo
的匿名对象的实例化是的，但它很难看：

foo.operator()<bool>( 42 );

foo.operator（）（42）；
不幸的是，您需要使用
foo.operator（）（42）用于此
foo
对C++14变量模板之类的东西有效，而不是模板调用运算符

您可以做的是标记类型，并将其作为参数传递给call运算符，以推断正确的类型：

//tag
template <typename T>
struct type{};

template<typename T>
struct Foo
{
    template<typename U>
    //deduction on the tagged type
    void operator()( type<U>, int )
    {
    }
};

int main(int argc, char *argv[])
{
    Foo<char> foo;
    foo( type<bool>{}, 42 );
    //   ^^^^^^^^^^^^ pass tag
}

//标记
模板
结构类型{}；
模板
结构Foo
{
模板
//关于标记类型的演绎
void运算符（）（类型，int）
{
}
};
int main（int argc，char*argv[]）
{
富富,；
foo（类型{}，42）；
//^^^^^^^^^^^^^^通过标记
}

您可以使用C++14变量模板为标记创建更好的标记：

template <typename T>
struct type_t{};

//variable template for nicer usage
template <typename T>
type_t<T> type;

template<typename T>
struct Foo
{
    template<typename U>
    void operator()( type_t<U>, int )
    {
    }
};

int main(int argc, char *argv[])
{
    Foo<char> foo;
    foo( type<bool>, 42 );
    //don't need {}^
}

模板
结构类型_t{}；
//变量模板，以便更好地使用
模板
类型\u t类型；
模板
结构Foo
{
模板
void运算符（）（类型为int）
{
}
};
int main（int argc，char*argv[]）
{
富富,；
foo（42型）；
//不需要{}^
}
它可以使用

foo.operator()<bool>( 42 );

或者仅仅是成员函数

template<typename U>
void my_func( int )
{
}
// called as...

foo.my_fun<bool>( 42 );

模板
作废我的函数（int）
{
}
//被称为。。。
福美芬（42）；
“运算符最适合推断模板参数类型”——值得记住。不过我遗漏了
&&
。@Olumide。使用
U&&
参数的目的是，如果类型比原语更复杂，则可以使用
std:：move
，或者
U&&
也可以绑定到临时类型。一个简单的
U
也可以。这个问题在
c++17
中仍然存在吗？@ar2015不确定模板推导指南是否会起作用，我还没有真正的理由经常使用它们。或者它们是否可用于运算符。
template<typename U>
void operator()( int, U&& /*initial*/ )
{
  // use the initial value of U
}
// called as...

foo(42, true); // U is bool in your example

template<typename U>
void my_func( int )
{
}
// called as...

foo.my_fun<bool>( 42 );