Übersicht der Datentypen

C++ Datentyp erlaubte Werte | Wertebereich |
Beispielcode 		Speicherbedarf Anwendungsbeispiele |
Wichtige Hinweise
bool (Boolean) 0, false, LOW
1, true, HIGH

bool lowBit = false;
bool highBit = true;
bool taster = LOW;
bool merker = 5;  // 1, true, HIGH 		8 Bit = 1 Byte Als Merker zum Speichern von Informationen oder Zuständen (Taster wurde betätigt, neue Messdaten liegen vor).
Achtung: In dem Byte kann ein Wert > 1 gespeichert werden, ohne dass es einen Fehler beim Compilieren gibt. Dieser wird dann als 1, true oder HIGH gewertet.
Bitte auf die korrekte Groß- und Kleinschreibung der binären Zustände achten!
byte
(uint8_t) 		0 bis 255
(0 bis 28–1)

byte dez = 2;
byte bin = 0b10110111;  // Binär
byte okt = 073;  // Oktal
byte hex = 0x20;  // Hex 		8 Bit = 1 Byte Für die Darstellung von kleinen dezimalen, binären, oktalen oder hexadezimalen Werten (z. B. für das Schreiben in interne Register eines Digitalbausteines).
Als alternative binäre Schreibweise kann auch byte bin = B10110111; verwendet werden. Jedoch ist diese Wertangabe auf 8 Bit beschränkt.
char 0 bis 255
(0 bis 28–1)

char zeichen = 'A';
char charHex = 0x20;  // Leerzeichen
char charDez = 43;  // Zeichen '+'
zeichen = zeichen + 1;  // Zeichen 'B'
zeichen = zeichen –1 + 32;
// Zeichen 'a'		 8 Bit = 1 Byte Zum Einlesen oder der Ausgabe einzelner ASCII-Zeichen. Es gibt bei der ASCII-Codierung keine negative Werte. Das führt beim Compilieren jedoch nicht zu einer Fehlermeldung.
Wertzuweisungen für die Variable vom Typ char müssen in einfachen Anführungszeichen stehen. Bei der Zuweisung wird das angegebene Zeichen als Zahlenwert gespeichert. Die Ausgabe eines Wertes vom Typ char erfolgt als ASCII-codiertes Zeichen. Es können im Seriellen Monitor der Arduino-IDE nur ASCII-Zeichen im dezimalen Zahlenraum von 0 bis 127 ausgegeben werden.
char (Array)
char-Array = String		 Ein Zahlenbereich kann aufgrund der Variabilität nicht angegeben werden.

char str1[10] = "Eingabe: ";
// Zeichenkette mit fester Größe
char str2[ ] = "Ready!";
// Zeichenkette mit undefinierter
// Größe. Der Speicherbedarf wird
// in Abhängigkeit von der
// Größe der Zeichenkette
// automatisch festgelegt.
String str3 = "Messung beendet!";
Serial.println(str2);  // Ready!		 1 Byte pro Zeichen + 1 Byte für das Textende-Zeichen ('\0') Zum Einlesen oder der Ausgabe von Zeichenketten.
Die Inhalte von Zeichenketten (hier als char-Array) müssen in doppelten Anführungsstrichen geschrieben werden!
Als Alternative kann auch der Datentyp String verwendet werden.
Bei Zeichenketten mit fester Größe ist die nutzbare Zeichenzahl immer um 1 kleiner als der reservierte Zeichenbereich, da am Ende der Zeichenkette zusätzlich ein Textende-Zeichen ('\0') eingefügt wird.
short
(int16_t) 		–32.768 bis +32.767
(–215 bis 215–1)
 16 Bit = 2 Bytes
 Zum Speichern von mittelgroßen positiven und negativen ganzen Zahlen.
unsigned short
(uint16_t)		 0 bis +65.535
(0 bis 216–1)
 		16 Bit = 2 Bytes
 		Zum Speichern von mittelgroßen positiven ganzen Zahlen.
int (integer)
(int16_t) oder
(int32_t) 		–32.768 bis +32.767
(–215 bis 215–1) oder
–2.147.483.648 bis +2.147.483.647
(–231 bis 231–1) 		16 Bit = 2 Bytes oder
32 Bit = 4 Bytes 		Zum Speichern von großen positiven und negativen ganzen Zahlen (z. B. aktuelle Werte eines Lage-Sensors mit großem Werteumfang)
Beim ESP32 werden 4 Bytes für eine Integer-Variable verwendet. Zwischen dem Variablentyp int und long gibt es somit keinen Unterschied.
unsigned int
(uint16_t) oder
(uint32_t) 		0 bis +65.535
(0 bis 216–1) oder
0 bis 4.294.967.295
(0 bis 232–1) 		16 Bit = 2 Bytes oder
32 Bit = 4 Bytes 		Zum Speichern von großen positiven ganzen Zahlen (z. B. aktuelle Werte eines digitalen Druck-Sensors mit großem Wertebereich).
Beim ESP32 werden 4 Bytes für eine Integer-Variable verwendet. Zwischen dem Variablentyp unsigned int und unsigned long gibt es somit keinen Unterschied.
long
(int32_t)
 		–2.147.483.648 bis +2.147.483.647
(–231 bis 231–1) 		32 Bit = 4 Bytes Zum Speichern sehr großer ganzahliger positiver und negativer Zahlenwerte
Beim ESP32 entspricht dieser Datentyp dem integer.
unsigned long
(uint32_t)
 		0 bis 4.294.967.295
(0 bis 232–1) 		32 Bit = 4 Bytes Zum Speichern sehr großer ganzahliger positiver und negativer Zahlenwerte
Beim ESP32 entspricht dieser Datentyp dem integer.
float –3,4028235 · 1038 bis
+3,4028235 · 1038

float pi = 3.414;
// Als Komma muss ein Punkt eingegenen werden!
float epsilon = 8.854E–12;
// Es kann ein kleines oder großes
// E für die Darstellung der Zehner-
// potenz verwendet werden 		32 Bit = 4 Bytes

1 Vorzeichenbit,
8 Bit für den Exponenten (Excess-127-Notation) und
23 Bit für die Mantisse 		Für Zahlenwerte mit Nachkommastellen (z. B. berechnete Geschwindigkeit, analog eingelesene und korrigierte Spannung).
Der Dateityp float ist eine Gleitkommazahl. In dieser gibt es eine feste Zahl von Bits für die Darstellung des Zahlenwertes (Mantisse, Zahl zwischen 1.0 und 2.0) und dem Exponenten (variable Kommaposition).
Der Datentyp float besitzt nur eine Genauigkeit von 6 oder 7 Dezimalstellen, wobei hier nicht die Stellen rechts vom Komma gemeint sind. Die Ungenauigkeiten einer Gleitkommazahl kann man sehr gut mit Hilfe eines float-Converters verdeutlichen, wenn man dort beispielsweise die Zahl 6379575.954323 eingibt.
double –1,79769313486231570 · 10308 bis
+1,79769313486231570 · 10308		 64 Bit = 8 Bytes

1 Vorzeichenbit,
11 Bit für den Exponenten (Excess-127-Notation) und
52 Bit für die Mantisse		 Für die Berechnung von Zahlenwerten mit Nachkommastellen und hoher Genauigkeit.
Beim ESP32 werden 8 Byte (64 Bit) im RAM für eine Gleitkommazahl mit doppelter Genauigkeit reserviert. Bei den meisten 8-Bit Arduino- bzw. ATMEGA-Boards (z. B. UNO, NANO) ist die Auflösung von double identisch mit der von float (Ausnahme: Arduino DUE). Die Verwendung von double führt somit bei diesen Boards nicht zu einem Gewinn an Genauigkeit.

Neben diesen Variablentypen bietet der Compiler der Arduino-IDE noch weitere Integer-Deklarationstypen. Diese sind in der Bibliothek stdint.h definiert, die Bestandteil der Arduino-Entwicklungsumgebung ist und automatisch eingebunden wird. Mit diesen Alias-Typen kann ein Programmierer den Speicherbedarf einer Integer-Variable in Bits exakt festlegen. Es empfiehlt sich, diese Variablentypen zu verwenden, da durch sie der Code besser lesbar ist und sich zudem einfacher auf andere Plattformen portieren lässt.

Alias-Datentypen
der Arduino-IDE 		Wertebereich
int8_t –128 bis 127 (signed, 8 Bit = 1 Byte)
uint8_t 0 bis 255 (unsigned, 8 Bit = 1 Byte)
int16_t –32.768 bis 32767 (signed, 16 Bit = 2 Byte)
uint16_t 0 bis 65.535 (unsigned, 16 Bit = 2 Byte)
int32_t –2.147.483.648 bis 2.147.483.647 (signed, 32 Bit = 4 Byte)
uint32_t 0 bis 4.294.967.295 (unsigned, 32 Bit = 4 Byte)
int64_t –9.223.372.036.854.775.808 bis 9.223.372.036.854.775.807 (signed, 64 Bit = 8 Byte)
uint64_t 0 bis 1,84467441•1019 (unsigned, 64 Bit = 8 Byte)

Übung 1:
Entwickle unter Verwendung der sizeof()-Funktion (sie gibt die Zahl der reservierten Bytes für einen Datentyp zurück) ein Arduino-Programm, das für unterschiedliche Controller die Zahl der benötigten Bytes für die o. g. Datentypen im Seriellen Monitor ausgibt.
Führe das Programm auf einem Arduino UNO und auf einem ESP32 aus und vergleiche die Ausgabe-Ergebnisse.

Übung 2:
Entwickle ein Programm, das den dezimalen Wertebereich von 0 bis 127 in einer Schleife durchläuft und die ASCII-Zeichen in Form einer Tabelle ausgeben kann. Nutze dazu die Escape-Sequenz für das Erzeugen eines Tabulators \t für die Ausgabe im Seriellen Monitor der Arduino-IDE.

// Beispiel-Code (Auszug) für die Ausgabe im Seriellen Monitor
Serial.print(dezimalwert);  // Ausgabe des Dezimalwertes
Serial.print("\t");  // Ausgabe Tabulator
Serial.println(ascii_zeichen);  // Ausgabe des ASCII-Zeichens

 

Überarbeitung: Gerhard Klähn

Zuletzt geändert: Sonntag, 12. Januar 2025, 01:27