C ++ - Typen
Der Speicher eines Computers ist eine Reihe von Zellen. Jede Zelle hat die Größe eines Byte. Die Größe eines Objekts ist in Bytes angegeben. Dieser Artikel enthält eine Zusammenfassung von C ++ - Typen. Sie sollten bereits grundlegende Kenntnisse über C ++ haben, um diesen Artikel zu verstehen.
Artikelinhalt
- Grundlegende Typen
- Möglichkeiten zur Konstruktion von zusammengesetzten Typen
- Arrays
- Aufzählung
- Klasse
- Union
- Verweise
- Funktionen
- Andere zusammengesetzte Typen
- Abschluss
Grundlegende Typen
Grundtypen sind Skalartypen.
bool
Ein Boolescher Typ oder Bool -Typ hat einen Wert von True oder False für 1 oder 0. Wahre oder falsch nimmt ein Byte ein.
Char, nicht signiertes Zeichen und unterschriebener Char
Ein STO ist normalerweise für einen westeuropäischen Charakter. Es nimmt normalerweise ein Byte ein. Es gibt auch ein nicht signiertes und signiertes Zeichen, das jeweils eine Acht-Bit-Ganzzahl ist. Unsignierte Zeichen beinhalten keine negativen Werte, während signierte Zeichen negative Werte beinhalten. Die Art des Wertes, den ein SHOD hält. Diese drei Arten von Zeichen werden genannt, schmale Charaktertypen und jeder nimmt ein Byte ein.
Ganze Zahl
Es gibt fünf unsignierte Standardgeistypen und fünf signierte Standardgeistypen. Die fünf nicht signierten Ganzzahltypen sind: "vorzeichenloses Zeichen", "vorzeichenloses kurzes int", "unsigned int", "unsigned long int" und "unsigned long Long Int". Die fünf entsprechenden signierten Ganzzahltypen sind: "Signiertes Zeichen", "Short Int", "int", "Long int" und "Long Long Int".
"Unsigned char" ist der gleiche Typ wie die schmalen Zeichentypen (siehe oben). "Signiertes Zeichen" ist der andere Typ der schmalen Zeichentypen (siehe oben).
Mit dem G ++ - Compiler befindet sich „nicht signiertes Zeichen“ oder „signiertes Zeichen“ ein Byte. "Unsigned Short Int" oder "Short Int" nimmt zwei Bytes ein; "Unsigned int" oder "int" besetzt vier Bytes; "Unsigned Long INT" oder "Long Int" besetzt 8 Bytes; "Unsigned Long Long Int" oder "Long Long Int" nimmt immer noch 8 Bytes ein (ab sofort).
char16_t, char32_t, wchar_t
Im Umgang mit westeuropäischen Charakteren reicht der Char -Typ in vielen Situationen aus. Wenn Sie jedoch mit chinesischen und anderen östlichen Sprachen umgehen, ist char16_t oder char32_t oder wchar_t erforderlich. Mit dem G ++ - Compiler befindet sich char16_t zwei Bytes; char32_t nimmt vier bytes ein und wchar_t nimmt auch vier bytes ein.
Das Bool, das Zeichen, das char16_t, der char32_t, das wchar_t, der signierte und die nicht signierten Ganzfleisch -Typen bilden einen anderen Satz, das als Integral (Ganzzahl) Typen bezeichnet wird.
Zu diesem Zeitpunkt im Artikel wurden zwei kollektive Typen erwähnt: enge Charaktertypen und Integraltypen.
Schwimmende Punkttypen
Angenommen, die Zahlen 457.000 und 457.230 sind dieselbe Lesart, gemessen an zwei verschiedenen Messinstrumenten. 457.230 sind präziser als 457.000, da der Wert detaillierter ist (kleinere Orte: + 200 plus 30). Eine Schwimmpunktzahl ist eine Zahl mit einem fraktionalen (Dezimal-) Teil. Obwohl Zahlen im Computer eine Abfolge von Bits sind, sind einige schwimmende Punktzahlen präziser als die anderen.
Einige Messinstrumente ergreifen Messungen in minimalen Schritten, z. B. 10 Einheiten. Ein solches Instrument hätte die folgenden Lesungen: 10, 20, 30, 40,… 100, 110, 130, 140,… 200, 210, 220, 230, 240 usw. Obwohl Zahlen im Computer eine Abfolge von Bits sind, reichen die Gleitkomma-Zahlen in einigen minimalen Schritten (viel kleiner als 10 Einheiten).
C ++ hat drei Gleitkomma-Typen, nämlich: Float, Double und Long Double. Für jeden Compiler muss das Doppel die Präzision haben, die höher ist als die des Schwimmers oder zumindest die des Schwimmers; Langes Doppel muss die Genauigkeit haben, die höher ist als die des Doppel- oder zumindest die des Doppel.
Es gibt einen dritten kollektiven Namen: arithmetischer Typ. Dies ist der Name für Integral- und Gleitkomma-Typen. Beachten Sie, dass dies auch der Name für alle Skalartypen ist, wie bisher erläutert.
Mit dem G ++ - Compiler beträgt die Anzahl der Bytes für einen Schwimmer vier; Die Anzahl der Bytes für ein Doppel ist acht; Die Anzahl der Bytes für ein langes Doppel beträgt sechzehn.
Hohlraumtyp
Mit dem G ++ - Compiler ist die Größe des Hohlraumtyps ein Byte. Das Byte hat offiziell keine Teile, was bedeutet, dass sein Standort leere Inhalte hat.
Möglichkeiten zur Konstruktion von zusammengesetzten Typen
Verbundtypen sind nicht fundamentale Typen. Dies bedeutet, dass Verbundtypen nicht-Scalar-Typen sind. Dieser Abschnitt erklärt die Grundlagen von zusammengesetzten Typen.
Arrays
Das folgende Code -Segment zeigt eine Reihe von INTs und eine Reihe von Zeichen:
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:
enum 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 ein Aufzähler.
Klasse
Eine Klasse ist eine verallgemeinerte Einheit, aus der viele Objekte derselben verallgemeinerten Einheit erstellt werden können (instanziiert). Das folgende Programm zeigt eine Klasse und zwei Objekte, die daraus instanziiert sind. Ein solches Objekt unterscheidet sich von einem skalaren Objekt.
#enthaltenVerwenden von Namespace STD;
Klasse Thecla
öffentlich:
int num = 5;
int fn ()
Rückgabe num;
;
int main ()
Thecla obj1;
Thecla obj2;
Cout << obj1.num << " << obj2.num <<'\n';
Rückkehr 0;
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 Datenmitglied und FN ist eine Mitgliedsfunktion.
Union
Struktur
Eine Struktur ist wie ein Array, aber anstatt Index-/Wertpaare zu haben, enthält sie Namen/Wertpaare. Die Namen können in jeder Reihenfolge geschrieben werden. Das folgende Programm zeigt eine Struktur und ihre Verwendung:
#enthaltenVerwenden von Namespace STD;
Struktur Thecla
int num = 5;
float flt = 2.3;
char ch = 'a';
obj1, obj2;
int main ()
Cout << obj2.num <<", "<< obj2.flt <<
","<< obj2.ch <<'\n';
Rückkehr 0;
Die Ausgabe ist:
5, 2.3, aDer Name der Struktur ist Thecla. OBJ1 und OBJ2 sind zwei verschiedene Objekte der Struktur.
Union
Das folgende Programm zeigt eine Gewerkschaft und ihre Verwendung:
#enthaltenVerwenden von Namespace STD;
Union thecla
int num;
float flt = 2.3;
char ch;
obj1, obj2;
int main ()
Cout << obj2.flt <<'\n';
Rückkehr 0;
Die Ausgabe ist: 2.3. Die Gewerkschaft ähnelt einer Struktur. Der Hauptunterschied zwischen einer Struktur und einer Gewerkschaft besteht darin, dass für eine Struktur nur ein Mitglied zu jeder Zeit einen Wert (initialisiert) haben kann. Im obigen Programm hat das Mitglied FLT einen Wert von 2.3. Jedes der anderen Mitglieder, Num oder CH, kann als nächstes nur einen Wert 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 eine Kennung 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 zu ID.
LVALUE -Referenz und RValue -Referenz
Die obigen Referenzen sind lvalue Referenzen. Der folgende Code zeigt RValue -Referenz:
int && ref = 5;Cout << ref <<'\n';
Die Ausgabe ist: 5. Diese Referenz wird erstellt, ohne einen Ort im Speicher zu identifizieren. Um dies zu erreichen, wird doppelt und wird benötigt, ich.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 spitzen Objekt und Ptrid ist das Zeigerobjekt. & ptdid gibt die Adresse des spitzen Objekts zurück, das PTRID zugeordnet ist. Verwenden Sie *PTRID, um den Wert des spitzen Objekts zurückzugeben, um *PTRID zu verwenden.
Funktionen
Grundfunktion und ihr Aufruf
Der folgende Code zeigt eine grundlegende Funktionsdefinition und ihren Aufruf an:
#enthaltenVerwenden von Namespace STD;
int fn (int num)
Cout<<"seen"<<'\n';
Rückgabe num;
int main ()
int ret = fn (5);
Cout << ret <<'\n';
Rückkehr 0;
Die Ausgabe ist
gesehen5
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 Erklärung erklärt einen Zeiger auf eine Funktion:
int (*func) ();Hier ist Func der Name des Zeigers auf die Funktion. Das erste Paar von Klammern unterscheidet diesen Funktionszeiger von einem skalaren Objektzeiger. Func kann gemacht werden, um die Adresse einer von FN identifizierten Funktion wie folgt zu halten:
func = &fn;Das folgende Programm bringt die Funktionsreferenz und den Zeiger in Aktion:
#enthaltenVerwenden von Namespace STD;
int fn (int num)
/ * einige Aussagen */
Rückgabe num;
int main ()
int (*func) (int);
func = &fn;
int ret = func (5);
Cout << ret <<'\n';
Rückkehr 0;
Die Ausgabe ist: 5. Beachten Sie, dass sowohl FN als auch Func jeweils den INT -Parameter in der Deklaration haben.
Andere zusammengesetzte Typen
Die obigen grundlegenden Verbundtypen sind an sich zusammengesetzt. Sie werden auch verwendet, um ausgearbeitete Verbundtypen zu konstruieren.
Typedef
Das reservierte Wort typedef wird verwendet, um eine Abfolge von Typen durch einen Namen zu ersetzen (für die Sequenz). Das folgende Codesegment zeigt dies:
typedef unsigned long int ideuil;IDUIL MYINT = 555555555555555555;
Cout << myInt <<'\n';
Der Ausgang ist 5555555555555555555. Im Code ist IDUIL ein Typ geworden, der für "nicht signiertes langes int" steht, der steht.
Strukturierte Bindung
Die strukturierte Bindung ist eine Funktion, die es ermöglicht, Namen den UnterObjekten zu verabreichen. Der folgende Code zeigt dies für das Array:
int arr [3] = 1, 2, 3;Auto [x, y, z] (arr);
Cout << x <<"<< y <<"<< z <<'\n';
Der Ausgang ist 1 2 3. Also, die Werte: 1, 2, 3 haben die Namen x, y, z gegeben. Beachten Sie die Verwendung und Position des reservierten Wortes, automatisch. Beachten Sie auch die Verwendung der Quadratklammern.
Bitfeld
Das Gedächtnis ist eine Sequenz von Zellen. Jede Zelle nimmt ein Byte. Außerdem besteht jedes Byte aus acht Teilen. Eine Gruppe von Bits, nicht unbedingt acht Bits, kann festgelegt und geändert werden. Eine solche Gruppe heißt ein Bitfeld. Diese Gruppen würden nebeneinander liegen. Wenn die Gruppen keinen Typ ausmachen, sagen wir 16 Bit für einen kurzen Int, werden Polsterbits hinzugefügt. Der folgende Code zeigt dies mit der Struktur:
Strukturdatumnicht signiertes kurzes WKDAY: 3; // 3 Bit
nicht signierter kurzer Montag: 6; // 6 Bit
nicht signiertes kurzes Mon: 5; // 5 Bit
nicht signiertes kurzes Jahr: 8; // 8 Bit für 2 Ziffernjahr
dte;
dte.wkday = 1; dte.Montag = 2; dte.mon = 2; dte.Jahr = 21;
Cout << dte.mon <<'/'<< dte.monDay <<'/'<< dte.yr <<'\n';
Die Ausgabe ist: 2/2/21. Die Gesamtzahl der Bits für WKday, Montag und Mon beträgt 3 + 6 + 5 = 14. Daher würden zwei Polsterbits hinzugefügt, um 16 Bit für die kurze Ganzzahl von 2 Bytes (16 Bit) auszugleichen. Die nächsten 8 Bit beginnen das nächste kurze Int, das dann mit 8 Polsterbits gefüllt ist.
HINWEIS: Vermeiden Sie die Verwendung von Bitfeldern; Verwenden Sie es nur für die Forschung.
Namespace
Ein Namespace ist eine Reihe von Namen, die nicht mit den gleichen Namen anderer Namenssätze in Konflikt stehen dürfen. Das folgende Programm zeigt die Verwendung der gleichen Namen aus zwei verschiedenen Namenspaces, die im Namespace der Main () -Funktion angewendet werden:
#enthaltenVerwenden von Namespace STD;
Namespace NS1
int myint = 8;
float flt;
Namespace NS2
int myint = 9;
float 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';
Rückkehr 0;
Die Ausgabe ist:
98
2.5
4.8
Es gibt zwei widersprüchliche gleiche Int -Namen und zwei widersprüchliche gleiche Float -Namen im Code.
Vorlage und Vorlagespezialisierung
Das Vorlagenschema ermöglicht die Verwendung eines Platzhalters für verschiedene mögliche Skalartypen. Spezialisierung ist die Auswahl eines bestimmten Skalartyps. Der folgende Code zeigt dies für eine Funktion:
#enthaltenVerwenden von Namespace STD;
Vorlage
void func (t cha, u no)
Cout << "I need bread for " << cha << no << '.' << '\n';
int main ()
func ('$', 3);
Rückkehr 0;
Die Ausgabe ist:
Ich brauche Brot für $ 3.Vorlageparameterpack
Compiler müssen diese Funktion noch vollständig implementieren - siehe später.
Abschluss
C ++ - Typen existieren in zwei Kategorien: grundlegende Typen und zusammengesetzte Typen. Grundtypen sind Skalartypen. Grundlegende zusammengesetzte Typen sind Arrays, Aufzählungen, Klassen, Gewerkschaften, Referenzen, Zeiger und Funktionen. Diese grundlegenden Verbundtypen werden verwendet, um ausgearbeitete Verbundtypen zu konstruieren, die typedef, strukturierte Bindungen, Bitfelder, Namespace und Vorlagenfunktionen sind.