C++如何指定一个类的模板转换运算符的参数

Question

我想指定一个类的模板转换运算符的模板参数，但我似乎无法得到正确的语法。在http://liveworkspace.org/code/35sqXe$4

#include <iostream> 
using namespace std; 

class C 
{ 
    int i_; 
public: 
    C(int i) : i_(i) {} 
    template<int adder> int get() { return i_ + adder; } 
    template<int adder> int operator()() { return i_ + adder; } 
    template<int adder> operator int() { return i_ + adder; } 
    // If I add a default argument to operator int()'s adder template parameter this compiles fine 
    // (of course, I still can't figure out how to specify it...) 
}; 

int main(int, char*[]) 
{ 
    C c(10); 
    cout << c.get<2>() << endl;   // I can specify template argument here the regular way. 
// cout << c() << endl;     // No template argument specified, so I wouldn't have expected this to work. 
    cout << c.operator()<3>() << endl;  // We have to call it this way. 
// cout << (int)c << endl;    // In the same vein I wouldn't expect this to work either. 
    cout << c.operator int<4>() << endl; // But how do I specify template argument here? This seems to be an error for some compilers. 
    return 0; 
}  

相同的代码当与克++ 4.7.2

$ g++ -std=c++11 -Wall -W -pedantic "template conversion operator.cpp" 

Compilation finished with errors: 
source.cpp: In function 'int main(int, char**)': 
source.cpp:23:23: error: 'int' is not a template 
source.cpp:23:30: error: no matching function for call to 'C::operator int()' 
source.cpp:23:30: note: candidate is: 
source.cpp:11:24: note: template<int adder> C::operator int() 
source.cpp:11:24: note: template argument deduction/substitution failed: 
source.cpp:23:30: note: couldn't deduce template parameter 'adder' 

当与G ++ 4.8.0（20130224）

$ g++ -std=c++11 -Wall -W -pedantic "template conversion operator.cpp" 

Compilation finished with errors: 
source.cpp: In function 'int main(int, char**)': 
source.cpp:23:23: error: 'int' is not a template 
    cout << c.operator int<4>() << endl; 
        ^
source.cpp:23:30: error: no matching function for call to 'C::operator int()' 
    cout << c.operator int<4>() << endl; 
          ^
source.cpp:23:30: note: candidate is: 
source.cpp:11:24: note: template<int adder> C::operator int() 
    template<int adder> operator int() { return i_ + adder; } 
         ^
source.cpp:11:24: note: template argument deduction/substitution failed: 
source.cpp:23:30: note: couldn't deduce template parameter 'adder' 
    cout << c.operator int<4>() << endl; 
          ^

当与编译铛++编译编译3.2

$ clang++ -std=c++11 -Wall -W -pedantic "template conversion operator.cpp" 

Compilation finished with errors: 
source.cpp:23:12: error: reference to non-static member function must be called 
    cout << c.operator int<4>() << endl; 
      ^~~~~~~~~~~~~~ 
source.cpp:23:30: error: expected expression 
    cout << c.operator int<4>() << endl; 
          ^
2 errors generated. 

当ICC 13.0.1

$ icc -std=c++11 -Wall -W -pedantic "template conversion operator.cpp" 

Compilation finished with warnings: 
source.cpp(11): warning #488: constant "adder" is not used in declaring the parameter types of function template "C::operator int" 
    template<int adder> operator int() { return i_ + adder; } 
       ^

其他编译则警告，国际商会似乎很好地工作。

这些编译器错误？或者它是我的语法问题？

编辑

由于Yakk问我原来的/实际的问题是什么：
我有一个类PTR（模板上它指的类型），我想有一个转换的PTR为constŤ （虽然我知道在这种情况下并不重要），如果T已经是const类型，我希望转换运算符不在那里。由于您没有为转换运算符指定返回类型或方法参数，因此我将enable_if作为方法模板参数的一部分。由于Yakk（和其他问题中的其他人）已发布，简单的template <typename = typename std::enable_if<!std::is_const<T>::value>::type>不起作用，因为当Ptr被实例化时，T在编译器获得此声明时已知。由于没有推导出T不存在SFINAE。由于我们知道!is_const<T>::value是错误的，因此没有“类型”成员，并且声明无效。使模板依赖于新类型（U），推导出U，然后检查U与T相同，并且T不是常量，然后生成无效声明是SFINAE的有效使用，并且可以工作如预期。

template <typename T> 
class Ptr 
{ 
    template <typename U, 
      typename = typename std::enable_if<std::is_same<T, U>::value && 
               !std::is_const<U>::value>::type> 
    operator Ptr<const U>() const { return active; } 
}; 

但后来我对自己说，这是一个模板化的成员函数。那些模板参数不必保留默认值，它们可以由实例化该函数的任何人指定。对于任何其他运算符xxx函数，执行此操作的语法是显而易见的并且有效（请参阅上面的operator（））。对于这个例子：

Ptr<const int> ci; 
ci.operator Ptr<const int><const int, void>(); // assuming this syntax is valid 

空隙（或任何其他类型的有）将指定的转换运算符的第二个模板参数，并将含有enable_if默认将不被考虑。当我试图使它不存在时，这将使这种方法存在。

但是gcc，clang和msvc似乎对这个语法有问题。我假设由于转换运算符拼写为operator typename，因此模板参数会让编译器认为它们是针对typename而不是操作符。

确实有一些解决方法（只包括转换运算符，当T已经是const时不会转换为const T），但这是针对此特定问题的。也许不可能为转换运算符指定模板参数，因此，将这些类型推断/默认是没问题的。或者也许有一个语法（icc似乎把它...），所以我打开自己，以指定模板参数和实例化方法，我不希望他们的用户。我已经为我的具体问题找到了解决方案（在类型确实重要的时候，在转换运算符的类型检查中使用static_assert），但这个问题是关于C++语言及其语法的。顶部的类C只是我想要搜索该语法的最简单方法。

Answer 1

这里有一个问题的答案，你也没问，该怎么办SFINAE enable_if操作上的隐式转换运营商，启用或取决于模板参数类本身禁用它们：

#include <iostream> 
#include <type_traits> 

template<int n> 
struct Foo { 
    template<typename T,typename=typename std::enable_if<std::is_convertible<T,int>::value && (n!=0)>::type> 
    operator T() const { return n; } 
}; 

int main() { 
    Foo<0> zero; 
    Foo<1> one; 
    int x = 0; 
    x = one; 
    int y = 0; 
    // y = zero; -- does not compile, because Foo<0> cannot be converted to int 
    std::cout << x << "," << y << "\n"; 
} 

这并不完美，因为is_convertible意味着我们生成了大量的隐式类型转换，但它相对接近。

这里是如何模板参数传递给铸造运营商，或者至少一种方式接近它：

template<int n> 
struct int_wrapper { 
    int i; 
    operator int() const { return i; } 
    int_wrapper(int i_):i(i_) {} 
}; 
// in class C: 
template<int adder> operator int_wrapper<adder>() { return i_ + adder; } 

在这里，我已经创建了一个玩具式int_wrapper其打包int参数。这个int参数完全没有用，除了允许显式地将模板参数传递给operator int_wrapper<n>。虽然返回int_wrapper<...>不是int的完美替代品，但它非常接近。

Answer 2

你试图达到的目标有点不清楚......真的没有什么理由让所有这些成员函数成为一般的模板，你可以使它们以adder为参数的常规函数​​。

的get功能，很好，并没有真正得到，而是增加，所以你可以把它叫做add。函数调用运算符operator()()很可能以int为参数。转换运算符为int从字面上看没有意义作为模板，并且不能像定义的那样调用。如果你坚持具有get和operator()为模板，你可以打电话给他们：

C c(0); 
c.get<5>(); // 5 
c<5>();  // 5 

但我建议你重新设计，决定你真正需要和模板是否要走的路... （请注意，即使是在非模板的版本，它并没有真正意义的有转化为int，需要一个值，你是不是转换，但创建一个不同的int！）