оператор кастинга и частичная специализация

Question

Я хочу шаблонизировать оператор приведения со специализацией для bool, но он не работает.

template<typename T> //Don't know if the fact that C is templated itself is relevant here
class C
{ 
...
        template<typename U> operator U() const { return another_namespace::MyCast<U>(*this); }
        template<> operator bool() const { return IsValid(); } 
};

Это дает мне (g ++ 4.6)

явная специализация в не-namespace scope 'class C '

Теперь просто

operator bool() const { return IsValid(); }

само по себе работает, как и MyCast (это функция друга, объявленная во внешнем пространстве имен).Есть ли какой-нибудь способ, которым я могу получить намеченный бехавиор здесь?

Редактировать: впоследствии я нашел этот , похоже на тот же основной вопрос, однако ответ (который дает очень сложное решение)выглядит разработан специально для струн.Кроме того, проблема оказалась неоднозначной, которая, я думаю, здесь не проблема - я получаю совершенно другое сообщение об ошибке компилятора.

Answer 1

Вы можете перегружать операторы преобразования, поэтому просто используйте не шаблонную версию operator bool():

template<typename T>
class C
{ 
...
        template<typename U> operator U() const { ... }
        operator bool() const { ... } 
};

Answer 2

Я пытался специализировать шаблон оператора приведения типа, и у меня возникла та же проблема, когда я определил специализацию внутри определения класса. Но когда я вышел на улицу, это сработало как шарм!

Пример определения:

struct A {
  int i;
  A(int v) : i(v) { 
    cout << __PRETTY_FUNCTION__ << endl; 
  }
  template <typename T>
  operator T() { 
    cout << __PRETTY_FUNCTION__ << " - NOT IMPLEMENTED" << endl; 
    throw; 
    return 0;
  }

  // Compilation error
  // error: explicit specialization in non-namespace scope ‘struct A’
  //template <>
  //operator double() { 
  //  cout << __PRETTY_FUNCTION__ << " - !!! IMPLEMENTED" << endl; 
  //  return (double)i; 
  //}
};
// But this works well!!
template <>
A::operator double() { 
  cout << __PRETTY_FUNCTION__ << " - !!! IMPLEMENTED" << endl; 
  return (double)i; 
}

Пример main:

A a(5);
double d = a;
long l = a;

Выход:

A::A(int)
A::operator T() [with T = double] - !!! IMPLEMENTED
A::operator T() [with T = long int] - NOT IMPLEMENTED
terminate called without an active exception

Протестировано: g ++ (Debian 4.7.2-5) 4.7.2 без каких-либо дополнительных аргументов.

Я тоже попробую под более старым g ++ ...