# Langage C++/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 |