Här är de primitiva datatyperna som ofta hanteras av CPU:er, tillsammans med deras typiska storlekar och representationer:
grundläggande typer
* heltal (int):
* Representerar hela siffror (inga fraktioner).
* Vanligtvis 16 bitar (2 byte), 32 bitar (4 byte) eller 64 bitar (8 byte) i storlek.
* Signerad:Kan representera både positiva och negativa värden.
* Unsigned:Kan endast representera icke-negativa värden.
* Exempel:-10, 0, 5, 2147483647
* flytande punkt (flottör/dubbel):
* Representerar siffror med fraktionella delar (decimaler).
* Vanligtvis 32 bitar (4 byte) för `float` och 64 bitar (8 byte) för` dubbel '.
* Följer IEEE 754 Standard för representation.
* Exempel:3.14, -0.005, 1.2345E -10
* karaktär (char):
* Representerar ett enda tecken (bokstav, siffra, symbol).
* Vanligtvis 8 bitar (1 byte).
* Använder ofta ASCII eller Unicode -kodning för kartläggningstecken till numeriska värden.
* Exempel:'a', '!', '?', '1'
boolean (bool):
* Representerar sanningsvärden (sant eller falskt).
* Vanligtvis 1 bit (även om det ofta lagras som en byte för effektivitet).
* Exempel:sant, falska
Andra primitiva typer (beroende på arkitektur)
* pekare:
* Lagrar minnesadressen för ett annat dataelement.
* Storlek beror på arkitekturen (t.ex. 32-bitars eller 64-bitars).
* bitfield:
* Tillåter att packa flera booleska värden i en enda byte.
* Varje bit representerar ett separat booleskt värde.
Viktiga anteckningar
* Arkitektur: Den exakta storleken och representationen av primitiva typer kan variera mellan CPU-arkitekturer (t.ex. x86, ARM, RISC-V).
* Programmeringsspråk: Programmeringsspråk på hög nivå som C, C ++, Java och Python tillhandahåller vanligtvis sin egen uppsättning primitiva datatyper, som ofta kartlägger de underliggande CPU-typerna.
Låt mig veta om du vill ha en mer detaljerad förklaring av en specifik primitiv typ!
