Шаблонные чистые виртуальные методы

    template <typename T, class = typename std::enable_if<std::is_integral<T>::value>::type> class AbstractIntergal {
    public:
        typedef T value_type;
        value_type value;
        AbstractIntergal() : value(0) {}
 
        AbstractIntergal(value_type src) : value(src) { }
 
        virtual template <class Chr, class Alloc> std::basic_string<Chr, std::char_traits<Chr>, Alloc> toString() = 0;
    };

    class Int32 : public AbstractIntergal<__int32> {
    public:
        Int32() : AbstractIntergal()    {};
 
        Int32(value_type src) : AbstractIntergal(src)   {};
 
        template <class Chr, class Alloc> std::basic_string<Chr, std::char_traits<Chr>, Alloc> toString() {
            char buff[10];
            sprintf(buff, "%d", value);
            return std::basic_string<Chr, std::char_traits<Chr>, Alloc>(buff);
        }
    };

template <typename T, class = typename std::enable_if<std::is_integral<T>::value>::type>
class AbstractIntergal
{
public:
    typedef T value_type;
    value_type value;
    AbstractIntergal() : value(0) {}
 
    AbstractIntergal(value_type src) : value(src) { }
 
    template <class Chr, class Alloc>
    std::basic_string<Chr, std::char_traits<Chr>, Alloc> toString()
    {
        Chr buf[PossibleStringSize<T>::value + 1];
        if(size_t len = toStringInternal(buf, sizeof(buf)/sizeof(*buf))
        {
            return std::basic_string<Chr, std::char_traits<Chr>, Alloc>(buf, len);
        }
        return std::basic_string<Chr, std::char_traits<Chr>, Alloc>();
    }
 
protected:
    virtual size_t toStringInternal(char * buf, size_t len) = 0;
    virtual size_t toStringInternal(wchar_t * buf, size_t len) = 0;
};

        template<class T> struct PossibleStringSize
        {
    //      static const unsigned value = max_digits_impl<T, std::numeric_limits<T>::max()>::value;
        // vs 2012 не поддерживает constexpr, на 13 потом попробую так
            static const unsigned value = max_digits_impl<T, 2000000>::value; 
            //искулючительно для теста и упрощения
        };
 
        template <typename T, T Number> struct max_digits_impl
        {
            static const unsigned value = max_digits_impl<T, Number / 10>::value + 1;
        };
 
        template <typename T> struct max_digits_impl<T, 0> 
        {
            static const unsigned value = 0;
        };

static const unsigned int value = 0;

int main()
{
    unsigned i = 0;
    i++;
    cout <<i<< endl;
    system("pause");
}

template <typename T, T Number> struct max_digits_impl
{
    static const unsigned value = max_digits_impl<T, Number / 10>::value + 1;
};
 
template <typename T> struct max_digits_impl<T, T()> 
{
    static const unsigned value = 0;
};

template <typename T, T Number, bool Exit = Number == 0>
struct max_digits_impl
{
    static const unsigned value = max_digits_impl<T, Number / 10>::value + 1;
};
 
template <typename T, T Number>
struct max_digits_impl<T, Number, true>
{
    static const unsigned value = 0;
};