Programmation impérative en C - LIPN - Université Paris 13

Université Paris 13
Institut Galilée
Licence 1ère année
2005-2006















Programmation Impérative
Polycopié de cours n° 2















C. Recanati

Table des matières

5 Fonctions 3

5.1 Exemple 4
5.1.1 Déclaration et définition de fonctions 4
5.1.2 Appel de fonction et passage des paramètres par valeur 7
5.2 Passage de paramètres 10
5.2.1 Passage par valeur 10
5.2.2 Passage de pointeurs : altération possible des valeurs 11
5.2.3 Passage par référence : le cas des tableaux 11
5.3 Variables locales et variables globales 13

6 Tableaux 15

6.1 Tableaux à 1 dimension 15
6.1.1 Déclaration 15
6.1.2 Initialisation 16
6.1.3 Les tableaux de caractères 17
6.1.4 Exemples de fonctions manipulant des tableaux de caractères 20
6.2 Tableaux multi-dimensionnels 23
6.2.1 Tableaux à deux dimensions 23
6.2.2 Tableaux à plus de deux dimensions 26
6.3 Fonctions et tableaux 27

7 Structures et unions 29

7.1 Structures 29
7.2 Opérations sur les structures 30
7.3 Fonctions à paramètre de type structure 31
7.4 Unions 31



Les types que nous avons utilisés jusqu'à présent sont des types de base
simples. Or, il arrive souvent en programmation que l'on ait à traiter des
données nombreuses, mais formant des groupes relativement homogènes.
Mémoriser ces données dans des variables ayant des noms différents, rend le
traitement difficile, voire impossible. Par exemple, s'il s'agit de lire
une suite de 1000 réels pour les afficher en ordre inverse, déclarer 1000
variables de type float dans le programme n'est guère faisable, et nous
avons vu qu'il existait dans ce cas la possibilité d'utiliser le type
tableau. Dans d'autres cas, on ne connaîtra pas par avance le nombre de
données à lire, et l'on ne pourra pas se contenter de tableaux. Pour
résoudre ce type de question, les langages impératifs offrent diverses
possibilités de définition de types structurés de données. Un type
structuré est un assemblage de types simples, définis par le programmeur ou
prédéfinis par le langage.

Dans les sections qui suivent, nous présentons les types structurés du
langage C : fonctions, tableaux, structures, unions et pointeurs. Ces types
ont en commun de permettre l'accès à des ensembles de plusieurs valeurs.

Sous cet aspect, une fonction est en effet une variable permettant de
lancer le calcul de valeurs paramétrées, au moyen d'une expression
particulière : l'appel de fonction. Les variables de types tableaux,
structures ou unions, offrent de leur côté différents moyens de regrouper
plusieurs valeurs au sein d'une même entité. Les tableaux sont constitués
de valeurs d'un même type rangées successivement en mémoire (dans des
emplacements de même taille). Les structures et les unions, sont
constituées de valeurs également contiguës, mais de types et de tailles
possiblement différentes.

Les variables de types pointeurs enfin, permettent d'accéder à des valeurs
d'un type donné quelconque à partir d'une adresse qui sera leur valeur
initiale. Les pointeurs (sur des int, des float, etc.) permettent ainsi de
parcourir les adresses des différentes cellules d'un tableau d'éléments
d'un même type qui sera généralement un type de base, mais on manipule
aussi des pointeurs sur des types structurés, comme des pointeurs sur des
tableaux, sur des structures ou même des pointeurs sur des fonctions.

Fonctions


Une fonction est un moyen d'effectuer un calcul à partir d'arguments. La
notion mathématique ne s'intéresse qu'au rapport entre les valeurs
arguments et la valeur résultat (supposée unique) du calcul, mais les
langages de programmation ont étendu la notion, car un calcul dans un
programme est aussi susceptible d'avoir d'autres effets (appelés effets de
bords). On pense toujours, concernant les effets de bords, à la
modification des valeurs de certaines variables (on écrit en quelque sorte
dans des variables), mais il s'agit a priori d'opérations d'écriture sur
des supports variés (écran, imprimantes, fichiers...).

Dans certains langages de programmation, on a cherché à sauver la notion
mathématique en introduisant la distinction entre une fonction - qui
rapporte un résultat, et une procédure, qui ne retourne aucune valeur, et
qui a, justement, des effets de bords. Ainsi, les procédures avaient par
définition des effets, et les fonctions étaient censées se conformer au
modèle mathématique, c'est-à-dire, dans le contexte de la programmation, ne
faire rien d'autre que de rapporter le résultat d'un calcul[1]. La volonté
sous-jacente des concepteurs de ces langages était de se libérer de la
notion de variable en tant qu'emplacement mémoire, pour ne garder que la
partie abstraite de cette notion : une valeur typée.

Mais la distinction procédure/fonction proposée alors était illusoire, car
le problème soulevé ne provenait pas de la présence ou de l'absence d'une
valeur de retour, et il restait en réalité possible, malgré cette
distinction superficielle, de définir dans ces langages des « fonctions »
ayant des effets de bords[2]. Le langage C n'effectue pas cette
distinction, et ses « procédures » (les fonctions dont la valeur de retour
est de type void) ne sont pas spécialement distinguées des autres
fonctions[3].

Conceptuellement, une fonction C n'a donc simplement rien à voir avec une
fonction mathématique. Elle fournit juste un moyen pratique de définition
pour l'encapsulation d'un module de calcul. Quand des fonctions sont
proprement conçues, on peut ignorer comment elles effectuent leur tâche et
se contenter de savoir ce qu'elles font (qu'il y ait effets de bords ou
non) - ce qui permet, bien entendu, de coller au modèle mathématique dans
les cas qui s'y prêtent.

1 Exemple


Voici l'exemple classique de la fonction puissance[4]. La fonction
principale de ce programme teste simplement cette fonction sur quelques
valeurs :

1. #include
2. #include
3.
4. /* declaration de la fonction puissance */
5. /* i.e. des types de depart et d'arrivee */
6. /* puissance : Int x Int -------> Int */
7. int puissance(int m, int n) ;
8.
9. int main ()
10. {
11. int i ;
12.
13. printf("%d\n", puissance (2,i) ) ;
14. return EXIT_SUCCESS ;
15. }
16.
17. /* definition de la fonction puissance */
18. /* puissance(x,n)= x a la puissance n avec n >=0 */
19. int puissance (int x, int n)
20. {
21. int i, p ;
22.
23. p = 1 ;
24. for (i = 1 ; i