Wikiversité

Langage
C++/Introduction
< Langage C++

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 =

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 =

où 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 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\
0b00000000 0b00000001 ... 0b01111110 0b01111111 0b10000000 0b10
Valeurs

Interprétation
0 1 ... 126 127 128 129
Non-Signé

Interprétation
0 1 ... 126 127 -128 -127
Signé

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) :

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.

Récupérée de
« https://fr.wikiversity.org/w/index.php?
title=Langage_C%2B%2B/Introduction&oldid=875
977 »

Wikiversité

La dernière modification de cette page a été faite

le 7 mai 2022 à 21:39. •
Le contenu est disponible sous licence CC BY-SA
3.0 sauf mention contraire.