Espressioni e dichiarazioni in programmazione C ++ - dummies

Parte di C ++ per Dummies Cheat Sheet

Per eseguire un calcolo nel programma C ++ hai bisogno di un'espressione. Un'espressione è un'affermazione che ha sia un valore che un tipo. Nel programma C ++, una dichiarazione è una dichiarazione che definisce una variabile o è un "serbatoio di riserva" per una sorta di valore come un numero o un carattere.

Espressioni

Espressioni assumono una delle seguenti forme:

objName // per un'espressione di operatore oggetto semplice // per operatori unari expr1 operatore expr2 // per operatori binari expr1? expr2: expr3 // per l'operatore ternario funcName ([elenco argomenti]); // per chiamate di funzioni

Espressioni letterali

Un letterale è una forma di espressione costante. I vari tipi di letterali sono definiti nella seguente tabella.

Esempio	Tipo
1	int
1L	lungo int
1LL	lungo int lungo
1. 0	doppio
1. 0F	float
'1'	char
"una stringa"	char * (terminato automaticamente con un carattere null)
L "a string"	wchar_t * > u8 "questa è una stringa UTF-8 con un carattere UTF-8: u2018"
char8_t *	u "questa è una stringa UTF-16 con un carattere UTF-16: u2018"
char16_t *	U "questa è una stringa UTF-32 con un carattere UTF-32:
U00002018" char32_t *	vero, falso
bool	0b101
binario (C ++ 2014 standard)

Dichiarazioni

Le dichiarazioni utilizzano sia tipi intrinseci che definiti dall'utente. I tipi intrinseci sono

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

Le dichiarazioni hanno una delle seguenti forme:

[] [const] tipo var [= espressione]; // variable [] [const] type array [size] [= {lista}]; // array [const] type object [(elenco argomenti)]; // object [const] type object [= {argument list}]; // alternativa [const] tipo * [const] ptr [= espressione del puntatore]; // tipo di puntatore & refName = oggetto; // tipo di riferimento fnName ([elenco argomenti]); // function

La parola chiave auto può essere usata se C ++ può determinare il tipo di variabile stessa:

auto var = 1L; // il tipo di var è long int

La parola chiave decltype estrae il tipo di un'espressione. Questo tipo può quindi essere utilizzato ovunque venga utilizzato un nome di tipo. Ad esempio, l'esempio seguente utilizza decltype per dichiarare una seconda variabile con lo stesso tipo di una variabile esistente:

decltype (var1) var2; // il tipo di var2 è lo stesso di var1

Una definizione di funzione ha il seguente formato:

// funzione semplice [] tipo fnName (elenco argomenti) {…} // funzione membro definita al di fuori della classe [inline] tipo Classe:: func (elenco argomenti) [const] {…} // costruttore / distruttori possono anche essere definiti al di fuori della classe Classe:: Classe ([elenco argomenti]) {…} Classe:: ~ Classe () {… } // costruttori / distruttori possono essere cancellati o default // al posto della definizione Classe:: Class ([argument list]) =; Classe:: ~ Classe () =;

Un operatore sovraccarico ha l'aspetto di una definizione di funzione.Gli operatori più sovraccarichi possono essere scritti come membri o semplici funzioni. Quando viene scritto come funzione membro, * questo è il primo argomento assunto per l'operatore:

MyClass e operatore + (const MyClass & m1, const MyClass & m2); // simple MyClass & MyClass:: operator + (const MyClass & m2); // membro;

Gli utenti possono anche definire i propri tipi usando le parole chiave class o struct:

ClassName [: [virtuale] [pubblico] BaseClass] {: // costruttore Nomi ([elenco arg]] ClassName () [=;] // destructor [virtuale] ~ ClassName () <{…} | [=; > // dati pubblici membri digitano dataMemberName [= initialValue]; // funzioni membro pubbliche tipo memberFunctionName ([elenco arg]] [{…}] // const tipo funzione membro memberFunctionName ([elenco argomenti]) const [{…}] // funzioni membro virtuali tipo virtuale memberFunctionName ([elenco arg]) [{…}]; // pure virtual member functions virtual type memberFunctionName ([arg lista]) = 0; // funzione che deve sovrascrivere un tipo di funzione di base member memberFunctionName ([arg lista]) override; // una funzione che non può essere sovrascritta in un tipo di sottoclasse memberFunctionName ([arg lista]) final;};

Inoltre, un costruttore con un singolo argomento può essere contrassegnato come un significato esplicito che non verrà utilizzato in una conversione implicita da un tipo all'altro. Contrassegnare un costruttore come predefinito significa "usare la definizione predefinita del costruttore C ++". Contrassegnare un costruttore come delete rimuove la definizione di costruttore C ++ predefinita.

C ++ supporta due tipi di tipi enumerati. Il seguente tipo di enumerazione precedente non crea un nuovo tipo:

enum STATE {DC, // ottiene 0 ALABAMA, // ottiene 1 ALASKA, // ottiene 2 ARKANSAS, // ottiene 3 // … e così via}; int n = ALASKA; // ALASKA è di tipo int

Per impostazione predefinita una singola voce è di tipo int ma può essere modificata nello standard C ++ 2011:

enum ALFABETO: char {A = 'a', // gets 'a' B, // ottiene 'b' C, // ottiene 'c' // … e così via}; char c = A; // A è di tipo char

C ++ 2011 consente un secondo formato che crea un nuovo tipo:

// la seguente enumerazione definisce un nuovo tipo STATE enum class STATE {DC, // ottiene 0 ALABAMA, // ottiene 1 ALASKA, // ottiene 2 ARKANSAS, // ottiene 3 // … e così via}; STATO s = STATO:: ALASKA; // ora STATE è un nuovo tipo // il seguente utilizza una classe enum di tipo sottostante differente ALPHABET: char {A = 'a', // ottiene 'a' B, // ottiene 'b' C, // ottiene 'c ' //… e così via}; ALFABETO c = ALFABETO:: A; // A è di tipo ALPHABET

Le dichiarazioni dei modelli hanno un formato leggermente diverso:

// tipo T è fornito dal programmatore in uso template type Nome funzione ([arg lista]) template class ClassName {{…}};