C ++ pour les nuls

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 {{...}} -

Les opérateurs en C ++ Programming

Tous les opérateurs en C ++ exercent une partie fonction définie. Ce tableau montre l'opérateur, la priorité (qui détermine qui va d'abord), cardinal, et l'associativité dans le programme C ++.

OpérateurCardinalitéAssociativité
Priorité la plus élevée() [] ->.unairede gauche à droite
! ~ + - ++ - * (Fonte) sizeofunairede gauche à droite
* /%binairede gauche à droite
+ -binairede gauche à droite
lt; lt; >>binairede gauche à droite
lt; lt; =>> =binairede gauche à droite
==! =binairede gauche à droite
binairede gauche à droite
^binairede gauche à droite
|binairede gauche à droite
binairede gauche à droite
||binairede gauche à droite
?:ternairede droite à gauche
= * = / =% = + = - = = ^ = | = lt; lt; = = >>binairede droite à gauche
La plus basse priorité,binairede gauche à droite

Flow Control en C ++ Programming

Les structures suivantes ++ C dirigent le flux de contrôle à travers le programme. Si vous êtes un programmeur expérimenté, la fonction de ces structures sera familier à d'autres langues.

SI

Les évalue de commande suivantes booleanEXpression. Si l'évaluation vrai, alors le contrôle passe à expressions1. Si non, alors le contrôle passe à l'option expressions2.

si (booleanExpression) {expressions1 -} [else {} expressions2-]

TANDIS QUE


Les évalue de commande suivantes booleanEXpression. Si cela est évaluée à vrai, alors le contrôle passe à expressions. À la fin du bloc, le contrôle passe à dos booleanExpression et répète le processus.

while (booleanExpression) {} expressions-

DO # 133-TOUT

Exécution de la commande suivants expressions. Il évalue ensuite booleanExpression. Si cette true, le contrôle revient au début de la boucle et répète le processus.

do {} while expressions- (booleanExpression) -

POUR

Exécution de la commande suivants initCommand qui peut être une expression ou une déclaration de variable. Il évalue ensuite boolExpression. Si cela est évaluée à vrai, alors le contrôle passe à expressions1. Si boolExpression est faux, alors le contrôle passe à la première déclaration après l'accolade de fermeture de la pour boucle. Une fois expressions complète, le contrôle passe à l'expression contenue dans loopExpression avant de retourner à boolExpression à répéter le processus. Si initCommand déclare une nouvelle variable, il est hors de portée dès que le contrôle passe à l'extérieur de la boucle.

pour (initCommand- boolExpression- loopExpression) {} expressions-

POUR CHAQUE)

Le Standard 2011 introduit une deuxième forme de pour boucle parfois connu comme un "pour chaque" en raison de sa similitude avec la pour chaque trouvé dans d'autres langues. Dans cette forme, la variable déclarée dans déclaration prend la valeur du premier élément de liste et exécute le expressions bloc. Une fois terminé, la variable déclarée prend la deuxième valeur de liste et exécute expressions de nouveau. Ce processus est répété pour chaque valeur de liste.

pour (déclaration: liste) {} expressions-

COMMUTATEUR

Les évalue de commande suivantes integerEXpression et compare le résultat à chacun des cas indiqués. Si la valeur trouvée est égale à une des valeurs entières constants, val1, val2, etc., le contrôle passe à l'ensemble correspondant d'expressions et continue jusqu'à ce que le contrôle rencontre un pause. Si l'expression ne correspond pas à l'une des valeurs, le contrôle passe au expressionsN suivant défaut.

interrupteur (integerExpression) {cas, val1: expressions1-break cas val2: expressions2-percée [défaut: expressionsN-]}

Break, continue, GOTO

UN continuer le contrôle passe à l'extrémité de l'entretoise de fermeture de l'une des commandes de bouclage. Cela provoque la boucle de poursuivre l'itération suivante. Par exemple, la boucle suivante traite des nombres premiers entre 1 et 20:

for (int i = 0 à i lt; 20- i ++) {// si le nombre est pas premier ... si) {// ... sauter sur la prochaine valeur de icontinue (isPrime (i!) -} // Procéder sur le traitement}

UN pause passe le contrôle à la première déclaration après l'accolade de fermeture de l'une des commandes de bouclage. Cela provoque l'exécution de sortir de la boucle immédiatement. Par exemple, le suivant lit des caractères jusqu'à ce que et à la fin de fichier est rencontrée:

while (true) {// lire une ligne de l'entrée objectinput >> ligne - // si une panne ou à la fin de fichier se produit ... si (cin.eof () || cin.fail ()) {// ... puis quittez le LoopBreak -} // processus de la ligne}

UN étiquette goto passe le contrôle à l'étiquette fournie. L'exemple de cassure au-dessus aurait pu être écrit comme suit:

while (true) {// lire une ligne de l'entrée objectinput >> ligne - // si une panne ou à la fin de fichier se produit ... si (cin.eof () || cin.fail ()) {// ... puis quittez le exitLabel de loopgoto -} // processus de la ligne} exitLabel: // contrôle continue ici

» » » » C ++ pour les nuls