Définition bit.

Toute information sera traitée comme une suite de 0 et de 1.

L’unité d’information est le chiffre binaire (0 ou 1), que l’on appelle bit
(pour binary digit, chiffre binaire).
Types fondamentaux en C++

Type bool

(Institute) 01/02 2 / 46
Définition bit.
Toute information sera traitée comme une suite de 0 et de 1.
L’unité d’information est le chiffre binaire (0 ou 1), que l’on appelle bit
(pour binary digit, chiffre binaire).
Types fondamentaux en C++

Type bool
Types de caractères

(Institute) 01/02 2 / 46
Définition bit.
Toute information sera traitée comme une suite de 0 et de 1.
L’unité d’information est le chiffre binaire (0 ou 1), que l’on appelle bit
(pour binary digit, chiffre binaire).
Types fondamentaux en C++

Type bool
Types de caractères
Types entiers

(Institute) 01/02 2 / 46
Définition bit.
Toute information sera traitée comme une suite de 0 et de 1.
L’unité d’information est le chiffre binaire (0 ou 1), que l’on appelle bit
(pour binary digit, chiffre binaire).
Types fondamentaux en C++

Type bool
Types de caractères
Types entiers
Types à virgule flottante

(Institute) 01/02 2 / 46
Le type bool
Un booléen peut prendre les valeurs true ou false. Il est possible de
convertir un booléen en entier et vice-versa; dans ce cas, true se convertit
en 1, false se convertit en 0. Dans l’autre sens, 0 est converti en false et
tout entier non nul est converti en true.

(Institute) 01/02 3 / 46
Types de caractères
Exemple: Variables de carctères
Les caractères sont des données non numériques : il n’y a pas de sens à
additionner ou multiplier deux caractères. Par contre, il est souvent utile
de comparer
deux caractères, par exemple pour les trier dans l’ordre alphabétique.
Les caractères, appelés symboles alphanumériques, incluent les lettres
majuscules et minuscules, les symboles de ponctuation (& ~, . ; # " -
etc...),
et les chiffres.
Un texte, ou chaîne de caractères, sera représenté comme une suite de
caractères.
Le codage des caractères est fait par une table de correspondance
indiquant la configuration binaire représentant chaque caractère. Les deux
codes les plus connus sont:
l’EBCDIC (en voie de disparition) et le code ASCII (American Standard
Code for Information Interchange).

(Institute) 01/02 4 / 46
Plusieurs points importants à propos du code ASCII :
— Les codes compris entre 0 et 31 ne représentent pas des caractères, ils ne
sont pas affichables. Ces codes, souvent nommés caractères de contrôles
sont utilisés pour indiquer des actions comme passer à la ligne (\n),
émettre un bip sonore (\a), tabulation horizontale (\t), tabulation
verticale (\v) etc.
— Les lettres se suivent dans l’ordre alphabétique (codes 65 à 90 pour les
majuscules, 97 à 122 pour les minuscules), ce qui simplifie les
comparaisons.
— On passe des majuscules au minuscules en modifiant le 5ième bit, ce qui
revient à ajouter 32 au code ASCII décimal.
— Les chiffres sont rangés dans l’ordre croissant (codes 48 à 57), et les 4
bits de poids faibles définissent la valeur en binaire du chiffre.
Exercice le code de caractères le plus courant, l’ASCII est codé sur 7 bits
Précisez pourquoi 7 bits suffisent pour coder les caractères.

(Institute) 01/02 5 / 46
Il code miniscules (26 lettres) majuscules (26 lettres) chiffres (10)
ce qui fait 62 caractères auxquels il faut ajouter l’espace et la ponctuation.
Il faut doncau minimum 7 bits qui permettent de coder 128 caractères.
Exercice Donnez le code haxadécimal ASCII des caractères ’Cac 40’.
Indication: les codes hexadécimaux de ’ ’,’0’ et ’ A’ sont 20H, 30H et 41H.

(Institute) 01/02 6 / 46
Les codes se suivent. Les minuscules sont à +61H.
La chaîne est donc en hexa 43 61 63 20 34 30 H..

(Institute) 01/02 7 / 46
Exemple: imprime le caractère et sa valeur entière stocké en interne
int main ()
{
char c=’A’;
cout << "c= "<< c <<", int (c)= "<< int (c) << endl;
char c=’t’;
cout << "c= "<< c <<", int (c)= "<< int (c) << endl;
char c=’\t’;
cout << "c= "<< c <<", int (c)= "<< int (c) << endl;
char c=’ !’;
cout << "c= "<< c <<", int (c)= "<< int (c) << endl;
}

(Institute) 01/02 8 / 46
c=A, in(c)=65
c=t, in(c)=116
c= , in(c)=9
c=!, in(c)=33
L’opération de transtypage (conversion) int ( ) permet de révéler la
valeur intégrale correspondante codes ASCII.

(Institute) 01/02 9 / 46
Types entiers
En C++ il existe 6 types short, int, long, unsigned short, unsigned int,
unsigned long.
Les entiers naturels (positifs ou nuls) sont codés sur un nombre d’octets
fixé (un octet est un groupe de 8 bits). On rencontre habituellement des
codages sur 1,
2 ou 4 octets, plus rarement sur 64 bits (8 octets, par exemple sur les
processeurs DEC Alpha).
Un codage sur n bits permet de représenter tous les nombres naturels
compris entre 0 et 2n -1. Par exemple sur 1 octet, on pourra coder les
nombres de 0 à 255 = 28 -1.
Plages des types entiers

(Institute) 01/02 10 / 46
# include < iostream>
# include < climits> // définit les constantes SHRT_MIN etc,
using namespace std;
int main ()
{
cout << "minimum d’un short =" << SHRT_MIN <<endl;
cout << "maximum d’un short =" << SHRT_MAX <<endl;
cout << "minimum d’un unsigned short = 0" << endl;
cout << "maximum d’un unsigned short =" << USHRT_MAX <<
endl;
cout << "minimum d’un int =" << INT_MIN <<endl;
cout << "maximum d’un int =" << INT_MAX <<endl;
}

(Institute) 01/02 11 / 46
minimum d’un short = -32 768
maximum d’un short = 32767
minimum d’un unsigned short = 0
maximum d’un unsigned short =65535
minimum d’un int = -2147483648
maximum d’un int = 2147483647

(Institute) 01/02 12 / 46
Types à virgule flottante

C++ prend en charge 3 types de nombres réels: float, double, long

double.
Dans la plus part des systèmes, un double utilise deux fois plus d’octets
qu’un float.
En règle générale, un float utilise 4 octets, un double 8 octets et un long
double 8,10, 12, ou 16 octets.
Les types employés pour des nombres réels sont qualifiés de type"à virgule
flottante"
12,346=1.101 + 2.100 + 3.10−1 + 4.10−2 + 6.10−3
En général, en base b, on écrit :

an an −1 an −2 ....a1 a0 a−1 a−2 ....a−p

= an bn + an −1 bn −1 + ... + a0 b0 + a−1 b −1 + .... + a−p b −p

(Institute) 01/02 13 / 46
123,45 est stocké d’abord en nombre binaire.

123, 45 = 1111011, 011100112

La virgule est ensuite rendue "flottante" de sorte que tous les bits soient
placés à driote de celle-ci.

123, 45 = 0, 1111011011100112 × 27 ֋ exposant

| {z }
mantisse

La représentation interne de ce nombre serait effectuée en stockant:

- la mantisse 111101101110011
- l’exposant 7 séparément.

(Institute) 01/02 14 / 46
Pour un type flottant de 32 bits: la mantisse est sockée dans un
segment de 23 bits et l’exposant dans un segment de 8 bits, un bit
étant réservé pour le signe du nombre.
Pour un type double de 64 bits: la mantisse est sockée dans un
segment de 52 bits et l’exposant dans un segment de 11 bits, un bit
étant réservé pour le signe du nombre.

(Institute) 01/02 15 / 46
Pointeurs

Adresse et valeur d’un objet

On appelle Lvalue (left value) tout objet pouvant être placé à gauche
d’un opérateur d’affectation. Une Lvalue est caractérisée par :
— son adresse, c’est-à-dire l’adresse-mémoire à partir de laquelle l’objet est
stocké ;
— sa valeur, c’est-à-dire ce qui est stocké à cette adresse.

(Institute) 01/02 16 / 46
Dans l’exemple,
int i, j;
i = 3;
j = i;
Si le compilateur a placé la variable i à l’adresse 4831836000 en mémoire,
et la variable j à l’adresse 4831836004, on a

objet adresse valeur

i 4831836000 3
j 4831836004 3

(Institute) 01/02 17 / 46
Deux variables différentes ont des adresses différentes. L’affectation i = j;
n’opère que sur les valeurs des variables. Les variables i et j étant de type
int, elles sont stockées sur 4 octets.
Ainsi la valeur de i est stockée sur les octets d’adresse 4831836000 à
4831836003.
L’adresse d’un objet étant un numéro d’octet en mémoire, il s’agit d’un
entier quelque soit le type de l’objet considéré. Le format interne de cet
entier (16 bits, 32 bits ou 64 bits) dépend des architectures.
L’opérateur & permet d’accéder à l’adresse d’une variable. Toutefois &i
n’est pas une Lvalue mais une constante : on ne peut pas faire figurer &i à
gauche d’un opérateur d’affectation.
Pour pouvoir manipuler des adresses, on doit donc recourir un nouveau
type d’objets, les pointeurs.

(Institute) 01/02 18 / 46
Un pointeur est un objet (Lvalue) dont la valeur est égale à l’adresse d’un
autre objet. On déclare un pointeur par l’instruction :

type *nom-du-pointeur;

où type est le type de l’objet pointé. Cette déclaration déclare un

identificateur, nom-du-pointeur, associé à un objet dont la valeur est
l’adresse d’un autre objet de type type. L’identificateur nom-du-pointeur
est donc en quelque sorte un identificateur d’adresse. Comme pour
n’importe quelle Lvalue, sa valeur est modifiable.
Même si la valeur d’un pointeur est toujours un entier (´eventuellement un
entier long), le type d’un pointeur dépend du type de l’objet vers lequel il
pointe. Cette distinction est indispensable à l’interprétation de la valeur
d’un pointeur. En effet, pour un pointeur sur un objet de type char, la
valeur donne l’adresse de l’octet où cet objet est stocké. Par contre, pour
un pointeur sur un objet de type int, la valeur donne l’adresse du premier
des 4 octets où l’objet est stocké.

(Institute) 01/02 19 / 46
Dans l’exemple suivant, on définit un pointeur p qui pointe vers un entier i
:
int i = 3;
int *p;
p = &i;
On se trouve dans la configuration

objet adresse valeur

i 4831836000 3
p 4831836004 4831836000

L’opérateur unaire d’indirection * permet d’accéder directement à la valeur

de l’objet pointé. Ainsi, si p est un pointeur vers un entier i, *p désigne la
valeur de i.

(Institute) 01/02 20 / 46
Par exemple, le programme en C
main()
{
int i = 3;
int *p;
p = &i;
printf("*p = %d \n",*p);
}
imprime *p = 3.
Dans ce programme, les objets i et *p sont identiques : ils ont mêmes
adresse et valeur.
Nous sommes dans la configuration :
objet adresse valeur
i 4831836000 3
p 4831836004 4831836000
*p 4831836000 3
Cela signifie en particulier que toute modification de *p modifie i. Ainsi, si
l’on ajoute l’instruction *p = 0; à la fin du programme précédent, la valeur
de i devient nulle.
(Institute) 01/02 21 / 46
On peut donc dans un programme manipuler à la fois les objets p et *p.
Ces deux manipulations sont trés différentes. Comparons par exemple les
deux programmes suivants :
main()
{
int i = 3, j = 6;
int *p1, *p2;
p1 = &i;
p2 = &j;
*p1 = *p2;
}
et

(Institute) 01/02 22 / 46
main()
{
int i = 3, j = 6;
int *p1, *p2;
p1 = &i;
p2 = &j;
p1 = p2;
}

(Institute) 01/02 23 / 46
Avant la dernière affectation de chacun de ces programmes, on est dans
une configuration du type :

objet adresse valeur

i 4831836000 3
j 4831836004 6
p1 4831835984 4831836000
p2 4831835992 4831836004

(Institute) 01/02 24 / 46
Après l’affectation *p1 = *p2; du premier programme, on a

objet adresse valeur

i 4831836000 6
j 4831836004 6
p1 4831835984 4831836000
p2 4831835992 4831836004

Par contre, l’affectation p1 = p2 du second programme, conduit à la

situation :

objet adresse valeur

i 4831836000 3
j 4831836004 6
p1 4831835984 4831836004
p2 4831835992 4831836004

(Institute) 01/02 25 / 46
Arithmétique des pointeurs
La valeur d’un pointeur étant un entier, on peut lui appliquer un certain
nombre d’opérateurs arithmétiques classiques. Les seules opérations
arithmétiques valides sur les pointeurs sont :
— l’addition d’un entier à un pointeur. Le résultat est un pointeur de meme
type que le pointeur de départ ;
— la soustraction d’un entier à un pointeur. Le résultat est un pointeur de
même type que le pointeur de départ ;
— la différence de deux pointeurs pointant tous deux vers des objets de
même type. Le résultat est un entier.
Notons que la somme de deux pointeurs n’est pas autorisée.
Si i est un entier et p est un pointeur sur un objet de type type
l’expression p + i désigne un pointeur sur un objet de type type
dont la valeur est égale à la valeur de p incrémentée de i *
sizeof(type). Il en va de même pour la soustraction d’un entier à un
pointeur, et pour les opérateurs d’incrémentation et de
décrémentation ++ et —.
(Institute) 01/02 26 / 46
Le programme en C
main()
{
int i = 3;
int *p1, *p2;
p1 = &i;
p2 = p1 + 1;
printf("p1 = %ld \t p2 = %ld\n",p1,p2);
}
affiche p1 = 4831835984 p2 = 4831835988.

(Institute) 01/02 27 / 46
Par contre, le même programme avec des pointeurs sur des objets de type
double :
main()
{
double i = 3;
double *p1, *p2;
p1 = &i;
p2 = p1 + 1;
printf("p1 = %ld \t p2 = %ld\n",p1,p2);
}
affiche p1 = 4831835984 p2 = 4831835992.

(Institute) 01/02 28 / 46
Allocation dynamique
Avant de manipuler un pointeur, et notamment de lui appliquer
l’opérateur d’indirection *, il faut l’initialiser. Sinon, par défaut, la valeur
du pointeur est égale à une constante
symbolique notée NULL définie dans stdio.h. En général, cette constante
vaut 0. Le test p == NULL permet de savoir si le pointeur p pointe vers
un objet.
On peut initialiser un pointeur p par une affectation sur p. Par exemple,
on peut affecter à p l’adresse d’une autre variable. Il est également
possible d’affecter directement une valeur à *p. Mais pour cela, il faut
d’abord réserver à *p un espace-mémoire de taille adéquate. L’adresse de
cet espace-mémoire sera la valeur de p. Cette opération consistant à
réserver un espace-mémoire pour stocker l’objet pointé s’appelle allocation
dynamique.
Elle se fait en C par la fonction malloc de la librairie standard stdlib.h.
malloc(nombre-octets)
en C++ à l’aide de l’opérateur new
(Institute) 01/02 29 / 46
En effet
float *p; // p pointe vers un float
seule la mémoire pour le pointeur est allouée. La valeur du pointeur est
représentée par une adresse mémoire, mais la mémoire de cette adresse
n’est pas encore allouée. Ceci signifie que la mémoire peut déja être
utilisée par una autre variable. Dans ce cas, p est non initialisé: il ne
pointe vers aucune mémore allouée. toute tentative d’accès à la mémoire
vers laquelle il pointe générera une erreur:
*p=4.5; //Erreur aucune mémoire n’ été allouée à *p
L’initialisation des pointeurs lors de leur décalaration vos permet d’éviter
ce problème
float x=4.5;
float *p=&x // p contient l’adresse de x;
cout << *p // OK *p a été alloué
Dans ce cas, l’accès à *p ne pose pas de problème car la mémoire requise
pour le stockage du flottant 4.5 a été automatiquement allouée lors de la
déclaration de x; p pointe vers la mémoire allouée.

(Institute) 01/02 30 / 46
Une autre façon de contourner ce problème consiste à allouer de la
mémoire au pointeur de façon explicite
#include <stdlib.h>
int *p;
p = (int*)malloc(sizeof(int));
––––––––––––––-
float *q;
q=new float; // alloue l’espace de stockage pour un float
*q=4.5; // OK *p a été alloué
L’opérateur new renvoie l’adresse d’un bloc d’octets non alloués.
Ces deux derniers peuvent donc etre combinés

float*q=new float;

(Institute) 01/02 31 / 46
Ainsi, pour initialiser un pointeur vers un entier, on écrit : (programme en
C)
#include <stdlib.h>
int *p;
p = (int*)malloc(sizeof(int));
ou
p = (int*)malloc(4);
puisqu’un objet de type int est stocké sur 4 octets.

(Institute) 01/02 32 / 46
Le programme suivant
#include <stdio.h>
#include <stdlib.h>
main()
{
int i = 3;
int *p;
printf("valeur de p avant initialisation = %ld\n",p);
p = (int*)malloc(sizeof(int));
printf("valeur de p apres initialisation = %ld\n",p);
*p = i;
printf("valeur de *p = %d\n",*p);
}

(Institute) 01/02 33 / 46
définit un pointeur p sur un objet *p de type int, et affecte à *p la valeur
de la variable i.
Il imprime à l’écran :
valeur de p avant initialisation = 0
valeur de p après initialisation = 5368711424
valeur de *p = 3
Avant l’allocation dynamique, on se trouve dans la configuration

objet adresse valeur

i 4831836000 3
p 4831836004 0

A ce stade, *p n’a aucun sens. En particulier, toute manipulation de la

variable *p générerait une violation mémoire, détectable à l’exécution par
le message d’erreur Segmentation fault.

(Institute) 01/02 34 / 46
L’allocation dynamique a pour résultat d’attribuer une valeur à p et de
réserver à cette adresse un espace-mémoire composé de 4 octets pour
stocker la valeur de *p. On a alors

objet adresse valeur

i 4831836000 3
p 4831836004 5368711424
*p 5368711424 ? (int)

(Institute) 01/02 35 / 46
*p est maintenant définie mais sa valeur n’est pas initialisée. Cela signifie
que *p peut valoir n’importe quel entier (celui qui se trouvait
précédemment à cette adresse). L’affectation *p= i; a enfin pour résultat
d’affecter ‘a *p la valeur de i. A la fin du programme, on a donc

objet adresse valeur

i 4831836000 3
p 4831836004 5368711424
*p 5368711424 3

(Institute) 01/02 36 / 46
Enfin, lorsque l’on n’a plus besoin de l’espace-mémoire alloué
dynamiquement (c’est-à-dire quand on n’utilise plus le pointeur p), il faut
libérer cette place en mémoire. Ceci se fait à l’aide de l’instruction free
(C) delete (C++) qui a pour syntaxe
free(nom-du-pointeur);

(Institute) 01/02 37 / 46
Pointeurs et chaînes de caractères

Une chaîne de caractères est un tableau à une dimension d’objets de type

char, se terminant par le caractère nul ’\0’.
char nom [ ]="omar"
Ce tableau contient 5 éléments: ’o’, ’m’, ’a’, ’r’ et ’\0’
cout << nom affiche omar.
On peut manipuler toute chaîne de caractères à l’aide d’un pointeur sur un
objet de type char.
char *chaine;
chaine = "ceci est une chaine";
Exercice
Ecrire un programme qui imprime le nombre de caractères d’une chaîne
(sans compter le caractère nul).

(Institute) 01/02 38 / 46
#include <stdio.h>
main()
{
int i;
char *chaine;
chaine = "chaine de caracteres";
for (i = 0; *chaine != ’\0’; i++)
chaine++;
printf("nombre de caracteres = %d\n",i);
}
La fonction donnant la longueur d’une chaîne de caractères, définie dans la
librairie standard string.h, procède de manière identique. Il s’agit de la
fonction strlen dont la syntaxe est
strlen(chaine);
où chaine est un pointeur sur un objet de type char. Cette fonction
renvoie un entier dont la valeur est égale à la longueur de la chaîne passée
en argument (moins le caractère ’\0’).

(Institute) 01/02 39 / 46
Dans un tableau, les variables doivent être de type homogène, cela
signifiant qu’il n’est pas possible de juxtaposer des char et des int dans un
tableau. Lorsque l’on souhaite faire cohabiter dans une variable non
scalaire des types hétérogènes, on utilise des structures.
Une structure, appelée enregistrement dans d’autres langages, est une
variable contenant plusieurs variables, appelées champs.
Déclaration
Pour créer un type structure, on utilise la syntaxe suivante :
struct nomdutype
{
typechamp_1 nomchamp_1;
typechamp_2 nomchamp_2;
...
typechamp_n nomchamp_n;
};

(Institute) 01/02 40 / 46
Exemple
struct point
{
double abs ;
double ord ;
};

struct point p ;
Accès aux champs

nomvariable.nomduchamp

(Institute) 01/02 41 / 46
#include<stdio.h>
struct point
{
double abs ;
double ord ;
};
main ( )
{
struct point p ;
p.ord = 2 ;
p.abs = p.ord + 1 ;
printf ( "p = (%f , %f )\n" , p.abs , p.ord ) ;
}
Ce programme affiche :
p = (3.000000, 2.000000)

(Institute) 01/02 42 / 46
Typedef
On se débarasse du mot clé struct en renommant le type, on utilisera par
exemple la syntaxe suivante :
#include<stdio h>
typedef struct point
{
double abs ;
double ord ;
} point ;
main ( )
{
point p ;
p.ord = 2 ;
p.abs = p.ord + 1;
printf ( "p = (%f , %f )\n" , p.abs , p.ord );
}

(Institute) 01/02 43 / 46
le programme suivant crée, à l’aide d’un pointeur, un tableau d’objets de
type structure.
#include <stdlib.h>
#include <stdio.h>
struct eleve
{
char nom[20];
int date;
};
typedef struct eleve *classe;
main()
{
int n, i;
classe tab;
printf("nombre d’eleves de la classe = ");
scanf("%d",&n);
tab = (classe)malloc(n * sizeof(struct eleve));

(Institute) 01/02 44 / 46
for (i =0 ; i < n; i++)
{
printf("\n saisie de l’eleve numero %d\n",i);
printf("nom de l’eleve = ");
scanf("%s",&tab[i].nom);
printf("\n date de naissance JJMMAA = ");
scanf("%d",&tab[i].date);
}
printf("\n Entrez un numero ");
scanf("%d",&i);
printf("\n Eleve numero %d:",i);
printf("\n nom = %s",tab[i].nom);
printf("\n date de naissance = %d\n",tab[i].date);
free(tab);
}

(Institute) 01/02 45 / 46
Si p est un pointeur sur une structure, on peut accéder à un membre de la
structure pointé par l’expression

(*p).membre

L’usage de parenthèses est ici indispensable car l’opérateur d’indirection *

à une priorité plus élevée que l’opérateur de membre de structure. Cette
notation peut être simplifiée grace à l’opérateur pointeur de membre de
structure, noté ->. L’expression précédente est strictement équivalente

p->membre

Ainsi, dans le programme précédent, on peut remplacer tab[i].nom et

tab[i].date respectivement
par (tab + i)->nom et (tab + i)->date.

(Institute) 01/02 46 / 46