c++ - 嵌套名称说明符中使用的不完整类型，为什么？

Question

下面的代码是固定长度算术类型的一部分，我尽可能地减少它只包含问题。

namespace MathX
{
typedef signed int    int32;
typedef unsigned int uint32;

typedef signed long long    int64;
typedef unsigned long long uint64;

typedef uint32 mathx_ucomp;
typedef  int32 mathx_scomp;
typedef uint64 mathx_udcomp;
typedef  int64 mathx_sdcomp;

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

template<uint64 val>
struct is_power_of_2
{
    static const bool value = !(val & (val - 1u));
};

enum type_classes { tc_native,  tc_custom };

enum type_ids { ti_basic_int, ti_basic_float, ti_int_t, ti_uint_t, ti_float_t };

template <typename t>
struct basic_info
{
    static const bool is_signed = (t(-1) == -1);
    static const bool is_integer = (t(3.14) != 3.14);
    static const uint32 num_of_bits = sizeof_ex<t>::value;
    static const uint32 comp_bits = num_of_bits;
    static const type_classes type_class = tc_native;
    static const type_ids type_id = is_integer? ti_basic_int: ti_basic_float;
};

template<typename t>
struct global_int
{
    static const t zero;   
    static const t one;    
    static const t mone;   
    static const t minval; 
    static const t maxval; 

    static const uint32 full_t = is_power_of_2<basic_info<t>::num_of_bits>::value? basic_info<t>::num_of_bits: 0u;
    static const uint32 used_t = full_t - int32(basic_info<t>::type_id == ti_int_t);
    static const bool   sign_t = (full_t != used_t);
    static const uint32 half_t = full_t >> 1u;
    static const uint32 comp_b = is_power_of_2<basic_info<t>::comp_bits>::value? basic_info<t>::comp_bits: 0;
    static const uint32 comp_d = comp_b << 1u;
    static const uint32 comp_c = full_t / comp_b;
};

template<typename t> const t global_int<t>::zero = t(0u);
template<typename t> const t global_int<t>::one  = t(1u);
template<typename t> const t global_int<t>::mone = t(-1);
template<typename t> const t global_int<t>::minval = t(global_int<t>::sign_t? (typename t::ucomp)1 << (global_int<t>::comp_b - 1): 0, 0);
template<typename t> const t global_int<t>::maxval = t(global_int<t>::sign_t? (typename t::ucomp)~0 >> 1: (typename t::ucomp)~0, (typename t::ucomp)~0);

template <uint32 bit_count, typename ut, typename st, typename udt, typename sdt> struct int_t;

template <uint32 bit_count, typename ut, typename st, typename udt, typename sdt>
struct basic_info< int_t<bit_count, ut, st, udt, sdt> >
{
    static const bool is_signed = true;
    static const bool is_integer = true;
    static const uint32 num_of_bits = bit_count;
    static const uint32 comp_bits = sizeof_ex<ut>::value;
    static const type_classes type_class = tc_custom;
    static const type_ids type_id = ti_int_t;
};

template <typename t>
inline void mathx_int_setn(t* me)
{
    for (uint32 i=0; i < global_int<t>::comp_c; ++i) me->comp[i] = (typename t::ucomp)-1;
}


template <typename t>
inline void mathx_int_setz(t* me)
{
    for (uint32 i=0; i < global_int<t>::comp_c; ++i) me->comp[i] = 0;
}

template <typename t, typename u>
inline void mathx_int_iTt(t* me, const u& value)
{
    if (sizeof(t) > sizeof(u))
    {
        if (basic_info<u>::is_signed && ((basic_info<u>::type_id != ti_basic_int && value < global_int<u>::zero) || value < 0))
            mathx_int_setn<t>(me);
        else
            mathx_int_setz<t>(me);

        *(u*)me->comp = value;

        return;
    }

    *me = *(t*)&value;
}

template <typename t>
inline void mathx_int_init(t* me, typename t::ucomp hi, typename t::ucomp rest)
{
    typedef global_int<t> gint;
    for (uint32 i=0; i<gint::comp_c-1; ++i) me->comp[i] = rest;
    me->comp[gint::comp_c-1]=hi;
}

template <uint32 bit_count, typename ut, typename st, typename udt, typename sdt>
struct int_t
{
    typedef ut  ucomp;
    typedef st  scomp;
    typedef udt udcomp;
    typedef sdt sdcomp;

    typedef int_t<bit_count, ut, st, udt, sdt> t;
    typedef global_int<t> gint;

    ut comp[gint::comp_c];

    int_t() {}

    int_t(ut hi, ut rest) { mathx_int_init<t>(this, hi, rest); }

    template<typename u>
    int_t(const u& value)
    {
        if (basic_info<u>::is_integer)
            mathx_int_iTt<t, u>(this, value);
    }
};

typedef int_t<128, mathx_ucomp, mathx_scomp, mathx_udcomp, mathx_sdcomp > int128;

}

在编译下一行时用前面的代码，编译没有问题:

int main()
{
   MahtX::int128 q = 1024;
}

现在我想添加对 numeric_limits 的支持类所以我添加了以下代码(这是类的一部分):

#include <limits>
namespace std
{
    using namespace ::MathX;

    template < uint32 bit_count, typename ut, typename st, typename udt, typename sdt>
    class numeric_limits< int_t< bit_count, ut, st, udt, sdt > >
    {
    public:
        typedef int_t< bit_count, ut, st, udt, sdt > t;
        typedef global_int<t> gint;

        static const bool is_specialized = true;
        static t min() throw() { return gint::minval; }
        static t max() throw()  { return gint::maxval; }
        static const int32 digits = gint::used_t;
        static const int32 digits10 = int32(digits * 0.301f);
        static const bool is_signed = true;
        static const bool is_integer = true;
        static const bool is_exact = true;
        static const int32 radix = 2;
    };
}

编译以下代码时:

int main()
{
    unsigned b = std::numeric_limits< MathX::int128 >::digits10;
}

gcc 编译器产生以下错误: error: incomplete type 'MathX::int_t<128u, unsigned int, int, long long unsigned int, long long int>::gint' used in nested name specifier .

VC++ 编译器产生以下错误:error C2039: 'comp_c' : is not a member of 'MathX::global_int<t>' .

当我删除类型为 t 的变量声明时来自类型 global_int连同他们的定义，代码编译没有问题，但我必须保留这些行，我既不能解决这个问题，也不能找出它发生的原因。

Answer 1

根据 完整 MSVC10 编译器错误消息:

unsigned b = std::numeric_limits< MathX::int128 >::digits10;

需要实例化:

template < uint32 bit_count, typename ut, typename st, typename udt, typename sdt>
class numeric_limits< int_t< bit_count, ut, st, udt, sdt > >
{
public:
    static const int32 digits = gint::used_t;
    static const int32 digits10 = int32(digits * 0.301f);
}

需要实例化:

template<typename t>
struct global_int
{
    static const uint32 full_t = is_power_of_2<basic_info<t>::num_of_bits>::value? basic_info<t>::num_of_bits: 0u;
    static const uint32 used_t = full_t - int32(basic_info<t>::type_id == ti_int_t);
}

需要实例化:

template <uint32 bit_count, typename ut, typename st, typename udt, typename sdt>
struct int_t
{
    typedef global_int<t> gint;
    ut comp[gint::comp_c];
}

需要实例化:

template<typename t>
struct global_int
{
    static const uint32 full_t = is_power_of_2<basic_info<t>::num_of_bits>::value? basic_info<t>::num_of_bits: 0u;
    static const uint32 comp_b = is_power_of_2<basic_info<t>::comp_bits>::value? basic_info<t>::comp_bits: 0;
    static const uint32 comp_c = full_t / comp_b;
}

所以，global_int<int_t>在 int_t 之前无法实例化被实例化，并且int_t在 global_int<int_t> 之前无法实例化被实例化。这种循环依赖导致它无论如何都会尝试而不加载最里面的 global_int<int_t>。 ，导致不完整的类型错误。

解决方案(显然)是制作 int_t不依赖 global_int<int_t> .

另外，避免 using <namespace>尽可能在 header 中，永远不要在 std 命名空间内执行此操作。这是非法的。