Welchen Wertebereich können Ganzzahltypen in C ++ speichern?

Kann unsigned long inteine zehnstellige Nummer (1.000.000.000 - 9.999.999.999) auf einem 32-Bit-Computer gespeichert werden?

Darüber hinaus , was sind die Bereiche unsigned long int, long int, unsigned int, short int, short unsigned int, und int?

Die Mindestbereiche, auf die Sie sich verlassen können, sind:

• short intund int: -32.767 bis 32.767
• unsigned short intund unsigned int: 0 bis 65.535
• long int: -2.147.483.647 bis 2.147.483.647
• unsigned long int: 0 bis 4,294,967,295

Dies bedeutet, dass Sie long int sich nicht darauf verlassen können, eine 10-stellige Nummer zu speichern. In long long intC99 und C ++ in C ++ 11 wurde jedoch ein größerer Typ in C eingeführt (dieser Typ wird häufig auch als Erweiterung von Compilern unterstützt, die für ältere Standards erstellt wurden, die ihn nicht enthielten). Der Mindestbereich für diesen Typ, sofern Ihr Compiler ihn unterstützt, ist:

• long long int: -9.223.372.036.854.775.807 bis 9.223.372.036.854.775.807
• unsigned long long int: 0 bis 18.446.744.073.709.551.615

Dieser Typ ist also groß genug (wieder, wenn Sie ihn zur Verfügung haben).

Eine Notiz für diejenigen, die glauben, dass ich mit diesen Untergrenzen einen Fehler gemacht habe - ich habe es nicht getan. Die C-Anforderungen für die Bereiche sind so geschrieben, dass sie Ganzzahldarstellungen mit Komplement oder Vorzeichengröße ermöglichen, wobei sich der niedrigste darstellbare Wert und der höchste darstellbare Wert nur im Vorzeichen unterscheiden. Es ist auch zulässig, eine Zweierkomplementdarstellung zu haben, wobei der Wert mit dem Vorzeichenbit 1 und allen Wertbits 0 eher eine Trap-Darstellung als ein zulässiger Wert ist. Mit anderen Worten, es intist nicht erforderlich, den Wert -32.768 darstellen zu können.

Die Größe der numerischen Typen ist im C ++ - Standard nicht definiert, obwohl die Mindestgrößen sind. Um festzustellen, welche Größe sie auf Ihrer Plattform haben, verwenden Sie numerische Grenzwerte

Der Maximalwert für ein int kann beispielsweise ermittelt werden durch:

std::numeric_limits<int>::max();

Computer arbeiten nicht in Basis 10, was bedeutet, dass der Maximalwert in Form von 2 ⁿ -1 liegt, da die Anzahl der Darstellungen im Speicher liegt. Nehmen Sie zum Beispiel acht Bits (1 Byte)

  0100 1000

Das am weitesten rechts stehende Bit (Zahl), wenn es auf 1 gesetzt ist, repräsentiert 2 ⁰ , das nächste Bit 2 ¹ , dann 2 ² usw., bis wir zum am weitesten links liegenden Bit gelangen, das, wenn die Zahl ohne Vorzeichen ist, 2 ^{7 darstellt} .

Die Zahl steht also für 2 ⁶ + 2 ³ = 64 + 8 = 72, da das 4. Bit von rechts und das 7. Bit von rechts links gesetzt sind.

Wenn wir alle Werte auf 1 setzen:

11111111

Die Zahl ist jetzt (unter der Annahme ohne Vorzeichen )
128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255 = 2 ⁸ - 1
Und wie wir sehen können, ist dies der größtmögliche Wert, der mit 8 Bits dargestellt werden kann.

Auf meinem Computer sind int und a long gleich und können jeweils zwischen -2 ³¹ und 2 ³¹ - 1 halten. Nach meiner Erfahrung ist dies die häufigste Größe auf modernen 32-Bit-Desktop-Computern.

So ermitteln Sie die Grenzen Ihres Systems:

#include <iostream>
#include <limits>
int main(int, char **) {
  std::cout
    << static_cast< int >(std::numeric_limits< char >::max()) << "\n"
    << static_cast< int >(std::numeric_limits< unsigned char >::max()) << "\n"
    << std::numeric_limits< short >::max() << "\n"
    << std::numeric_limits< unsigned short >::max() << "\n"
    << std::numeric_limits< int >::max() << "\n"
    << std::numeric_limits< unsigned int >::max() << "\n"
    << std::numeric_limits< long >::max() << "\n"
    << std::numeric_limits< unsigned long >::max() << "\n"
    << std::numeric_limits< long long >::max() << "\n"
    << std::numeric_limits< unsigned long long >::max() << "\n";
}

Beachten Sie, dass dies long longnur in C99 und in C ++ 11 zulässig ist.

Andere Leute hier werden Links zu Datengrößen und Präzisionen usw. posten.
Ich werde Ihnen sagen, wie Sie es selbst herausfinden können.
Schreiben Sie eine kleine App, die Folgendes ausführt.

unsigned int ui;
std::cout <<  sizeof(ui));

Dadurch werden (je nach Compiler und Architektur) 2, 4 oder 8 gedruckt, wobei 2 Bytes, 4 Bytes usw. angegeben werden.

Nehmen wir an, es ist 4.

Sie möchten nun den Maximalwert, den 4 Bytes speichern können. Der Maximalwert für ein Byte ist (in hex) 0xFF. Der Maximalwert von vier Bytes ist 0x, gefolgt von 8 fs (ein Paar fs für jedes Byte, das 0x teilt dem Compiler mit, dass die folgende Zeichenfolge eine Hex-Zahl ist). Ändern Sie nun Ihr Programm, um diesen Wert zuzuweisen, und drucken Sie das Ergebnis

unsigned int ui = 0xFFFFFFFF;
std::cout <<  ui;

Dies ist der Maximalwert, den ein Int ohne Vorzeichen halten kann (siehe Darstellung in Basis 10).

Tun Sie das jetzt für lange, kurze Hosen und jeden anderen INTEGER-Wert, auf den Sie neugierig sind.

NB: Dieser Ansatz funktioniert nicht für Gleitkommazahlen (dh Double oder Float).

Hoffe das hilft

In C ++ werden jetzt int und andere Daten mithilfe der Komplimentmethode von 2 gespeichert. Das heißt, die Reichweite ist:

-2147483648 to 2147483647

oder -2 ^ 31 bis 2 ^ 31-1

1 Bit ist für 0 reserviert, daher ist der positive Wert eins weniger als 2 ^ (31)

Sie können die in der Header-Datei vorhandenen Funktionen numeric_limits<data_type>::min()und verwenden und die Grenzen der einzelnen Datentypen ermitteln.numeric_limits<data_type>::max()limits

#include <iostream>
#include <limits>
using namespace std;
int main()
{
    cout<<"Limits of Data types:\n";    
    cout<<"char\t\t\t: "<<static_cast<int>(numeric_limits<char>::min())<<" to "<<static_cast<int>(numeric_limits<char>::max())<<endl;
    cout<<"unsigned char\t\t: "<<static_cast<int>(numeric_limits<unsigned char>::min())<<" to "<<static_cast<int>(numeric_limits<unsigned char>::max())<<endl;
    cout<<"short\t\t\t: "<<numeric_limits<short>::min()<<" to "<<numeric_limits<short>::max()<<endl;
    cout<<"unsigned short\t\t: "<<numeric_limits<unsigned short>::min()<<" to "<<numeric_limits<unsigned short>::max()<<endl;
    cout<<"int\t\t\t: "<<numeric_limits<int>::min()<<" to "<<numeric_limits<int>::max()<<endl;
    cout<<"unsigned int\t\t: "<<numeric_limits<unsigned int>::min()<<" to "<<numeric_limits<unsigned int>::max()<<endl;
    cout<<"long\t\t\t: "<<numeric_limits<long>::min()<<" to "<<numeric_limits<long>::max()<<endl;
    cout<<"unsigned long\t\t: "<<numeric_limits<unsigned long>::min()<<" to "<<numeric_limits<unsigned long>::max()<<endl;
    cout<<"long long\t\t: "<<numeric_limits<long long>::min()<<" to "<<numeric_limits<long long>::max()<<endl;
    cout<<"unsiged long long\t: "<<numeric_limits<unsigned long long>::min()<<" to "<<numeric_limits<unsigned long long>::max()<<endl;
    cout<<"float\t\t\t: "<<numeric_limits<float>::min()<<" to "<<numeric_limits<float>::max()<<endl;
    cout<<"double\t\t\t: "<<numeric_limits<double>::min()<<" to "<<numeric_limits<double>::max()<<endl;
    cout<<"long double\t\t: "<<numeric_limits<long double>::min()<<" to "<<numeric_limits<long double>::max()<<endl;
}

Die Ausgabe lautet: Grenzen der Datentypen:

• char: -128 bis 127
• Zeichen ohne Vorzeichen: 0 bis 255
• kurz: -32768 bis 32767
• unsigned short: 0 bis 65535
• int: -2147483648 bis 2147483647
• unsigned int: 0 bis 4294967295
• lang: -2147483648 bis 2147483647
• unsigned long: 0 bis 4294967295
• lang lang: -9223372036854775808 bis 9223372036854775807
• unsigned long long: 0 bis 18446744073709551615
• float: 1.17549e-038 bis 3.40282e + 038
• doppelt: 2,22507e-308 bis 1,79769e + 308
• langes Doppel: 3.3621e-4932 bis 1.18973e + 4932

Für den vorzeichenlosen Datentyp gibt es kein Vorzeichenbit und alle Bits sind für Daten; Während für den vorzeichenbehafteten Datentyp MSB das Vorzeichenbit angegeben ist und die verbleibenden Bits für Daten sind.

Um den Bereich zu finden, gehen Sie wie folgt vor:

Schritt: 1 -> Ermitteln Sie die Anzahl der Bytes für den Datentyp give.

Schritt: 2 -> Folgende Berechnungen anwenden.

      Let n = no of bits in data type  

      For signed data type ::
            Lower Range = -(2^(n-1)) 
            Upper Range = (2^(n-1)) - 1)  

      For unsigned data type ::
            Lower Range = 0 
            Upper Range = (2^(n)) - 1 

Zum Beispiel

Für vorzeichenlose int-Größe = 4 Bytes (32 Bit) -> Bereich [0, (2 ^ (32)) - 1]

Für vorzeichenbehaftete int-Größe = 4 Bytes (32 Bit) -> Bereich [- (2 ^ (32-1)), (2 ^ (32-1)) - 1]

Kann unsigned long int eine zehnstellige Nummer (1.000.000.000 - 9.999.999.999) auf einem 32-Bit-Computer enthalten.

Nein

Nein, nur ein Teil der zehnstelligen Nummer kann in einem vorzeichenlosen langen Int gespeichert werden, dessen gültiger Bereich zwischen 0 und 4.294.967.295 liegt. Sie können darauf verweisen: http://msdn.microsoft.com/en-us/library/s3f49ktz(VS.80).aspx

Sie sollten sich die Spezialisierungen der Vorlage numeric_limits <> für einen bestimmten Typ ansehen. Es ist in der Kopfzeile.