Is de grootte van C “int” 2 bytes of 4 bytes?

Neemt een integer-variabele in C 2 of 4 bytes in beslag? Van welke factoren hangt het af?

De meeste leerboeken zeggen dat integer-variabelen 2 bytes in beslag nemen.
Maar als ik een programma uitvoer dat de opeenvolgende adressen van een reeks gehele getallen afdrukt, wordt het verschil van 4 weergegeven.


Antwoord 1, autoriteit 100%

Ik weet dat het gelijk is aan sizeof(int). De grootte van een intis echt compiler-afhankelijk. Vroeger, toen processors 16 bits waren, was een int2 bytes. Tegenwoordig is het meestal 4 bytes op zowel 32-bits als 64-bits systemen.

Toch is het gebruik van sizeof(int)de beste manier om de grootte van een geheel getal te krijgen voor het specifieke systeem waarop het programma wordt uitgevoerd.

EDIT:Verkeerde uitspraak verholpen dat int8 bytes is op de meeste 64-bits systemen. Het is bijvoorbeeld 4 bytes op 64-bits GCC.


Antwoord 2, autoriteit 55%

Dit is een van de punten in C die in het begin verwarrend kan zijn, maar de C-standaard specificeert alleen een minimumbereikvoor integer-typen dat gegarandeerd wordt ondersteund. intkan gegarandeerd -32767 tot 32767 bevatten, wat 16 bits vereist. In dat geval is int2 bytes. Implementaties zijn echter vrij om verder te gaan dan dat minimum, aangezien je zult zien dat veel moderne compilers int32-bit maken (wat ook betekent dat 4 bytes vrij alomtegenwoordig is).

De reden dat er in uw boek 2 bytes staat, is hoogstwaarschijnlijk omdat het oud is. Ooit was dit de norm. Over het algemeen moet u altijd de operator sizeofgebruiken als u wilt weten hoeveel bytes het is op het platform dat u gebruikt.

Om dit aan te pakken, heeft C99 nieuwe typen toegevoegd waar je expliciet om een bepaald geheel getal kunt vragen, bijvoorbeeld int16_tof int32_t. Daarvoor was er geen universele manier om een geheel getal met een specifieke breedte te krijgen (hoewel de meeste platforms vergelijkbare typen per platform boden).


Antwoord 3, autoriteit 17%

Er is geen specifiek antwoord. Het hangt af van het platform. Het is implementatie-gedefinieerd. Het kan 2, 4 of iets anders zijn.

Het idee achter intwas dat het moest overeenkomen met de natuurlijke “woord”-grootte op het gegeven platform: 16 bit op 16-bit platforms, 32 bit op 32-bit platforms, 64 bit op 64-bits platforms snap je het idee. Voor achterwaartse compatibiliteitsdoeleinden houden sommige compilers echter liever vast aan 32-bits int, zelfs op 64-bits platforms.

De tijd van 2-byte intis echter allang voorbij (16-bit platforms?) Tenzij u een ingebed platform met een 16-bit woordgrootte gebruikt. Je studieboeken zijn waarschijnlijk erg oud.


Antwoord 4, autoriteit 10%

Het antwoord op deze vraag hangt af van het platform dat u gebruikt.
Maar ongeacht het platform kunt u op betrouwbare wijze de volgende typen aannemen:

[8-bit] signed char: -127 to 127
 [8-bit] unsigned char: 0 to 255
 [16-bit]signed short: -32767 to 32767
 [16-bit]unsigned short: 0 to 65535
 [32-bit]signed long: -2147483647 to 2147483647
 [32-bit]unsigned long: 0 to 4294967295
 [64-bit]signed long long: -9223372036854775807 to 9223372036854775807
 [64-bit]unsigned long long: 0 to 18446744073709551615

Antwoord 5, autoriteit 8%

C99 N1256 standaard concept

http://www.open-std. org/JTC1/SC22/WG14/www/docs/n1256.pdf

De grootte van inten alle andere integer-types zijn door de implementatie gedefinieerd, C99 specificeert alleen:

  • minimale maat garanties
  • relatieve maten tussen de typen

5.2.4.2.1 “Grootten van integer-types <limits.h>” geeft de minimale afmetingen:

1 […] Hun implementatie-gedefinieerde waarden zullen gelijk zijn aan of groter zijn in grootte (absolute waarde) aan die getoond […]

  • UCHAR_MAX 255 // 2 8 − 1
  • USHRT_MAX 65535 // 2 16 − 1
  • UINT_MAX 65535 // 2 16 − 1
  • ULONG_MAX 4294967295 // 2 32 − 1
  • ULLONG_MAX 18446744073709551615 // 2 64 − 1

6.2.5 “Typen” zegt dan:

8 Voor twee willekeurige typen gehele getallen met dezelfde ondertekendheid en verschillende conversierang voor gehele getallen
(zie 6.3.1.1), het bereik van waarden van het type met een kleinere geheeltallige conversierang is a
subbereik van de waarden van het andere type.

en 6.3.1.1 “Boolean, tekens en gehele getallen” bepalen de relatieve conversierangen:

1 Elk type geheel getal heeft een conversierang voor gehele getallen die als volgt is gedefinieerd:

  • De rangorde van lange lange int zal groter zijn dan de rangorde van lange int, wat:
    groter zijn dan de rangorde van int, die groter zal zijn dan de rangorde van short
    int, die groter zal zijn dan de rang van ondertekende char.
  • De rangorde van elk type geheel getal zonder teken is gelijk aan de rangorde van de corresponderende
    ondertekend integer type, indien aanwezig.
  • Voor alle typen gehele getallen T1, T2 en T3, als T1 een hogere rang heeft dan T2 en T2 heeft
    hogere rang dan T3, dan heeft T1 een hogere rang dan T3

Antwoord 6, autoriteit 6%

Neemt een integer-variabele in C 2 bytes of 4 bytes in beslag?

Dat hangt af van het platform dat u gebruikt, en ook van hoe uw compiler is geconfigureerd. Het enige gezaghebbende antwoord is het gebruik van de sizeofoperator om te zien hoe groot een geheel getal is in uw specifieke situatie.


Van welke factoren hangt het af?

Bereikkan het beste worden overwogen, in plaats van maat. Beide zullen in de praktijk variëren, hoewel het veel onfeilbaarder is om variabele typen te kiezen op bereik dan op grootte, zoals we zullen zien. Het is ook belangrijk op te merken dat de standaard ons aanmoedigt om onze integer-typen te kiezen op basis van bereikin plaats van grootte, maar laten we voor nu de standaardpraktijk negeren, en laat onze nieuwsgierigheid sizeof, bytes en CHAR_BITen integere representatie onderzoeken… laten we in het konijnenhol graven en het zelf zien…


sizeof, bytes en CHAR_BIT

De volgende verklaring, overgenomen uit de C-standaard (gekoppeld aan hierboven), beschrijft dit in woorden die volgens mij niet verbeterd kunnen worden.

De operator sizeoflevert de grootte (in bytes) van zijn operand op, wat een uitdrukking kan zijn of de naam tussen haakjes van een type. De grootte wordt bepaald aan de hand van het type operand.

Ervan uitgaande dat een duidelijk begrip zal leiden tot een discussie over bytes. Algemeen wordt aangenomen dat een byteacht bits is, terwijl in feite CHAR_BITvertelt je hoeveel bits er in een byte zitten. Dat is gewoon weer een van die nuances waar geen rekening mee wordt gehouden als we het hebben over de gewone gehele getallen van twee (of vier) bytes.

Laten we het tot nu toe afronden:

  • sizeof=> grootte in bytes, en
  • CHAR_BIT=> aantal bits in byte

Dus, afhankelijk van uw systeem, kan sizeof (unsigned int)elkewaarde groter dan nul zijn (niet alleen 2 of 4), alsof CHAR_BITis 16, dan heeft een enkele (zestien-bits) bytegenoeg bits om het zestien-bits gehele getal te vertegenwoordigen dat wordt beschreven door de standaarden (hieronder vermeld). Dat is niet per se nuttige informatie, toch? Laten we dieper graven…


Gehele weergave

De C-standaard specificeert de minimale precisie/het minimumbereik voor alle standaard integer-typen (en ook CHAR_BITfwiw) hier. Hieruit kunnen we een minimumafleiden voor het aantal bits dat nodig is om de waardeop te slaan, maar we kunnen onze variabelen net zo goed kiezen op basis van bereikenem>. Desalniettemin bevindt een groot deel van de details die nodig zijn voor dit antwoord zich hier. Bijvoorbeeld het volgende dat de standaard unsigned int(minstens) zestien bits opslag vereist:

UINT_MAX                                65535 // 2¹⁶ - 1

Zo kunnen we zien dat unsigned int(minstens) 16 bitsvereist, en dat is waar je de twee bytes krijgt (ervan uitgaande dat CHAR_BIT8) is… en later, toen die limiet werd verhoogd tot 2³² - 1, gaven mensen in plaats daarvan 4 bytes aan. Dit verklaart de verschijnselen die je hebt waargenomen:

De meeste leerboeken zeggen dat integer-variabelen 2 bytes in beslag nemen. Maar als ik een programma uitvoer dat de opeenvolgende adressen van een reeks gehele getallen afdrukt, wordt het verschil van 4 weergegeven.

Je gebruikt een oud leerboek en compiler die je niet-draagbare C leert; de auteur die je leerboek heeft geschreven, weet misschien niet eens van CHAR_BIT. U moetuw leerboek (en compiler) upgraden en ernaar streven om te onthouden dat I.T. is een steeds evoluerend veld dat je vooropmoet blijven om te kunnen concurreren… Maar genoeg daarover; laten we eens kijken welke andere niet-draagbare geheimen die onderliggende integer bytesopslaan…

Waardebitszijn wat de meest voorkomende misvattingen lijken te tellen. Het bovenstaande voorbeeld gebruikt een unsignedinteger type dat doorgaans alleen waardebits bevat, dus het is gemakkelijk om de duivel in de details te missen.

Tekenbits… In het bovenstaande voorbeeld heb ik UINT_MAXaangehaald als de bovengrens voor unsigned intomdat het een triviaal voorbeeld is om extraheer de waarde 16uit de opmerking. Voor ondertekende typen moeten we, om onderscheid te maken tussen positieve en negatieve waarden (dat is het teken), ook het tekenbit opnemen.

INT_MIN                                -32768 // -(2¹⁵)
INT_MAX                                +32767 // 2¹⁵ - 1

Opvulbits… Hoewel het niet gebruikelijk is om computers tegen te komen met opvulbits in gehele getallen, staat de C-standaard dat toe; sommige machines (bijv. deze) implementeer grotere integer-types door twee kleinere (signed) integer-waarden samen te combineren… en wanneer je ondertekende integers combineert, krijg je een verspild tekenbit. Dat verspilde bit wordt beschouwd als paddingin C. Andere voorbeelden van opvulbits kunnen zijn: pariteitsbits en trapbits.


Zoals je kunt zien, lijkt de standaard aan te moedigen om reeksen als INT_MIN..INT_MAXen andere minimum/maximum waarden van de standaardbij het kiezen van integer-types, en ontmoedigtom te vertrouwen op formaten, aangezien er andere subtiele factoren zijn die waarschijnlijk worden vergeten, zoals CHAR_BITen opvulbits die de waarde van sizeof (int)kunnen beïnvloeden (dwz de algemene misvattingen van gehele getallen van twee bytes en vier bytesnegeren deze details).


Antwoord 7, autoriteit 4%

De enige garanties zijn dat charminstens8 bits breed, shorten intmoet zijn minstens16 bits breed en longmoet minstens32 bits breed zijn, en dat sizeof (char)<= sizeof (short)<= sizeof (int)<= sizeof (long)(hetzelfde geldt voor de niet-ondertekende versies van die soorten).

intkan tussen de 16 en 64 bits breed zijn, afhankelijk van het platform.


Antwoord 8, autoriteit 4%

Is de grootte van C “int” 2 bytes of 4 bytes?

Het antwoord is “ja” / “nee” / “misschien” / “misschien niet”.

De programmeertaal C specificeert het volgende: de kleinste adresseerbare eenheid, bekend onder charen ook wel “byte”genoemd, is precies CHAR_BITbits breed, waarbij CHAR_BITminimaal 8 is.

Dus, één bytein C is niet noodzakelijkerwijs een octet, d.w.z. 8 bits. In het verleden had een van de eerste platforms waarop C-code (en Unix) draaide 4-byte int– maar in totaal had int36 bits, omdat CHAR_BITwas 9!

intwordt verondersteld de natuurlijke gehele grootte te zijn voor het platform met een bereik van minstens -32767 ... 32767. Je kunt de grootte van intin de platformbytes krijgen met sizeof(int); als je deze waarde vermenigvuldigt met CHAR_BITweet je hoe breed deze is in bits.


Hoewel 36-bits machines meestal dood zijn, zijn er nog steeds platforms met niet-8-bits bytes. Gisteren was er een vraag over een Texas Instruments MCU met 16-bits bytes, die een C99, C11-compatibele compiler heeft .

Op TMS320C28xlijkt het erop dat char, shorten intzijn allemaal16 bits breed, en dus één byte. long intis 2 bytes en long long intis 4 bytes. Het mooie van C is dat je nog steeds een efficiënt programma kunt schrijven voor een platform als dit, en dat zelfs op een draagbare manier!


Antwoord 9, autoriteit 2%

Het hangt meestal af van het platform dat u gebruikt. Het hangt af van compiler tot compiler. Tegenwoordig is intin de meeste compilers 4 bytes.
Als u wilt controleren wat uw compiler gebruikt, kunt u sizeof(int)gebruiken.

main()
{
    printf("%d",sizeof(int));
    printf("%d",sizeof(short));
    printf("%d",sizeof(long));
}

Het enige dat de compiler belooft, is dat de grootte van short gelijk moet zijn aan of kleiner moet zijn dan int en de grootte van long gelijk moet zijn aan of groter moet zijn dan int.Dus als de grootte van int 4 is, dan kan de grootte van short 2 of 4 zijn maar niet groter dan dat. Hetzelfde geldt voor lang en int. Er staat ook dat de maat kort en lang niet hetzelfde kan zijn.


Antwoord 10

Dit hangt af van de implementatie, maar gewoonlijk nemen x86 en andere populaire architecturen zoals ARM ints 4 bytes in beslag. U kunt tijdens het compileren altijd controleren met sizeof(int)of een ander type dat u wilt controleren.

Als je er zeker van wilt zijn dat je een type van een specifieke maat gebruikt, gebruik dan de typen in <stdint.h>


Antwoord 11

#include <stdio.h>
int main(void) {
    printf("size of int: %d", (int)sizeof(int));
    return 0;
}

Dit geeft 4 terug, maar het is waarschijnlijk machine-afhankelijk.


Antwoord 12

Is de grootte van C “int” 2 bytes of 4 bytes?

Neemt een integer-variabele in C 2 bytes of 4 bytes in beslag?

C staat toe dat “bytes” iets anders is dan 8 bits per “byte”.

CHAR_BITaantal bits voor het kleinste object dat geen bitveld (byte) is C11dr §5.2.4.2.1 1

Een waarde van meer dan 8 wordt steeds zeldzamer. Gebruik voor maximale draagbaarheid CHAR_BITin plaats van 8. De grootte van een intin bitsin C is sizeof(int) * CHAR_BIT.

#include <limits.h>
printf("(int) Bit size %zu\n", sizeof(int) * CHAR_BIT);

Van welke factoren hangt het af?

De bitgrootte intis gewoonlijk 32 of 16 bits. C gespecificeerde minimum bereiken:

minimumwaarde voor een object van het type intINT_MIN-32767
maximale waarde voor een object van het type intINT_MAX+32767
C11dr §5.2.4.2.1 1

Het minimumbereikvoor intdwingt de bitgrootte om minstens16 te zijn – zelfs als de processor “8-bits” was. Een grootte als 64 bits wordt gezien in gespecialiseerde processors. Andere waarden zoals 18, 24, 36, etc. hebben plaatsgevonden op historische platforms of zijn in ieder geval theoretisch mogelijk. Moderne codering maakt zich zelden zorgen over niet-power-of-2 intbitgroottes.

De processor en architectuur van de computer sturen de selectie van de intbitgrootte aan.

Maar zelfs met 64-bits processors kan de grootte van de intvan de compiler 32-bit zijn om compatibiliteitsredenen, aangezien grote codebases afhankelijk zijn van het feit dat int32-bit is (of 32/16).


Antwoord 13

Dit is een goede bron om deze vraag te beantwoorden.

Maar deze vraag is een soort van altijd waarheidsantwoord “Ja. Beide.”

Het hangt af van uw architectuur. Als u op een 16-bits machine of minder gaat werken, mag deze niet 4 byte (=32 bit) zijn. Als u op een 32-bits of betere machine werkt, is de lengte 32-bits.

Om erachter te komen, maak je programma klaar om iets leesbaars uit te voeren en gebruik je de “sizeof”-functie. Dat retourneert de grootte in bytes van uw gedeclareerde datatype. Maar wees voorzichtig met het gebruik van dit met arrays.

Als je int t[12];declareert, wordt 12*4 byte geretourneerd. Om de lengte van deze array te krijgen, gebruik je gewoon sizeof(t)/sizeof(t[0]).
Als je een functie gaat bouwen, die de grootte van een send-array zou moeten berekenen, onthoud dan dat als

typedef int array[12];
int function(array t){
    int size_of_t = sizeof(t)/sizeof(t[0]);
    return size_of_t;
}
void main(){
    array t = {1,1,1};  //remember: t= [1,1,1,0,...,0]
    int a = function(t);    //remember: sending t is just a pointer and equal to int* t
   print(a);   // output will be 1, since t will be interpreted as an int itselve. 
}

Dus dit levert niet eens iets anders op. Als je een array definieert en daarna de lengte probeert te krijgen, gebruik dan sizeof. Als u een array naar een functie verzendt, onthoud dan dat de verzendwaarde slechts een aanwijzer is op het eerste element. Maar in het geval dat u altijd weet welke grootte uw array heeft. Geval twee kan worden bedacht door twee functies te definiëren en wat prestaties te missen. Definieer functie (array t) en definieer functie2 (array t, int size_of_t). Roep “function(t)” aan, meet de lengte door wat kopieerwerk en stuur het resultaat naar function2, waar je kunt doen wat je wilt met variabele array-groottes.

Other episodes