Uitdrukkingen en Verklaringen in C ++ Programmeren - dummies

Deel van C ++ voor Dummy's Cheat Sheet

Voor het uitvoeren van een berekening in het C ++ -programma heeft u een uitdrukking nodig. Een uitdrukking is een instructie die zowel een waarde als een type heeft. In het C ++ -programma is een verklaring een verklaring die een variabele definieert of een "opslagtank" voor een soort waarde zoals een getal of teken.

Expressies

Uitdrukkingen nemen een van de volgende vormen aan:

objName // voor een expressie van een eenvoudige objectoperator // voor unaire operatoren expr1 operator expr2 // voor binaire operatoren expr1? expr2: expr3 // voor de ternaire operator funcName ([argumentlijst]); // voor functieaanroepen

Letterlijke uitdrukkingen

Een letterlijke is een vorm van constante expressie. De verschillende typen letterlijke waarden worden in de volgende tabel gedefinieerd.

Voorbeeld	Type
1	int
1L	lang int
1LL	lang lang int
1. 0	dubbele
1. 0F	zweven
'1'	teken
"een tekenreeks"	teken * (automatisch beëindigd met een leeg teken)
L "een tekenreeks"	wchar_t * > u8 "dit is een UTF-8 string met een UTF-8 karakter: u2018"
char8_t *	u "dit is een UTF-16 string met een UTF-16 karakter: u2018"
char16_t *	U "dit is een UTF-32-reeks met een UTF-32-teken:
U00002018" char32_t *	true, false
bool	0b101
binary (C ++ 2014 standaard)

Verklaringen

Verklaringen gebruiken zowel intrinsieke als door de gebruiker gedefinieerde typen. De intrinsieke types zijn

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

Verklaringen hebben een van de volgende vormen:

[] [const] typ var [= expression]; // variabele [] [const] type array [size] [= {list}]; // array [const] type object [(argumentlijst)]; // object [const] type object [= {argumentlijst}]; // alternatief [const] type * [const] ptr [= aanwijzeruitdrukking]; // pointer type & refName = object; // verwijzingstype fnName ([argumentlijst]); // function

Het trefwoord auto kan worden gebruikt als C ++ het type variabele zelf kan bepalen:

auto var = 1L; // het type var is lang int

Het sleutelwoord decltype haalt het type expressie eruit. Dit type kan dan overal worden gebruikt waar een type naam wordt gebruikt. In het volgende voorbeeld wordt bijvoorbeeld decltype gebruikt om een ​​tweede variabele met hetzelfde type als een bestaande variabele te declareren:

decltype (var1) var2; // het type var2 is hetzelfde als var1

Een functiedefinitie heeft de volgende notatie:

// eenvoudige functie [] type fnName (argumentlijst) {…} // ledfunctie gedefinieerd buiten de klasse [inline] type Class:: func (argumentlijst) [const] {…} // constructor / destructors kunnen ook buiten class Class worden gedefinieerd:: Class ([argument list]) {…} Class:: ~ Class () {… } // constructors / destructor kan worden verwijderd of in gebreke gesteld // in plaats van definitie Class:: Class ([argument list]) =; Klasse:: ~ Klasse () =;

Een overbelaste operator ziet eruit als een functiedefinitie.De meeste overbelaste operators kunnen worden geschreven als lid of als eenvoudige functies. Wanneer geschreven als een lidfunctie, * is dit het veronderstelde eerste argument voor de operator:

MyClass & operator + (const MyClass & m1, const MyClass & m2); // simple MyClass & MyClass:: operator + (const MyClass & m2); // lid;

Gebruikers kunnen ook hun eigen typen definiëren met behulp van de klasse- of struct-sleutelwoorden:

ClassName [: [virtual] [public] BaseClass] {: // constructor ClassName ([arg list]) ClassName () [=;] // destructor [virtueel] ~ ClassName () <{…} | [=; > // openbare gegevens leden typen dataMemberName [= initialValue]; // public member functions type memberFunctionName ([arg list]) [{…}] // const member function type memberFunctionName ([arg list]) const [{…}] // virtueel lidfuncties virtueel type memberFunctionName ([arglist]) [{…}]; // pure virtuele lidfuncties virtueel type memberFunctionName ([arg list]) = 0; // functie die een elementhefklassetype for memberFunctionName ([arg list]) moet overschrijven; // een functie die niet kan worden overschreven in een subklasse-type memberFunctionName ([arg list]) final;};

Bovendien kan een constructor met een enkel argument worden gemarkeerd als expliciete betekenis dat het niet zal worden gebruikt bij een impliciete conversie van het ene type naar het andere. Een constructor markeren als standaard betekent "gebruik de standaard C ++ constructor definitie". Markeren van een constructor als verwijderen verwijdert de standaard C ++ constructor definitie.

C ++ ondersteunt twee soorten opgesomde typen. Het volgende oude opsommingstype maakt geen nieuw type aan:

enum STATE {DC, // krijgt 0 ALABAMA, // krijgt 1 ALASKA, // krijgt 2 ARKANSAS, // krijgt 3 // … enzovoort}; int n = ALASKA; // ALASKA is van het type int

Standaard is een individueel item van het type int, maar dit kan worden gewijzigd in de C ++ 2011-standaard:

enum ALPHABET: char {A = 'a', // gets 'a' B, // wordt 'b' C, // wordt 'c' // … enzovoort}; char c = A; // A is van het type char

C ++ 2011 staat een tweede indeling toe die wel een nieuw type maakt:

// de volgende opsomming definieert een nieuw type STATE enum class STATE {DC, // krijgt 0 ALABAMA, // krijgt 1 ALASKA, // krijgt 2 ARKANSAS, // krijgt 3 // … enzovoort}; STATE s = STATE:: ALASKA; // nu STATE is een nieuw type // het volgende gebruikt een ander onderliggend type enum klasse ALPHABET: char {A = 'a', // krijgt 'a' B, // gets 'b' C, // gets 'c ' //… enzovoort}; ALFABET c = ALFABET:: A; // A is van het type ALPHABET

Sjabloondeclaraties hebben een iets ander formaat:

// type T wordt geleverd door de programmeur bij gebruikssjabloontype FunctionName ([arg list]) template class ClassName {{…}};