it-swarm.com.de

Wertebereich in C Int und Long 32 - 64 Bit

Ich bin mit dem Wertebereich der Variablen Int in C verwirrt.

Ich weiß, dass ein 32-Bit-Integer ohne Vorzeichen einen Bereich von 0 bis 65.535 hat. So lange hat 0 bis 4.294.967.295

Dies ist in 32-Bit-Maschine in Ordnung. Aber jetzt bleibt bei 64-Bit-Maschinen alles gleich? Oder vielleicht ist meine int-Kapazität anders?

Ich verstehe diese Fragen als Neuling, bin aber wirklich verwirrt. .__ Diese Methodensignatur hilft auch nicht. :)

unsigned long long int atomicAdd(unsigned long long int* address, unsigned long long int val);
42
Custodio

In C und C++ haben Sie die geringsten Anforderungen (d. H. Die tatsächlichen Implementierungen können größere Beträge haben.)

signed char: -2^07+1 to +2^07-1
short:       -2^15+1 to +2^15-1
int:         -2^15+1 to +2^15-1
long:        -2^31+1 to +2^31-1
long long:   -2^63+1 to +2^63-1

Bei bestimmten Implementierungen gibt es jetzt verschiedene Bitbereiche. Der Wikipedia-Artikel beschreibt dies nett.

Nein, int in C ist nicht, definiert als 32 Bit. int und long haben überhaupt keine bestimmte Größe. Das einzige, was die Sprache garantiert, ist sizeof(char)<=sizeof(short)<=sizeof(long)

Theoretisch könnte ein Compiler short, char und long alle gleich viele Bits machen. Ich kenne einige, die das tatsächlich getan haben für alle diese Typen außer char.

Deshalb definiert C jetzt Typen wie uint16_t und uint32_t. Wenn Sie eine bestimmte Größe benötigen, sollten Sie eine davon verwenden.

18
T.E.D.

Auszug aus K & R:

short ist oft 16 Bits, long 32 Bits und int entweder 16 Bits oder 32 Bit. Jeder Compiler kann seine eigenen Größen auswählen Hardware, unterliegt nur der Einschränkung, dass shorts und ints .__ sind. mindestens 16 Bit, longs sind mindestens 32 Bit, und short ist nein länger als int, was nicht länger als long ist.


Sie können limits.h verwenden, der die Definition der Grenzwerte für die Dezimal-/Flottatypen enthält:

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <float.h>


int main(int argc, char** argv) {

    printf("CHAR_BIT    :   %d\n", CHAR_BIT);
    printf("CHAR_MAX    :   %d\n", CHAR_MAX);
    printf("CHAR_MIN    :   %d\n", CHAR_MIN);
    printf("INT_MAX     :   %d\n", INT_MAX);
    printf("INT_MIN     :   %d\n", INT_MIN);
    printf("LONG_MAX    :   %ld\n", (long) LONG_MAX);
    printf("LONG_MIN    :   %ld\n", (long) LONG_MIN);
    printf("SCHAR_MAX   :   %d\n", SCHAR_MAX);
    printf("SCHAR_MIN   :   %d\n", SCHAR_MIN);
    printf("SHRT_MAX    :   %d\n", SHRT_MAX);
    printf("SHRT_MIN    :   %d\n", SHRT_MIN);
    printf("UCHAR_MAX   :   %d\n", UCHAR_MAX);
    printf("UINT_MAX    :   %u\n", (unsigned int) UINT_MAX);
    printf("ULONG_MAX   :   %lu\n", (unsigned long) ULONG_MAX);
    printf("USHRT_MAX   :   %d\n", (unsigned short) USHRT_MAX);
    printf("FLT_MAX     :   %g\n", (float) FLT_MAX);
    printf("FLT_MIN     :   %g\n", (float) FLT_MIN);
    printf("-FLT_MAX    :   %g\n", (float) -FLT_MAX);
    printf("-FLT_MIN    :   %g\n", (float) -FLT_MIN);
    printf("DBL_MAX     :   %g\n", (double) DBL_MAX);
    printf("DBL_MIN     :   %g\n", (double) DBL_MIN);
    printf("-DBL_MAX     :  %g\n", (double) -DBL_MAX);

    return (EXIT_SUCCESS);
}

Möglicherweise müssen Sie möglicherweise ein wenig an Ihrem Computer anpassen, aber es ist eine gute Vorlage, um eine Vorstellung von den (implementierungsdefinierten) min- und max-Werten zu erhalten.

17
Ely

Es gibt keine Antwort. Die Norm definiert Mindestbereiche. Ein int muss mindestens 65535 enthalten können. Die meisten modernen Compiler erlauben jedoch, dass ints 32-Bit-Werte sind. Darüber hinaus hindert nichts daran, dass mehrere Typen die gleiche Kapazität haben (z. B. int und long). 

Davon abgesehen sagt der Standard in Ihrem speziellen Fall:

0 → +18446744073709551615

wie der Bereich für unsigned long long int.

Weiterführende Literatur: http://en.wikipedia.org/wiki/C_variable_types_and_declarations#Size

9
Joe

In C und C++ Speicheranforderungen einiger Variablen:

signed char: -2^07 to +2^07-1
short: -2^15 to +2^15-1
int: -2^15 to +2^15-1
long: -2^31 to +2^31-1
long long: -2^63 to +2^63-1 

signed char: -2^07 to +2^07-1
short: -2^15 to +2^15-1
int: -2^31 to +2^31-1
long: -2^31 to +2^31-1
long long: -2^63 to +2^63-1 

hängt vom Compiler und der Architektur der Hardware ab

Der internationale Standard für die C-Sprache erfordert nur, dass die Größe von kurzen Variablen kleiner oder gleich der Größe des Typs int sein sollte, die wiederum kleiner oder gleich der Größe des Typs long sein sollte.

2
Vipin Diwakar

In der Tat wird das vorzeichenlose int auf den meisten modernen Prozessoren (ARM, Intel/AMD, Alpha, SPARC, Itanium, PowerPC) einen Bereich von 0 bis 2 ^ 32 - 1 haben. Dies ist 4.294.967.295 = 0xffffffff Weil int (sowohl signiert als auch unsigned) ist 32 Bit lang und die größte ist wie angegeben.

(Kurzzeichen ohne Vorzeichen haben maximalen Wert 2 ^ 16 - 1 = 65.535)

(unsigned) long long int hat eine Länge von 64 Bit (long int reicht unter den meisten 64-Bit-64-Bit-Servern usw. aus, aber der Standard verspricht 64 bit für long long int) . Daher haben diese den Bereich 0 bis 2 ^ 64-1 = 18446744073709551615

2
Henno Brandsma

Schauen Sie sich die limits.h-Datei in Ihrem System an, die die systemspezifischen Grenzen angibt. Oder man limits.h überprüfen und zum Abschnitt "Numerical Limits" gehen.

1
phoxis

Werfen Sie einen Blick auf limits.h . Sie finden die spezifischen Werte für Ihren Compiler. INT_MIN und INT_MAX sind von Interesse. 

1
Paul Rubel

Ein vorzeichenloser 32-Bit-Int hat einen Bereich von 0 bis 4.294.967.295. 0 bis 65535 wäre ein vorzeichenloses 16-Bit.

Eine vorzeichenlose long long (und bei einer 64-Bit-Implementierung möglicherweise auch ulong und möglicherweise auch uint) hat einen Bereich (mindestens) von 0 bis 18.446.744.073.709.551.615 (264-1). Theoretisch könnte es größer sein als das, aber zumindest für den Moment ist das selten bis nicht existent.

0
Jerry Coffin