Expressions et déclarations en programmation C ++ - mannequins

Partie de C ++ pour Dummies Cheat Sheet

Pour effectuer un calcul dans le programme C ++ vous avez besoin d'une expression. Une expression est une instruction qui a à la fois une valeur et un type. Dans le programme C ++, une déclaration est une déclaration qui définit une variable ou un "réservoir de stockage" pour une sorte de valeur comme un nombre ou un caractère.

Expressions

Les expressions prennent l'une des formes suivantes:

objName // pour une expression simple d'opérateur d'objet // pour les opérateurs unaires expr1 opérateur expr2 // pour les opérateurs binaires expr1? expr2: expr3 // pour l'opérateur ternaire funcName ([liste d'arguments]); // pour les appels de fonctions

Expressions littérales

Un littéral est une forme d'expression constante. Les différents types de littéraux sont définis dans le tableau suivant.

Exemple	Type
1	int
1L	long int
1LL	long long int
1. 0	double
1. 0F	float
'1'	char
"une chaîne"	char * (terminé automatiquement par un caractère nul)
L "une chaîne"	wchar_t * > u8 "c'est une chaîne UTF-8 avec un caractère UTF-8: u2018"
char8_t *	u "c'est une chaîne UTF-16 avec un caractère UTF-16: u2018"
char16_t *	U "c'est une chaîne UTF-32 avec un caractère UTF-32:
U00002018" char32_t *	vrai, faux
bool	0b101
binaire (C ++ 2014 standard)

Déclarations

Les déclarations utilisent des types intrinsèques et définis par l'utilisateur. Les types intrinsèques sont

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

Les déclarations ont l'une des formes suivantes:

[] [const] type var [= expression]; // variable [] [const] type tableau [taille] [= {liste}]; // tableau [const] type objet [(liste d'arguments)]; // Objet [const] type objet [= {liste d'arguments}]; // alternative [const] type * [const] ptr [= expression du pointeur]; // type de pointeur & refName = object; // type de référence fnName ([liste d'arguments]); // function

Le mot-clé auto peut être utilisé si C ++ peut déterminer le type de variable lui-même:

auto var = 1L; // le type de var est long int

Le mot clé decltype extrait le type d'une expression. Ce type peut ensuite être utilisé partout où un nom de type est utilisé. Par exemple, l'exemple suivant utilise decltype pour déclarer une deuxième variable du même type qu'une variable existante:

decltype (var1) var2; // le type de var2 est le même que var1

Une définition de fonction a le format suivant:

// simple fonction [] type fnName (liste d'arguments) {…} // fonction membre définie en dehors de la classe [inline] type Classe:: func (liste d'arguments) [const] {…} // constructeur / destructeurs peuvent également être définis en dehors de la classe Classe:: Classe ([liste d'arguments]) {…} Classe:: ~ Class () {… } // constructors / destructor peut être supprimé ou par défaut // au lieu de la définition Class:: Class ([liste d'arguments]) =; Classe:: ~ Class () =;

Un opérateur surchargé ressemble à une définition de fonction.La plupart des opérateurs surchargés peuvent être écrits en tant que membres ou fonctions simples. Lorsqu'il est écrit en tant que fonction membre, * ceci est le premier argument supposé de l'opérateur:

MyClass & opérateur + (const MyClass & m1, const MyClass & m2); // simple MyClass & MyClass:: opérateur + (const MyClass & m2); // membre;

Les utilisateurs peuvent également définir leurs propres types en utilisant les mots-clés class ou struct:

ClassName [: [virtual] [public] BaseClass] {: // constructeur NomClasse ([liste arg]] NomClasse () [=;] // destructor [virtual] ~ ClassName () <{…} | [=; > // membres de données publics type dataMemberName [= initialValue]; // public member functions type memberFunctionName ([liste_arg]) [{…}] // type de fonction membre const memberFunctionName ([liste d'arguments]) const [{…}] // membre virtuel fonctions type virtuel memberFunctionName ([liste d'arguments]) [{…}]; // fonctions de membre virtuel pur type virtuel memberFunctionName ([liste d'arguments]) = 0; // fonction qui doit remplacer un type de fonction de classe de base memberFunctionName ([arg list]) override; // une fonction qui ne peut pas être remplacée dans un type de sous-classe memberFunctionName ([arg list]) final;};

En outre, un constructeur avec un seul argument peut être marqué comme explicite, ce qui signifie qu'il ne sera pas utilisé dans une conversion implicite d'un type à un autre. Marquer un constructeur par défaut signifie "utiliser la définition du constructeur C ++ par défaut". Marquer un constructeur comme delete supprime la définition du constructeur C ++ par défaut.

C ++ supporte deux types de types énumérés. L'ancien type d'énumération suivant ne crée pas un nouveau type:

enum STATE {DC, // obtient 0 ALABAMA, // obtient 1 ALASKA, // obtient 2 ARKANSAS, // obtient 3 // … et ainsi de suite}; int n = ALASKA; // ALASKA est de type int

Par défaut une entrée individuelle est de type int mais ceci peut être changé dans la norme C ++ 2011:

enum ALPHABET: char {A = 'a', // obtient 'a' B, // obtient 'b' C, // obtient 'c' // … et ainsi de suite}; char c = A; // A est de type char

C ++ 2011 autorise un second format qui crée un nouveau type:

// l'énumération suivante définit un nouveau type STATE enum class STATE {DC, // obtient 0 ALABAMA, // obtient 1 ALASKA, // obtient 2 ARKANSAS, // obtient 3 // … etc}; ÉTAT s = ÉTAT:: ALASKA; // maintenant STATE est un nouveau type // le suivant utilise un type sous-jacent différent enum class ALPHABET: char {A = 'a', // obtient 'a' B, // obtient 'b' C, // obtient 'c ' //… etc}; ALPHABET c = ALPHABET:: A; // A est de type ALPHABET

Les déclarations de modèles ont un format légèrement différent:

// le type T est fourni par le programmeur lors de l'utilisation du template type FunctionName ([arg list]) template className {{…}};