C++ Template für die sichere integer CASTET

Können Sie die minimale und maximale sichere Werte (und eine ganze Menge andere Informationen) für jeden fundamentalen Typ auf viel elegantere Weise mit der std::numeric_limits Vorlage, z.B. std::numeric_limits<T>::max(). Sie müssen <limits>.

Referenz: http://www.cplusplus.com/reference/std/limits/numeric_limits/

Ich denke, dass diese Arbeit nun, unabhängig davon, ob Sie Zweierkomplement oder nicht. Bitte ausgiebig testen, bevor Sie es verwenden. Sie geben die folgenden Ergebnisse. Jede Zeile gibt einen assertion-Fehler (nur ändern, in Ausnahmen, wie du willst)

/* unsigned -> signed, overflow */
safe_cast<short>(UINT_MAX);

/* unsigned -> unsigned, overflow */
safe_cast<unsigned char>(ULONG_MAX);

/* signed -> unsigned, overflow */
safe_cast<unsigned long>(-1);

/* signed -> signed, overflow */
safe_cast<signed char>(INT_MAX);

/* always works (no check done) */
safe_cast<long>(INT_MAX);

//giving these assertion failures results
(type)f <= (type)is_signed<To>::v_max
f <= (To)-1
f >= 0
f >= is_signed<To>::v_min && f <= is_signed<To>::v_max

Umsetzung. Zunächst einige Dienstprogramme zu überprüfen, für integer Ränge (Arten mit höheren Rängen werden können, enthalten die Werte der Varianten mit niedrigerem Rang, da Sie das gleiche Vorzeichen. Und einige promotion-tools, um in der Lage sein, um herauszufinden, eine gemeinsame, sichere Typ (das wird nie Ausbeute eine signierte geben, wenn ein vorzeichenloser Typ ist beteiligt, wenn das signed-Typ nicht in der Lage, speichern Sie alle Werte von unsigned eins).

/* ranks */
template<typename> struct int_rank;
#define RANK(T, I) template<> struct int_rank<T> \
    { static int const value = I; }

RANK(char, 1); RANK(unsigned char, 1); RANK(signed char, 1); 
RANK(short, 2); RANK(unsigned short, 2);
RANK(int, 3); RANK(unsigned int, 3);
RANK(long, 4); RANK(unsigned long, 4);
#undef RANK

/* usual arith. conversions for ints (pre-condition: A, B differ) */
template<int> struct uac_at;
template<> struct uac_at<1> { typedef int type; };
template<> struct uac_at<2> { typedef unsigned int type; };
template<> struct uac_at<3> { typedef long type; };
template<> struct uac_at<4> { typedef unsigned long type; };

template<typename A, typename B>
struct uac_type { 
    static char (&f(int))[1];
    static char (&f(unsigned int))[2];
    static char (&f(long))[3];
    static char (&f(unsigned long))[4];
    typedef typename uac_at<sizeof f(0 ? A() : B())>::type type; 
};

/* signed games */
template<typename> struct is_signed { static bool const value = false; };
#define SG(X, TT) template<> struct is_signed<X> { \
    static bool const value = true;                \
    static X const v_min = TT##_MIN;               \
    static X const v_max = TT##_MAX;               \
}

SG(signed char, SCHAR); 
SG(short, SHRT); 
SG(int, INT); 
SG(long, LONG); 
#undef SG

template<> struct is_signed<char> { 
    static bool const value = (CHAR_MIN < 0); 
    static char const v_min = CHAR_MIN; //just in case it's signed...
    static char const v_max = CHAR_MAX;
};

Die Umwandlung von Vorlagen Gebrauch machen, um herauszufinden, für jeden Fall wenn was getan werden muss oder nicht getan.

template<typename To, typename From, 
         bool to_signed = is_signed<To>::value, 
         bool from_signed = is_signed<From>::value,
         bool rank_fine = (int_rank<To>::value >= int_rank<From>::value)>
struct do_conv;

/* these conversions never overflow, like int -> int, 
 * or  int -> long. */
template<typename To, typename From, bool Sign>
struct do_conv<To, From, Sign, Sign, true> {
    static To call(From f) {
        return (To)f; 
    }
};

template<typename To, typename From>
struct do_conv<To, From, false, false, false> {
    static To call(From f) {
        assert(f <= (To)-1);
        return (To)f;
    }
};

template<typename To, typename From>
struct do_conv<To, From, false, true, true> {
    typedef typename uac_type<To, From>::type type;
    static To call(From f) {
        /* no need to check whether To's positive range will
         * store From's positive range: Because the rank is
         * fine, and To is unsigned. 
         * Fixes GCC warning "comparison is always true" */
        assert(f >= 0);
        return (To)f;
    }
};

template<typename To, typename From>
struct do_conv<To, From, false, true, false> {
    typedef typename uac_type<To, From>::type type;
    static To call(From f) {
        assert(f >= 0 && (type)f <= (type)(To)-1);
        return (To)f;
    }
};

template<typename To, typename From, bool Rank>
struct do_conv<To, From, true, false, Rank> {
    typedef typename uac_type<To, From>::type type;
    static To call(From f) {
        assert((type)f <= (type)is_signed<To>::v_max);
        return (To)f;
    }
};

template<typename To, typename From>
struct do_conv<To, From, true, true, false> {
    static To call(From f) {
        assert(f >= is_signed<To>::v_min && f <= is_signed<To>::v_max);
        return (To)f;
    }
};

template<typename To, typename From>
To safe_cast(From f) { return do_conv<To, From>::call(f); }

Bin ich richtig in der Annahme, dass in dem Fall, dass R unterzeichnet ist, können Sie versuchen, zu füllen, rMax mit all 1s, außer für das Letzte Stück? Wenn das der Fall ist, dann sollten Sie 0x80 (1000 0000) anstelle von 0x10 (0001 0000).

Es auch nicht Aussehen, Ihre Funktion unterstützt negative zahlen für die Quelle.

Edit:

Hier ist eine leicht bearbeitete version, die ich getestet habe für die Umwandlung von ints in chars:

template< typename T, typename R >
void safe_cast( const T& source, R& result )
{
    //get the maximum safe value of type R
    R rMax = (R) ~0;
    if ( rMax < 0 ) //R is a signed type
    {
        //assume that we're on an 8-bit twos-compliment machine
    rMax = ( 0x80 << ( ( sizeof( R ) - 1 ) * 8 ) );
    if(source >= 0)
        rMax = ~rMax;
    }

    if ( (source >= 0 && ( source & rMax  ) != source) || (source < 0 && (source & rMax) != rMax) )
    {
        throw new IntegerOverflowException( source );
    }

    result = static_cast<R>( source );
}

Edit: Fehler behoben.

Ich muss etwas fehlen, ist aber nicht das, was Sie wollen?:

//using a more cast-like prototype, if I may:
template<class to, class from> inline
to safe_cast(from f)
{
   to t = static_cast<to>(f);
   if ( t != f ) throw whatever; //no new!
   return t;
}