INTERVENANT

HABIB NDIAYE
INGÉNIEUR DÉVELOPPEUR
+221 77 319 94 76 /
habibndiaye08@gmail.com
PLAN

INTRODUCTION AUX LANGAGES DE PROGRAMMATION

LANGAGE C : HISTORIQUE & CARACTERISTIQUES
BASES DU LANGAGE C
INSTRUCTIONS
STRUCTURES DE DONNEES
POINTEURS
FONCTIONS
LISTES CHAINEES
FICHIERS
INTRODUCTION AUX LANGAGES DE PROGRAMMATION

Un langage de programmation ressemble à une langue : il dispose de son propre

vocabulaire et de ses règles de grammaire et de syntaxe. Une autre définition est
celle-ci : formalisme basé sur une langue et qui définit une manière de donner des
ordres à l’ordinateur.

- programme (ou exécutable) : algorithme écrit dans un langage de

programmation; ensemble d’instructions exécutables par un ordinateur;
- programmeur : celui qui donne à des ordres à l’ordinateur en écrivant des
programmes.
- code source = fichier texte contenant un ensemble d’instructions écrit dans un
certain langage de programmation. En C, un code source est un (ou plusieurs)
fichier(s) portant l’extension .c;
- programmation : activité de rédaction du code source d’un programme.
INTRODUCTION AUX LANGAGES DE PROGRAMMATION

On peut regrouper les langages de programmation en deux catégories :

- les langages de bas niveau : ils se rapprochent plus du langage machine
(langage binaire, langage du processeur) ;
- les langages de haut niveau : ils sont proches du langage humain et
indépendants de la machine utilisée (portabilité). Plus un langage est de haut
niveau, plus il est proche du langage humain.

Le langage assembleur et le langage machine sont des exemples de langages de

bas niveau. Parmi les langages de haut niveau, on retrouve le C, C++, Java, PHP,
etc...
INTRODUCTION AUX LANGAGES DE PROGRAMMATION

Il est possible de faire une traduction du langage de haut niveau vers celui de bas
niveau, avec un traducteur. On distingue alors deux types de traducteurs :
- l’interpréteur : il traduit le programme instruction par instruction.
- le compilateur : il traduit le programme dans son ensemble.

Suivant le type de traducteur utilisé, on parlera alors de langage compilé (cas du C,

de Latex, etc.) ou de langage interprété (cas de Ruby, PHP, HTML, etc.). Certains
langages, tels que Java, sont intermédiaires.
LANGAGE C : HISTORIQUE & CARACTERISTIQUES
Historique

Le langage C a été créé en 1978 par Brian W. Kernighan et Denis Ritchie au sein des
laboratoires Bell, avec pour objectif de créer un système d’exploitation (une
réécriture de UNIX). Face à sa popularité grandissante, il a été normalisé en 1989
par le NIST. De nombreux autres langages comme Java, JavaScript ou C# ont
largement repris la syntaxe du C, mais sans être compatibles.

- K&R C : normalisé en 1978; version initiale du C, telle qu’introduite par

Kernighan et Ritchie. C’est le C « traditionnel ».
- C++ : 1983; extension du C avec le concept de classe. Normalisé en 1998 pour
devenir le Standard C++.
- Objective-C : contient le C comme sous-ensemble; est orienté objet.
- ANSI-C (ou C89) : normalisation du K&R C en 1989; version la plus utilisée du
C
LANGAGE C : HISTORIQUE & CARACTERISTIQUES
Caractéristiques

Le langage C est un langage de haut niveau( on dit parfois aussi qu’il est le plus bas
des langages de haut niveau!!!), impératif, compilé, typé et déclaratif.
Avantages
- Grande notoriété et très utilisé ; donc possibilité d’avoir de la documentation et
/ou de l’aide ;
- Certain nombre de fonctions prédéfinies dans des bibliothèques ;
- Langage portable et standardisé ;
- Simplicité ;
- Gestion de la mémoire ;
- Vitesse d’exécution.
Inconvénients
- Rigueur d’écriture ;
- Définition de certains concepts par soi-même .
LANGAGE C : HISTORIQUE & CARACTERISTIQUES
Etapes de la compilation en C

Le C est un langage compilé(par opposition aux langages interprétés). Cela signifie

qu’un programme C est décrit par un fichier texte, appelé fichier source. Ce fichier
n’étant évidemment pas exécutable par le microprocesseur, il faut le traduire en
langage machine. Cette opération est effectuée par un programme appelé
compilateur. La compilation se décompose en fait en 4 phases successives:

- la pré-compilation (ou prétraitement, pre-processing) : le fichier source est

analysé par le préprocesseur qui effectue des transformations purement
textuelles (remplacement de chaînes de caractères, inclusion d’autres fichiers
source ...).
- la compilation proprement dite (compiling) : la compilation proprement dite
traduit le fichier généré par le préprocesseur en assembleur, c’est-à-dire en une
suite d’instructions du microprocesseur qui utilisent des mnémoniques rendant
la lecture possible.
LANGAGE C : HISTORIQUE & CARACTERISTIQUES
Etapes de la compilation en C

- l’assemblage (assembling) : cette opération transforme le code assembleur en

un fichier binaire, c’est-à-dire en instructions directement compréhensibles par
le processeur. Généralement, la compilation et l’assemblage se font dans la
foulée, sauf si l’on spécifie explicitement que l’on veut le code assembleur. Le
fichier produit par l’assemblage est appelé fichier objet.

- l’édition des liens (linking) : un programme est souvent séparé en plusieurs

fichiers source, pour des raisons de clarté mais aussi parce qu’il fait
généralement appel à des librairies de fonctions standard déjà écrites. Une fois
chaque code source assemblé, il faut donc lier entre eux les différents fichiers
objets. L’édition de liens produit alors un fichier dit exécutable.
Bases du langage C
Les composants élémentaires du C

Un programme en langage C est constitué des six groupes de composants

élémentaires suivants:

- les identificateurs,
- les mots-clés,
- les constantes,
- les chaînes de caractères,
- les opérateurs,
- les signes de ponctuation.

On peut ajouter à ces six groupes les commentaires, qui sont enlevés par le
préprocesseur.
Bases du langage C
Les identificateurs

Le rôle d’un identificateur est de donner un nom à une entité du programme.

Un identificateur est une suite de caractères parmi :
- les lettres (minuscules ou majuscules, mais non accentuées),
- les chiffres,
- le “blanc souligné” (_).

Le premier caractère d’un identificateur ne peut pas être un chiffre.

Par exemple, var1, tab23 ou _deb sont des identificateurs valides; par contre, 1i et
i:j ne le sont pas. Il est cependant déconseillé d’utiliser _ comme premier caractère
d’un identificateur car il est souvent employé pour définir les variables globales de
l’environnement C.

Les majuscules et minuscules sont différenciées.

Bases du langage C
Les mots réservés

Il existe une série de mots réservés (aussi appelés mots-clés) au langage C, c’est-à-
dire qu’on ne peut pas les utiliser comme identificateurs ( de variables, de fonctions
ou de nouveaux types). Ils sont au nombre de 32 :
Bases du langage C
Les commentaires

Dans un programme, il est souvent nécessaire de documenter les parties

importantes (par exemple pour indiquer l’auteur du code, la date de création, le
rôle d’une fonction ou d’un bloc d’instructions). Pour cela, on utilise la notion de
commentaire. Le texte placé dans un commentaire est ignoré par le compilateur
lors de l’exécution. On distingue deux sortes de commentaires :
- les commentaires portant sur une ligne : on utilise //;
- les commentaires portant sur plusieurs lignes : ils débutent par /* et se
terminent par */.
Exemples :
//Ceci est un commentaire sur une ligne
/*Ceci est
un commentaire sur
plusieurs lignes*/
Bases du langage C
Structure d’un programme C

Un programme C est décrit par un ou plusieurs fichiers d’extension .c (appelés

fichiers source) et est constitué d’un programme principal pouvant faire appel à
des sous-programmes qui réalisent chacun une certaine tâche.
Un programme C comporte généralement :
- les directives du préprocesseur ;
- la définition de structures et de types secondaires ;
- la déclaration des variables globales et des constantes ;
- la définition des sous-programmes ;
- la fonction principale (appelée fonction main).

Chaque instruction dans le code source se termine par un ;.

Le préprocesseur est un programme exécuté lors de la précompilation (première
étape de la compilation). Il effectue des modifications textuelles sur le fichier
source à partir de directives. Une directive du préprocesseur est une ligne du code
source commençant par #.
Il existe trois manières de définir une directive du préprocesseur :

- #include <nomFichier> : indique l’utilisation d’une librairie prédéfinie et se

trouvant dans le fichier nomFichier;

- #define : pour la définition de constantes symboliques et de macros

- #if, #ifdef, #ifndef : directives de compilation conditionnelle.

La fonction MAIN

Un programme C doit contenir au minimum une fonction spéciale appelée fonction

main. La fonction main est le point d’entrée du programme, c’est-à-dire que c’est la
première fonction qui sera invoquée lors de l’exécution.
Sa présence est obligatoire.
Exemples:
Les variables

Le C est un langage typé. Cela signifie en particulier que toute variable, constante
ou fonction est d’un type précis. Le type d’un objet définit la façon dont il est
représenté en mémoire.
La mémoire de l’ordinateur se décompose en une suite continue d’octets. Chaque
octet de la mémoire est caractérisé par son adresse, qui est un entier. Deux octets
contigus en mémoire ont des adresses qui diffèrent d’une unité. Quand une
variable est définie, il lui est attribué une adresse. Cette variable correspondra à une
zone mémoire dont la longueur (le nombre d’octets) est fixée par le type.
Règles d’écriture des identificateurs (noms) des variables :
- ils peuvent contenir des lettres, des chiffres et le caractère ;
- ils ne doivent pas commencer par un chiffre;
- les accents sont interdits;
- il sont sensibles à la casse : par exemple, la variable prix est différent de la
variable PRIX;
Les types prédéfinis
Le type caractère

Pour déclarer une variable de type caractère, on utilise le mot-clé char.

En C, la notion de caractère dépasse celle de caractère imprimable, c’est à dire
auquel est associé un graphisme (lettres, chiffres, ponctuation, caractères spéciaux
etc).

Par exemple

Le type char a une particularité : en effet, on considère qu’une donnée de type char
n’est rien d’autre qu’un entier codé sur un octet. Et donc tout objet de type char
peut être utilisé dans une expression qui utilise des objets de type entier. Par
exemple, si une variable c est de type char, l’expression c + 1 sera correcte.
Les types prédéfinis
Le type caractère

Le ASCII(American Standard Code for Information Interchange) donne les

correspondances entre les caractères et les entiers qui les représentent.
Quand un caractère est imprimable il est noté entre les quotes simples : ’a’, ’+’, ’5’, ’
’, etc.
Les caractères non imprimables possèdent une représentation conventionnelle
utilisant le caractère antislash(\).
Il existe deux façons d’affecter une valeur à une variable de type char :
- soit en lui donnant directement la valeur du caractère mise entre quotes
- soit en utilisant le code ASCII correspondant à ce caractère.
Les types prédéfinis
Le type entier

Pour déclarer une variable de type entier, on utilise le mot-clé int. Le type entier se
définit de plusieurs manières :
- en précisant est-ce que c’est un entier signé (mot-clé signed) ou non-signé
(mot-clé unsigned). Le bit de poids fort de l’entier correspond au signe (0 pour
positif, 1 pour négatif). Par défaut, les entiers sont signés.
- et/ou en précisant l’intervalle de valeurs avec les mots-clés : short ou long. (il
existe aussi long long sur certains compilateurs)
Le tableau ci-dessous résume les types entiers.
Les types prédéfinis
Le type entier

Remarques
- Le plus souvent, on utilisera juste int pour déclarer une variable de type entier.
- Les spécifications pour le type entier sont définies dans la librairie limits.h.
- Les intervalles des entiers dépendent du système d’exploitation, du compilateur
et/ou du processeur utilisé.
Les types prédéfinis
Le type réel

Les flottants (les réels) sont désignés par les mot-clés float, double et long
double.

Remarques
- Pour les flottants, pas besoin d’utiliser les mots-clés signed et unsigned.
- Le plus souvent, on utilisera juste float pour déclarer une variable de type
flottant.
- Pour les nombres à virgule, le point remplace la virgule.
Les types prédéfinis
Le type void

Il existe un type spécial, appelé void, qui exprime l’idée de ”aucune valeur” ou
”vide”. On l’utilise par exemple :
- comme type de retour d’une fonction ne retournant pas de valeur;
- dans le prototype de fonctions sans paramètres;
- pour déclarer un pointeur générique.

NB :
Le type booléen n’existe pas explicitement en C.
Il est plutôt défini par le langage C++ (type bool). Dans la pratique, si on veut
définir une variable booléenne en C, on passera par le type int : 0 pour false, 1
pour true.
Les opérateurs
L’affectation

En C, l’affectation est un opérateur à part entière. Elle est symbolisée par le signe =.
Sa syntaxe est la suivante :
variable = expression ;

Le terme de gauche de l’affectation peut être une variable simple, un élément de

tableau mais pas une constante. Cette expression a pour effet d’évaluer expression
et d’affecter la valeur obtenue à variable. De plus, cette expression possède une
valeur, qui est celle expression. Ainsi, l’expression i = 5 vaut 5.

L’affectation effectue une conversion de type implicite: la valeur de l’expression

(terme de droite) est convertie dans le type du terme de gauche. Par exemple, le
programme suivant
Les opérateurs
L’affectation

imprime pour x la valeur 6.5 (et non 7), car dans l’instruction i = j + x;, l’expression j
+ x a été convertie en entier.
Les opérateurs
Opérateurs arithmétiques

Les opérateurs arithmétiques classiques sont l’opérateur unaire - (changement de

signe) ainsi que les opérateurs binaires :
+ addition
- soustraction
* multiplication
/ division
% reste de la division (modulo)
Ces opérateurs agissent de la façon attendue sur les entiers comme sur les
flottants. Leurs seules spécificités sont les suivantes:
- Si les deux opérandes sont de type entier, l’opérateur / produira une division
entière (quotient de la division). Par contre, il délivrera une valeur flottante dès
que l’un des opérandes est un flottant.
Les opérateurs
Opérateurs arithmétiques

x = 3 / 2; affecte à x la valeur 1. Par contre, x = 3 / 2.; affecte à x la valeur 1.5

- L’opérateur % ne s’applique qu’à des opérandes de type entier. Si l’un des deux
opérandes est négatif, le signe du reste dépend de l’implémentation, mais il est
en général le même que celui du dividende.
Les opérateurs
Opérateurs relationnels

> strictement supérieur

>= supérieur ou égal
< strictement inferieur
<= inferieur ou égal
== égal
!= différent
Leur syntaxe est : expression1 op expression2
Les deux expressions sont évaluées puis comparées. La valeur rendue est de type
int (il n’y a pas de type booléen en C); elle vaut 1 si la condition est vraie, et 0 sinon.

Attention à ne pas confondre l’opérateur de test d’égalité == avec l’opérateur

d’affection =.
Les opérateurs
Opérateurs logiques booleens, incrementation et decrementation

&& Et logique
|| Ou logique
! Négation logique
Comme pour les opérateurs de comparaison, la valeur retournée par ces
opérateurs est un int qui vaut 1 si la condition est vraie et 0 sinon.

Les opérateurs d’incrémentation ++ et de décrémentation -- s’utilisent aussi bien

en suffixe (i++) qu’en préfixe (++i). Dans les deux cas la variable i sera
incrémentée, toutefois dans la notation suffixe la valeur retournée sera l’ancienne
valeur de i alors que dans la notation préfixe, ce sera la nouvelle. Par exemple:
Les opérateurs
L’opérateur de conversion de types (ou cast)

Les conversions de types (ou casts) permettent de passer d’un type de base `a un
autre type de base. La conversion peut être :
- implicite : elle est alors effectuée directement par le compilateur. Par exemple, la
somme d’une variable de type float et d’une autre de type int sera
automatiquement de type float; pas besoin donc de le signaler au compilateur.
- explicite : en utilisant la syntaxe suivante : (unType) objet; où objet peut être un
nom de variable ou une expression à convertir dans le type unType.
Les fonctions d’entrées-sorties classiques
La fonction d’écriture printf

La fonction printf est une fonction d’impression formatée, ce qui signifie que les
données sont converties selon le format particulier choisi. Sa syntaxe est :

printf("chaîne de contrôle ", expression-1, ..., expression-n);

La chaîne de contrôle contient le texte à afficher et les spécifications de format

correspondant à chaque expression de la liste. Les spécifications de format ont
pour but d’annoncer le format des données à visualiser. Elles sont introduites par le
caractère %, suivi d’un caractère désignant le format d’impression.
Les fonctions d’entrées-sorties classiques
La fonction d’écriture printf
Les fonctions d’entrées-sorties classiques
La fonction de saisie scanf

La fonction scanf permet de saisir des données au clavier et de les stocker aux
adresses spécifiées par les arguments de la fonctions.

scanf(" format ", argument-1,...,argument-n);

On indique le format dans lequel les données lues sont converties. Elle ne contient
pas d’autres caractères (notamment pas de \n). Comme pour printf, les
conversions de format sont spécifiées par un caractère précédé du signe %. Les
formats valides pour la fonction scanf diffèrent légèrement de ceux de la fonction
printf.
Les fonctions d’entrées-sorties classiques
La fonction de saisie scanf
Impression et lecture de caractères

Les fonctions getchar et putchar permettent respectivement de lire et d’imprimer

des caractères. Il s’agit de fonctions d’entrées-sorties non formatées.
La fonction getchar retourne un int correspondant au caractère lu. Pour mettre le
caractère lu dans une variable char, on écrit :
caractere = getchar();

Lorsqu’elle détecte la fin de fichier, elle retourne l’entier EOF (End Of File), valeur
définie dans la librairie stdio.h. En général, la constante EOF vaut -1. La fonction
putchar écrit caractere sur la sortie standard:
putchar(caractere);
Elle retourne un int correspondant à l’entier lu ou à la constante EOF en cas
d’erreur.
Les instructions
Les branchements conditionnels : if---else

On appelle instruction de contrôle toute instruction qui permet de contrôler le

fonctionnement d’un programme. Parmi les instructions de contrôle, on distingue
les instructions de branchement et les boucles. Les instructions de branchement
permettent de déterminer quelles instructions seront exécutées et dans quel ordre.
Les instructions
Les branchements conditionnels : if---else

L’opérateur conditionnel ? est un opérateur ternaire. Sa syntaxe est la suivante :

condition ? expression1: expression2;
Cette expression est égale à expression1 si condition est satisfaite, et à expression2
sinon.
Par exemple:
x >= 0 ? x : -x ;
correspond à la valeur absolue d’un nombre. De même l’instruction
m = ((a > b) ? a : b);
affecte à m le maximum de a et de b.
Les instructions
Les branchements conditionnels : switch

Si la valeur de expression est égale à l’une des constantes, la liste d’instructions

correspondant est exécutée. Sinon la liste d’instructions ∞ correspondant à default
est exécutée. L’instruction default est facultative.
Les instructions
Les boucles : while

La syntaxe de while est la suivante :

while (expression) {
Instruction;
}
Tant que expression est vérifiée, instruction est exécutée. Si expression est nulle
au départ, instruction ne sera jamais exécutée. instruction peut évidemment être
une instruction composé. Par exemple, le programme suivant imprime les entiers
de 1 à 9.
i = 1;
while (i < 10) {
printf("\n i = %d", i);
i++;
}
Les instructions
Les boucles : do …. while

Il peut arriver que l’on ne veuille effectuer le test de continuation qu’après avoir
exécuté l’instruction. Dans ce cas, on utilise la boucle do---while. Sa syntaxe est :
do {
instruction;
} while(expresion);

Ici, instruction sera exécutée tant que expression est non nulle. Cela signifie donc
que instruction est toujours exécutée au moins une fois.

A faire : Ecrire un programme qui permet de saisir un nombre compris entre 1 et

10.
Les instructions
Les boucles : for

La syntaxe de for est :

for ( expr1; expr2; expr3){
instruction;
}
Par exemple, pour imprimer tous les entiers de 0 à 9, on écrit :

for (i = 0; i < 10; i++) {

printf("\n i = %d", i);
}
A la fin de cette boucle, i vaudra 10.

A faire : Ecrire un programme qui permet de calculer la factorielle d’un entier.

Les instructions
Branchement non conditionnel : break

On a vu le rôle de l’instruction break; au sein d’une instruction de branchement

multiple switch. L’instruction break peut, plus généralement, être employée à
l’intérieur de n’importe quelle boucle. Elle permet d’interrompre le déroulement de
la boucle, et passe à la première instruction qui suit la boucle. En cas de boucles
imbriquées, break fait sortir de la boucle la plus interne. Par exemple, le
programme suivant :
Les instructions
Branchement non conditionnel : continue

L’instruction continue permet de passer directement au tour de boucle suivant,

sans exécuter les autres instructions de la boucle. Ainsi le programme
Les conventions d’écriture d’un programme C

Il existe très peu de contraintes dans l’écriture d’un programme C. Toutefois ne

prendre aucune précaution aboutirait à des programmes illisibles. Aussi existe-t-il
un certain nombre de conventions.
- On n’écrit qu’une seule instruction par ligne : le point virgule d’une instruction
ou d’une déclaration est toujours le dernier caractère de la ligne.
- Les instructions sont disposées de telle façon que la structure modulaire du
programme soit mise en évidence. En particulier, une accolade ouvrante
marquant le début d’un bloc doit être seule sur sa ligne ou placée à la fin d’une
ligne. Une accolade fermante est toujours seule sur sa ligne.
- On laisse un blanc
- entre les mots-clés if, while, do, switch et la parenthèse ouvrante qui suit,
- après une virgule,
- de part et d’autre d’un opérateur binaire.
Les conventions d’écriture d’un programme C

- On ne met pas de blanc entre un opérateur unaire et son opérande, ni entre les
deux caractères d’un opérateur d’affectation composée.
- Les instructions doivent être indentées afin que toutes les instructions d’un
même bloc soient alignées.
Les structures de données
Les tableaux

Un tableau est un ensemble fini d’éléments de même type, stockés en mémoire à

des adresses contigües. La déclaration d’un tableau à une dimension se fait de la
façon suivante:
type nom-tableau[nombre-éléments];
Où nombre-éléments est une expression constante entière positive. Par exemple, la
déclaration int tab[10]; indique que tab est un tableau de 10 éléments de type int.
Cette déclaration alloue donc en mémoire pour l’objet tab un espace de 10×4
octets consécutifs. Pour plus de clarté, il est recommandé de donner un nom à la
constante nombre-éléments par une directive au préprocesseur, par exemple
#define nombre-éléments 10
On accède à un élément du tableau en lui appliquant l’opérateur [ ]. Les éléments
d’un tableau sont toujours numérotés de 0 à nombre-éléments -1.
Les structures de données
Les tableaux

Exemple : Initialisation et affichage des éléments d’un tableau

Les structures de données
Les tableaux

De manière similaire, on peut déclarer un tableau à plusieurs dimensions. Par

exemple, pour un tableau à deux dimensions:
type nom-tableau[nombre-lignes][nombre-colonnes];
En fait, un tableau à deux dimensions est un tableau unidimensionnel dont chaque
élément est lui-même un tableau. On accède à un élément du tableau par
l’expression “tableau[i][j]”. Pour initialiser un tableau à plusieurs dimensions à la
compilation, on utilise une liste dont chaque élément est une liste de constantes:
Les structures de données
Les structures

Une structure est une suite finie d’objets de types différents. Contrairement aux
tableaux, les différents éléments d’une structure n’occupent pas nécessairement
des zones contigües en mémoire. Chaque élément de la structure, appelé membre
ou champ, est désigné par un identificateur.
On distingue la déclaration d’un modèle de structure de celle d’un objet de type
structure correspondant à un modèle donné. La déclaration d’un modèle de
structure dont l’identificateur est modele suit la syntaxe suivante :

Pour déclarer un objet de type structure correspondant

au modèle précédent, on utilise la syntaxe:
struct modele objet;
Les structures de données
Les structures

ou bien, si le modèle n’a pas été déclaré au préalable :

On accède aux différents membres d’une structure grâce à l’opérateur membre de

structure, noté « . ». Le i-ème membre de objet est désigné par l’expression
objet.membre-i
On peut effectuer sur le i-ème membre de la structure toutes les opérations valides
sur des données de type type-i.
A faire : Un programme définissant la structure complexe, composée de deux
champs de type double; calculer la norme d’un nombre complexe
Les structures de données
Les énumérations

Les énumérations permettent de définir un type par la liste des valeurs qu’il peut
prendre. Un objet de type énumération est défini par le mot-clé enum et un
identificateur de modèle, suivis de la liste des valeurs que peut prendre cet objet :
enum modele {constante-1, constante-2,...,constante-n};
En réalité, les objets de type enum sont représentés comme des int. Les valeurs
possibles constante-1, constante-2, ..., constante-n sont codées par des entiers
de 0 à n-1. Par exemple, le type enum booleen défini dans le programme suivant
associe l’entier 0 à la valeur faux et l’entier 1 à la valeur vrai.

On peut modifier le codage par défaut des valeurs de

la liste lors de la déclaration du type énuméré, par
exemple: enum booleen {faux = 12, vrai = 23};
Les structures de données
Définition de types composés avec typedef

Pour alléger l’écriture des programmes, on peut affecter un nouvel identificateur à

un type composé à l’aide de typedef :
typedef type synonyme;
Par exemple :
Les pointeurs
Adresse et valeur d’un objet

Toute variable manipulée dans un programme est stockée quelque part en

mémoire centrale. Cette mémoire est constituée d’octets qui sont identifiés de
manière univoque par un numéro qu’on appelle adresse.
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 :

Deux variables différentes ont des adresses différentes. L’affectation j = i; n’opère

que sur les valeurs des variables.
Les pointeurs
Notion de pointeur

Un pointeur est un objet 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.

Même si la valeur d’un pointeur est toujours un entier (éventuellement 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.
Les pointeurs
Notion de 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é. 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 :

Les pointeurs
Notion de pointeur

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.
Par exemple, le programme
main() {
int i = 3;
int *p;
p = &i;
printf("*p = %d \n",*p);
}