Leçons de niveau 14

Langage C++/Introduction

Une page de Wikiversité.
Sauter à la navigation Sauter à la recherche
Début de la boite de navigation du chapitre
Introduction
Icône de la faculté
Chapitre no 1
Leçon : Langage C++
Retour auSommaire
Chap. suiv. :Mots clés
fin de la boite de navigation du chapitre
Icon falscher Titel.svg
En raison de limitations techniques, la typographie souhaitable du titre, « Langage C++ : Introduction
Langage C++/Introduction
 », n'a pu être restituée correctement ci-dessus.

Préambule :[modifier | modifier le wikicode]

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 :[modifier | modifier le wikicode]

Des Chiffres et des BITs[modifier | modifier le wikicode]

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 =

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 =

Il existe une formule qui permet de convertir n’importe quel nombre binaire en nombre décimal :

Nombre_décimal = est le bit de rang 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 valeurs,
  • le plus grand nombre que l’on peut représenter avec cet ensemble sera .

Pour le nombre binaire 1010 nous avons :

Conversion Binaire → Décimal
1         0         1         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 . 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

→ 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 soucis 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 suffixant de la lettre "b".

ex:

Nombre décimal Nombre hexadécimal Nombre binaire
26 0x1A 00011010b

Les Octets :[modifier | modifier le wikicode]

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 :[modifier | modifier le wikicode]

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 :[modifier | modifier le wikicode]

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 00000000b 00000001b ... 01111110b 01111111b 10000000b 10000001b 10000010b ... 11111110b 11111111b
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 :[modifier | modifier le wikicode]

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 :[modifier | modifier le wikicode]

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 accessibles au C++ :

Opérateur YES (OUI) :[modifier | modifier le wikicode]

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) :[modifier | modifier le wikicode]

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) :[modifier | modifier le wikicode]

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) :[modifier | modifier le wikicode]

L'opérateur NAND effectue une comparaison entre 2 valeurs logiques. Si l'une des 2 valeurs est fausse alors la sortie est vraie, sinon elle est fausse. 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) :[modifier | modifier le wikicode]

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) :[modifier | modifier le wikicode]

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) :[modifier | modifier le wikicode]

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.