Min- und Max-Wert des Datentyps in C

Was ist die Funktion zum ermitteln der min und der max mögliche Wert-Datentypen (ich.e, int, char.etc) in C?

InformationsquelleAutor der Frage SuperString | 2010-01-13

Werden Sie verwenden möchten Grenzen.h stellt die folgenden Konstanten (wie in der verlinkten Referenz):

CHAR_BIT   = number of bits in a char
SCHAR_MIN  = minimum value for a signed char
SCHAR_MAX  = maximum value for a signed char
UCHAR_MAX  = maximum value for an unsigned char
CHAR_MIN   = minimum value for a char
CHAR_MAX   = maximum value for a char
MB_LEN_MAX = maximum multibyte length of a character accross locales
SHRT_MIN   = minimum value for a short
SHRT_MAX   = maximum value for a short
USHRT_MAX  = maximum value for an unsigned short
INT_MIN    = minimum value for an int
INT_MAX    = maximum value for an int
UINT_MAX   = maximum value for an unsigned int
LONG_MIN   = minimum value for a long
LONG_MAX   = maximum value for a long
ULONG_MAX  = maximum value for an unsigned long
LLONG_MIN  = minimum value for a long long
LLONG_MAX  = maximum value for a long long
ULLONG_MAX = maximum value for an unsigned long long

Wo U*_MIN entfällt für offensichtliche Gründe (alle unsigned-Typ hat einen minimalen Wert von 0).

Ähnlich float.h bietet die Grenzwerte für float und double Typen:

-FLT_MAX = most negative value of a float
FLT_MAX  = max value of a float
-DBL_MAX = most negative value of a double
DBL_MAX  = max value of a double
-LDBL_MAX = most negative value of a long double
LDBL_MAX = max value of a long double

Sollten Sie den Artikel Lesen auf floats.h sorgfältig, obwohl float und double können, halten Sie die vorgeschriebenen minimalen und maximalen Werte, sondern die Präzision, mit der jede Art vertreten können Daten möglicherweise nicht mit dem übereinstimmen, was es ist Sie versuchen, zu speichern. Insbesondere ist es schwierig zu speichern ist eine außergewöhnlich hohe Anzahl mit extrem kleinen Fraktionen angeschlossen. So float.h bietet eine Reihe weiterer Konstanten, die Ihnen helfen, zu bestimmen, ob ein float oder eine double können,in der Tat,stellen eine Besondere Zahl.

InformationsquelleAutor der Antwort Mark Elliot

"Aber " Glyphe", höre ich Sie Fragen, "was, wenn ich haben zu bestimmen, der den maximalen Wert für ein opaker Typ, dessen maximum sich vielleicht irgendwann ändern?" Sie könnte weiter: "Was ist, wenn es eine Typdefinition in einer Bibliothek, die ich nicht kontrollieren?"

Ich bin froh, dass Sie fragte, denn ich verbrachte ein paar Stunden Kochen, bis eine Lösung (die musste ich dann wegwerfen, weil es Sie nicht lösen meinem eigentlichen problem).

Können Sie mit diesem handlichen maxof makro zum ermitteln der Größe eines gültigen integer-Typ.

#define issigned(t) (((t)(-1)) < ((t) 0))

#define umaxof(t) (((0x1ULL << ((sizeof(t) * 8ULL) - 1ULL)) - 1ULL) | \
                    (0xFULL << ((sizeof(t) * 8ULL) - 4ULL)))

#define smaxof(t) (((0x1ULL << ((sizeof(t) * 8ULL) - 1ULL)) - 1ULL) | \
                    (0x7ULL << ((sizeof(t) * 8ULL) - 4ULL)))

#define maxof(t) ((unsigned long long) (issigned(t) ? smaxof(t) : umaxof(t)))

Können Sie es verwenden, etwa so:

int main(int argc, char** argv) {
    printf("schar: %llx uchar: %llx\n", maxof(char), maxof(unsigned char));
    printf("sshort: %llx ushort: %llx\n", maxof(short), maxof(unsigned short));
    printf("sint: %llx uint: %llx\n", maxof(int), maxof(unsigned int));
    printf("slong: %llx ulong: %llx\n", maxof(long), maxof(unsigned long));
    printf("slong long: %llx ulong long: %llx\n",
           maxof(long long), maxof(unsigned long long));
    return 0;
}

Wenn Sie möchten, können Sie werfen '(t)' auf der Vorderseite dieser Makros, so dass Sie geben Sie ein Ergebnis von der Art, dass Sie Fragen, und Sie müssen nicht Gießen zu vermeiden, Warnungen.

InformationsquelleAutor der Antwort Glyph

5

Maximale Wert jeder vorzeichenlose Integrale Typ: (~(t)0)

Maximale Wert jeder signierten ganzzahligen Typ: Wenn Sie eine nicht signierte Variante des Typs t, ((t)((~(unsigned t)0)>>1)) geben Sie das Schnellste Ergebnis, die Sie benötigen (siehe Beispiel Linux-kernel source code referenziert unten). Ansonsten sollten Sie wahrscheinlich verwenden (~(1ULL<<(sizeof(t)*CHAR_BIT-1))).

Mindestens Wert jeder signierten ganzzahligen Typ: Sie müssen wissen, die Zahl unterzeichnet die Vertretung Ihrer Maschine. Die meisten Maschinen verwenden 2 ergänzen, und so -(~(1ULL<<(sizeof(t)*CHAR_BIT-1)))-1 wird für Sie arbeiten.

Erkennen, ob Ihre Maschine verwendet, um 2 zu ergänzen, zu erkennen, ob (~(t)0U) und (t)(-1) stellen die gleiche Sache. So, kombiniert mit den oben:
```
((~(t)0U) == (t)(-1) ? -(~(1ULL<<(sizeof(t)*CHAR_BIT-1)))-1 :
                       -(~(1ULL<<(sizeof(t)*CHAR_BIT-1))))
```
geben Sie den minimalen Wert keine signierten ganzzahligen Typ. (Tatsächlich gibt es andere Darstellungen, wenn Sie wissen, 2er-Komplement-Darstellung. Zum Beispiel (t)(1ULL<<(sizeof(t)*CHAR_BIT-1)) sollte äquivalent zu (t)(-(~(1ULL<<(sizeof(t)*CHAR_BIT-1)))-1) .)

Beispiel: (~(size_t)0) liefert den maximalen Wert von size_t. (Und ratet mal, was das ist, wie SIZE_MAX ist #definiert in Linux kernel source code.)

Einer VORBEHALT aber: alle diese Ausdrücke, die die Verwendung von type-casting und so nicht die Arbeit in Präprozessor-Bedingungen (#if ... #elif ... #endif und wie).

InformationsquelleAutor der Antwort Explorer09
3

Blick auf die folgenden Seiten auf Grenzen.h und float.hdie als Teil der standard-c-Bibliothek.

InformationsquelleAutor der Antwort Nixuz

Schrieb ich einige Makros, die Rückgabe der min-und max-von jeder Art, unabhängig davon, Fehler:

#define MAX_OF(type) \
    (((type)(~0LLU) > (type)((1LLU<<((sizeof(type)<<3)-1))-1LLU)) ? (long long unsigned int)(type)(~0LLU) : (long long unsigned int)(type)((1LLU<<((sizeof(type)<<3)-1))-1LLU))
#define MIN_OF(type) \
    (((type)(1LLU<<((sizeof(type)<<3)-1)) < (type)1) ? (long long int)((~0LLU)-((1LLU<<((sizeof(type)<<3)-1))-1LLU)) : 0LL)

Beispiel-code:

#include <stdio.h>
#include <sys/types.h>
#include <inttypes.h>

#define MAX_OF(type) \
    (((type)(~0LLU) > (type)((1LLU<<((sizeof(type)<<3)-1))-1LLU)) ? (long long unsigned int)(type)(~0LLU) : (long long unsigned int)(type)((1LLU<<((sizeof(type)<<3)-1))-1LLU))
#define MIN_OF(type) \
    (((type)(1LLU<<((sizeof(type)<<3)-1)) < (type)1) ? (long long int)((~0LLU)-((1LLU<<((sizeof(type)<<3)-1))-1LLU)) : 0LL)

int main(void)
{
    printf("uint32_t = %lld..%llu\n", MIN_OF(uint32_t), MAX_OF(uint32_t));
    printf("int32_t = %lld..%llu\n", MIN_OF(int32_t), MAX_OF(int32_t));
    printf("uint64_t = %lld..%llu\n", MIN_OF(uint64_t), MAX_OF(uint64_t));
    printf("int64_t = %lld..%llu\n", MIN_OF(int64_t), MAX_OF(int64_t));
    printf("size_t = %lld..%llu\n", MIN_OF(size_t), MAX_OF(size_t));
    printf("ssize_t = %lld..%llu\n", MIN_OF(ssize_t), MAX_OF(ssize_t));
    printf("pid_t = %lld..%llu\n", MIN_OF(pid_t), MAX_OF(pid_t));
    printf("time_t = %lld..%llu\n", MIN_OF(time_t), MAX_OF(time_t));
    printf("intptr_t = %lld..%llu\n", MIN_OF(intptr_t), MAX_OF(intptr_t));
    printf("unsigned char = %lld..%llu\n", MIN_OF(unsigned char), MAX_OF(unsigned char));
    printf("char = %lld..%llu\n", MIN_OF(char), MAX_OF(char));
    printf("uint8_t = %lld..%llu\n", MIN_OF(uint8_t), MAX_OF(uint8_t));
    printf("int8_t = %lld..%llu\n", MIN_OF(int8_t), MAX_OF(int8_t));
    printf("uint16_t = %lld..%llu\n", MIN_OF(uint16_t), MAX_OF(uint16_t));
    printf("int16_t = %lld..%llu\n", MIN_OF(int16_t), MAX_OF(int16_t));
    printf("int = %lld..%llu\n", MIN_OF(int), MAX_OF(int));
    printf("long int = %lld..%llu\n", MIN_OF(long int), MAX_OF(long int));
    printf("long long int = %lld..%llu\n", MIN_OF(long long int), MAX_OF(long long int));
    printf("off_t = %lld..%llu\n", MIN_OF(off_t), MAX_OF(off_t));

    return 0;
}

InformationsquelleAutor der Antwort craig65535

3

Die header-Datei Grenzen.h definiert Makros zu erweitern, um die verschiedenen Grenzen und Parameter des standard-integer-Typen.

InformationsquelleAutor der Antwort Prasoon Saurav

#include<stdio.h>

int main(void)
{
    printf("Minimum Signed Char %d\n",-(char)((unsigned char) ~0 >> 1) - 1);
    printf("Maximum Signed Char %d\n",(char) ((unsigned char) ~0 >> 1));

    printf("Minimum Signed Short %d\n",-(short)((unsigned short)~0 >>1) -1);
    printf("Maximum Signed Short %d\n",(short)((unsigned short)~0 >> 1));

    printf("Minimum Signed Int %d\n",-(int)((unsigned int)~0 >> 1) -1);
    printf("Maximum Signed Int %d\n",(int)((unsigned int)~0 >> 1));

    printf("Minimum Signed Long %ld\n",-(long)((unsigned long)~0 >>1) -1);
    printf("Maximum signed Long %ld\n",(long)((unsigned long)~0 >> 1));

    /* Unsigned Maximum Values */

    printf("Maximum Unsigned Char %d\n",(unsigned char)~0);
    printf("Maximum Unsigned Short %d\n",(unsigned short)~0);
    printf("Maximum Unsigned Int %u\n",(unsigned int)~0);
    printf("Maximum Unsigned Long %lu\n",(unsigned long)~0);

    return 0;
}

InformationsquelleAutor der Antwort rahul gupta

0

MIN-und MAX-Werte von Datentyp integer berechnet werden kann, ohne Verwendung von Bibliotheks-Funktionen als unten ein und dieselbe Logik angewendet werden können, um anderen integer-Typen short, int und long.
```
printf("Signed Char : MIN -> %d & Max -> %d\n", ~(char)((unsigned char)~0>>1), (char)((unsigned char)~0 >> 1));
printf("Unsigned Char : MIN -> %u & Max -> %u\n", (unsigned char)0, (unsigned char)(~0));
```
InformationsquelleAutor der Antwort Arjun
0

Um den Maximalwert einer vorzeichenlosen integer-Typ t deren Breite zumindest eines der unsigned int (ansonsten bekommt man Probleme mit integer-promotions): ~(t) 0. Wenn man will, zu unterstützen auch kürzere Typen, man kann hinzufügen, ein weiterer cast: (t) ~(t) 0.

Wenn der integer-Typ t unterzeichnet wird, vorausgesetzt, dass es keine Polsterung-bits, verwendet werden kann.
```
((((t) 1 << (sizeof(t) * CHAR_BIT - 2)) - 1) * 2 + 1)
```
Der Vorteil dieser Formel ist, dass Sie nicht auf einige unsignierte version von t (oder eine größere Art), die möglicherweise unbekannt oder nicht verfügbar (auch uintmax_t möglicherweise nicht ausreichend sein, mit nicht-standard-Erweiterungen). Beispiel mit 6 bits (nicht möglich in der Praxis, nur zur besseren Lesbarkeit):
```
010000  (t) 1 << (sizeof(t) * CHAR_BIT - 2)
001111  - 1
011110  * 2
011111  + 1
```
In zwei der Ergänzung, der minimale Wert ist das Gegenteil von dem maximalen Wert minus 1 (bei den anderen integer-Darstellungen erlaubt, durch den ISO-C-standard, das ist genau das Gegenteil von dem maximalen Wert).

Hinweis: um Zu erkennen, Fehler in, um sich zu entscheiden welche version zu verwenden: (t) -1 < 0 funktioniert mit jedem integer-Darstellung, die 1 (true) vorzeichenbehafteter integer-Typen und 0 (false) für unsigned integer-Typen. So kann man verwenden:
```
(t) -1 < 0 ? ((((t) 1 << (sizeof(t) * CHAR_BIT - 2)) - 1) * 2 + 1) : (t) ~(t) 0
```
InformationsquelleAutor der Antwort vinc17

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.