C++ von den Grundlagen bis zum Profi — Folge 5

Die in diesem Blog verfassten Artikel wurden mit dem Ziel erstellt, zu unterrichten. Außerdem können die Informationen im Artikel falsch sein, also seien Sie bitte vorsichtig.

Lassen Sie uns etwas über die Datentypen von Variablen lernen. Es lässt sich grob in vier Kategorien einteilen.

Grundlegender Datentyp. Dies sind die grundlegendsten Typen, die direkt dem Speicher zugeordnet werden.

1-A. Besonderer Zweck

void: hat keine Größe. Es belegt nicht direkt den Speicher und ist ein unvollständiger Typ.

std::nullptr_t: Typ des Nullzeigerliterals nullptr.

void DoSomething() {} //Funktion ohne Rückgabewert
void* ptr = nullptr;  //untypisierter Zeiger
std::nullptr_t null_val = nullptr;

1-B. Arithmetischer Typ

1-B-1. Ganze Zahl char, signiertes char, unsigniertes char: Zeichen speichern. Es gibt auch wchar_t für Unicode. short, int, long, long long: Speichert vorzeichenbehaftete Ganzzahlen. unsigned short, unsigned int, unsigned long, unsigned long long: Speichert vorzeichenlose Ganzzahlen. Da keine negativen Zahlen gespeichert werden, ist der Speicherplatz für positive Zahlen doppelt so groß wie für vorzeichenbehaftete. bool: Speichert wahr oder falsch. Verwendet 1 Byte, nicht 1 Bit.

char c = 'A';
int count = -10;
unsigned int u_count = 20;
bool is_valid = true;

1-B-2 Gleitkommatyp

Typen, die IEEE 754 folgen, Grundsätzlich gibt es Float, Double und Long Double. Es gibt auch std::float16t, std::float32t, std::float64t, std::float128t und std::bfloat16_t. (C++23-Erweiterung)

float f_val = 3.14f;
double d_val = 3.1415926535;

2. Komplexer Datentyp Dies ist ein Typ, der eine Struktur im Speicher definiert, indem er Basistypen oder andere komplexe Typen kombiniert.

Zeiger (T): Zeigt auf eine Speicheradresse eines anderen Typs T. Zeiger auf Member (T::): Ein spezieller Zeiger, der auf den Speicheroffset einer bestimmten Membervariablen oder -funktion innerhalb einer Klasse zeigt.

Referenz: L-Wert-Referenz (T&): Ein Alias ​​für ein Objekt (L-Wert), das einen Namen und eine Substanz im Speicher hat. Rvalue-Referenz (T&&, C++11): Bindet an temporäre Objekte und ist ein Kerntyp von Move Semantics und Perfect Forwarding.

Array (Array, T[N] / T[]): Ordnet aufeinanderfolgenden Speicherblöcken Daten desselben Typs zu. Funktion: Auch die Signatur selbst, bestehend aus einem Rückgabetyp und einer Parameterliste, ist ein eindeutiger Typ. (z. B. int(double, char))

Aufzählung: Aufzählung: Eine einfache Aufzählung ohne Angabe des Bereichs (ermöglicht implizite Ganzzahlkonvertierung).

Enum-Klasse (C++11): Eine Aufzählung mit strengem Gültigkeitsbereich (starke Typprüfung und Bereichsgarantien). Benutzerdefinierter Typ (Klasse/Struktur/Union): Ein Typ, der objektorientierte und Datenstrukturen implementiert, indem er Speicherauffüllungs- und Ausrichtungsregeln steuert.

int value = 10;
int* ptr = &value; //Zeiger
int& ref = value;  //L-Wert-Referenz
int&& r_ref = 20;  //R-Wert-Referenz


struct MyStruct { int x; };
int MyStruct::* member_ptr = &MyStruct::x; //Mitgliedszeiger


int arr[5] = {1, 2, 3, 4, 5}; //Anordnung
int(*func_ptr)(int, int);     //Funktionszeiger


enum class Color { Red, Green, Blue }; //strenge Aufzählung

3. Systemarchitekturspezifischer Alias Hierbei handelt es sich um Kernaliastypen, deren Größe je nach Compiler und Betriebssystemarchitektur (32-Bit/64-Bit) dynamisch bestimmt wird. (<cstddef>-Header)

std::sizet: Rückgabetyp des sizeof-Operators. Es handelt sich um eine vorzeichenlose Ganzzahl, die die Bytegröße des größten Objekts ausdrücken kann, das im System erstellt werden kann. (Standardeinheit für die Containerindizierung und Speicherzuweisung) std::ptrdifft: Eine Ganzzahl mit Vorzeichen, die den Abstand darstellt, wenn zwei Zeiger subtrahiert werden. Wird zur Berechnung der Differenz zwischen Speicheradressen verwendet.

#include <cstddef>

int arr[10];
std::size_t arr_size = sizeof(arr); //Maximale Größe je nach Systemarchitektur garantiert
std::ptrdiff_t diff = &arr[5] - &arr[0]; //Abstand zwischen Zeigern berechnen (5)

4. CV-Qualifikanten Wenn im Typsystem von C++ allen oben genannten Datentypen Qualifizierer hinzugefügt werden, werden diese aus Sicht des Compilers als völlig unterschiedliche Typen behandelt und überladen. (z. B. int und const int sind unterschiedliche Typen)

const: Verhindert das Schreiben in den entsprechenden Speicherbereich und sorgt für Unveränderlichkeit. flüchtig: Verhindert zwangsweise die Speicher-Lese-/Schreiboptimierung des Compilers. Bei der Steuerung von Hardwareregistern oder der Kommunikation mit MMIO (Memory-Mapped I/O) wird es im Wesentlichen verwendet, um den Compiler darüber zu informieren, dass Registerwerte von einer externen Quelle geändert werden können.

const int MAX_VALUE = 100; //Schreibgeschützt, kann nicht geändert werden
//MAX_VALUE = 200; // Kompilierungsfehler ist aufgetreten

volatile int hardware_register; //Vermeiden Sie Compileroptimierung
//Externe Hardware kann den Wert ändern, sodass er jedes Mal direkt aus dem Speicher und nicht aus dem Cache gelesen wird