Les éléments de base en C

1) Introduction
==> Programmer c’est quoi ?
Programmer signifie réaliser des « programmes informatiques ». Les
programmes demandent à l’ordinateur d'effectuer des actions.
==> Votre ordinateur est rempli de programmes comme:
*La calculatrice est un programme
* votre traitement de texte (Word)est un programme
* votre logiciel de chat «WhatsApp» est un programme
* les jeux vidéo sont des programmes.

==> De quels logiciels a-t-on besoin pour programmer ?

Il existe plusieurs enivrements de développement (IDE). Parmi les
environnements de développement, on peut citer : DEV C++, Code :: Bloc

==>Un minimum de code

Pour n' importe quel programme, il faudra taper un minimum de code.
Ce code ne fera rien de particulier mais il est indispensable.

!!! pour ouvrir un nouveau projet (le fichier sur lequel on va écrire notre
premier programme ) taper Ctrl+N . après bien sur d'installation de
logiciel Dev C++ , puis écrire le programme que vous souhaitez si vous
avez un peu d'expérience, sinon taper le programme proposé ci-dessous ,
à la fin d'écriture le code vous pouvez tester votre programme est ce qu'il
ça marche bien ou non en cliquant sur le boutton d’exécution qui se trouve
dans la figure suivante:
C'est ce « code minimum » que nous allons découvrir maintenant. Il
devrait servir de base pour la plupart de vos programmes en langage C.

* int main() Ou bien

int main ( int argc , char * argv[] )
Les deux écritures sont possibles, mais la seconde (plus compliquée)
est la plus courante. En ce qui nous concerne, que l'on utilise l'une ou
l'autre des écritures, ça ne changera rien pour nous. surtout que nous
n'avons pas encore le niveau pour analyser ce que ça signifie.

* #include <stdio.h>
 #include <stdlib.h>
Ce sont des lignes spéciales que l'on ne voit qu'en haut des fichiers
source. Ces lignes sont facilement reconnaissables car elles
commencent par un dièse #. Ces lignes spéciales, on les appelle
directives de préprocesseur (un nom compliqué, n'est-ce pas ?).
Ce sont des lignes qui seront lues par un programme appelé
préprocesseur, un programme qui se lance au début de la compilation.
Le mot include en anglais signifie « inclure » en français. Ces lignes
demandent d'inclure des fichiers au projet, c'est-à-dire d'ajouter des
fichiers pour la compilation. Il y a deux lignes, donc deux fichiers inclus.
Ces fichiers s'appellent stdio.h et stdlib.h. Ces fichiers existent déjà,
des fichiers source tout prêts. On verra plus tard qu'on les appelle des
bibliothèques. En gros, ces fichiers contiennent du code tout prêt
qui permet d'afficher du texte à l'écran.

* int main() { .............. }

Cette fonction s'appelle la fonction main. C'est un nom de fonction
particulier qui signifie « principal ». main est la fonction principale de votre
programme, c'est toujours par la fonction main que le programme
commence. Une fonction a un début et une fin, délimités par des
accolades{ et }. Toute la fonction main se trouve donc entre ces
accolades.

* printf("Hello world!\n") ;
return 0 ;
Ces lignes à l'intérieur d'une fonction s’appellent instructions, Chaque
instruction est une commande à l'ordinateur. Chacune de
ces lignes demande à l'ordinateur de faire quelque chose. Par exemple la
première demande par l’ordinateur d’afficher le message Hello world! à
l'écran, puis passer à l'instruction suivante return 0 ; . Cette ligne indique
qu'on arrive à la fin de notre fonction main et demande de renvoyer la
valeur 0.

Pourquoi mon programme retourne le nombre 0 ?

En fait, chaque programme une fois terminé renvoie une valeur, par
exemple pour dire que tout s'est bien passé. En pratique, 0 signifie «
tout s'est bien passé » et n'importe quelle autre valeur signifie « erreur ».
La plupart du temps, cette valeur n'est pas vraiment utilisée, mais il faut
quand même en renvoyer une. Votre programme aurait marché sans le
return 0, mais on va dire que c'est plus propre et plus sérieux de le
mettre, donc on le met.

!! Très important: toute instruction se termine obligatoirement par un

point-virgule « ; ». Si vous oubliez de mettre un point -virgule à la fin
d'une instruction, votre programme ne compilera pas !.

* Écrire un message à l'écran

À partir de maintenant, on va modifier nous -mêmes le code de ce
programme minimal. Qui permet d’afficher le message « Bonjour » à
l'écran. "Essayez"

* Les caractères spéciaux

Les caractères spéciaux sont des lettres spéciales qui permettent
d'indiquer qu'on veut aller à la ligne, faire une tabulation, etc. Ils sont
faciles à reconnaître : c'est un ensemble de deux caractères. Le premier
d' entre eux est toujours un anti-slash ( \ ), et le second un nombre ou
une lettre. Voici deux caractères spéciaux courants que vous aurez
probablement besoin d'utiliser, ainsi que leur signification:

\n : retour à la ligne « Entrée » ;

\t : tabulation.
Dans notre cas, pour faire une entrée, il suffit de taper \n pour créer un
retour à la ligne. Si je veux donc faire une tabulation, je devrais taper \t.
* Les commentaires
Lorsqu'un programme devient long, il est conseillé d’ajouter des lignes de
commentaires dans le programme, c’est-à-dire des lignes qui ont pour but
de donner des indications sur les instructions effectuées et d’expliquer le
fonctionnement de programme sans que le compilateur ne les prenne en
compte.
On va voir deux types de commentaires :

Commentaire sur une ligne :

// un commentaire

Commentaire sur plusieurs lignes :

Remarque : Parfois on utilise les commentaires pour annuler l’action de

quelques instructions dans un programme au lieu de les effacer comme
dans cet exemple :

Le programme ignore l’instruction qui se trouve entre le commentaire et

affiche seulement Bonjour .

2) Les variables et les constantes

2-1) Notion de variable
Les données ainsi que les résultats des calculs intermédiaires ou finaux,
sont rangés dans des cases mémoires qui correspondent à des variables,
Ainsi, une variable est rangée dans un emplacement mémoire nommé, de
taille fixe (ou non) prenant au cours du déroulement de programme un
nombre indéfini de valeurs différentes.

2-2) déclaration des variables

La partie déclaration consiste à énumérer toutes les variables dont on aura
besoin au cours de programme. Chaque déclaration doit comporter le nom
de variable (identificateur) et son type.
Syntaxe : type identificateur ;

Identificateur : Un identificateur est le nom donné à une variable. Ce

nome doit obligatoirement commencer par une lettre suivie d’une suite de
lettres et les chiffres et il ne doit pas contenir d’espace.
Types de données :
Le type de variable est l’ensemble des valeurs qu’elle peut prendre.
int : sert à manipuler les nombres entiers positifs ou négatifs.
Par exemple : 5 , 20 , -4
float : sert à manipuler les nombres à virgule. Par exemple : 5.0 , 2.1, -
1.278
char : sert à manipuler des caractères, Par exemple : 'A' , '6'

Exemple :
int N ;
float e , r ;
char letter ;
Les opérations sur des variables :

2-3) Les constantes

Comme une variable, il existe une constante correspond un emplacement
mémoire réservé auquel on accède par le nom qui lui a été attribué, mais
dont la valeur stockée ne sera jamais modifiée au cours du programme.

Syntaxe :
const Nom_Constante = valeur ;
Exemple : const float pi = 3.14 ;

3) Les instructions de base

Une instruction est une action élémentaire commandant à la machine un
calcul, ou une communication avec l’un de ses périphériques d’entrées ou
de sorties. Les instructions de base sont :

3-1) L’instruction d’affectation :

L’affectation permet d’affecter une valeur à une variable. Elle est
symbolisée par =
Syntaxe : Variable = Expression ;
Exemple :
int N = 6 ;
float e = 2.56 ;
char letter = 'A' ;

3-2) L’instruction d’entrée :

L’instruction d’entrée ou de lecture donne la main à l’utilisateur pour saisir
une donnée au clavier. La valeur saisie sera affectée à une variable. Cette
instruction est effectuée via la fonction scanf . Vous devez mettre un
format pour indiquer ce que l'utilisateur doit entrer (un int, un float, ...).
Puis vous devez ensuite indiquer le nom de la variable précédé par
le symbole & (signifie l’adresse de cette variable) qui va recevoir le
nombre.
Exemple : scanf("%d", &age ) ;

!! On doit mettre le %d entre guillemets.

Par ailleurs, il faut mettre le symbole & devant le nom de la variable qui
va recevoir la valeur.

4-3) L’instruction de sortie :

Avant de lire une variable, il est conseillé d’écrire un message à l’écran, afin
de prévenir l’utilisateur de ce qu’il doit taper.
L’instruction de sortie (d’écriture) permet d’afficher des informations à
l’écran.

Syntaxe:
printf ("message à l'écran");

Exemple:
printf (" Entrer votre email : ") ;
Remarque
Pour afficher la valeur d’une variable à l’écran on ajoute un symbole
spécial à l’endroit où l’on veut afficher la valeur de cette variable. .
int (%d ) float (%f ) char ( % c)

Exemple :
printf (" Votre âge est %d ans ", age) ;

*** Chapitre 2 : Les structures alternatives et répétitives

***

1) Les structures alternatives

1-1) Introduction :
Contrairement au traitement séquentiel, la structure alternative ou
conditionnelle permet d’exécuter ou non une série d’instructions selon la
valeur d’une condition.
1-2) La structure if {} ou if {} else {}
Syntaxe :
Une condition est une expression logique ou une variable logique évaluée
à Vrai ou faux. La condition est évaluée. Si elle est vraie, la série
d’instruction(s)1 est exécutée et l’ensemble d’instruction(s) 2 est ignoré, la
machine sautera directement à la première instruction située après cette
structure.
De même, au cas où la condition était fausse la machine saute
directement à la première ligne située après le else et exécute l’ensemble
d’instruction2.

Exercice d’application 1
Ecrire un programme qui affiche si un nombre entier saisi au clavier est
pair ou impair.
Remarque : il existe aussi un autre type de condition c’est la condition
composées.
Certains problèmes exigent de formuler des conditions qui ne peuvent être
exprimées sous la forme simple, par exemple la condition de note de
devoir doit être inclus dans l’intervalle [0, 20], cette condition est
composée de deux conditions simples qui sont note ≥0 et note ≤ 20

Exercice d’application 2
Ecrire un programme qui permet de faire une remarque d’une note saisi
au clavier ( si la note supérieur à 10 alors on affiche validé sinon non
validé (NB : la note comprise entre 0 et 20 ! ).
Exercice 1:
Ecrire un programme qui demande deux nombres m et n à l’utilisateur et
l’informe ensuite si le produit de ces deux nombres est positif ou négatif.
On inclut dans le programme le cas où le produit peut être nul.
Exercice 2:
Une boutique propose à ces clients, une réduction de 15% pour les
montants d’achat supérieurs à 200 dh. Ecrire un programme permettant de
saisir le prix total HT et de calculer le montant TTC en prenant en compte la
réduction et la TVA=20%.
1-3) Structure à choix multiples (Switch)
La condition if... else que l'on vient de voir est le type de condition le plus
souvent utilisé. Toutefois, le if... else peut s'avérer quelque peu… répétitif :
Prenons cet exemple :
 Pour résoudre ce problème de la répétition de if else if else ….
plusieurs fois. On utilise une nouvelle structure à choix
multiples. Cette structure conditionnelle permet de choisir
le traitement à effectuer en fonction de la valeur ou de l’intervalle de
valeurs d’une variable ou d’une expression.

Syntaxe :
Lorsque l’ordinateur rencontre cette instruction, il vérifie la valeur de la
variable, et il la compare aux différentes valeurs.
Les valeurs sont évaluées dans l’ordre, les unes après les autres, et une
fois la valeur de variable est vérifiée l’action associée est exécutée. On
peut utiliser une instruction default (facultative), dont l’action sera exécutée
si aucune des valeurs évaluées n’a pas été remplie.

Exercice d’application :
Ecrire un programme permettant d’afficher le mois en lettre selon
le numéro saisi au clavier (janvier=1 , février =2 …….. décembre = 12).
Remarque : Vous devez mettre une instruction break ; à la fin de chaque
cas. Pour ignorer les instructions en dessous !
L'instruction break ; commande en fait à l'ordinateur de « sortir »
des accolades. Et instruction defaulf ; sera exécutée si aucune des
valeurs évaluées n’a pas été remplie.

2) Les Structures répétitives

2-1) Introduction
Prenons d’une saisie au clavier, par exemple, on pose une question à
laquelle doit répondre par « oui » ou « non ».
L’utilisateur risque de taper autre chose (une autre lettre), le programme
peut soit planter par une erreur d’exécution soit dérouler normalement
jusqu'au bout, mais en produisant des résultats fantaisistes.
Pour éviter ce problème, on peut mettre en place un contrôle de saisie pour
vérifier que les données entrées au clavier correspondent bien à celles
attendues par le programme.

!!! Le programme ci-dessus résout le problème si on se trompe

qu’une seule fois, et on fait entrer une valeur correcte à la deuxième
demande. Sinon en cas de deuxième erreur, il faudrait rajouter un « if ».
Et ainsi de suite, on peut rajouter des centaines de « if »
* La solution à ce problème consiste à utiliser une structure répétitive.
Une structure répétitive, encore appelée boucle, est utilisée quand une
instruction ou une liste d’instruction, doit être répétée plusieurs fois. La
répétition est soumise à une condition.

2-2) La boucle while

La boucle while permet de répéter un traitement tant que la condition est
vraie.

Syntaxe :

==> L’exécution de la boule dépend de la valeur de la condition. Si est vrai,

le programme exécute les instructions qui suivent, jusqu’à ce
qu’il rencontre la accolade }. Il retourne ensuite sur la ligne du while,
procède au même examen, et ainsi de suite.
==> La boucle ne s’arrête que lorsque prend la valeur fausse, et dans ce
cas le programme poursuit son exécution après la boucle « sortir des
accolades ».

Exemple:
Remarque : Si la structure while contient la condition ne devient jamais
fausse. Le programme tourne dans une boucle infinie et n’en sort plus.

Exemple :

Dans cet exemple nous avons une boucle infinie. L’ordinateur ne s’arrêtera
jamais d’afficher le message Bonsoir car la variable i qui est testée dans la
condition n’est jamais incrémenter. Alors pour résoudre le problème de
boucle infinie dans ce cas-là, on incrémente la variable i à chaque tour de
boucle pour afficher Bonsoir 10 fois exactement.

Exercice 1
Ecrire un programme qui calcule la somme S = 1+2+3+4+……..+ 10.
Utilisant la boucle while.

Exercice 2
Ecrire un programme qui calcule la somme S= 1+2+3+4+……..+ N, où N
saisi par l’utilisateur.

2-3) La boucle for

La boucle for permet de répéter une liste d’instructions un nombre connu

de fois.
Syntaxe :

Exemple:
Cet exemple permet d’afficher le message bonjour 10 fois, et tant que la
condition est vraie la boucle répète l’exécution des instructions qui se
trouvent entre les accolades.
==> La partie d’initialisation est de type entier. Elle est initialisée par la
valeur initiale, la partie instruction(s) augmente cette valeur par 1
automatiquement à chaque tour de boucle jusqu'à la valeur finale.
==> Lorsque la valeur compteur vaut la valeur finale, le traitement est
exécuté une seule fois puis le programme sort de la boucle.

Exemple:

Exercice 1
Ecrire un programme qui calcule S=1+2+3+….+ 10. Utilisant la boucle for.
Exercice 2
Ecrire un programme qui calcule S=1+2+3+…+ N. Utilisant la boucle for.

Exercice 3
Ecrire un programme qui affiche la table de multiplication de 5. Utilisant la
boucle for.

Exercice 4
Ecrire un programme qui affiche la table de multiplication d’un entier saisie
par l’utilisateur, Utilisant la boucle for.
2-4) La boucle do ….While
Cette boucle permet de répéter les instructions qui se trouvent entre les
accolades tant que la condition est vraie.
Remarque : Cette boucle ne s’utilise en général que pour des menus, elle
est dangereuse car il n’y a pas de vérification de la condition avant d’y
entrer.
Ce type de boucle est très similaire à while, bien qu’un peu moins utilisé
en général.
La seule chose qui change en fait par rapport à while, c'est la position de
la condition. Au li eu d'être au début de la boucle, la condition est à la fin:

Syntaxe :
la boucle while pourrait très bien ne jamais être exécutée si la condition
est fausse dès le départ. Par exemple, si la condition est fausse dès le
début et on ne serait jamais rentré dans la boucle. et Pour la
boucle do… while, c'est différent: cette boucle s'exécutera toujours au
moins une fois même si la condition est fausse.
Il est donc parfois utile de faire des boucles de ce type, pour s'assurer
que l'on rentre au moins une fois dans la boucle.

!!! N'oubliez pas de mettre un point-virgule après le while, si non votre

programme plantera à la compilation !

Exemple:
En utilisant la boucle do…..while, on écrit un programme qui
affiche Bonjour 10 fois.
Exercice 1
Ecrire un programme qui calcule la somme S= 1+2+3+…+ 10. Utilisant la
boucle do…..while.

Exercice 2
Ecrire un programme qui affiche la table de multiplication de 5. Utilisant la
boucle do …. While.
 Chapitre 3: Les Tableaux
1) Introduction
Imaginons que dans un algorithme, nous avons besoin d’un grand nombre
de variables, il devient difficile de donner un nom pour chaque variable.
Exemple :
Ecrire un programme permettant de saisir cinq notes et de les afficher
après avoir multiplié toutes les notes par trois.
==> La même instruction répète cinq fois. Imaginons que si l’on voudrait
réaliser ce programme avec 100 notes, cela devient très difficile.
==> Pour résoudre ce problème, il existe un type de données qui permet de
définir plusieurs variables de même type.

2) Définition
Un tableau est une suite d’éléments de même type. Il utilise plusieurs
cases mémoire à l’aide d’un seul nom. Comme toutes les cases portent le
même nom, elles se différencient par un numéro ou un indice.
Nous pouvons représenter schématiquement un tableau nommé Note
composé de cinq cases, dans la mémoire comme suit :
3) Tableau à une dimension
3-1) Déclaration
La déclaration d’un tableau permet d’associer à un nom d’une zone
mémoire composée d’un certain nombre de cases mémoires de même
type.
Syntaxe : type nom_tableau[taille_max] ;
Exemple : float Notes[40] ;

Remarques :
==> Le premier élément d’un tableau porte l’indice 0 .
==> La valeur d’un indice doit être un nombre entier
==> La valeur d’un indice doit être inférieure ou égale au nombre
d’éléments du tableau. Par exemple, avec le tableau tab[20], il est
impossible d’écrire tab[21] ou tab[26], ces expressions font référence à des
éléments qui n’existe pas.
==> L’utilisation de ces éléments se fait en suite, via le nom du tableau et
son indice. Ce dernier peut être soit une valeur (tab[3] ) , soit une variable
( tab [i] ) ou encore une expression ( tab[i+1] ).

==> Pour Faire un parcours complet sur un tableau, on utilise une boucle.

Exercice 1
Ecrire un programme permettant de saisir 20 notes et de les stocker dans
un tableau nommé Etudiant, puis les afficher.
Exercice 2 : Ecrire un programme permettant de saisir 20 notes et de les
afficher
après avoir multiplié toutes ces notes par un coefficient fourni par
l’utilisateur.
Exercice 3
Ecrire un programme permettant de saisir 12 notes et qui affiche la
moyenne de ces notes.
Exercice 4
Ecrire un programme permettant de saisir 12 notes et qui affiche le
maximum de ces notes.
Exercice 5
Ecrire un programme qui demande à l’utilisateur de taper 10 entiers qui
seront stockés dans un tableau. Le programme doit trier le tableau par
ordre croissant et doit afficher le tableau.
Exercice 6
4) Tableau à deux dimensions
Reprenons l’exemple des notes en considérant cette fois qu’un
étudiant a plusieurs notes (une note pour chaque matière). On
peut simplifier des choses comme suite.

==> Les tableaux à deux dimensions se représentent comme une

matrice ayant un certain nombre de lignes (première dimension)
et un certain nombre de colonne (seconde dimension).
4-1) Déclaration
Type Nom_Tableau [nb_lignes][ nb_colonnes] ;
Exemple : float Tableau[3][4] ;

Remarques:
==> L’utilisation d’une matrice se fait via son nom et ses indices.
Ces derniers peuvent être soient des valeurs (tab[1][3] ) , soient
des variables ( tab [i][j] ) ou encore des expressions ( tab[i+1]
[j] ).
==> Pour Faire un parcours complet sur une matrice, on utilise
deux boucles, l’une au sein de l’autre, c’est ce qu’on appelle les
boucles imbriquées. La première boucle pour parcourir les lignes
tandis que la deuxième est utilisée pour parcourir les éléments
de la ligne précisée par la boucle principale (la première boucle).
Exemple :
Ecrire un programme permettant de saisir les notes d’une
classe de 30 étudiants en 5 matières.
 chapitre 4 : Les Pointeurs
1) Introduction
La plupart des langages de programmation offrent la possibilité
d'accéder aux données dans la mémoire de l'ordinateur à l'aide
de pointeurs, c’est-à-dire. à l'aide de variables auxquelles on peut
attribuer les adresses d'autres variables.

En C, les pointeurs jouent un rôle principal dans la définition de

fonctions: Comme le passage des paramètres en C se fait
toujours par la valeur, les pointeurs sont le seul moyen de
changer le contenu de variables déclarées dans d'autres
fonctions. Ainsi le traitement de tableaux et de chaînes de
caractères dans des fonctions serait impossible sans l'utilisation
de pointeurs.
En outre, les pointeurs nous permettent d'écrire des programmes
plus compacts et plus efficace et fournissent souvent la seule
solution raisonnable à un problème. Ainsi, la majorité
des applications écrites en C profitent extensivement des
pointeurs.

2) Adressage de variables
Avant de parler de pointeurs, il est indiqué brièvement les deux
modes d'adressage principaux, qui vont d'ailleurs nous
accompagner tout au long des chapitres suivants.

2-1) Adressage direct

Dans la programmation, nous utilisons des variables pour stocker
des informations. La valeur d'une variable se trouve à un endroit
spécifique dans la mémoire interne de l'ordinateur. Le nom de la
variable nous permet alors d'accéder directement à cette valeur.

Exemple: Int A=12 ;

2-2) Adressage indirect
Si nous ne voulons ou ne pouvons pas utiliser le nom d'une
variable A, nous pouvons copier l'adresse de cette variable dans
une variable spéciale P, appelée pointeur. Ensuite, nous pouvons
retrouver l'information de la variable A en passant par le pointeur
P. ce dernier contient l'adresse de variable A.

Exemple :
Soit A une variable contenant la valeur 10 et P un pointeur qui
contient l'adresse de A. En mémoire, A et P peuvent se présenter
comme suit:
3) Les pointeurs
Un pointeur est une variable spéciale qui peut contenir
l'adresse d'une autre variable En C, chaque pointeur est limité à
un type de données. Il peut contenir l'adresse d'une variable
simple de ce type ou l'adresse d'une composante d'un tableau de
ce type.
si un pointeur P contient l'adresse d'une variable A, on dit que P
pointe sur A.

Remarque :
Les pointeurs et les noms de variables ont le même rôle: Ils
donnent accès à un emplacement dans la mémoire interne de
l'ordinateur. Il faut quand même bien faire la différence:
*Un pointeur est une variable qui peut "pointer" sur différentes
adresses
*Le nom d'une variable reste toujours lié à la même adresse

2-1) Les opérateurs de base

Lors du travail avec des pointeurs, nous avons besion
==> d'un opérateur "adresse de " : & pour obtenir l'adresse d'une
variable.
==> d'un opérateur " contenu de " : * pour accéder au contenu
d'une adresse.
==> d'un syntaxe de déclaration : pour déclarer un pointeur.

L'opérateur "adresse de" : & NomVariable permet de

fournir l'adresse de la variable NomVariable

Exemple :

p = &A ; cette instruction permet d’affecter l’adresse de

variable A à la variable p.

&A : signifie l’adresse de variable A (E0H5), et aussi le contenu

de variable p.

printf(" l’adresse de A est %d ", p) ; ou

printf("l’adresse de A est %d ", &A) ;

Le message qui va afficher sur l’écran est ceci : l’adresse de A

est E0H5 .

L'opérateur "contenu de": * <NomVariable> désigne le

contenu de l'adresse référencée par le pointeur <NomPointeur>.
Exemple :

*p : signifie le contenu de l'adresse référencée par le pointeur,

dans ce cas-là c’est la valeur de variable A (10).

printf("le contenu de A est %d ", A) ; ou printf("le

contenu de A est %d ", *p) ;

Le message qui va afficher sur l’écran est ceci : le contenu de A

est : 10.

Déclaration d'un pointeur :

Type * NomPointeur ;

Cette instruction permet de déclarer un pointeur <NomPointeur>

qui peut recevoir des adresses de variables du type <Type>.

Exemples : int * P ; float * P ;

Exemple d’application
4) Pointeurs et tableaux
4-1) introduction
En C, il existe une relation très étroite entre tableaux et pointeurs. Ainsi,
chaque opération avec des indices de tableaux peut aussi être exprimée à
l'aide de pointeurs. En général, les versions formulées avec des pointeurs
sont plus compactes et plus efficientes, surtout à l'intérieur de fonctions.
Mais, du moins pour des débutants, le 'formalisme pointeur' est un peu
inhabituel .

4-2) Adressage des éléments d'un tableau

On définit le nom d'un tableau comme l'adresse de son premier élément.
En d’autres termes: &tableau[0] et tableau sont une seule et même
adresse.
En simplifiant, nous pouvons retenir que le nom d'un tableau est
un pointeur constant sur le premier élément du tableau.
Exemple :

Pour obtenir l’adresse du premier élément du tableau:

==> L’expression tableau signifie l’adresse du premier élément du
tableau, alors elle contient 8767
==> L’expression &tableau [0] signifie l’adresse du premier élément du
tableau, c’est-à-dire 8767

Pour obtenir l’adresse du deuxième élément du tableau on

incrémente par 1
==> L’expression tableau +1 signifie l’adresse du deuxième élément du
tableau, c’est-à-dire 8768
==> L’expression &tableau [1] signifie l’adresse du premier élément du
tableau, c’est-à-dire 8768
Pour obtenir l’adresse du i ème élément du tableau
==> L’expression tableau + i signifie l’adresse du deuxième élément du
tableau, c’est-à-dire 8767 + i
==> L’expression &tableau [i] signifie l’adresse du premier élément du
tableau, c’est-à-dire 8767 + i

Pour obtenir la valeur du premier élément du tableau

==> L’expression * tableau signifie la valeur du premier élément du

tableau, alors elle contient 5

==> L’expression &tableau [0] signifie la valeur du premier élément du

tableau, c’est-à-dire 5

Pour obtenir la valeur du deuxième élément du tableau, on

incrémente par 1
==> L’expression *(tableau +1) signifie l’adresse du deuxième élément du
tableau, c’est-à-dire 2
==> L’expression tableau [1] signifie l’adresse du premier élément du
tableau, c’est-à-dire 2

En résume :
Le nom d'un tableau est un pointeur constant sur le premier élément du
tableau.
Les deux expressions &tableau[0] et tableau sont équivalents.

Exercice d’application
Ecrire un programme permettant de saisir 5 entiers et de les stocker dans
un tableau nommé tableau, puis les afficher. (NB. utiliser la notion de
pointeur !!!!)
Exercice 1
Soit P un pointeur qui 'pointe' sur un tableau A:
int A[] = {12, 23, 34, 45, 56, 67, 78, 89, 90};
int *P; P = A;
Quelles valeurs ou adresses fournissent ces expressions:

a) *P+2
b) *(P+2)
c) &P+1
d) &A[4]-3
e) A+3
f) 1+(*P-10)
g) *(P + *(P+8)-A[7])

solution
a) 14
b) 34
c) l’adresse du 2éme élement du tableau
d) l’adresse du 2éme élement du tableau
e) l’adresse du 4éme élement du tableau
f) 3
g) 23

Exercice 2
Ecrire un programme qui range les éléments d'un tableau A du
type int dans l'ordre inverse. Le programme utilisera des pointeurs P1 et P2
et une variable numérique AIDE pour la permutation des éléments.