Phenquestions
Der Speicher eines Computers besteht aus einer Reihe von Zellen. Jede Zelle hat die Größe eines Bytes, normalerweise ist dies der Platz, der von einem westeuropäischen Zeichen eingenommen wird. Die Größe eines Objekts wird in Bytes angegeben. Dieser Artikel gibt eine Zusammenfassung der C++-Typen. Sie sollten bereits Grundkenntnisse in C++ haben, um diesen Artikel zu verstehen.
Artikelinhalt
- Grundlegende Typen
- Möglichkeiten zur Konstruktion zusammengesetzter Typen
- Arrays
- Aufzählung
- Klasse
- Union
- Verweise
- Funktionen
- Andere zusammengesetzte Typen
- Fazit
Grundlegende Typen
Fundamentale Typen sind skalare Typen.
bool
Ein boolescher Typ oder bool-Typ hat den Wert true oder false für 1 oder 0. Wahr oder falsch belegt ein Byte.
char, unsigned char und signiertes char
Ein Zeichen steht normalerweise für ein westeuropäisches Zeichen. Es belegt normalerweise ein Byte. Es gibt auch ein vorzeichenloses und ein vorzeichenbehaftetes Zeichen, das jeweils eine 8-Bit-Ganzzahl ist. Zeichen ohne Vorzeichen enthalten keine negativen Werte, während Zeichen mit Vorzeichen negative Werte enthalten. Die Art des Wertes, den ein char hat, hängt vom Compiler ab und kann nur ein vorzeichenloses char sein. Diese drei Zeichentypen werden als schmale Zeichentypen bezeichnet und jeder belegt ein Byte.
Ganze Zahl
Es gibt fünf ganzzahlige Standardtypen ohne Vorzeichen und fünf ganzzahlige Standardtypen mit Vorzeichen. Die fünf vorzeichenlosen Integer-Typen sind: „unsigned char“, „unsigned short int“, „unsigned int“, „unsigned long int“ und „unsigned long long int“. Die fünf entsprechenden vorzeichenbehafteten Integer-Typen sind: „signed char“, „short int“, „int“, „long int“ und „long long int“.
„unsigned char“ ist der gleiche Typ wie die schmalen Zeichentypen (siehe oben). „signed char“ ist der andere Typ der schmalen Zeichentypen (siehe oben).
Beim g++-Compiler belegt „unsigned char“ oder „signed char“ ein Byte; „unsigned short int“ oder „short int“ belegt zwei Bytes; „unsigned int“ oder „int“ belegt vier Byte; „unsigned long int“ oder „long int“ belegt 8 Byte; „unsigned long long int“ oder „long long int“ belegt noch 8 Byte (Stand jetzt).
char16_t, char32_t, wchar_t
Beim Umgang mit westeuropäischen Zeichen reicht der Zeichentyp in vielen Situationen aus. Beim Umgang mit Chinesisch und anderen östlichen Sprachen wird jedoch char16_t oder char32_t oder wchar_t benötigt. Beim g++-Compiler belegt char16_t zwei Byte; char32_t belegt vier Bytes und wchar_t belegt ebenfalls vier Bytes.
Der bool-, der char-, der char16_t-, der char32_t-, der wchar_t-, der vorzeichenbehaftete und der vorzeichenlose Integer-Typ bilden eine weitere Menge, die als ganzzahlige (integer) Typen bezeichnet wird.
An dieser Stelle des Artikels wurden zwei Kollektivtypen erwähnt: schmale Zeichentypen und ganzzahlige Typen.
Gleitkommatypen
Angenommen, die Zahlen 457.000 und 457.230 sind die gleichen Werte, gemessen von zwei verschiedenen Messgeräten. 457.230 ist genauer als 457.000, weil der Wert detaillierter ist (bezieht sich auf kleinere Stellen: + 200 plus 30). Eine Gleitkommazahl ist eine Zahl mit einem gebrochenen (dezimalen) Teil. Obwohl Zahlen im Computer eine Folge von Bits sind, sind einige Gleitkommazahlen genauer als die anderen.
Einige Messgeräte nehmen Messungen in minimalen Schritten vor, sagen wir 10 Einheiten. Ein solches Instrument hätte die folgenden Messwerte: 10, 20, 30, 40,… 100, 110, 130, 140,… 200, 210, 220, 230, 240 usw. Obwohl Zahlen im Computer eine Folge von Bits sind, bewegen sich Gleitkommazahlen in einigen Mindestschritten (viel kleiner als 10 Einheiten).
C++ hat drei Gleitkommatypen: float, double und long double. Für jeden Compiler muss double die Genauigkeit haben, die höher ist als die von float oder zumindest die von float; long double muss die Genauigkeit haben, die höher ist als die von double oder mindestens die von double.
Es gibt einen dritten Sammelnamen: arithmetischer Typ. Dies ist der Name für Ganzzahl- und Gleitkommatypen. Beachten Sie, dass dies auch der Name für alle Skalartypen ist, wie bisher erklärt.
Beim g++-Compiler beträgt die Anzahl der Bytes für einen Float vier; die Anzahl der Bytes für ein Double beträgt acht; Die Anzahl der Bytes für ein langes Double beträgt sechzehn.
ungültiger Typ
Beim g++-Compiler beträgt die Größe des void-Typs ein Byte. Das Byte hat offiziell keine Bits, was bedeutet, dass seine Position einen leeren Inhalt hat.
Möglichkeiten zur Konstruktion zusammengesetzter Typen
Zusammengesetzte Typen sind nicht fundamentale Typen. Dies bedeutet, dass zusammengesetzte Typen nicht skalare Typen sind. Dieser Abschnitt erklärt die Grundlagen der zusammengesetzten Typen.
Arrays
Das folgende Codesegment zeigt ein Array von Ints und ein Array von Chars:
int arrInt[] = 1, 2, 3, 4, 5;char arrCha[] = 'a', 'b', 'c', 'd', 'e';
cout << arrInt[2] <<" <
Aufzählung
Eine Aufzählung ist ein Typ mit benannten Konstanten. Betrachten Sie das folgende Codesegment:
Aufzählung a=3, b, c;cout << b <<'\n';
Die Ausgabe ist: 4. Die erste Zeile des Codesegments ist eine Aufzählung und a, b oder c ist eine Aufzählung.
Klasse
Eine Klasse ist eine verallgemeinerte Einheit, aus der viele Objekte derselben verallgemeinerten Einheit erstellt (instanziiert) werden können. Das folgende Programm zeigt eine Klasse und zwei daraus instanziierte Objekte. Ein solches Objekt unterscheidet sich von einem skalaren Objekt.
#einschließenVerwenden von Namespace-Std;
Klasse TheCla
Öffentlichkeit:
int-Zahl = 5;
int fn()
Rückgabenummer;
;
int main()
TheCla obj1;
TheCla obj2;
cout << obj1.num << " << obj2.num <<'\n';
0 zurückgeben;
Die Ausgabe ist: 5 5. Der Name der Klasse ist TheCla und die Namen der beiden Objekte sind obj1 und obj2. Beachten Sie das Semikolon direkt nach der Beschreibung (Definition) der Klasse. Beachten Sie, wie die beiden Objekte in der main()-Funktion instanziiert wurden.
Hinweis: num ist ein Datenmember und fn ist eine Memberfunktion.
Union
strukturieren
Eine Struktur ist wie ein Array, hat aber keine Index/Wert-Paare, sondern Name/Wert-Paare. Die Namen können in beliebiger Reihenfolge geschrieben werden. Das folgende Programm zeigt eine Struktur und ihre Verwendung:
#einschließenVerwenden von Namespace-Std;
struct TheCla
int-Zahl = 5;
Schwimmer flt = 2.3;
char ch = 'a';
obj1, obj2;
int main()
cout << obj2.num <<", "<< obj2.flt <<", "<< obj2.ch <<'\n';
0 zurückgeben;
Die Ausgabe ist:
5, 2.3, a
Der Name der Struktur ist TheCla. obj1 und obj2 sind zwei verschiedene Objekte der Struktur.
Union
Das folgende Programm zeigt eine Union und ihre Verwendung:
#einschließenVerwenden von Namespace-Std;
Gewerkschaft TheCla
int-Zahl;
Schwimmer flt = 2.3;
char-ch;
obj1, obj2;
int main()
cout << obj2.flt <<'\n';
0 zurückgeben;
Die Ausgabe ist: 2.3. Die Vereinigung ähnelt einer Struktur. Der Hauptunterschied zwischen einer Struktur und einer Union besteht darin, dass bei einer Struktur immer nur ein Member einen Wert (initialisiert) haben kann. Im obigen Programm hat das Mitglied flt den Wert 2.3. Jedes der anderen Elemente, num oder ch, kann nur einen Wert next haben, wenn der Wert für flt aufgegeben wird.
Verweise
Eine Referenz ist ein Synonym für eine Kennung. Das folgende Codesegment zeigt, wie Sie einen Verweis auf einen Bezeichner erhalten:
int-ID = 5;int& ref1 = id;
int& ref2 = id;
cout << id << " << ref1 << " << ref2 <<'\n';
Die Ausgabe ist: 5 5 5. ref1 und ref2 sind Synonyme für id.
lvalue-Referenz und rvalue-Referenz
Die obigen Referenzen sind Lvalue-Referenzen. Der folgende Code zeigt eine Rvalue-Referenz:
int&& ref = 5;cout << ref <<'\n';
Die Ausgabe ist: 5. Diese Referenz wird erstellt, ohne einen Speicherort zu identifizieren. Um dies zu erreichen, wird doppeltes & benötigt, d.h.e., &&.
Zeiger
Ein Zeiger ist nicht wirklich eine C++-Entität. Es bietet jedoch ein besseres Schema für den Umgang mit Referenzen. Der folgende Code zeigt, wie ein Zeiger erstellt werden kann:
int ptdId = 5;int ptdId = 5;
int *ptrId;
ptrId = &ptdId;
cout << *ptrId <<'\n';
Die Ausgabe ist: 5. Beachten Sie den Namensunterschied zwischen ptdId und ptdId. ptdId ist das Pointer-Objekt und ptrId ist das Pointer-Objekt. &ptdId gibt die Adresse des Objekts zurück, das ptrId zugewiesen ist. Um den Wert des angezeigten Objekts zurückzugeben, verwenden Sie *ptrId.
Funktionen
Grundfunktion und ihr Aufruf
Der folgende Code zeigt eine grundlegende Funktionsdefinition und ihren Aufruf:
#einschließenVerwenden von Namespace-Std;
int fn(int num)
cout<<"seen"<<'\n';
Rückgabenummer;
int main()
int ret = fn(5);
cout << ret <<'\n';
0 zurückgeben;
Die Ausgabe ist
Funktionsdefinition
5
Der Funktionsaufruf ist fn(5). Der Name der Funktion ist fn.
Referenz und Zeiger auf eine Funktion
&fn gibt die Adresse im Speicher der Funktion zurück, deren Name fn ist. Die folgende Anweisung deklariert einen Zeiger auf eine Funktion:
int (*funktion)();Hier ist func der Name des Zeigers auf die Funktion. Das erste Klammerpaar unterscheidet diesen Funktionszeiger von einem skalaren Objektzeiger. func kann die Adresse einer durch fn identifizierten Funktion wie folgt enthalten:
Funktion = &fn;Das folgende Programm setzt die Funktionsreferenz und den Zeiger in Aktion:
#einschließenVerwenden von Namespace-Std;
int fn(int num)
/* einige Aussagen */
Rückgabenummer;
int main()
int (*funktion)(int);
Funktion = &fn;
int ret = func(5);
cout << ret <<'\n';
0 zurückgeben;
Die Ausgabe ist: 5. Beachten Sie, dass sowohl fn als auch func jeweils den int-Parameter in der Deklaration haben.
Andere zusammengesetzte Typen
Die oben genannten grundlegenden Verbindungstypen sind in sich selbst zusammengesetzt. Sie werden auch verwendet, um ausgearbeitete Verbundtypen zu konstruieren.
Typdef
Das reservierte Wort typedef wird verwendet, um eine Sequenz von Typen durch einen Namen zu ersetzen (für die Sequenz). Das folgende Codesegment veranschaulicht dies:
typedef unsigned long int IduIL;
IduIL myInt = 555555555555555555;cout << myInt <<'\n';
Die Ausgabe ist 555555555555555555. Im Code ist IduIL zu einem Typ geworden, der für „unsigned long int“ steht.
Strukturierte Bindung
Die strukturierte Bindung ist eine Funktion, die es ermöglicht, Unterobjekten Namen zu geben. Der folgende Code veranschaulicht dies für das Array:
int arr[3] = 1, 2, 3;auto [x, y, z](arr);
cout << x <<"<< y <<"<< z <<'\n';
Die Ausgabe ist 1 2 3. Die Werte: 1, 2, 3 haben also die Namen x, y, z. Beachten Sie die Verwendung und Position des reservierten Wortes auto. Beachten Sie auch die Verwendung der eckigen Klammern.
Bit-Feld
Der Speicher ist eine Abfolge von Zellen. Jede Zelle benötigt ein Byte. Außerdem besteht jedes Byte aus acht Bits. Es kann eine Gruppe von Bits, nicht unbedingt acht Bits, gesetzt und geändert werden. Eine solche Gruppe heißt Bitfeld. Diese Gruppen würden nebeneinander liegen. Wenn die Gruppen keinen Typ bilden, sagen wir 16 Bit für ein kurzes Int, werden Füllbits hinzugefügt. Der folgende Code veranschaulicht dies mit der Struktur:
struct Datumunsignierter kurzer wkDay : 3; // Bits
unsignierter kurzer Montag: 6; ///6 Bits
unsigned short mon : 5; ///5 Bits
unsigniert kurzes Jahr : 8; ///8 Bits für 2-stellige Jahreszahl
Tee;
Tee.Wochentag = 1; Tee.Montag = 2; Tee.Montag = 2; Tee.Jahr = 21;
cout << dte.mon <<'/'<< dte.monDay <<'/'<< dte.yr <<'\n';
Die Ausgabe ist: 2/2/21. Die Gesamtzahl der Bits für wkDay, MonDay und mon beträgt 3 + 6 + 5 = 14. Es würden also zwei Füllbits hinzugefügt, um 16 Bits für die kurze Ganzzahl von 2 Bytes (16 Bits) zu bilden. Die nächsten 8 Bits beginnen mit dem nächsten kurzen Int, das dann mit 8 Padding-Bits aufgefüllt wird.
Hinweis: Vermeiden Sie die Verwendung von Bitfeldern; Verwenden Sie es nur für die Forschung.
Namensraum
Ein Namensraum ist eine Menge von Namen, die nicht mit den gleichen Namen anderer Namensmengen kollidieren sollte. Das folgende Programm veranschaulicht die Verwendung derselben Namen aus zwei verschiedenen Namensräumen, die im Namensraum der Funktion main() angewendet werden:
#einschließenVerwenden von Namespace-Std;
Namensraum NS1
int myInt = 8;
Schwimmer flt;
Namensraum NS2
int myInt = 9;
Schwimmer flt;
int main()
cout << NS1::myInt << '\n';
cout << NS2::myInt << '\n';
NS1::flt = 2.5;
NS2::flt = 4.8;
cout << NS1::flt << '\n';
cout << NS2::flt << '\n';
0 zurückgeben;
Die Ausgabe ist:
9
8
2.5
4.8
Es gibt zwei widersprüchliche gleiche int-Namen und zwei widersprüchliche gleiche Float-Namen im Code.
Template und Template-Spezialisierung
Das Vorlagenschema ermöglicht die Verwendung eines Platzhalters für verschiedene mögliche Skalartypen. Spezialisierung ist die Wahl eines bestimmten Skalartyps. Der folgende Code veranschaulicht dies für eine Funktion:
#einschließenVerwenden von Namespace-Std;
Vorlage void func (T cha, U no)
cout << "I need bread for " << cha << no << '.' << '\n';
int main()
func('$', 3);
0 zurückgeben;
Die Ausgabe ist:
„Ich brauche Brot für 3 Dollar.”
Vorlagen-Parameterpaket
Compiler müssen diese Funktion noch vollständig implementieren - siehe später.
Fazit
C++-Typen gibt es in zwei Kategorien: grundlegende Typen und zusammengesetzte Typen. Fundamentale Typen sind skalare Typen. Grundlegende zusammengesetzte Typen sind Arrays, Enumerationen, Klassen, Unions, Referenzen, Zeiger und Funktionen. Diese grundlegenden zusammengesetzten Typen werden verwendet, um ausgearbeitete zusammengesetzte Typen zu konstruieren, bei denen es sich um Typedef, strukturierte Bindungen, Bitfelder, Namensräume und Vorlagenfunktionen handelt.
Chrys
