Uttrykk og erklæringer i C ++ Programming - dummies <[SET:descriptionno]For å utføre en beregning i C ++-programmet du trenger et uttrykk.

En del av C ++ for Dummies Cheat Sheet

For å utføre en beregning i C ++-programmet trenger du et uttrykk. Et uttrykk er en uttalelse som har både en verdi og en type. I C ++-programmet er en erklæring setning som definerer en variabel, eller det er en "holding tank" for en slags verdi som et tall eller et tegn.

Uttrykk

Uttrykk tar en av følgende former:

objName // for et enkelt objektoperatøruttrykk // for unary operatører expr1 operator expr2 // for binære operatører expr1? expr2: expr3 // for den ternære operatør funcName ([argumentliste]); // for funksjonssamtaler

Bokstavelige uttrykk

En bokstavlig er en form for konstant uttrykk. De ulike typene bokstavene er definert i følgende tabell.

Eksempel	Type
1	int
1L	lang int
1LL	lang lang int
1. 0	dobbel
en. 0F	float
'1'	char
"en streng"	char * (automatisk avsluttet med nulltegn)
L "en streng"	wchar_t * > u8 "Dette er en UTF-8-streng med et UTF-8-tegn: u2018"
char8_t *	u "Dette er en UTF-16-streng med et UTF-16 tegn: u2018"
char16_t *	U "Dette er en UTF-32-streng med et UTF-32-tegn:
U00002018" char32_t *	true, false
bool	0b101
binær standard)

Deklarasjoner

Forklaringer bruker både inneboende og brukerdefinerte typer. De innebygde typene er

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

Erklæringer har en av følgende former:

[] [const] type var [= uttrykk]; // variabel [] [const] type array [size] [= {list}]; // array [const] type objekt [(argumentliste)]; // objekt [const] type objekt [= {argumentliste}]; // alternativ [const] type * [const] ptr [= pekeruttrykk]; // pekertype & refName = objekt; // referansetype fnName ([argumentliste]); // funksjon

Søkeordet automatisk kan brukes hvis C ++ kan bestemme typen av variabel selv:

auto var = 1L; // typen var er lang int

Søkeordet decltype trekker ut uttrykkstypen. Denne typen kan da brukes hvor et typebetegn brukes. For eksempel bruker følgende eksempel decltype til å erklære en andre variabel med samme type som en eksisterende variabel:

decltype (var1) var2; // typen var2 er den samme som var1

En funksjonsdefinisjon har følgende format:

// enkel funksjon [] type fnName (argumentliste) {…} // medlemsfunksjon definert utenfor klasse [inline] type Klasse:: func (argumentliste) [const] {…} // constructor / destructors kan også defineres utenfor klassen Klasse:: Klasse ([argumentliste]) {…} Klasse:: ~ Klasse () } // constructors / destructor kan bli slettet eller defaulted // i stedet for definisjon Klasse:: Klasse ([argumentliste]) =; Klasse:: ~ Klasse () =;

En overbelastet operatør ser ut som en funksjonsdefinisjon.De fleste overbelastede operatører kan skrives enten som medlemmer eller enkle funksjoner. Når dette er skrevet som en medlemsfunksjon, er dette det antatte første argumentet til operatøren:

MyClass & operator + (const MyClass & m1, const MyClass & m2); // enkel MyClass & MyClass:: operator + (const MyClass & m2); // medlem

Brukere kan også definere sine egne typer ved hjelp av klassen eller struct nøkkelord:

ClassName [: [virtual] [offentlig] BaseClass] {: // constructor ClassName ([arg liste]) ClassName () [=;] // destructor [virtual] ~ ClassName () <{…} | [=; > // offentlige data medlemmer skriver dataMemberName [= initialValue]; // offentlige medlemsfunksjoner type memberFunctionName ([arg liste]) [{…}] // const medlem funksjonstype memberFunctionName ([arg liste]) const [{…}] // virtuelle medlemsfunksjoner virtuell type memberFunctionName ([arg list]) [{…}]; // rent virtuelt medlem funksjoner virtuelt type memberFunctionName ([arg list]) = 0; // funksjon som må overstyre en baseklassefunksjonstype memberFunctionName ([arg list]) overstyre; // en funksjon som ikke kan overstyres i en subclass-type memberFunctionName ([arg list]) final;};

I tillegg kan en konstruktør med et enkelt argument flagges som eksplisitt, noe som betyr at den ikke vil bli brukt i en implisitt konvertering fra en type til en annen. Merking av en konstruktør som standard betyr "bruk standard C ++-konstruktørdefinisjon". Hvis du flagger en konstruktør som slett fjerner du standard C ++-konstruktørdefinisjonen.

C ++ støtter to typer opptatte typer. Følgende gamle oppsummeringstype oppretter ikke en ny type:

enum STATE {DC, // blir 0 ALABAMA, // får 1 ALASKA, // får 2 ARKANSAS, // får 3 // … og så videre}; int n = ALASKA; // ALASKA er av typen int

Som standard er en individuell oppføring av type int, men dette kan endres i C ++ 2011 standard:

enum ALPHABET: char {A = 'a', // får 'a' B, // blir 'b' C, // får 'c' // … og så videre}; char c = A; // A er av typen char

C ++ 2011 tillater et andre format som lager en ny type:

// følgende tall definerer en ny type STATE enum klasse STATE {DC, // blir 0 ALABAMA, // får 1 ALASKA, // får 2 ARKANSAS, // får 3 // … og så videre}; STAT S = STATE:: ALASKA; // nå STATE er en ny type // følgende bruker en annen underliggende type enum klasse ALPHABET: char {A = 'a', // får 'a' B, // får 'b' C, // får 'c ' //… og så videre}; ALPHABET c = ALPHABET:: A; // A er av typen ALPHABET

Maldeklarasjoner har et litt annet format:

// type T er gitt av programmøren ved bruk mal type Funksjonnavn ([arg liste]) mal klasse Klassenavn {{}}};