🤪 Kapitel 1.05.1 - Atomare Datentypen
Anfang der 1990’er Jahre hat Karl Bihlmeier eine Comicfigur entwickelt, die bei Amiga Fans zum Kult wurde.
Es war „Hermann der User“, er beschäftigt sich mit den typischen Problemen eines Computer-Nerd in und mit seinem Umfeld.
Veröffentlicht wurden diese unter anderem im „Amiga Magazin“ des Markt & Technik Verlags.
Vielen Dank an Karl Bihlmeier für die Erlaubnis zur Veröffentlichung 😉
Es war „Hermann der User“, er beschäftigt sich mit den typischen Problemen eines Computer-Nerd in und mit seinem Umfeld.
Veröffentlicht wurden diese unter anderem im „Amiga Magazin“ des Markt & Technik Verlags.
Vielen Dank an Karl Bihlmeier für die Erlaubnis zur Veröffentlichung 😉
🤪 Zuerst eine kleine historische Anmerkung
Zu Beginn der Programmiersprache C wurde die Größe eines Datentypes an die Busbreite der zugrunde liegenden CPU gemünzt. Also auf 16 Bit Systemen wie zum Beispiel der ↗ Intel 8086 war der generische Datentyp für eine Integerzahlint
16 Bit breit. Auf neueren CPUs dann 32- oder 64 Bit breit. Das führte dann zu Problemen, da viele Programmierer die Größe fest in Ihren Programmen “verdrahtet” haben, nämlich wenn diese auf eine anderer CPU übertragen wurden, passen plötzlich Indizes nicht mehr oder es wurde zu wenig Speicher angefordert. Auch viele aktuellen Probleme das in App-Stores viele Programme nicht mehr auf neueren Systemen verfügbar sind, ist auf genau diese Problematik zurück zu führen da eine Anpassung der Codebasis zu aufwendig ist aufgrund zu vieler "Annahmen" vom internen Verhalten des benutzten Compilers.
Mit einer der frühen ↗ ANSI-C Standarisierung 1999 wurde das Problem adressiert, das generische Datentypen mit festen Angaben zur Größe versehen werden konnten um solche Probleme zu reduzieren.
-
int8_t
char
Erklärung:
8 Bit Ganzzahl mit Vorzeichen
Wertebereich:
-128 bis 127 -
uint8_t
unsigned char
Erklärung:
8 Bit Ganzzahl ohne Vorzeichen
Wertebereich:
0 bis 255 -
int16_t
short
Erklärung:
16 Bit Ganzzahl mit Vorzeichen - Achtung: Der Datentyp ist nur dann Atomar, wenn die CPU in der Lage ist, 16 Bit Werte direkt zu verarbeiten, sonst wird dieser mit mehreren Operationen verarbeitet.
Wertebereich:
-32768 bis 32767 -
uint16_t
unsigned short
Erklärung:
16 Bit Ganzzahl ohne Vorzeichen - Achtung: Der Datentyp ist nur dann Atomar, wenn die CPU in der Lage ist, 16 Bit Werte direkt zu verarbeiten, sonst wird dieser mit mehreren Operationen verarbeitet.
Wertebereich:
0 bis 65535 -
int32_t
long
Erklärung:
32 Bit Ganzzahl mit Vorzeichen - Achtung: Der Datentyp ist nur dann Atomar, wenn die CPU in der Lage ist, 32 Bit Werte direkt zu verarbeiten, sonst wird dieser mit mehreren Operationen verarbeitet.
Wertebereich:
-2147483648 bis 2147483647 -
uint32_t
unsigned long
Erklärung:
32 Bit Ganzzahl ohne Vorzeichen - Achtung: Der Datentyp ist nur dann Atomar, wenn die CPU in der Lage ist, 32 Bit Werte direkt zu verarbeiten, sonst wird dieser mit mehreren Operationen verarbeitet.
Wertebereich:
0 bis 4294967295 -
int64_t
long long
Erklärung:
64 Bit Ganzzahl mit Vorzeichen - Achtung: Der Datentyp ist nur dann Atomar, wenn die CPU in der Lage ist, 64 Bit Werte direkt zu verarbeiten, sonst wird dieser mit mehreren Operationen verarbeitet.
Wertebereich:
-9223372036854775808 bis 9223372036854775807 -
uint64_t
unsigned long long
Erklärung:
64 Bit Ganzzahl ohne Vorzeichen - Achtung: Der Datentyp ist nur dann Atomar, wenn die CPU in der Lage ist, 64 Bit Werte direkt zu verarbeiten, sonst wird dieser mit mehreren Operationen verarbeitet.
Wertebereich:
0 bis 18446744073709551615 -
float
Erklärung:
32 Bit Gleitkommazahl mit Vorzeichen und einfacher Genauigkeit, 6 Stellen Genauigkeit, ab der 7. Gerundet
Die Gleitkommazahlen sind nach der ↗ IEEE 754 spezifiziert.
Wertebereich:
±1,175494351 * 10⁻³⁸ bis ±3,402823466 * 10³⁸ -
double
Erklärung:
64 Bit Gleitkommazahl mit Vorzeichen und doppelte Genauigkeit, 15 Stellen Genauigkeit, ab der 16. Gerundet
Die Gleitkommazahlen sind nach der ↗ IEEE 754 spezifiziert.
Achtung: Der Datentyp ist nur dann Atomar, wenn die CPU in der Lage ist, 64 Bit Werte direkt zu verarbeiten, sonst wird dieser mit mehreren Operationen verarbeitet.
Wertebereich:
±2,2250738585072014 * 10⁻³⁰⁸ bis ±1,7976931348623157 * 10³⁰⁸ -
long double
Erklärung:
128 Bit Gleitkommazahl mit Vorzeichen und erhöhter doppelter Genauigkeit, Ab 18 Stellen Genauigkeit, dieser Typ wird je nach System/Compiler unterschiedlich behandelt.
Die Gleitkommazahlen sind nach der ↗ IEEE 754 spezifiziert.
Achtung: Der Datentyp ist nur dann Atomar, wenn die CPU in der Lage ist, 128 Bit Werte direkt zu verarbeiten, sonst wird dieser mit mehreren Operationen verarbeitet.
Wertebereich:
ca. ±3,4 × 10⁻⁴⁹³² bis ±1,1 × 10⁴⁹³²
Alle Downloads zu diesem Projekt:
💾 DatentypenAtomar.c
💾 DatentypenAtomar.pro
Inhalt von: DatentypenAtomar.c
..1: //+------------------------------------------------------------------
..2: //|
..3: //| Projekt : Kapitel1 - DatentypenAtomar
..4: //| Versionsnummer : V1.00
..5: //| Projektbeschreibung : Vorstellung der wichtigsten Atomaren
..6: //| : Datentypen unter C
..7: //|
..8: //| Autor : Salomo Sokoll - ss@salomo-sokoll.de
..9: //| Programmierung mit C und C++ ohne ideologischen Ballast
.10: //| https://salomo-sokoll.de/Buch/C_CPP/index.html
.11: //|
.12: //+------------------------------------------------------------------
.13:
.14: // Einbinden aller benötigten Header-Dateien (.h)
.15: #include "stdio.h"
.16: #include "inttypes.h"
.17: #include "math.h"
.18:
.19: int main( )
.20: {
.21:
.22: // *
.23: // ** Integer (Ganze Zahlen)
.24: // *
.25:
.26: // Integer mit 8 Bit Breite
.27: int8_t Test_Vozeichen_8 = -100;
.28: uint8_t Test_Vozeichenlos_8 = 250;
.29:
.30: printf( "int8_t = %d\n", Test_Vozeichen_8 );
.31: printf( "uint8_t = %u\n", Test_Vozeichenlos_8 );
.32:
.33: // Integer mit 16 Bit Breite
.34: int16_t Test_Vozeichen_16 = -32000;
.35: uint16_t Test_Vozeichenlos_16 = 60000;
.36:
.37: printf( "int16_t = %d\n", Test_Vozeichen_16 );
.38: printf( "uint16_t = %u\n", Test_Vozeichenlos_16 );
.39:
.40: // Integer mit 32 Bit Breite
.41: int32_t Test_Vozeichen_32 = -1000000;
.42: uint32_t Test_Vozeichenlos_32 = 4000000000;
.43:
.44: printf( "int32_t = %d\n", Test_Vozeichen_32 );
.45: printf( "uint32_t = %u\n", Test_Vozeichenlos_32 );
.46:
.47: // Integer mit 64 Bit Breite
.48: int64_t Test_Vozeichen_64 = -4000000000000;
.49: uint64_t Test_Vozeichenlos_64 = 8000000000000;
.50:
.51: printf( "int64_t = %lld\n", Test_Vozeichen_64 );
.52: printf( "uint64_t = %llu\n", Test_Vozeichenlos_64 );
.53:
.54: // *
.55: // ** Gleitkommazahl (5 Stellen Genauigkeit, ab der 6. gerundet)
.56: // ** Einfache Genauigkeit
.57: // *
.58:
.59: float Test_Gleit32 = M_PI;
.60:
.61: printf( "float = %.6f\n", Test_Gleit32 );
.62:
.63: // *
.64: // ** Gleitkommazahl (15 Stellen Genauigkeit, ab der 16. gerundet)
.65: // ** Doppelte Genauigkeit
.66: // *
.67:
.68: double Test_Gleit64 = M_PI;
.69:
.70: printf( "double = %.15f\n", Test_Gleit64 );
.71:
.72: // *
.73: // ** Gleitkommazahl (Ab 18 Stellen Genauigkeit)
.74: // ** Erhöhter Doppelte Genauigkeit
.75: // ** Achtung: Dieser Typ wird je nach System/Compiler unterschiedlich behandelt
.76: // *
.77:
.78: long double Test_Gleit128 = M_PI;
.79:
.80: printf( "long double = %.18Lf\n", Test_Gleit128 );
.81:
.82:
.83: return( 0 );
.84: }
.85:
Inhalt von: DatentypenAtomar.pro
..1: #+------------------------------------------------------------------
..2: #|
..3: #| Projekt : Kapitel1 - DatentypenAtomar
..4: #| Versionsnummer : V1.00
..5: #| Projektbeschreibung : Vorstellung der wichtigsten Atomaren
..6: #| : Datentypen unter C
..7: #| Lauffähig unter : Alle Systeme / Compiler ab ANSI-C 1999
..8: #|
..9: #| Autor : Salomo Sokoll - ss@salomo-sokoll.de
.10: #| Programmierung mit C und C++ ohne ideologischen Ballast
.11: #| https://salomo-sokoll.de/Buch/C_CPP/index.html
.12: #|
.13: #+------------------------------------------------------------------
.14:
.15: TARGET = DatentypenAtomar
.16: TEMPLATE = app
.17:
.18: SOURCES += DatentypenAtomar.c
💾 DatentypenAtomar.c
💾 DatentypenAtomar.pro
Inhalt von: DatentypenAtomar.c
..1: //+------------------------------------------------------------------
..2: //|
..3: //| Projekt : Kapitel1 - DatentypenAtomar
..4: //| Versionsnummer : V1.00
..5: //| Projektbeschreibung : Vorstellung der wichtigsten Atomaren
..6: //| : Datentypen unter C
..7: //|
..8: //| Autor : Salomo Sokoll - ss@salomo-sokoll.de
..9: //| Programmierung mit C und C++ ohne ideologischen Ballast
.10: //| https://salomo-sokoll.de/Buch/C_CPP/index.html
.11: //|
.12: //+------------------------------------------------------------------
.13:
.14: // Einbinden aller benötigten Header-Dateien (.h)
.15: #include "stdio.h"
.16: #include "inttypes.h"
.17: #include "math.h"
.18:
.19: int main( )
.20: {
.21:
.22: // *
.23: // ** Integer (Ganze Zahlen)
.24: // *
.25:
.26: // Integer mit 8 Bit Breite
.27: int8_t Test_Vozeichen_8 = -100;
.28: uint8_t Test_Vozeichenlos_8 = 250;
.29:
.30: printf( "int8_t = %d\n", Test_Vozeichen_8 );
.31: printf( "uint8_t = %u\n", Test_Vozeichenlos_8 );
.32:
.33: // Integer mit 16 Bit Breite
.34: int16_t Test_Vozeichen_16 = -32000;
.35: uint16_t Test_Vozeichenlos_16 = 60000;
.36:
.37: printf( "int16_t = %d\n", Test_Vozeichen_16 );
.38: printf( "uint16_t = %u\n", Test_Vozeichenlos_16 );
.39:
.40: // Integer mit 32 Bit Breite
.41: int32_t Test_Vozeichen_32 = -1000000;
.42: uint32_t Test_Vozeichenlos_32 = 4000000000;
.43:
.44: printf( "int32_t = %d\n", Test_Vozeichen_32 );
.45: printf( "uint32_t = %u\n", Test_Vozeichenlos_32 );
.46:
.47: // Integer mit 64 Bit Breite
.48: int64_t Test_Vozeichen_64 = -4000000000000;
.49: uint64_t Test_Vozeichenlos_64 = 8000000000000;
.50:
.51: printf( "int64_t = %lld\n", Test_Vozeichen_64 );
.52: printf( "uint64_t = %llu\n", Test_Vozeichenlos_64 );
.53:
.54: // *
.55: // ** Gleitkommazahl (5 Stellen Genauigkeit, ab der 6. gerundet)
.56: // ** Einfache Genauigkeit
.57: // *
.58:
.59: float Test_Gleit32 = M_PI;
.60:
.61: printf( "float = %.6f\n", Test_Gleit32 );
.62:
.63: // *
.64: // ** Gleitkommazahl (15 Stellen Genauigkeit, ab der 16. gerundet)
.65: // ** Doppelte Genauigkeit
.66: // *
.67:
.68: double Test_Gleit64 = M_PI;
.69:
.70: printf( "double = %.15f\n", Test_Gleit64 );
.71:
.72: // *
.73: // ** Gleitkommazahl (Ab 18 Stellen Genauigkeit)
.74: // ** Erhöhter Doppelte Genauigkeit
.75: // ** Achtung: Dieser Typ wird je nach System/Compiler unterschiedlich behandelt
.76: // *
.77:
.78: long double Test_Gleit128 = M_PI;
.79:
.80: printf( "long double = %.18Lf\n", Test_Gleit128 );
.81:
.82:
.83: return( 0 );
.84: }
.85:
Inhalt von: DatentypenAtomar.pro
..1: #+------------------------------------------------------------------
..2: #|
..3: #| Projekt : Kapitel1 - DatentypenAtomar
..4: #| Versionsnummer : V1.00
..5: #| Projektbeschreibung : Vorstellung der wichtigsten Atomaren
..6: #| : Datentypen unter C
..7: #| Lauffähig unter : Alle Systeme / Compiler ab ANSI-C 1999
..8: #|
..9: #| Autor : Salomo Sokoll - ss@salomo-sokoll.de
.10: #| Programmierung mit C und C++ ohne ideologischen Ballast
.11: #| https://salomo-sokoll.de/Buch/C_CPP/index.html
.12: #|
.13: #+------------------------------------------------------------------
.14:
.15: TARGET = DatentypenAtomar
.16: TEMPLATE = app
.17:
.18: SOURCES += DatentypenAtomar.c
Die Ausgabe sollte in etwa so aussehen:
int8_t = -100
uint8_t = 250
int16_t = -32000
uint16_t = 60000
int32_t = -1000000
uint32_t = 4000000000
int64_t = -4000000000000
uint64_t = 8000000000000
float = 3.141593
double = 3.141592653589793
long double = 3.141592653589793116
uint8_t = 250
int16_t = -32000
uint16_t = 60000
int32_t = -1000000
uint32_t = 4000000000
int64_t = -4000000000000
uint64_t = 8000000000000
float = 3.141593
double = 3.141592653589793
long double = 3.141592653589793116
