use of undefined template type

Question

In the following code

template<unsigned bits_count, typename ut_t, typename udt_t, template <typename> class meta_t>
struct uint_t
{
    typedef uint_t<bits_count, ut_t, udt_t, meta_t> t;

    typedef ut_t     ut; 
    typedef udt_t   udt; 

    typedef meta_t<t> meta;

    ut comp[meta::array_count];
};

namespace mxi
{

template<typename type>
struct basic_info
{
    static const bool is_native = true;
    static const bool is_signed = (type(-1) < type(0));

    static const int num_of_bytes = sizeof(type);
    static const int num_of_bits = sizeof(type) * 8;
};

template<unsigned bits_count, typename ut_t, typename udt_t, template <typename> class meta_t>
struct basic_info< uint_t<bits_count, ut_t, udt_t, meta_t> >
{
    static const bool is_native = false;
    static const bool is_signed = false;

    static const int num_of_bytes = bits_count / 8;
    static const int num_of_bits = bits_count;
};

template<typename t>
struct isizeof
{
    static const int value = sizeof(t) * 8;
};

template<typename t>
struct num_of_dec_digits_in_type
{
    static const int value = int(isizeof<t>::value * 0.301f);
};

template <typename type>
struct default_meta
{
    static const int array_count = basic_info<type>::num_of_bits / isizeof<typename type::ut>::value;

    static const int dec_digits_count = num_of_dec_digits_in_type<type>::value;
};

}

int main()
{
    typedef uint_t<128, unsigned short int, unsigned int, mxi::default_meta> uint128_t;

    int a = uint128_t::meta::dec_digits_count;

    int b = mxi::num_of_dec_digits_in_type<uint128_t>::value;
}

GCC 4.8.1 compiles without problem, but Visual C++ 2008 SP1 compile with the following error:

line (40): error C2027: use of undefined type 'uint_t<bits_count,ut_t,udt_t,meta_t>'
    with
    [
        bits_count=128,
        ut_t=unsigned short,
        udt_t=unsigned int,
        meta_t=mxi::default_meta
    ]
    line(46) : see reference to class template instantiation 'mxi::isizeof<t>' being compiled
    with
    [
        t=uint_t<128,unsigned short,unsigned int,mxi::default_meta>
    ]
    line(54) : see reference to class template instantiation 'mxi::num_of_dec_digits_in_type<t>' being compiled
    with
    [
        t=uint_t<128,unsigned short,unsigned int,mxi::default_meta>
    ]
    line(11) : see reference to class template instantiation 'mxi::default_meta<type>' being compiled
    with
    [
        type=uint_t<128,unsigned short,unsigned int,mxi::default_meta>
    ]
    line(63) : see reference to class template instantiation 'uint_t<bits_count,ut_t,udt_t,meta_t>' being compiled
    with
    [
        bits_count=128,
        ut_t=unsigned short,
        udt_t=unsigned int,
        meta_t=mxi::default_meta
    ]

How uint_t is not defined when it's the first type defined in the file?

Note: I've stripped a lot of code to the only parts with error, i.e. most numbers here are computed at compile time, but I used them here directly to keep focus in the problem

Answer 1

Well I didn't understand why the type is not complete when I'm using a complete type - i.e. uint128_t - but i was able to find two solutions:

1- In num_of_dec_digits_in_type replace isizeof<t>::value with basic_info<t>::num_of_bits and that will do it.

2- Create new type num_of_dec_digits_in_type_size and use it instead of num_of_dec_digits_in_type:

template<int size>
struct num_of_dec_digits_in_type_size
{
    static const int value = int(size * 0.301f);
};

template <typename type>
struct default_meta
{
    .
    .

    static const int dec_digits_count = num_of_dec_digits_in_type_size< basic_info<type>::num_of_bits >::value;
};

The 2nd solution is a just a modification of the 1st solution.