Expressions et déclarations en c ++ programmation

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

Sommaire

Expressions

Expressions prennent l'une des formes suivantes:

objName // pour une expression de objectoperator simples // pour unaire expr2 opérateur operatorsexpr1 // pour operatorsexpr1 binaire? expr2: expr3 // pour la operatorfuncName ternaire ([liste des arguments]) - // pour les appels de fonction

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.

ExempleType
1int
1Llong int
1LLlong long int
10double
1.0Fflotteur
'1'carboniser
"un string"char * (automatiquement terminé par un caractère nul)
L "une chaîne"wchar_t *
U8 "ceci est une chaîne UTF-8 avec un caractère UTF-8: u2018"char8_t *
u "Ceci est une chaîne UTF-16 avec un caractère UTF-16: u2018"char16_t *
U "Ceci est une chaîne UTF-32 avec un caractère UTF-32: U00002018"char32_t *
vrai fauxbool
0b101binaire (C ++ 2014 standard)

Déclarations

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

[] char [] wchar_t [] [] Intfloat [longue] doublebool

Déclarations ont l'une des formes suivantes:

[] [const] type var [= expression] - // variable [] [const] type array [size] [= {liste}] - // array [const] type Object [(liste d'arguments)] - // objet [const] type Object [= {liste d'arguments}] - // alternatif [const] tapez * [const] ptr [= expression pointeur] - // pointertype RefName = object- // referenceType fnName ([liste des arguments]) - // fonction

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

auto var = 1L- // du type de var est long int

Le mot-clé decltype extrait le type d'une expression. Ce type peut alors être utilisé partout où un nom de type est utilisé. Par exemple, l'exemple suivant utilise decltype de déclarer une seconde variable avec le même type comme une variable existante:

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

Une définition de fonction a le format suivant:

// Fonction simple [] fnName (liste d'arguments) type {...} // fonction membre défini dehors de la classe [inline] type Class :: func (liste d'arguments) [const] {...} // Constructeur / destructeurs peut également être définie à l'extérieur de classClass :: Classe ([liste des arguments]) {...} Class :: ~ Classe () {...} // constructeurs / destructeur peuvent être supprimés ou en défaut // au lieu de definitionClass: : Classe ([liste des arguments]) = -Class :: ~ Classe () = -

Un opérateur surchargé ressemble à une définition de fonction. La plupart des opérateurs surchargés peuvent être rédigés soit en tant que membre ou des fonctions simples. Lorsque écrite comme une fonction membre, *ce est le premier argument supposé à l'opérateur:

Ma classe operator + (const MyClass m1, MyClass const m2) - // simpleMyClass MyClass :: operator + (const MyClass m2) - // de Membre

Les utilisateurs peuvent également définir leurs propres types en utilisant la classe ou struct Mots-clés:

 ClassName [: [virtuel] [publique] BaseClass] {: // constructorClassName ([liste arg]) lt; [: membre (val), ...] {...} | -> ClassName () [= -] // destructor [virtuel] ~ ClassName () lt; {...} | [= -> // Memberstype de données publique dataMemberName [= initialValue] - // membre public functionstype memberFunctionName ([liste arg]) [{...}] // const membre FunctionType memberFunctionName ([liste arg]) const [{. ..}] // virtuelle de type membre de functionsvirtual memberFunctionName ([liste arg]) [{...}] - // virtuelle pure Type membre de functionsvirtual memberFunctionName ([liste arg]) = 0 - // fonction qui doit remplacer une base FunctionType classe memberFunctionName ([arg list]) Commande - // une fonction qui ne peut pas être surchargée dans une memberFunctionName de subclasstype ([liste arg]) 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 à l'autre. Marquage d'un constructeur comme défaut signifie "utiliser la valeur par défaut C ++ de définition de constructeur». Marquage d'un constructeur comme effacer supprime constructeur la définition de la valeur par défaut C.

C ++ supporte deux types de types énumérés. Le vieux type d'énumération qui suit ne crée pas un nouveau type:

énumération ÉTAT {DC, // obtient 0ALABAMA, // obtient 1ALASKA, // obtient 2ARKANSAS, // 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 cela peut être changé dans la norme C ++ 2011:

énumération ALPHABET: char {A = 'a', // obtient 'A'b, // récupère' B'C, // récupère 'c' // ... et ainsi de suite} -char c = A- // A est de type char

C ++ 2,011 permet un second format qui fait créer un nouveau type:

// L'énumération suivante définit un état nouveau type classe STATEenum {DC, // obtient 0ALABAMA, // obtient 1ALASKA, // obtient 2ARKANSAS, // récupère 3 // ... et ainsi de suite} = DE L 'ETAT -state :: Alaska- // ETAT maintenant est un nouveau type // suit utilise un autre ALPHABET de classe typeenum sous-jacente: char {A = 'a', // obtient 'A'b, // obtient' B'C, // obtient ' c '// ... et ainsi de suite} -Alphabet c = ALPHABET :: A // A est de type ALPHABET

Modèle déclarations ont un format légèrement différent:

// Type T est fourni par le programmeur à usetemplate  Type FunctionName ([liste arg]) modèle  classe ClassName {{...}} -

» » » » Expressions et déclarations en c ++ programmation