Специализация шаблона оператора конверсии

Здесь в значительной степени академическое упражнение в понимании операторов преобразования, шаблонов и специализированных шаблонов. Шаблон оператора преобразования в следующем коде работает для int, float и double, но сбой при использовании с std::string... своего рода. Я создал специализацию преобразования в std::string, которая работает при использовании с инициализацией std::string s = a;, но сбой при использовании с литой static_cast<std::string>(a).

#include <iostream>
#include <string>
#include <sstream>

class MyClass {
     int y;
public:
    MyClass(int v) : y(v) {}
    template <typename T>
    operator T() { return y; };
};

template<>
MyClass::operator std::string() {
    std::stringstream ss;
    ss << y << " bottles of beer.";
    return ss.str();
}

int main () {
    MyClass a(99);
    int i    = a;
    float f  = a;
    double d = a;
    std::string s = a;

    std::cerr << static_cast<int>(a) << std::endl;
    std::cerr << static_cast<float>(a) << std::endl;
    std::cerr << static_cast<double>(a) << std::endl;
    std::cerr << static_cast<std::string>(a) << std::endl; // Compiler error
}

Вышеприведенный код генерирует ошибку компилятора в g++ и icc, и они жалуются, что никакое пользовательское преобразование не подходит для преобразования экземпляра MyClass в std::string в static_cast (приведения в стиле C ведут себя одинаково).

Если я заменил вышеприведенный код явными, нетературными версиями оператора преобразования, все будет счастливым:

class MyClass {
    int y;
public:
    MyClass(int v) : y(v) {}
    operator double() {return y;}
    operator float()  {return y;}
    operator int()    {return y;}
    operator std::string() {
        std::stringstream ss;
        ss << y << " bottles of beer.";
        return ss.str();
    }
};

Что не так с моей специализацией шаблона для std::string? Почему он работает для инициализации, но не выполняет листинг?

Update:

После некоторого шаблона wizardry by @luc-danton (метапрограммные трюки, которых я раньше не видел), у меня есть следующий код, работающий в g++ 4.4.5 после включения экспериментальных расширений С++ 0x. Помимо ужаса того, что делается здесь, требуя экспериментальных параметров компилятора, достаточно разумно один, чтобы не делать это. Несмотря на это, это, как мы надеемся, является образовательным для других, как и для меня:

class MyClass {
    int y;
public:
    MyClass(int v) : y(v) {}

    operator std::string() { return "nobody"; }

    template <
        typename T
        , typename Decayed = typename std::decay<T>::type
        , typename NotUsed = typename std::enable_if<
            !std::is_same<const char*, Decayed>::value &&
            !std::is_same<std::allocator<char>, Decayed>::value &&
            !std::is_same<std::initializer_list<char>, Decayed>::value
          >::type
    >
    operator T() { return y; }
};

Это, по-видимому, вынуждает компилятор выбрать преобразование operator std::string() для std::string, которое проходит мимо какой-либо двусмысленности, с которой сталкивался компилятор.

Ответы

std::string t(a);

template <
    typename T
    , typename Decayed = typename std::decay<T>::type
    , typename = typename std::enable_if<
        !std::is_same<
            const char*
            , Decayed
        >::value
        && !std::is_same<
            std::allocator<char>
            , Decayed
        >::value
        && !std::is_same<
            std::initializer_list<char>
            , Decayed
        >::value
    >::type
>
operator T();