Welke reeks waarden kunnen integer-types opslaan in C++

Kan unsigned long inteen getal van tien cijfers bevatten (1.000.000.000 – 9.999.999.999) op een 32-bits computer?

Bovendien, wat zijn de bereiken van unsigned long int, long int, unsigned int, short int, short unsigned inten int?


Antwoord 1, autoriteit 100%

De minimalebereiken waarop u kunt vertrouwen zijn:

  • short inten int: -32.767 tot 32.767
  • unsigned short inten unsigned int: 0 tot 65.535
  • long int: -2.147.483.647 tot 2.147.483.647
  • unsigned long int: 0 tot 4.294.967.295

Dit betekent dat er op nee, long intnietkan worden vertrouwd om een 10-cijferig nummer op te slaan. Er werd echter een groter type long long intgeïntroduceerd voor C in C99 en C++ in C++11 (dit type wordt ook vaak ondersteund als een extensie door compilers die zijn gebouwd voor oudere standaarden die het niet bevatten) . Het minimumbereik voor dit type, als uw compiler dit ondersteunt, is:

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

Dus dat type zal groot genoeg zijn (nogmaals, alsje het beschikbaar hebt).


Een opmerking voor degenen die denken dat ik een fout heb gemaakt met deze ondergrenzen: de C-vereisten voor de bereiken zijn geschreven om de complementaire of teken-magnitude integer-representaties mogelijk te maken, waarbij de laagste representeerbare waarde en de hoogste representeerbare waarde verschillen alleen in teken. Het is ook toegestaan om een twee-complement representatie te hebben waarbij de waarde met teken bit 1 en alle waarde bits 0 een val representatieis in plaats van een legale waarde. Met andere woorden, intis nietvereist om de waarde -32.768 weer te geven.


Antwoord 2, autoriteit 23%

De grootte van de numerieke typen is niet gedefinieerd in de C++-standaard, hoewel de minimumgroottes dat wel zijn. De manier om te zien hoe groot ze op uw platform zijn, is door numerieke limieten

De maximale waarde voor een int kan bijvoorbeeld worden gevonden door:

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

Computers werken niet in grondtal 10, wat betekent dat de maximale waarde in de vorm van 2n-1 zal zijn vanwege de manier waarop de getallen in het geheugen worden weergegeven. Neem bijvoorbeeld acht bits (1 byte)

 0100 1000

Het meest rechtse bit (getal) indien ingesteld op 1 staat voor 20, het volgende bit 21, dan 22enzovoort aan totdat we bij de meest linkse bit komen die, als het nummer niet is ondertekend, 27vertegenwoordigt.

Het getal staat dus voor 26+ 23= 64 + 8 = 72, omdat de 4e bit van rechts en de 7e bit rechts links zijn ingesteld.

Als we alle waarden instellen op 1:

11111111

Het nummer is nu (ervan uitgaande dat niet ondertekend)
128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255 = 28– 1
En zoals we kunnen zien, is dat de grootst mogelijke waarde die kan worden weergegeven met 8 bits.

Op mijn machine en int en een long zijn hetzelfde, elk kan tussen -231tot 231– 1 bevatten. In mijn ervaring de meest voorkomende maat op moderne 32-bits desktopcomputer.


Antwoord 3, autoriteit 10%

Om de limieten van uwsysteem te achterhalen:

#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";
}

Merk op dat long longalleen legaal is in C99 en in C++11.


Antwoord 4, autoriteit 8%

Andere mensen zullen hier links plaatsen naar data_sizes en precisies enz.
Ik ga je vertellen hoe je er zelf achter kunt komen.
Schrijf een kleine app die het volgende doet.

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

dit zal (afhankelijk van compiler en architectuur) 2, 4 of 8 afdrukken, zeg 2 bytes lang, 4 bytes lang enz.

Laten we aannemen dat het 4 is.

Je wilt nu de maximale waarde die 4 bytes kunnen opslaan, de maximale waarde voor één byte is (in hex)0xFF. De maximale waarde van vier bytes is 0x gevolgd door 8 f’s (een paar f’s voor elke byte, de 0x vertelt de compiler dat de volgende string een hexadecimaal getal is). Wijzig nu uw programma om die waarde toe te wijzen en het resultaat af te drukken

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

Dat is de maximale waarde die een niet-ondertekende int kan bevatten, weergegeven in basis 10 weergave.

Doe dat nu voor longs, shorts en alle andere INTEGER-waarden waar je nieuwsgierig naar bent.

NB: Deze benadering werkt niet voor getallen met drijvende komma (d.w.z. dubbel of zwevend).

Hopelijk helpt dit


Antwoord 5, autoriteit 6%

In C++ worden nu int en andere gegevens opgeslagen met behulp van de compliment-methode van 2.
Dat betekent dat het bereik is:

-2147483648 to 2147483647

of -2^31 tot 2^31-1

1 bit is gereserveerd voor 0, dus positieve waarde is één minder dan 2^(31)


Antwoord 6, autoriteit 3%

U kunt de functies numeric_limits<data_type>::min()en numeric_limits<data_type>::max()gebruiken die aanwezig zijn in limitsheader-bestand en vind de limieten van elk gegevenstype.

#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;
}

De uitvoer zal zijn:
Limieten van gegevenstypen:

  • char : -128 tot 127
  • unsigned char: 0 tot 255
  • kort: -32768 tot 32767
  • ongetekend kort: 0 tot 65535
  • int: -2147483648 tot 2147483647
  • unsigned int: 0 tot 4294967295
  • lang: -2147483648 tot 2147483647
  • unsigned long: 0 tot 4294967295
  • lang lang: -9223372036854775808 tot 9223372036854775807
  • unsigned long long: 0 tot 18446744073709551615
  • float: 1.17549e-038 tot 3.40282e+038
  • dubbel: 2.22507e-308 tot 1.79769e+308
  • lang dubbel: 3.3621e-4932 tot 1.18973e+4932

Antwoord 7

Voor niet-ondertekend gegevenstypeis er geen tekenbit en zijn alle bits voor gegevens
; terwijl voor ondertekend gegevenstypeMSB wordt aangegeven met tekenbit en resterende bits voor gegevens.

Doe het volgende om het bereik te vinden:

Stap:1 -> Ontdek het aantal bytes voor het gegeven gegevenstype.

Stap:2 -> Pas de volgende berekeningen toe.

     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 

Voor bijv.

Voor niet-ondertekende int-grootte = 4 bytes (32 bits) –> Bereik [0 , (2^(32)) – 1]

Voor ondertekende int-grootte = 4 bytes (32 bits) –> Bereik [-(2^(32-1)) , (2^(32-1)) – 1]


Antwoord 8

Nee, slechts een deel van het tiencijferige nummer kan worden opgeslagen in een niet-ondertekende lange int waarvan het geldige bereik 0 tot 4.294.967.295 is.
hier kun je naar verwijzen:
http://msdn.microsoft.com/en-us /bibliotheek/s3f49ktz(VS.80).aspx


Antwoord 9

Je moet kijken naar de specialisaties van de numeric_limits<> sjabloon voor een bepaald type. Het staat in de kop.


Antwoord 10

Kan niet-ondertekende lange int een getal van tien cijfers bevatten (1.000.000.000 – 9.999.999.999) op een 32-bits computer.

Nee

Other episodes