Template Conversion

Question

I have two classes int_t, uint_tboth the type of the signed and unsigned type:

template <typename lo_t> struct uint_t;

template <typename hi_t, typename lo_t>
struct int_t
{
    lo_t lo;
    hi_t hi;

    int_t() : hi(0), lo(0) {}
    int_t(int value) : lo(value), hi(value<0? -1: 0) {}
    int_t(unsigned value) : lo(value), hi(0) {}

    int_t(const uint_t<lo_t>&);

    //template<typename ty_a, typename ty_b> int_t(const int_t<ty_a, ty_b>&);
};

template <typename hi_lo>
struct uint_t
{
    hi_lo lo, hi;

    uint_t() : lo(0), hi(0) {}
    uint_t(int value) : lo(value), hi(value<0? -1: 0) {}
    uint_t(unsigned value) : lo(value), hi(0) {}

    template<typename hi_t>
    uint_t(const int_t<hi_t, hi_lo>& value) : hi(value.hi), lo(value.lo) {}
};

template <typename hi_t, typename lo_t>
int_t<hi_t, lo_t>::int_t(const uint_t<lo_t>& value) : hi(value.hi), lo(value.lo)
{}

Since I want them to work just like built-in types, I defined a conversion operator from one to another so that I can write code like the following and it still works:

typedef  int_t<int, unsigned>  int64;
typedef uint_t<unsigned>      uint64;

int64  a = 1000;
uint64 b = a;

uint64 x = 512;
 int64 y = x;

Now the only problem is converting from a higher or lower precision type int_tto another, so I declared a constructor with comments to do this, but I don’t know what to write in it?

Here is an example that I used to check the result of this constructor:

typedef  int_t<int, unsigned>  int64;
typedef uint_t<unsigned>      uint64;

typedef  int_t<int64, uint64> int128;
typedef uint_t<uint64>       uint128;

int64 a = 1024;
int128 b = a;

int128 x = 100;
int64 y = x;

Answer 1

I decided to answer the Little and Big Endians:

template<typename ty_a, typename ty_b>
int_t(const int_t<ty_a, ty_b>& value)
{
    *this = value < 0? -1: 0;

#ifdef BIG_ENDIAN
        if (sizeof(*this) < sizeof(value))
            *this = *((int_t*)&value.lo + (sizeof(value.lo)/sizeof(*this) - 1));
        else
            *((int_t<ty_a, ty_b>*)&hi + sizeof(*this)/sizeof(value) - 1) = value;
#else
        if (sizeof(*this) < sizeof(value))
            *this = *(int_t*)&value;
        else
            *(int_t<ty_a, ty_b>*)&lo = value;
#endif
}

, int_t

operator== operator<

Answer 2

, . , 0 . .

, . , ? , .