# Langage C++/Version imprimable

* Si vous imprimez cette page, choisissez « Aperçu avant impression » dans votre navigateur, ou cliquez sur le lien Version imprimable dans la boîte à outils, vous verrez cette page sans ce message, ni éléments de navigation sur la gauche ou en haut.
* Cliquez sur Rafraîchir cette page pour obtenir la dernière version du cours.
* Pour plus d'informations sur les version imprimables, y compris la manière d'obtenir une version PDF, vous pouvez lire l’article Versions imprimables.
Une version à jour et éditable de ce livre est disponible sur la Wikiversité, une bibliothèque de livres pédagogiques, à l'URL : http://fr.wikiversity.org/wiki/Langage_C%2B%2B

# Introduction
## Préambule :

Ce cours est pour le moment destiné à donner les clefs permettant l'apprentissage des bases du langage C++. Ce cours n'a pour le moment pas vocation à faire de vous des développeurs de haut vol mais simplement vous apprendre à utiliser le langage C++ de manière efficace à des fins d'aide de travail avec l'outil informatique.
Je m'efforcerai dans ce cours d’être précis, concis et pédagogique. Si d'aventure vous ne compreniez pas un point du cours, je m'efforcerai de répondre à vos questions.
Avant de commencer vous pouvez, si vous le désirez, consulter ce lien qui vous permettra d’en apprendre un peu plus sur l'histoire du C++

## Introduction :
### Des Chiffres et des BITs

Dans un ordinateur les données sont représentées par des ensembles de cases mémoires. Ces cases mémoires, appelées "BIT" (de l'anglais Binary-digIT), ne peuvent prendre que 2 valeurs. Soit la valeur 0, soit la valeur 1. Pour représenter des nombres plus grands que 0 ou 1 nous devons rajouter des rangs de bits.
Voici, pour exemple, la représentation binaire des nombres décimaux de 0 à 9 :
| Nombre décimal | Représentation binaire |
| 0 | 0000 |
| 1 | 0001 |
| 2 | 0010 |
| 3 | 0011 |
| 4 | 0100 |
| 5 | 0101 |
| 6 | 0110 |
| 7 | 0111 |
| 8 | 1000 |
| 9 | 1001 |
Il existe une formule mathématique qui permet de connaître le nombre de valeurs possibles qu'un ensemble de n bit(s) peut prendre :
nombre_de_valeurs_possibles = $2^{n}$
Il existe une formule mathématique permettant de connaître le nombre maximal que l’on peut représenter avec un ensemble de n bit(s) :
nombre_maximal_representable = $2^{n}-1$
Il existe une formule qui permet de convertir n’importe quel nombre binaire en nombre décimal :
Nombre_décimal = $x_{0}\times 2^{0}+x_{1}\times 2^{1}+x_{2}\times 2^{2}+...+x_{n}\times 2^{n}$ où $x_{i}$ est le bit de rang $i$ commençant à zéro en partant de la droite et en lisant vers la gauche.
Si nous appliquons ces formules à notre exemple ci-dessus cela donne :
Pour un ensemble de 4 bits, aussi appelé quartet, nous avons :
* nous pouvons représenter $2^{4}=16$ valeurs,
* le plus grand nombre que l’on peut représenter avec cet ensemble sera $2^{4}-1=15$.
Pour le nombre binaire 1010 nous avons :
* Conversion Binaire → Décimal
* 1         0         1         0
* $1\times 2^{3}+0\times 2^{2}+1\times 2^{1}+0\times 2^{0}$
* 8    +    0   +    2   +   0
* 10
Vous pourriez vous demander d'où vient cet écart de 1 entre le nombre de valeurs et la valeur maximale accessible, cela vient du fait que le 0 (en binaire sur 1 quartet : 0000) est comptabilisé dans le nombre de valeurs.
En informatique on appelle le bit le plus à droite d’un nombre binaire, le bit de poids faible car il représente la valeur $2^{0}=1$. Par opposition au bit de poids faible, on appelle le bit le plus à gauche du nombre binaire le bit de poids fort car il représente la valeur la plus forte du nombre, soit pour notre quartet $2^{3}=8$
→ Consultez ce lien pour plus d'informations à propos du système binaire
En regroupant des bits en quartets on s'aperçoit que l’on peut représenter toutes les valeurs par un seul chiffre hexadécimal.
Voici un tableau de conversions binaire <→ hexadécimal:
| Binaire | Hexadécimal |
| 0000 | 0 |
| 0001 | 1 |
| 0010 | 2 |
| 0011 | 3 |
| 0100 | 4 |
| 0101 | 5 |
| 0110 | 6 |
| 0111 | 7 |
| 1000 | 8 |
| 1001 | 9 |
| 1010 | A(10) |
| 1011 | B(11) |
| 1100 | C(12) |
| 1101 | D(13) |
| 1110 | E(14) |
| 1111 | F(15) |
→ Consultez ce lien pour plus d'informations à propos du système hexadécimal
À partir de maintenant et dans un souci de clarté, nous représenterons les valeurs exprimées dans le système hexadécimal en les préfixant par "0x" (les lettres seront en majuscules). Je n'utiliserai plus le système binaire qu’à des fins de démonstration en le préfixant par "0b".
ex:
| Nombre décimal | Nombre hexadécimal | Nombre binaire |
| 26 | 0x1A | 0b00011010 |

### Les Octets :

En informatique il est courant (surtout dans les architectures PC et Mac) que les bits soient regroupés en ensembles de 8 bits (soit 2 quartets) que l’on appelle octets. Ce regroupement apporte 2 avantages :
* Toutes ses valeurs peuvent être représentées par seulement 2 chiffres hexadécimaux (de 0x00 à 0xFF).
* Il a permis la création d’un jeu de caractères ASCII étendu.

### Des Octets et des Lettres :

Puisque l'informatique n'est capable de gérer que des 0 et/ou des 1, comment faire en sorte d'obtenir des lettres ? Tout simplement en donnant une valeur numérique à chaque lettre. Ainsi dans le jeu de caractère ASCII étendu, nous avons une représentation numérique de chaque caractère avec une différenciation minuscule/majuscule. En fait pour un ordinateur une lettre n'est ni plus ni moins qu'un simple nombre.
→ Consultez ce lien pour plus d'informations à propos du jeu de caractères ASCII

### Entiers, Relatifs, Naturels :

Nous avons vu que les octets peuvent représenter les nombres de 0 à 255 soit 256 valeurs. Mais comment l'ordinateur peut-il représenter des valeurs négatives ? En fait l'ordinateur ne sait pas faire la différence entre un nombre négatif et un nombre positif si on ne lui dit pas explicitement de la faire en lui indiquant qu’il doit travailler en mode signé.
Comment l'ordinateur représente-t-il des nombres entiers signés en nombres binaires ?
En mode signé, le bit de poids fort est interprété comme le signe du nombre (0 pour +, 1 pour -) on parle alors de bit de signe. Prenons l'exemple de l'octet :
| Modes\ Valeurs | 0b00000000 | 0b00000001 | ... | 0b01111110 | 0b01111111 | 0b10000000 | 0b1000000 | 0b10000010 | ... | 0b11111110 | 0b11111111 |
| Interprétation Non-Signé | 0 | 1 | ... | 126 | 127 | 128 | 129 | 130 | ... | 254 | 255 |
| Interprétation Signé | 0 | 1 | ... | 126 | 127 | -128 | -127 | -126 | ... | -2 | -1 |
On peut remarquer que les valeurs absolues sont dans un ordre inverse pour les nombres négatifs. Ceci est du à l’utilisation du complément à deux pour leur construction. Cet encodage, simple à mettre en œuvre, facilite ensuite énormément les opérations arithmétiques. (cf. lien)

### Réels Entiers :

Nous avons vu comment un ordinateur pouvait représenter des entiers, signés ou non. Comment alors, à partir de nombres entiers relatifs composés de bits, représenter des nombres réels ?
En fait, l'organisme IEEE (Institute of Electrical and Electronics Engineers), a défini une norme permettant de coder en binaire, sur 2 octets et plus, un nombre réel. Cette norme a été reprise par les fondeurs de processeurs et a donc été admise comme standard pour la représentation de nombres dits « à virgule flottante ».
Voici une schématisation de la norme :
| Signe du nombre | Valeur exposant signé | Valeur mantisse |
| 1 bit | Taille variable selon encodage | Taille variable selon encodage |
La partie qui représente les données du nombre, la mantisse, est entière. On est donc obligé de déplacer la virgule jusqu'à atteindre la bonne valeur, ce qui est fait grâce à l'exposant. La virgule se déplaçant, grâce à l'exposant, aléatoirement d’un nombre à l'autre on dit qu'elle flotte, d'où l’expression « nombre à virgule flottante ».
→ Consultez ce lien pour plus d'informations à propos des nombres à virgules flottantes
→ Consultez ce lien pour plus d'informations à propos de l’IEEE

## Opérations Logiques Binaire :

Pour pouvoir faire des opérations sur des valeurs logiques on doit savoir utiliser les opérateurs booléens de base.
Voici les différents opérateurs logiques booleens :

### Opérateur YES (OUI) :

L'opérateur YES effectue une comparaison sur une valeur logique. Si la valeur est vraie alors la sortie est vraie, sinon elle est fausse.
Voici la table de vérité de l'opérateur YES pour l'opération (YES x):
| YES | x = Faux | x = Vrai |
| Résultat | Faux | Vrai |

### Opérateur NOT (NON) :

L'opérateur NOT effectue une comparaison sur une valeur logique. Si la valeur est vraie alors la sortie est fausse, sinon elle est vraie.
Voici la table de vérité de l'opérateur NOT pour l'opération (NOT x):
| NOT | x = Faux | x = Vrai |
| Résultat | Vrai | Faux |

### Opérateur AND (ET) :

L'opérateur AND effectue une comparaison entre 2 valeurs logiques. Si les 2 valeurs sont vraies alors la sortie est vraie, sinon elle est fausse.
Voici la table de vérité de l'opérateur AND pour l'opération (x AND y):
| AND | y = Faux | y = Vrai |
| x = Faux | Faux | Faux |
| x = Vrai | Faux | Vrai |

### Opérateur NAND (NON-ET) :

L'opérateur NAND effectue une comparaison entre 2 valeurs logiques. Si les 2 valeurs sont vrai alors la sortie est fausse, sinon elle est vrai.
Voici la table de vérité de l'opérateur NAND pour l'opération (x NAND y):
| NAND | y = Faux | y = Vrai |
| x = Faux | Vrai | Vrai |
| x = Vrai | Vrai | Faux |

### Opérateur OR (OU Inclusif) :

L'opérateur OR effectue une comparaison entre 2 valeurs logiques. Si au moins 1 des 2 valeurs est vraie alors la sortie est vraie, sinon elle est fausse.
Voici la table de vérité de l'opérateur OR pour l'opération (x OR y):
| OR | y = Faux | y = Vrai |
| x = Faux | Faux | Vrai |
| x = Vrai | Vrai | Vrai |

### Opérateur NOR (NON-OU) :

L'opérateur NOR effectue une comparaison entre 2 valeurs logiques. Si les 2 valeurs sont fausses alors la sortie est vraie, sinon elle est fausse.
Voici la table de vérité de l'opérateur NOR pour l'opération (x NOR y):
| NOR | y = Faux | y = Vrai |
| x = Faux | Vrai | Faux |
| x = Vrai | Faux | Faux |

### Opérateur XOR (OU Exclusif) :

L'opérateur XOR effectue une comparaison entre 2 valeurs logiques. Si exactement 1 des 2 valeurs est vraie alors la sortie est vraie, sinon elle est fausse.
Voici la table de vérité de l'opérateur XOR pour l'opération (x XOR y):
| XOR | y = Faux | y = Vrai |
| x = Faux | Faux | Vrai |
| x = Vrai | Vrai | Faux |
En fait l'opérateur XOR peut être construit à partir d'autres opérateurs, mais, pour des raisons pratiques, il a directement été mis à disposition du langage.
XOR = ( ( (NOT x) AND (y) ) OR ( (x) AND (NOT y) ) )
À partir de tous ces opérateurs on peut réaliser n’importe quel modèle logique.
| Sommaire | Mots clés |

# Mots clés
## Les Mots Clés

En C++, comme en C d'ailleurs, il existe une série de mots qui ne peuvent et ne doivent être, en aucun cas, utilisés autrement que pour ce à quoi ils sont destinés. Ces mots sont dit "mots clés" et, dans certains cas, appelés "instructions", ou encore opérateurs, ou mots réservés et ont une signification particulière pour le compilateur.
Voici une liste des mots clés/mot réservés du C++ :
| Mots clés | Utilisation |
| +, -, /, *, =, ., <, <=, ==, >=, > &&, ||, &, |, !, ~, != ,(parenthèses), (Crochets)… (Triples Points), , (Virgule) | Opérateurs |
| &, * | Opérateur de référencement/déréferencement (référence/pointeur) |
| # | Préfixe de directives préprocesseur |
| 0x (Zéro-x) | Préfixe de nombre hexadécimal |
| 0 (Chiffre zéro) | Préfixe de nombre octal |
| (Accolades) | Délimitation de portée |
| :: (double deux points) | Opérateur de déréférencement de portée |

### A

| Mot Clé | Utilisation |
| asm | Déclarateur de code assembleur ! |
| auto | Déclarateur de variable à désallocation automatique "Pile"(stack). |

### B

| Mot Clé | Utilisation |
| break | Instruction de branchement dans une boucle ou un traitement de cas. |
| bool | Type de donnée logique dit "booléen". Prend la valeur vrai (true) ou faux (false). |

### C

| Mot Clé | Utilisation |
| case | Déclarateur de cas dans une instruction switch. |
| catch | Récupérateur d'erreur. |
| char | Type de donnée entier dit "caractère". En programmation structurée ce type est déconseillé à l’utilisation mais il permet de rendre certains services. |
| class | Déclarateur de définition de classe. |
| const | Déclarateur de constantes. |
| continue | Instruction de branchement dans une boucle imbriquée. |

### D

| Mot Clé | Utilisation |
| default | Déclarateur de cas par défaut dans une instruction switch. |
| delete | Désallocateur de mémoire dynamique "Tas"(heap). |
| do | Déclarateur de boucle. Ne peut être utilisé qu'en association avec while. |
| double | Type de donnée nombre flottant à double précision. |

### E

| Mot Clé | Utilisation |
| else | Déclarateur de cas par défaut dans une instruction if. |
| enum | Structure de donnée énuméré. |
| extern | Déclarateur d’une variable déclarée dans un autre fichier. |
| explicit | Interdit les constructeurs pour casts implicites. |

### F

| Mot Clé | Utilisation |
| false | Valeur logique (Faux) |
| float | Type de donnée nombre flottant à simple précision. |
| for | Déclarateur de boucle paramétrée. |
| friend | Déclarateur de classe ou de fonction ayant accès aux données privées. |

### G

| Mot Clé | Utilisation |
| goto | Instruction de branchement, en développement structuré son utilisation est interdite car elle rend la compréhension du code plus difficile. |

### I

| Mot Clé | Utilisation |
| if | Déclarateur de traitement conditionnel. |
| inline | Déclarateur de MACRO |
| int | Type de donnée entier. En programmation structurée ce type est déconseillé à l’utilisation mais il permet de rendre certains services. |

### L

| Mot Clé | Utilisation |
| long | Modificateur de longueur de type. |

### M

| Mot Clé | Utilisation |
| main | Méthode point d'entrée du programme. |
| mutable | Rend une partie d’un objet constant modifiable. |

### N

| Mot Clé | Utilisation |
| new | Allocateur de mémoire dynamique "Tas"(heap). |

### O

| Mot Clé | Utilisation |
| operator | Déclarateur de surcharge d'opérateur. |

### P

| Mot Clé | Utilisation |
| private | Déclarateur de membre privé. |
| protected | Déclarateur de membre protégé. |
| public | Déclarateur de membre public. |

### R

| Mot Clé | Utilisation |
| register | Déclarateur de variable registre. |
| return | Instruction de branchement. |

### S

| Mot Clé | Utilisation |
| short | Modificateur de longueur de type. |
| signed | Modificateur d'interprétation de signe de type entier. |
| sizeof | Opérateur spécial permettant de renvoyer la taille d’une variable stockée en pile(stack). |
| static | Déclarateur de variable statique dite "de classe". En programmation structurée, il est déconseillé à l’utilisation mais permet de rendre certains services. |
| struct | Déclarateur de structure. En programmation structurée il est déconseillé à l’utilisation il est préférable d’utiliser des classes à la place. |
| switch | Déclarateur de traitement conditionnel cardinal. |

### T

| Mot Clé | Utilisation |
| template | Declarateur de paramétrage. |
| this | Pointeur spécial désignant l'instance en cours de l'objet. En programmation structurée il est systématiquement et presque obligatoirement utilisé car il améliore la lisibilité. |
| throw | Déclencheur d'exceptions. |
| try | Déclarateur de section à déclenchement d'exceptions. |
| true | Valeur logique (Vrai) |
| typedef | Déclarateur de type. |

### U

| Mot Clé | Utilisation |
| unsigned | Modificateur d'interprétation de signe de type entier. |
| union | Déclarateur d'union. En programmation structurée, il est très fortement déconseillé à l’utilisation il n'est utilisé que dans des cas très rares et pour des applications très spécifiques. |

### V

| Mot Clé | Utilisation |
| virtual | Déclarateur de méthode virtuelle. |
| void | Indicateur d’une absence de type (là où un type serait attendu). |
| volatile | Déclarateur de membre critique nécessitant un traitement d'actualisation particulier notamment lors de l’utilisation de threads. |

### W

| Mot Clé | Utilisation |
| while | Déclarateur de boucle conditionnelle. |

### Instructions du langage C

| Mot Clé | Utilisation |
| include, define, ifdef, ifndef, pragma, error | Directives préprocesseur |
| malloc, realloc, calloc, free | Opérateurs C d'allocation/désallocation de mémoire dynamique. |
| Introduction | Types |

# Types
## Les Types

En C++ il existe plusieurs types organisés dans des catégories. Ces types ont différentes longueurs et différentes interprétations possibles dépendant de la plage de valeurs sur laquelle on veut travailler : signés ou non, à virgule flottante ou non.
* Selon l'architecture de votre ordinateur les tailles des types peuvent varier ! Ce cours se base sur une architecture PC. D'autres machines ont potentiellement des types de longueurs différentes de celles exprimées ici.

## Types Intrinsèques :

Il existe plusieurs catégories de types en C++ dont certaines sont incompatibles avec le langage C. Pour représenter les nombres non-signés on utilise le mot clé "unsigned". Pour représenter les nombres signés on utilise le mot clé "signed". Cela permet à l'ordinateur de savoir comment il doit interpréter les valeurs. Pour des raisons de simplification du codage, les types représentent par défaut des nombres signés, ce qui rend l’utilisation du mot clé "signed" facultative.

### Catégories de types
#### Le Type Vide

Cette catégorie, compatible avec le langage C, représente l'absence de type.
Le type vide est surtout utilisé pour l'écriture de méthodes (les méthodes ne renvoyant aucune valeur ont un type de retour vide), mais il arrive que l’on s'en serve pour accéder à une adresse mémoire sans essayer d’avoir une interprétation de la valeur se trouvant à cette adresse.
| Type de Base | Taille du type en octets | Nombres de valeurs possibles | Plage de valeurs possibles |
| void | (inaccessible) | (inaccessible) | (inaccessible) |

#### Le Type Char, un type lettré !

Le type char est un type un peu particulier : il se comporte comme un entier mais il est destiné à mémoriser des caractères (ou parfois des morceaux de caractères). Dans certains système d'exploitation il existe une table de 256 dessins représentant graphiquement, entre autres, les 26 lettres minuscules et majuscules (52 au total) ainsi que les 10 chiffres (0 à 9). Le reste des 256 codes permet de représenter d'autres caractères tels que le caractère null, l'espace, la tabulation, la ponctuation ou des caractères propres à des langues spéciales, parfois même des smileys. Le dessin de ces caractères ainsi que leur codage numérique sont définis par une norme de codage de caractères. Par exemple, la norme ASCII est une norme relativement ancienne, alors que la norme Unicode est plus universelle. L'ordinateur lui ne manipulera que les valeurs numérique de ce type, par contre les logiciels qui affichent la valeur de ce type à l'écran le font sous forme graphique, c'est-à-dire en affichant le dessin du caractère correspondant à la valeur affectée.
Commun aux processeurs 32 et 64 bit :
| Mode | Type de Base | Taille du type en octets | Nombres de valeurs possibles | Plage de valeurs possible dans le mode |
| non-signé | unsigned char | 1 | 256 | [0 ; 255] |
| signé | (signed) char | 1 | 256 | [ -128 ; +127 ] |
| caractère (non-signé) | (signed|unsigned) char | 1 | 256 | Caractères de la table ASCII |

#### Les Entiers

Cette catégorie, compatible avec le langage C, regroupe les types représentant les nombres entiers. À partir du type short, tous les types entiers se réfèrent au type int. Là encore pour simplifier le codage, l'écriture du mot clé "int" est facultative excepté pour le type int signé lui-même.
Commun aux processeurs 32 et 64 bit :
| Mode | Type de Base | Taille du type en octets | Nombres de valeurs possibles | Plage de valeurs possible dans le mode |
| non-signé | unsigned char | 1 | 256 | [ 0 ; 255 ] |
| signé | (signed) char | 1 | 256 | [ -128 ; +127 ] |
| non-signé | unsigned short (int) | 2 | 65 536 | [ 0 ; 65 535 ] |
| signé | (signed) short (int) | 2 | 65 536 | [ −32 768 ; 32 767 ] |
| non-signé | unsigned (int) | 4 | 4 294 967 296 | [0; 4 294 967 295 ] |
| signé | (signed) int | 4 | 4 294 967 296 | [ −2 147 483 648 ; 2 147 483 647 ] |
Spécifiques aux processeurs 32 bits :
| Mode | Type de Base | Taille du type en octets | Nombres de valeurs possibles | Plage de valeurs possible dans le mode |
| non-signé | unsigned long (int) | 4 | 4 294 967 296 | [0; 4 294 967 295 ] |
| signé | signed long (int) | 4 | 4 294 967 296 | [ −2 147 489 648 ; 2 147 489 647 ] |
| non-signé | unsigned long long (int) | 8 | 18 446 744 073 509 552 000 | [0; 18 446 744 073 509 552 000 ] |
| signé | (signed) long long (int) | 8 | 18 446 744 073 509 552 000 | [ −9 223 372 036 854 776 000 ; 9 223 372 036 854 776 000 ] |
Spécifiques aux processeurs 64 bits :
| Mode | Type de Base | Taille du type en octets | Nombres de valeurs possibles | Plage de valeurs possible dans le mode |
| non-signé | unsigned long (int) | 8 | 18 446 744 073 509 552 000 | [ 0 ; 18 446 744 073 509 552 000 ] |
| signé | (signed) long (int) | 8 | 18 446 744 073 509 552 000 | [ −9 223 372 036 854 776 000 ; 9 223 372 036 854 776 000 ] |
En effet, selon que l’on soit en présence d’un processeur 32 ou 64 bits, certains types ont des tailles et des plages de valeurs variables. C’est pour cette raison que normalement on doit utiliser les types dit "Entiers Fixes" dont nous parlerons plus loin.
Une règle détermine la validité des tailles des types entiers :
[signed|unsigned], char <= short <= int <= long [<= long long]

#### Les Flottants

Cette catégorie, compatible avec le langage C, regroupe les types représentant les nombres à virgule flottante.
Commun aux processeurs 32 et 64 bit :
| Type de Base | Taille du type en octets | Taille de l'exposant | Taille de la mantisse | Nombres de valeurs possibles | Plage de valeurs possible |
| float | 4 | 8 bits | 23 bits | 4 294 967 296 | (indisponible actuellement) |
| double | 8 | 11 bits | 52 bits | 18 446 744 073 509 552 000 | (indisponible actuellement) |
| long double | 12 | 15 bits | 64 bits | 79 008 162 513 705 380 000 000 000 000 | (indisponible actuellement) |

#### Le Type Logique

Ce type est un apport par rapport au langage C, il n'est donc pas compatible avec celui ci.
Le type bool est un type un peu particulier. Il est codé sur 4 octets et représente les données logiques vrai et faux par 2 mots clés respectivement "true" et "false". Ce type gère sa valeur de manière assez singulière :
true vaut 1, false vaut 0, mais d’une manière générale tout ce qui n’est pas false (égal à 0) vaut true (différent de 0). En effet comme ce type est codé sur 4 octets il possède la même plage de valeurs qu'un signed int et nous pouvons lui affecter n’importe quelle valeur de cette plage.
Commun aux processeurs 32 et 64 bit :
| Type de Base | Taille du type en octets | Nombres de valeurs possibles | Plage de valeurs possible | Valeur = 0 | Valeur = [ −2 147 489 648 ; -1 ] U [ +1 ; 2 147 489 647 ] |
| bool | 4 | 4 294 967 296 | [ −2 147 489 648 ; 2 147 489 647 ] | false | true |

#### Les Méthodes

Nous parlerons en détail de ce type dans le chapitre Méthodes.

#### Les Pointeurs, Tableaux et Références

Le type pointeur n'est qu'un raccourci vers la mémoire. Le type pointeur est en fait une adresse mémoire soit un entier non signé de la taille du bus d'adresse dans le contexte logiciel. Sa taille est donc variable suivant le matériel et le système d'exploitation utilisé.
Sa valeur représente l'adresse mémoire vers laquelle il pointe. Son type est le type dans lequel on lui demande de traduire la valeur existant à l'adresse où il pointe.
Il peut s'agir dans des cas peu fréquents de pointeurs sur méthodes mais nous verrons cela dans le chapitre Pointeur, Tableaux et Références.

#### Les Énumerations

Nous parlerons en détail de ce type dans le chapitre Énumérations.

#### Les Structures

Nous parlerons en détail de ce type dans le chapitre Structures, unions et champs de bits.

#### Les Champs de Bits

Nous parlerons en détail de ce type dans le chapitre Structures, unions et champs de bits.

#### Les Classes

Les classes sont le summum de l'architecture logicielle. Elles permettent la programmation-objet et la construction d'applications au code robuste réutilisable et relativement facile à debugger. Nous en reparlerons plus loin.

#### Structures vs Classes

* La visibilité d’une classe est par défaut privée, celle d’une structure, publique.
* L’héritage d’une classe est par défaut privé, celle d’une structure, publique.
* Template de classe, impossible en structure.

## Types Étendus

Les types étendus sont des types définis par les utilisateurs et sont le plus souvent des agglomérations de types intrinsèques et/ou types étendus. Ainsi il est possible de créer des types étendus agglomérant n’importe quel type intrinsèque en n’importe quelle quantité (dans les limites de la mémoire disponible) et dans n’importe quel ordre.
Le langage nous permet de définir de nouveaux types étendus grâce au mot clé "typedef".
La syntaxe de cette instruction est :
typedef NomDuTypeEtendu NomDuTypeDeBase;
Nous verrons des exemples concrets de cette syntaxe dans les chapitres suivants.
| Mots clés | Opérateurs |

# Opérateurs
## Les Opérateurs C++

Les opérateurs sont des symboles permettant d'effectuer des opérations sur des valeurs. Ils sont classés dans trois catégories.

### Opérateurs d'affectation
#### L'opérateur d'affectation simple "="

L'opérateur d'affectation simple est "=" il signifie "affecter à".
Syntaxe :
<Destination> = <Source>;
Où <Source> et <Destination> doivent être de même nature et où <Source> est une expression et <Destination> une variable ;

#### L'opérateur d'affectation additionneur "+="

L'opérateur d'affectation additionneur est "+=" il signifie "affecter en additionnant à".
Syntaxe :
<Destination> += <Source>;
Où <Source> et <Destination> doivent être de même nature et où <Source> est une expression et <Destination> une variable ;

#### L'opérateur d'affectation soustracteur "-="

L'opérateur d'affectation soustracteur est "-=" il signifie "affecter en soustrayant à".
Syntaxe :
<Destination> -= <Source>;
Où <Source> et <Destination> doivent être de même nature et où <Source> est une expression et <Destination> une variable ;

#### L'opérateur d'affectation multiplicateur "*="

L'opérateur d'affectation multiplicateur est "*=" il signifie "affecter en multipliant à".
Syntaxe :
<Destination> *= <Source>;
Où <Destination> et le résultat de l'opération doivent être de même nature et où <Source> est une expression et <Destination> une variable ;

#### L'opérateur d'affectation diviseur "/="

L'opérateur d'affectation diviseur est "/=" il signifie "affecter en divisant à".
Syntaxe :
<Destination> /= <Source>;
Où <Destination> et le résultat de l'opération doivent être de même nature et où <Source> est une expression et <Destination> une variable ;

#### L'opérateur d'affectation modulo "%="

L'opérateur d'affectation modulo est "%=" il signifie "affecter le modulo de, à".
Syntaxe :
<Destination> %= <Source>;
Où <Destination> et le résultat de l'opération doivent être de même nature et où <Source> est une expression et <Destination> une variable ;

### Les opérateurs mathématiques
#### Opérateur d'addition "+"

L'opérateur permettant l'addition est "+" il permet d'additionner un nombre ou le résultat numérique d’une expression à un autre.

#### Opérateur de soustraction "-"

L'opérateur permettant la soustraction est "-" il permet de soustraire un nombre ou le résultat numérique d’une expression à un autre.

#### Opérateur de multiplication "*"

L'opérateur permettant la multiplication est "*" il permet de multiplier un nombre ou le résultat numérique d’une expression à un autre.

#### Opérateur de division "/"

L'opérateur permettant la division est "/" il permet de diviser un nombre ou le résultat numérique d’une expression à un autre.
En c++ la division est entière si les deux opérandes sont entiers. Si l'un des opérandes est codé sur un format réel alors le résultat sera réel.

#### Opérateur de modulo "%"

L'opérateur permettant de récupérer le reste de la division entière d’un nombre ou du résultat numérique d’une expression par un autre, est "%".

### Les opérateurs comparatifs

Ils servent essentiellement à effectuer des tests logiques entre plusieurs valeurs numériques.

#### Comparateur d'égalité "=="

Le comparateur C++ d'égalité == permet de vérifier si la valeur de gauche est strictement égale à la valeur de droite.
Cela revient à faire une inversion de l'opérateur logique XOR (soit NOT XOR). Voici la table de vérité du comparateur == pour l'opération (x == y) :
| == (NOT XOR) | y = false | y = true |
| x = false | true | false |
| x = true | false | true |

#### Comparateur "!=" (différent de)

Le comparateur C++ différentiel "!=" permet de vérifier si la valeur de gauche est strictement différente de la valeur de droite. Cela revient à appliquer l'opérateur logique XOR.

#### Comparateur "<" (strictement inférieur à)

Le comparateur "<" (strictement inférieur à) permet de vérifier si la valeur numérique de gauche est strictement inférieure à la valeur numérique de droite. Cet opérateur renvoie true uniquement si la valeur numérique de gauche est strictement inférieure à la valeur numérique de droite.

#### Comparateur "<=" (inférieur à)

Le comparateur "<=" (inférieurs à) permet de vérifier si la valeur numérique de gauche est inférieure ou égale à la valeur numérique de droite. Cet opérateur renvoie true uniquement si la valeur numérique de gauche est inférieure ou égale à la valeur numérique de droite.

#### Comparateur ">=" (supérieur à)

Le comparateur ">=" (supérieur à) permet de vérifier si la valeur numérique de gauche est supérieure ou égale à la valeur numérique de droite. Cet opérateur renvoie true uniquement si la valeur numérique de gauche est supérieure ou égale à la valeur numérique de droite.

#### Comparateur ">" (strictement supérieur à)

Le comparateur ">" (strictement supérieur à) permet de vérifier si la valeur numérique de gauche est strictement supérieure à la valeur numérique de droite. Cet opérateur renvoie true uniquement si la valeur numérique de gauche est strictement supérieure à la valeur numérique de droite.

### Opérateurs logiques

Les opérateurs logiques représentent les manipulations et comparaisons possibles que l’on peut faire sur des données de types booléen et/ou binaire.
* Attention : les opérateurs &, | et ^ sont des opérateurs bit à bit ! Les opérateurs logiques correspondant au & et au | sont respectivement && et ||.

#### Les opérateurs logiques

Cette sous-catégorie représente les opérateurs logiques que nous avons vu en introduction en leur spécifiant une syntaxe. Il est à noter que l'opérateur logique YES n'a pas de représentation en C++. En effet le C++ utilise le postulat que les opérations doivent retourner true pour être vraies. Partant de ce principe, il n'est plus nécessaire d’avoir un opérateur YES.

##### Opérateur "!" (NOT)

L'opérateur logique inverseur NOT a pour syntaxe en C++ le symbole "!" (point d'exclamation) ou l'expression "not". Pour inverser une valeur on écrira donc en C++

##### Opérateur "&&" (AND)

Le comparateur C++ AND, représenté par "&&" (double "et commercial"), permet de vérifier si les 2 valeurs soumises sont vraies. Ce comparateur est souvent utilisé dans les tests car il permet une optimisation du code. Contrairement à l'opérateur logique "&" le comparateur "&&" teste la première valeur et si elle est false il renvoie directement false sans tester la deuxième valeur. Ce comportement permet un gain de temps sur les procédures de comparaison et permet d’éviter l'exécution d’un code qui serait invalide si le test de la première valeur renvoyait false.

##### Opérateur "||" (OR)

Le comparateur C++ OR "||" permet de vérifier si au moins une des valeurs soumises est vraie. Ce comparateur est souvent utilisé dans les tests car il permet une optimisation du code. Contrairement à l'opérateur logique "|", le comparateur "||" teste la première valeur, et si elle est à vrai, il renvoie directement true sans tester la deuxième valeur. Ce comportement permet un gain de temps sur les procédures de comparaison et permet d’éviter l'exécution d’un code qui serait invalide si le test de la première valeur renvoyait vrai.

#### Opérateurs bit à bit

Les opérateurs bit à bit travaillent sur les variables en s'appliquant bit à bit.

##### Opérateur "&" (AND)

L'opérateur AND a pour syntaxe en C++ le symbole "&" (l’esperluette ou et commercial). Pour effectuer un AND sur des valeurs on écrira donc en C++

##### Opérateur "|" (OR)

L'opérateur OR a pour syntaxe en C++ le symbole "|" (la barre verticale). Pour effectuer un OR sur des valeurs on écrira donc en C++ :

##### Opérateur "^" (XOR)

L'opérateur XOR a pour syntaxe en C++ le symbole "^" (Accent circonflexe). Pour effectuer un XOR sur des valeurs on écrira donc en C++ :

##### Opérateur "~" (NOT)

L'opérateur NOT a pour syntaxe en C++ le symbole "~" (tilde). Pour effectuer un NOT sur des valeurs on écrira donc en C++ :

### Opérateurs unaires

En C++, il existe des opérateurs qui ne nécessitent qu'un opérande. Ils sont appelés opérateurs unaires.

#### Opérateurs "++" (incrémentation)

L'opérateur "++" est un peu particulier car il possède 2 formes et des effets indésirables. Je n'en parle que pour vous permettre d’éviter les cas problématiques.

##### Forme préfixée

Dans sa forme préfixée la théorie veut que l'opérande associé soit d’abord incrémenté puis renvoyé.
Syntaxe :
Où operande est la valeur à incrémenter puis à renvoyer.

##### Forme suffixée

Dans sa forme suffixée la théorie veut que l'opérande associé soit d’abord renvoyé puis incrémenté.
Syntaxe :
Où operande est la valeur à renvoyer puis à incrémenter.

#### Opérateurs "--" (décrémentation)

L'opérateur "--" est un peu particulier car il possède 2 formes et des effets indésirables. Je n'en parle que pour vous permettre d’éviter les cas problématiques.

##### Forme préfixée

Dans sa forme préfixée la théorie veut que l'opérande associé soit d’abord décrémenté puis renvoyé.
Syntaxe :
Où operande est la valeur à décrémenter puis à renvoyer.

##### Forme suffixée

Dans sa forme suffixée la théorie veut que l'opérande associé soit d’abord renvoyé puis décrémenté.
Syntaxe :
Où operande est la valeur à renvoyer puis à décrémenter.

##### Effets secondaires

En C++ il existe un effet secondaire avec certains opérateurs. Si l’on utilise plusieurs opérateurs unaires ou d'affectation dans la même ligne de commande, le résultat est indéterminé par les spécifications du langage. Ce qui veut dire que le compilateur fait ce qu’il veut. En fait ce problème survient car l'opérateur lit et modifie la valeur de ses opérandes.
Dans ce cas, "a" peut valoir 1 ou 2 selon comment le compilateur a traité les opérateurs. Autre exemple
Dans ce cas, "a" peut valoir 0, 1 ou 3 selon comment le compilateur a traité les opérateurs.
autre exemple :
Ici l’affichage peut avoir bien des valeurs.
Il est donc recommandé d’utiliser ces opérateurs avec précaution et d’éviter toute expression trop complexe(comme ci-dessus). D'ailleurs, de telles expressions ont plutôt tendance à rendre le code moins lisible - ce qui est l'inverse du but initial - et cache souvent une mauvaise conception.
Néanmoins, une utilisation raisonnable de ces opérateurs permet de rendre un code plus concis, sans perdre en lisibilité.
Le code ci-dessous filtre dans tab les entiers superieurs à 5 et les place dans filtered_tab.
\n, signifie une le line-feed.
\t, signifie la tabulation horizontale.
Et leurs origines viennent des ordinateurs qui existaient avant la démocratisation des écrans. Et ils étaient destinés aux imprimantes.
Le \n est un caractère spéciale que les imprimantes interprétaient comme instruction de faire avancer le papier d’une ligne verticalement.
Le \t est un caractère spéciale qui donnait l’instruction d’avancer la tête d’impression de 1 à 8 espaces horizontalement. Soit la position divisible par huit sans reste la plus près de sa position actuelle.