PROGRAMMATION

EN
LANGAGE C
I. LES ETAPES DU PROCESSUS DE PROGRAMMATION

Le but de la programmation est de passer d'un problème à un programme qui décrit des calculs
(instructions) conduisant au résultat, à la solution du problème, en manipulant des informations et des
données. Il faut pour cela pouvoir:
fournir et mémoriser les informations
donner les instructions nécessaires à leur traitement
restituer les résultats.
II Les notions de base essentielles sont:
 les entrées: informations reçues du clavier ou d’un périphérique
les sorties: informations affichées à l’écran ou renvoyées à un périphérique
le type des données: entier, réel, caractère,...
Les opérations
L’exécution conditionnelle
Les boucles: exécution d’un ensemble d’instructions un certain nombre de fois tant qu’une condition
est vraie.
Les fonctions: ensemble d’instructions portant un nom et pouvant être exécuté en tout point du
programme par simple référence à ce nom.
Le processus de programmation comprend les étapes suivantes:
- spécifier le problème à résoudre
- trouver un algorithme comme résultat de la spécification
- prouver la vérité de l'algorithme
- coder l'algorithme en langage de programmation permettant de produire des programmes bien
lisibles et facilement corrigeables (C, Pascal, Fortran, Basic, …). Ce programme est ensuite traduit
en langage machine à l'aide du compilateur.
- tester le programme.
III STRUCTURE GENERALE D’UN
PROGRAMME C
Tout programme est toujours constitué de trois phases, à savoir:
- Lecture des données.
- Traitement des données (suite d'actions élémentaires).
- - Affichage des résultat

Remarque: On utilise un éditeur de texte pour créer un fichier source dont le nom doit
obligatoirement se terminer par un point et la lettre c ".c".
 IV Environnements de développement
De nombreux environnement sont disponibles sur le marché comme par exemple :

> Environnement de développement

Borland C++ Visual C++

> Environnement gratuits

DevC++ , Visual C++ Express , Code Blocks Studio

Le C est un langage compilé, contrairement au langage interprété ( PHP, Java, Perl,… )
 Nécessite une compilation ( c’est-à-dire une transformation) avant l’exécution sur la machine

Le passage d’un niveau de programmation vers le langage machine s’appelle l’étape de
COMPILATION d’un programme.

 Cette étape est bien sur fortement dépendante de la structure du calculateur sur lequel on doit
exécuter le programme (Chaque calculateur possède son propre assembleur et son propre
langage machine !!)

COMPILER un programme c’est simplement obtenir un code MACHINE directement exécutable

(compréhensible) par notre calculateur …

Un programme en langage C se compose en général d'une partie principale qui est exécutée en
premier lors du lancement ( <directives de compilation >et<déclaration de nom externes > ) et de
plusieurs sous-programmes appelées également fonctions. Dans le langage C, le programme
principal est aussi considéré comme une fonction, mais contrairement aux autres fonctions dont le
nom est librement définissable, le programme principal doit obligatoirement s'appeler main(). La
fonction principale se compose de l'en-tête "main()" suivi d'un "corps" qui contient des
instructions et qui est encadré par une paire d'accolades. La syntaxe est la suivante:
 Un programme C, à quoi ça ressemble ?

 Ci-dessous un petit programme exemple qui affiche Bonjour

Entête du programme en

/* Mon premier programme en C */ commentaire

Directive pré-processeur, ici module
#include <stdio.h> stdio.h pour l’affichage et math.h pour
#include <math.h>
les calculs )
Déclaration de sous-programmes

Programme principal débutant

main( )
{ par { et se terminant par }
printf( « Bonjour \n"); Le programme principal est
} constitué d’un suite
d’instruction

Chaque instruction se termine par un ;

Une partie facultative, mais très importante est constituée par les
commentaires, qui permettent d'expliquer les variables, les instructions à
exécuter et l'organisation du programme et facilite ainsi la maintenance
du programme. La syntaxe est la suivante:
Un programme C se présente donc sous la forme générale suivante: Seule la partie textes de fonctions est
obligatoire avec au minimum la fonction main() pour un programme complet.
Exemple: Imprimer un message
/********************MESSAGE.C ** ************/
#include <stdio.h>
main()
{
/* La séquence "\n" représente un caractère de contrôle, en l'occurrence un "saut de ligne" ou "interligne". */
printf("PROGRAMMEZ EN C \n"); /* Affichage d'un texte */
/* return(0);*/
}
 V- Directives de Compilation
Avant la compilation d'un programme écrit en C se déroule une phase de pré-compilation. Cette phase
est traitée par un programme appelé préprocesseur.
Les instructions traitées par le préprocesseur sont précédées de # écrit en première colonne. Nous allons
voir les deux instructions particulières #define et #include.
#DEFINE
#define permet de substituer, de remplacer n'importe quelle chaîne de caractères par une autre.
#define permet de définir des macros instructions qui peuvent parfois remplacer des
déclarations des fonctions. La visibilité de #define débute à partir de sa définition jusqu'à la fin du fichier
source, ou jusqu'à sa prochaine définition, ou bien jusqu'à son invalidation par la directive #undef.
Syntaxe
#define < ancienne_chaine> nouvelle_chaine
Remarquer qu'il n'y a pas de symbole d'affectation. En effet cette instruction ne sera pas traitée par le
compilateur C mais par le préprocesseur.
#define LONGUEUR 200
#define PI 3.14159
 VI Les variables en Langage C

 Pour utiliser une variable en C, il est OBLIGATOIRE de la déclarer

 Déclarer une variable revient à lui réserver un espace dans la mémoire du calculateur

 Mais c’est quoi une mémoire ?

Adresse Contenu

0 8 bits 0 1 0 1 0 1 1 0

1 8 bits 1 1 0 0 0 0 1 0

… 8 bits
N 8 bits
• Schématiquement, c’est un tableau comportant
des cases capables de stocker des bits
• Chaque ligne du tableau est repérée par un numéro
appelée l’adresse mémoire

 Quand une variable est déclarée, le calculateur réserve selon la taille de la variable, un
espace dans la mémoire. Cet espace est protégé et aucune autre variable ne pourra
accéder à cet espace.
 Les variables en Langage C

 En langage C , il existe des types prédéfinis lorsque l’on veut créer une variable

 Selon le type choisi :

- L’espace mémoire occupé est différent ( nombre d’octets réservé en mémoire )

- La variable est restreinte à un type d’information
- L’information contenue dans la variable est bornée ( limite inf et sup )

Les Types sont définis dans un fichier système <limits.h>, dont voici un aperçu
Type Format codage Limite inf Limite sup
int 4 octets –2147483648 2147483647
char 1 octets -128 +127
short 2 octets -32767 32768
unsigned int 4 octets 0 4294967295
unsigned char 1 octets 0 255
unsigned short 4 octets 0 65535
float 4 octets -3.40e38 3.40e38
double 8 octets -1.79e308 1.79e308
 La déclaration des variables

Déclarer une variable revient donc à:

 Donner un nom de variable
 Peut être constitué de lettre et de chiffre et du caractère _ ( ma_variable)
 Différentiation entre majuscule et minuscule (Toto et toto représentent 2 variables distinctes )
 Doit être différent des mots clefs du langage (int, main, long, float, etc …)
 Le plus explicite possible !!!!!
 Pas d’accent !
 Donner un type de variable
 Dépend de ce que l’on souhaite mettre dans la variable
 Type simple ou composé
Toute variable est codée au final
en binaire, seul langage connu
par un calculateur
Type de la variable nom_de_la_variable ;

 Exemple de déclaration

Sans initialisation Avec initialisation

int var1 ; /* un entier */ int var1 = 123;

float resultat, operande1 ; /* deux réels */ float resultat=12.1, operande1 =1e-5 ;
char var2 ; char var2 = 12 ;
 Manipulation des variables : Les opérateurs

 Les opérateurs d’affectation

 L’opérateur = réalise une affectation (droite à gauche). C’est l’équivalent de la notation

algorithmique  .

A3 se traduit A=3;

 en langage C, d’autre opérateur d’affectation sont disponibles comme par exemple le ( += )

int a=1, b=2, c=3;

a += b; /* ie a=a+b */
c *= a; /* ie c = c * a*/
b += b += a; /* ie b= b + ( b=b+a) */

 Les autres sont assez nombreux et découlent du principe énoncé :

( -= ) , ( *= ) , ( /= ) , ( %= ) , ( <<= ) , ( >>= ) , ( &= ) , ( |= ) , ( ^= )
 Manipulation des variables : Les opérateurs

 Les opérateurs arithmétiques

 Il y a 4 opérateurs arithmétiques (+, -, *, /)
int a=10, b=13, c=5, resultatEntier;
 Chaque opérateur travail sur un et un seul type de
float x=4.2, y=7.1, z=9.1,resultatDecimal;
données à la fois…
 il y a donc en fait un opérateur + qui additionne resultatEntier = a+b;
deux entier, resultatDecimal = x + y + z;
 un opérateur + qui additionne deux flottants
 etc…
int a=3;
float x=49.1, resultatDecimal;
 Que se passe-t-il si on additionne par exemple deux
variables de type différents ??
resultatDecimal = a + x;
 On obtient une conversion implicite de type

resultatDecimal = (float)a + revient à écrire conversion

implicite de a
x; en float

 Opérateur d’incrémentation int a=10, b=10;

 ++ ou –- j = a++; /* j=10 et a= 11 */
 post ou pré-incrémenté i= ++b; /* i=11 et a=11 */
 Manipulation des variables : Les opérateurs

 Les opérateurs relationnels

 Les opérateurs relationnels permettent de comparer des variables et donnent l’état du

test réalisé ( le test est-il VRAI ou FAUX ? ). Si le test est vrai, l’opérateur renvoie
un 1, s’il est faux, il renvoi 0.

 La première série d’opérateurs correspond à des opérateurs de comparaison:

supérieur ( > ), supérieur ou égal ( >= ), inférieur ( < ), inférieur ou égal ( <= )

 Deux autres opérateurs sont disponibles

 L’égalité ( == )
 L’inégalité ( != )

int a=3, b=4, resultat_test ;

resultat_test = ( a != b ); /* c’est vrai, renvoi 1 */

resultat_test = ( a == b ); /* c’est faux, renvoi 0 */

 Manipulation des variables : Les opérateurs

 Les opérateurs logiques

 Les opérateurs dit « logiques » sont des opérateurs permettant de réaliser des test
logiques entre des variables. L’opérateur logique répond uniquement 0 ( FAUX ) et 1
(VRAI)
 Il existe les opérateurs suivants :
 Le ET logique ( && )
Attention car pour un opérateur logique, toute
 le OU logique ( || )
variable = 0 est un FAUX et toute variable
 la négation ( ! ) différente de 0 est un VRAI (qq soit sa valeur )

 Exemples

int aPB=0, bPB=4, resultat ;

resultat = (aPB && 0) || (bPB && 1) ; /* c’est vrai, par défault = à 1 */

resultat = ( bPB || 0 ) && ( aPB || 1 ) ; /* c’est vrai, par défault = à 1 */

resultat = ! bPB /* c’est faux, car 4 est associé à l’état vrai */

 Nouveau types de variables : Les structures

 Les structures (ou enregistrement)

 Il s’agit d’un mécanisme de regroupement de types pour en construire un nouveau
 Permet de créer une infinité de nouvelles variables
 Supposons que l’on ait besoin d’écrire un programme qui devra manipuler des coordonnées dans
l’espace (x ,y, z). Pour le stockage de ces coordonnées, 2 solutions:
 Une pas très bonne :
Déclarer 3 variables permettant de stocker les coordonnées suivant chaque axe
 Une meilleure :
On créé une nouvelle variable (une structure) contenant 3 éléments. On déclare alors
une seule variable mais contenant plusieurs autres variables
 Aspect Syntaxe (mot clefs struct)

struct {
•La nouvelle variable rassemble trois variables de
double X;
type double permettant de stocker les coordonnées
double Y;
dans l’espace.
double Z;
} ensemblePoints; On donne un nom à cette nouvelle variable

Création d’une nouvelle variable constituée de plusieurs autres variables

 Nouveau types de variables : Les structures

 Exemple :
struct {
float X;
float Y; Déclaration de la variable Point1
float Z;
} Point1 ;

struct {
float X;
float Y; Déclaration de la variable Point2
float Z;
} Point2 ;

L’accès aux champs de la structure est réalisé par l’utilisation du point  variable . champ

main( )
{
Point1 . x = 1.2 ; Utilisation des variables dans un programme
…
Point2 . z = 0.45
}
 Nouveau types de variables : Les structures

 Il est également possible de créer un nouveau type réutilisable en utilisant le qualificatif

typedef
 Dans l’exemple précédent, les variables Point1 et Point2 sont uniques et il faut réécrire la
structure autant de fois que l’on veut de variable .
 Comment faire si je désire utiliser plusieurs variables construites sur ce modèle ?
 Créer un nouveau type

typedef struct { Le nouveau type rassemble trois variables de type double

double X; permettant de stocker les coordonnées dans l’espace.
double Y;
double Z;
} type_Point;
On donne un nom à ce nouveau type

 Ce nouveau type est maintenant utilisable comme tous les autres (int, float, ..) pour déclarer
des variables possédant le nouveau type créé :

type_ensemblePoints point1 , point 2 ;

Type Nom
de la variable de la variable
 Nouveau types de variables : Les structures

 On peut mélanger les types dans une structure.

 Exemple

- On souhaite maintenant rassembler dans une structure des données concernant des
personnes ( taille (cm), poids (kg), âge, … )
- On définit alors un nouveau type de variable que l’on nomme type_personne de la
façon suivante:

typedef struct {
int taille;
float poids; nouveau type de variable que l’on nomme typ_Personne
unsigned char age;
} typ_Personne;

 Pour accéder aux différents champs de la structure, on utilise toujours la syntaxe suivante :

typ_Personne personne1 ; personne1.taille=100 ;

personne1.age=28 ;
 Nouveau types de variables : Les structures

 Exemple de programme avec le type typ_Personne

définition
/* programme test Structure */
d’un nouveau
type
typedef struct {
int taille;
float poids;
unsigned char age;
} typ_Personne;

déclaration
main () identique à un
{ type
int var1; ‘’classique’’
typ_Personne Personne_1, Personne_2;
Affectation
Personne_1.taille = 185; de la taille de
Pesonne_2.poids = 70.3; la personne 1
…/…
}
Affectation
du poids de la
personne 2
 VII- Lecture et Ecriture
La fonction d'affichage printf():
La fonction printf de la librairie stdio.h permet un affichage formaté des données
- d'afficher des textes fixes: printf(<Texte>);
exemple: printf("Bonjour\n");
- mais aussi des paramètres variables:
printf(<Chaîne de commande>,<Variables ou constante>);
exemple:
printf("\nVos initiales sont %c.%c.\n", nom1, nom2);
printf(‘’Vous êtes ne(e) le %d/%d/%d\n", an, mois, jour);
printf("le résultat de la conversion est %2.1f mètres\n ", metre);
 Lecture et Ecriture
<Chaîne de commande>peut être un simple texte tout à fait ordinaire, mis entre guillemets. Si on
désire afficher un paramètre variable, la chaîne de commande doit comporter à l'emplacement
souhaité une spécification de format. Cette spécification précise le type du paramètre affiché et son
mode de représentation. Dans ce texte, le C remplace chaque occurrence % par le contenu de la
variable correspondante.
Spécifications des formats courants:
%d: entier décimal(int) %f: réel à virgule flottante (float)
%x ou %X: entier hexadécimal (int) %e ou %E: réel avec notation scientifique (float)
%o: entier octal (int) %lf ou%le: réel de type double
%u: entier non signé (unsigned int) %Lf ou % Le: réel de type long double
%ld: entier long (long int) %c: caractère (char)
%p: pointeur %s: chaîne de caractères
 Lecture et Ecriture
La fonction de saisie scanf ():
L'entrée des données fonctionne de façon analogue. Elle est prise en charge par un ordre appelé scanf()
de la librairie stdio.h. Elle permet la saisie formatée de données depuis le clavier.
Syntaxe:
scanf(< spécifications de format>, adresse1,adresse2,…);
scanf(< chaîne de commande >, &< param1 >, &< param2>,…);
param1 et param2 désignent ici exclusivement des variables. Elles sont précédées du symbole & pour
désigner l'adresse de la variable pour laquelle on souhaite lire une valeur. Les constantes sont interdites et
il faut autant de spécifications (%) que de paramètres. la fonction scanf lit des valeurs sur le clavier et les
range aux différentes adresses.
Exemple:
scanf(" %d/%d/%d", &an, &mois, &jour);
scanf("%d/%d", &centimetre, &decimetre);
Au moment de l'exécution du programme, il faudra taper tous les caractères autres que les spécifications,
et dans l'ordre exact où ils apparaissent dans la chaîne de commande. Autrement dit, dans notre exemple,
les deux nombres représentant le centimetre et decimetre doivent être séparés par une barre oblique.
Exercice
1-Ecrire un programme qui calcule la surface et le volume d'un sphère pour un rayon donné.
NB: SURFACE=4*PI*RAYON*RAYON
VOLUME=4/3*pi*RAYON*RAYON*RAYON
2-Ecrire un programme qui permute deux entiers saisis au clavier
3-Ecrire un programme qui demande un nombre à l’utilisateur, puis qui calcule et affiche le carré de ce
nombre.
4-Ecrire un algorithme qui lit trois entiers et qui calcule et affiche leur somme, leur produit et leur
moyenne.
 VIII INSTRUCTIONS DE CONTROLE
Le langage C exécute les instructions séquentiellement suivant l'ordre dans lequel elles figurent dans le
programme source, et cela à moins qu'une instruction dite structure de contrôle ne contraigne l'exécution
à se poursuivre à un endroit différent du programme. C dispose de plusieurs genres d'instructions de
contrôle
exemples :
while, for, do while sont des instructions pour contrôler les itérations.
if, if -else, switch sont des instructions pour contrôler les choix (contrôle fondé sur l'évaluation d'une
expression logique).
On peut les classer en deux groupes les structures alternatives et les structures itératives.
Les structures alternatives
Un ordre if ou son extension else peut déclencher l'exécution de tout un
bloc.
EXERCICE
Exercice 1 :
Écrire un algorithme qui prend en entrée la moyenne générale et déterminée en fonction de la moyenne
la mention :
• Si la moyenne est inférieure à 10, l'élève est recalé.
• Si la moyenne est supérieure ou égale à 10 et inférieur à 12, l'élève obtient une mention "Passable".
• Si la moyenne est supérieure ou égale à 12 et inférieur à 14, l'élève obtient une mention "Assez bien". •
Si la moyenne est supérieure ou égale à 14 et inférieur à 16, l'élève obtient une mention "Bien".
• Si la moyenne est supérieure ou égale à 16 et inférieur à 18, l'élève obtient une mention "Très bien".
• Si la moyenne est supérieure ou égale à 18, l'élève obtient une mention "Excellent".
Les instructions Switch et break
L'ordre if est très pratique pour distinguer deux cas: ou bien la est vérifiée,
ou bien elle ne l'est pas. Mais il est souvent nécessaire d'effectuer un test
plus différencié. L'instruction switch a été prévue à cet effet.
La syntaxe de l'ordre est la suivante:

L’ordre break provoque l'abandon du bloc sous switch

Exemple: OPERAT.C permet d'effectuer une des quatre opérations de base
sur deux nombres quelconques:
Les structures itératives
Le programme suivant indique comment utiliser l'instruction while
#include
main() {
int somme,i;
somme = 0; i = 1;
while(i<= 8) {
somme +=i;
++i;
}
}
On peut écrire ce programme avec une instruction for:
main() {
int somme , i , somme = 0;
for (i=l ; i<= 8 ; ++i) {
somme +=i;
}
printf(" la somme est = %d% \n", somme);
}
Une troisième structure de contrôle itérative (beaucoup moins employée
que while ou for) existe en langage C. Elle correspond à l'instruction :
répéter ... tant que et se note do ... while;
On peut écrire ce programme avec une instruction do
while:
main() {
int somme, i;
somme = 0 ;
i=l;
do {
somme +=i;
++i;
}
while (i <= 8);
printf(" la somme est = %d \n", somme);
}
Remarques On exécute toujours au moins une fois les instructions ...
bloc ... contrairement à l'instruction while. L'instruction do while ( ); se
termine par un point-virgule (ce qui est tout à fait normal puisque cela
indique la fin de l'instruction).
 IX LES TABLEAUX
Un tableau est une variable qui se compose d’un certain nombre de
données du même type rangées en mémoire les unes à la suite des
autres. Il est comparable à une liste de variables indicées. Il est possible
par ce moyen de stocker de grandes quantités de données dans
l'ordinateur tout en se réservant la faculté d'accéder individuellement à
chaque élément.
 Les tableaux
Imaginons que l’on souhaite calculer la moyenne de 6 notes. Il est dans ce cas nécessaire de
déclarer 6 variables et de calculer la moyenne comme suit: cases mémoires utilisées
(6 octets)

calcul de la moyenne de 6 notes

N1
DEBUT
type notes moyenne ← (N1+N2+N3+N4+N5+N6)/6 N2
entier N1 FIN
N3
entier N2
entier N3 N4
entier N4
entier N5 N5
entier N6 N6
entier moyenne

Il est possible de rassembler un ensemble de valeurs dans une seule entité repérée par nom et un indice.Un
ensemble de valeurs portant le même nom de variable est un tableau ou encore une variable indicée. Le
nombre servant à repérer les différents éléments s’appelle l’indice
cases mémoires utilisées
(6 octets)
calcul de la moyenne de 6 notes
Notes[0] : premier élément Notes[0]
type nom Notes[1]
entier Notes[6] Notes[2]
entier moyenne Notes[3]
Notes[4]
Notes[5] : dernier élément Notes[5]
Déclaration et utilisation d’un tableau
• Ensemble fini de données de même type, stockés dans des blocs de
mémoire contigus, désigné par un identificateur unique (le nom du
tableau), et qui se distinguent les unes des autres par leur numéro
d’indice.

• Les cases du tableau sont numérotées

– 0 est l’indice du premier élément
– n-1 est l’indice du dernier élément (si n est la taille du tableau)
Les tableaux: mise en garde!

Un tableau de taille N a des

indices allant de 0 à N-1 !!!
 De l’intérêt des tableaux

L’intérêt des tableaux réside dans le fait de pouvoir stocker un ensemble de données de même
nature sous un même nom.
Il n’y a donc qu’une seule déclaration à faire
Les données ont stockées les unes à la suite des autres
Accès plus rapide grâce à l’indexation.
Exemple: calculer la moyenne de 100 notes

Sans tableau
type nom Avec tableau
entier N1
entier N2 type nom
entier N3 entier Notes[100]
entier … entier moyenne
entier N99 entier k
entier N100
entier moyenne DEBUT
moyenne ← 0
DEBUT Pour k allant de 0 jusque 99
moyenne ← (N1+N2+N3+N4+N5+… moyenne ← moyenne +Notes[k]
…+N23+N24+N25+… fin Pour
…+N76+N77+… moyenne ← moyenne/100
…+N99+N100)/100 FIN
FIN
 Déclaration et utilisation d’un tableau
• Un tableau est caractérisé par 3 éléments:
– un nom
– une taille
– le type des éléments qu’il contient
• Déclaration d’une variable de type tableau:
nom_tableau: tableau [N] de type ou
– nom_tableau = identificateur du tableau
– N = taille du tableau (constante positive ou nulle)
– type = type des éléments du tableau
• Exemples:
– salaires : tableau[6] de réel
– nom_clients: tableau [20] de caractère
– notes : tableau[8] d’entier
Remarques:
 Le nombre d’éléments est précisé dans la définition et la taille d’un
tableau ne peut donc pas être modifiée au cours de l’exécution du
programme.
 Le premier élément d’un tableau a toujours l’indice 0.
Syntaxe:
name [0] pour le 1er élément,
name [i] pour le (i+1)ème élément.
L’indice i varie de 0 à n-1 pour un tableau de dimension n.
 Les tableaux (déclarations)

 La syntaxe de déclaration et d’utilisation des tableaux est la suivante :

Type_stocké nom_du pointeur [nombre d’élément du tableau] ;

 Exemples
 Déclaration d’un tableau de 23 int : int tab[23]

Adr Contenu tab contient l’adresse à laquelle le calculateur va

Le calculateur 1423 stocker le tableau soit tab=1423
réserve l’espace … Espace de *(tab+i) permet d’accéder à l’élément i du tableau.
nécessaire en
23*4 octets On peut aussi écrire tab[i]
mémoire

Le pointeur intègre la taille des

éléments de base
 Déclaration d’un tableau de 10 char : char tab[10] : tab+i décale de i éléments
Adr Contenu
1533
Le calculateur tab contient l’adresse à laquelle le calculateur va
réserve l’espace … Espace de stocker le tableau soit tab=1533
nécessaire en 10*1 octets
mémoire
*(tab+i) permet d’accéder à l’élément i du tableau.
On peut aussi écrire tab[i]
 Les tableaux (déclarations)

 Autres Exemples

double tab[100];  Tableau de 100 double

float memo[20];  Tableau de 20 float
float save[5] = {1, 345, 456, 59, -123}; /* avec initialisation */
typ_personne liste[20] ;  Tableau de 20 variables de type typ_person

 Déclaration de tableaux à plusieurs dimensions.

 Il est possible de déclarer en C des tableaux avec plusieurs dimensions. On obtient alors
l’image d’une matrice que l’on peut manipuler avec des indices ligne-colonne
Adr Contenu
tab[1][2]=99 ;
int tab[10][100] ; Adr
ad0 AdresseContenu
tableau 0
Accès ligne 1 colonne 2
ad1 Adresse tableau 1
ad0Adr AdresseContenu
tableau 0
Adr Contenu ad2 Adresse tableau 2
ad1
ad0AdrAdresse tableau
Adresse 1 0
tableau
Contenu
ad3 Adresse tableau 3
ad2
ad1e0 Adresse tableau
Adresse 2 1
tableau
 C’est en fait une subtilité d’écriture. ad0 Adresse tableau 0 Elément 0 tableau 3
L’organisation en mémoire consiste ad1 Adresse tableau 1 ad3
ad2e1 Adresse tableau
Adresse
Elémenttableau3 2
1 tableau 3
en fait à stocker des adresses de ad3e2 Adresse tableau 3 3
ad2 Adresse tableau 2 Elément 2 tableau
tableaux
ad3 Adresse tableau 3 e3 Elément 3 tableau 3

lignes colonnes
Exercices d’application