Die überprüfung, ob eine Eingabe innerhalb der Vielzahl von limits in C++

Ich brauche, um mehrere Funktionen, die prüfen, ob eine Eingabe gültig ist oder nicht.
Hier sind meine codes:

bool IsValidRange(signed char s)
{
    bool isValid = true;
    if (!((s>=SCHAR_MIN)&&(s<=SCHAR_MAX)))
    {
        isValid = false;
    }
    return isValid;
}

bool IsValidRange(int s)
{
    bool isValid = true;
    if (!((s>=INT_MIN)&&(s<=INT_MAX)))
    {
        isValid = false;
    }
    return isValid;
}

Bin ich mit dem header limits.h für diese. Mache ich das der richtige Weg? Bitte beachten Sie, dass ich bin nur ein Anfänger. Ich hoffe, Sie alle werden verstehen. Danke!

Diese Funktionen können niemals den Wert false zurück. Per definition, eine int kann niemals fallen, die außerhalb des Bereichs INT_MIN:INT_MAX. Auch return v >= min && v <= max; Keine Notwendigkeit für so viele Linien.
Gibt es eine Möglichkeit, kann ich dies erreichen? Ich werde versuchen, Ihren code. Danke!
Gut, darüber nachzudenken. Wie könnte eine int-fallen möglicherweise außerhalb INT_MIN-INT_MAX? Welche Nummer wäre das genau? Diese Konstanten repräsentieren die unteren und oberen Grenzen der int.
Argh, sieht aus wie Sie mich zu schlagen um gut 2 Minuten. Ich hasse so langsam am schreiben Englisch. 🙁
Gut, das ist der falsche Weg, es zu tun. Der integral-Wert des Zeichens ! ist innerhalb des Bereichs von int. Hast du falsch verstanden die Abtretung mitteilt. Sie möchten eine is_numeric(char) Art-Funktion oder die Sie überprüfen möchten, einen kleineren Bereich.

InformationsquelleAutor Christian Mark Ramos Godoy | 2013-09-05

  1. 5

    dem obigen template wird nicht funktionieren, für die Mischung von signed-und unsigned-Typen, zusätzlich zu den Schwimmern.

    template<typename RangeType, typename ValueType >
bool IsInRange( ValueType value ) 
{
    if( ! numeric_limits<RangeType>::is_integer )
    {
        return  (value > 0 ? value  : -value) <= numeric_limits<RangeType>::max(); 
    }

    if ( numeric_limits<RangeType>::is_signed == 
         numeric_limits<ValueType>::is_signed )
    {
        return value >= numeric_limits<RangeType>::min() &&
               value <= numeric_limits<RangeType>::max();
    }
    else if( numeric_limits<RangeType>::is_signed )
    {
        return value <= numeric_limits<RangeType>::max();
    }
    else
    {
        return value >= 0 && value <=  numeric_limits<RangeType>::max();
    }
}
    Schön! Vielleicht unter die ersten if, die return - Anweisung erweitert werden soll, mit || (std::isinf(value) && numeric_limits<RangeType>::has_infinity)
    Cool. Leider ist es nicht unterdrücken, die compiler-Warnungen über die Zeichen ändern, die auf integer-Konvertierungen. Auch meiner Meinung nach, es funktioniert für mixture of signed and unsigned types im Gegensatz zu dem, was Sie schreiben. Das Gemisch problem war, warum ich war Googeln.

    InformationsquelleAutor RadioKat

  2. 2
    #include <limits>

template<typename ValueType, typename RangeType >
bool IsInRange( ValueType value ) {
    return (value >= numeric_limits<RangeType>::min()) &&
           (value <= numeric_limits<RangeType>::max());
}

    Dieser Arbeit wird für Integrale Datentypen mit Ausnahme für floating-point-Werte. numeric_limits<T>::min() zurück die minimalen normalisierten positive Wert für floating-point-Typen. C++11 eingeführt numeric_limits<T>::lowest() um das Problem zu beheben.

    Versuchen Sie, diese mit IsInRange< int16_t, uint32_t > wird es nicht und geben auch eine compiler-Warnung, die erklärt, warum: warning: integer conversion resulted in a change of sign

    InformationsquelleAutor IInspectable

  3. 1

    First off, Sie brauchen nicht alle diese Windungen mit booleans. Einfach nur wieder den Ausdruck direkt:

    return (s >= SCHAR_MIN) && (s <= SCHAR_MAX);

    Zweitens sollten Sie erkennen, dass beide Ihre Funktionen immer Ausbeute true: per definition, ein signed char ist immer im Bereich [SCHAR_MIN, SCHAR_MAX], und ein int ist immer im Bereich [INT_MIN, INT_MAX].

    Aber wenn Sie gewählt haben verschiedene Grenzen, dies wäre in der Tat der Weg, es zu tun (unter Berücksichtigung meine erste Bemerkung).

    Als EdS. vorgeschlagen, Sie könnte verwenden Sie eine vorgefertigte Lösung zur Verringerung der Anzahl der Funktionen/überladungen, die Sie brauchen:

    template<class T>
bool check_range(T value, T min, T max) {
    return (value >= min) && (value <= max);
}
    Wie mache ich, dass "unterschiedliche Grenzen"? Ich denke, das ist die eine, die ich erreichen möchte...
    Und oh, Wenn ich geben Sie ein int, das ist mehr als 2147483647 wird es möglich, die false zurück? Danke!
    Gut, Sie scheinen zu verwechseln, die die string-Darstellung einer Zahl (zB. "123" ist nur eine Folge aus 3 Zeichen) und die "native" Darstellung von ganzen zahlen, die Computer verarbeiten intern (zB. 4 Byte für eine int auf vielen Plattformen). Wenn int 4 bytes auf Ihrer Plattform, dann werden Sie nicht haben ein int größer als 2147483647 (INT_MAX) , das ist einfach unmöglich. Ich vermute, dass Sie möglicherweise verwenden möchten, strtol und Freunde zu konvertieren einen string in einen integer.
    OK. Ich werde mehr studieren. Danke!
    Nichts für ungut, aber es sieht aus wie Sie ' re fehlen einige sehr grundlegende Konzepte (vor allem, wenn man sich die Fragen der Geschichte, der alle drehen sich um das gleiche Thema). Mein beste Rat wäre zu diskutieren es mit Ihrem Lehrer, so dass (s)er kann klar Missverständnisse Sie möglicherweise konfrontiert werden. ALSO ist nicht wirklich der richtige Ort, um Erklärungen zu grundlegenden Themen (Fragen, die nicht zeigen, ein minimale Verständnis von dem problem off-topic hier, hart es auch klingen mag, es ist die Hausordnung). Viel Glück!

    InformationsquelleAutor syam

  4. 0

    Dies ist eine Implementierung auf der Grundlage der Antwort von RadioKat, aber es unterdrückt compiler-Warnungen wie:

    warning: pointless comparison of unsigned integer with zero
warning: integer conversion resulted in a change of sign

    durch die Verwendung von template meta-Programmierung:

    #include <limits>

template< typename T_Range, typename T_Value, bool T_RangeSigned, bool T_ValueSigned >
struct InIntegerRange;

template< typename T_Range, typename T_Value >
struct InIntegerRange< T_Range, T_Value, false, false >
{
    bool operator()( T_Value const & x )
    {
        return x >= std::numeric_limits< T_Range >::min() &&
               x <= std::numeric_limits< T_Range >::max();
    }
};

template< typename T_Range, typename T_Value >
struct InIntegerRange< T_Range, T_Value, false, true >
{
    bool operator()( T_Value const & x )
    {
        return x >= 0 && x <= std::numeric_limits< T_Range >::max();
    }
};

template< typename T_Range, typename T_Value >
struct InIntegerRange< T_Range, T_Value, true, false >
{
    bool operator()( T_Value const & x )
    {
        return x <= std::numeric_limits< T_Range >::max(); /* x >= 0 is given */
    }
};

template< typename T_Range, typename T_Value >
struct InIntegerRange< T_Range, T_Value, true, true >
{
    bool operator()( T_Value const & x )
    {
        return x >= std::numeric_limits< T_Range >::min() &&
               x <= std::numeric_limits< T_Range >::max();
    }
};

template< typename T_Range, typename T_Value >
inline bool inRange( T_Value const & x )
{
    if( std::numeric_limits< T_Range >::is_integer )
    {
        return InIntegerRange< T_Range, T_Value,
                               std::numeric_limits< T_Range >::is_signed,
                               std::numeric_limits< T_Value >::is_signed >()( x );
    }
    else
    {
        return ( x > 0 ? x : -x ) <= std::numeric_limits< T_Range >::max() ||
               ( std::isnan(x) && std::numeric_limits< T_Range >::has_quiet_NaN ) ||
               ( std::isinf(x) && std::numeric_limits< T_Range >::has_infinity );
    }
}

    InformationsquelleAutor mxmlnkn

Schreibe einen Kommentar