Ausdrücke und Deklarationen in C ++ Programmierung - Dummys

Teil von C ++ für Dummies Cheat Sheet

Um eine Berechnung im C ++ - Programm durchzuführen, benötigen Sie einen Ausdruck. Ein Ausdruck ist eine Anweisung, die sowohl einen Wert als auch einen Typ hat. Im C ++ - Programm ist eine Deklaration eine Anweisung, die eine Variable definiert, oder es ist ein "Vorratstank" für eine Art Wert wie eine Zahl oder ein Zeichen.

Expressions

Ausdrücke haben eine der folgenden Formen:

objName // für einen einfachen Objektoperatorausdruck // für unäre Operatoren expr1 operator expr2 // für binäre Operatoren expr1? expr2: expr3 // für den ternären Operator funcName ([Argumentliste]); // für Funktionsaufrufe

Literalausdrücke

Ein Literal ist eine Form von konstantem Ausdruck. Die verschiedenen Arten von Literalen sind in der folgenden Tabelle definiert.

Beispiel	Typ
1	int
1L	lang int
1LL	lang lang int
1. 0	doppelt
1. 0F	float
'1'	char
"a string"	char * (automatisch mit einem Null-Zeichen abgeschlossen)
L "a string"	wchar_t * > u8 "Dies ist ein UTF-8-String mit einem UTF-8-Zeichen: u2018"
char8_t *	u "Dies ist ein UTF-16-String mit einem UTF-16-Zeichen: u2018"
char16_t *	U "Dies ist eine UTF-32-Zeichenkette mit einem UTF-32-Zeichen:
U00002018" char32_t *	wahr, falsch
bool	0b101
binär (C ++ 2014 Standard)

[] char [] wchar_t [] [] int float [long] double bool

Deklarationen haben eine der folgenden Formen:

[] [const] Typ var [= Ausdruck]; // Variable [] [const] Typ Array [Größe] [= {Liste}]; // array [const] Typ Objekt [(Argumentliste)]; // Objekt [const] Typ Objekt [= {Argumentliste}]; // alternative [const] Typ * [const] ptr [= Zeigerausdruck]; // Zeigertyp & RefName = Objekt; // Referenztyp fnName ([Argumentliste]); // function

Das Schlüsselwort auto kann verwendet werden, wenn C ++ den Typ der Variablen selbst bestimmen kann:

auto var = 1L; // Der Typ von var ist long int

Das Schlüsselwort decltype extrahiert den Typ eines Ausdrucks. Dieser Typ kann dann überall dort verwendet werden, wo ein Typname verwendet wird. Im folgenden Beispiel wird beispielsweise Decltype verwendet, um eine zweite Variable mit demselben Typ wie eine vorhandene Variable zu deklarieren:

decltype (var1) var2; // Der Typ von var2 ist derselbe wie var1

Eine Funktionsdefinition hat folgendes Format:

// simple function [] Typ fnName (Argumentliste) {…} // Memberfunktion definiert außerhalb der Klasse [inline] type Klasse:: func (Argumentliste) [const] {…} // Konstruktor / Destruktoren können auch außerhalb der Klasse definiert werden Klasse:: Class ([Argumentliste]) {…} Klasse:: ~ Class () {… } // constructors / destructor kann gelöscht werden oder wird zurückgesetzt // anstelle der Definition Class:: Class ([Argumentliste]) =; Klasse:: ~ Klasse () =;

Ein überladener Operator sieht wie eine Funktionsdefinition aus.Die meisten überladenen Operatoren können entweder als Member oder einfache Funktionen geschrieben werden. Wenn dies als Elementfunktion geschrieben wird, ist dies das angenommene erste Argument für den Operator:

MeineKlasse & operator + (const MyClass & m1, const MyClass & m2); // einfach MyClass & MyClass:: operator + (const MyClass & m2); // Mitglied;

Benutzer können ihre eigenen Typen auch mit den Schlüsselwörtern class oder struct definieren:

ClassName [: [virtual] [public] BaseClass] {: // Konstruktor ClassName ([Argumentliste]) ClassName () [=;] // Destruktor [virtuell] ~ Klassenname () <{…} | [=; > // Öffentliche Datenelemente geben dataMemberName [= initialValue] ein. // Öffentliche Memberfunktionen type memberFunctionName ([Argumentliste]) [{…}] // Konst-Member Funktionstyp memberFunctionName ([Argumentliste]) const [{…}] // virtueller Memberfunktionen virtueller Typ memberFunctionName ([arg list]) [{…}]; // reiner virtueller Member Funktionen virtueller Typ memberFunctionName ([arg list]) = 0; // Funktion, die einen Basisklassenfunktionstyp überschreiben muss memberFunctionName ([arg list]) override; // eine Funktion, die in einer Unterklasse nicht überschrieben werden kann memberFunctionName ([arg list]) final;};

Darüber hinaus kann ein Konstruktor mit einem einzelnen Argument als explizite Bedeutung gekennzeichnet werden, sodass er nicht in einer impliziten Konvertierung von einem Typ zu einem anderen verwendet wird. Das Markieren eines Konstruktors als Standard bedeutet "Verwenden Sie die Standard-C ++ - Konstruktordefinition". Wenn Sie einen Konstruktor als delete markieren, wird die Standard-C ++ - Konstruktordefinition entfernt.

C ++ unterstützt zwei Arten von Aufzählungstypen. Der folgende alte Aufzählungstyp erzeugt keinen neuen Typ:

enum STATE {DC, // bekommt 0 ALABAMA, // bekommt 1 ALASKA, // bekommt 2 ARKANSAS, // bekommt 3 // … und so weiter}; int n = ALASKA; // ALASKA ist vom Typ int

Standardmäßig hat ein einzelner Eintrag den Typ int, dies kann jedoch im C ++ 2011-Standard geändert werden:

enum ALPHABET: char {A = 'a', // bekommt 'a' B, // bekommt 'b' C, // bekommt 'c' // … und so weiter}; charc = A; // A ist vom Typ char

C ++ 2011 erlaubt ein zweites Format, das einen neuen Typ erzeugt:

// die folgende Enumeration definiert einen neuen Typ STATE enum class STATE {DC, // holt 0 ALABAMA, // bekommt 1 ALASKA, // bekommt 2 ARKANSAS, // bekommt 3 // … und so weiter}; STATE s = ZUSTAND:: ALASKA; // jetzt ist STATE ein neuer Typ // der folgende verwendet einen anderen zugrunde liegenden Typ enum class ALPHABET: char {A = 'a', // bekommt 'a' B, // bekommt 'b' C, // bekommt 'c ' //… und so weiter}; ALPHABET c = ALPHABET:: A; // A ist vom Typ ALPHABET

Template-Deklarationen haben ein etwas anderes Format:

// Typ T wird vom Programmierer bei der Verwendung des Vorlagentyps zur Verfügung gestellt Funktionsname ([arg list]) Vorlagenklasse ClassName {{…}};