précédent suivant haut Contents Index

La syntaxe du C


Second exemple, définitions

Considérons le programme ci-dessous :

#include <stdio.h>          
void affiche_calcul(float,float); /* prototype */
float produit(float,float);
int varglob;

int main(void)
 {
  float a,b; /* déclaration locale */
  varglob=0;
  puts("veuillez entrer 2 valeurs");
  scanf("%f %f",&a,&b);
  affiche_calcul(a,b);
  printf("nombre d'appels à produit : %d\n",varglob);
 }

float produit(float r, float s)
 {
  varglob++;
  return(r*s);
 }

void affiche_calcul(float x,float y)
 {
  float varloc;
  varloc=produit(x,y);
  varloc=produit(varloc,varloc);
  printf("le carré du produit est %f\n",varloc);
 }

Un programme C est composé (voir le schéma complet) :

Les fonctions (détaillées plus loin) sont écrites sous la forme : entête { corps }
L'entête est de la forme : type_résultat nom (arguments) . Le type_résultat n'était obligatoire (avant la norme ANSI) que s'il était différent de int (entier). Il doit désormais être void (rien) si la fonction ne renvoie rien (dans un autre langage on l'aurait alors appelé sous-programme, procédure, ou sous-routine). Les arguments, s'ils existent, sont passés par valeur. Si la fonction ne nécessite aucun argument, il faut indiquer (void) d'après la norme ANSI, ou du moins ().

Le corps est composé de déclarations de variables locales, et d'instructions.

Variables / identificateurs / adresse / pointeurs

On appelle variable une mémoire de l'ordinateur (ou plusieurs), à laquelle on a donné un nom, ainsi qu'un type (on a précisé ce qu'on mettra dans cette variable (entier, réel, caractère,...), pour que le compilateur puisse lui réserver la quantité de mémoire nécessaire. Dans cette variable, on pourra y stocker une valeur, et la modifier au cours du programme.

Exemple : int a; a est une variable entière, le compilateur va lui réserver en mémoire la place nécessaire à un entier (2 octets en Turbo C, 4 sous gcc). Le nom de cette variable est choisi par le programmeur. On préfère utiliser le terme identificateur plutôt que nom, car il permet d'identifier tout objet que l'on voudra utiliser (pas seulement les variables). Les identificateurs doivent suivre quelques règles de base : il peut être formé de lettres (A à Z), de chiffres et du caractère _ (souligné). Le premier caractère doit être une lettre (ou _ mais il vaut mieux le réserver au compilateur). Par exemple valeur1 ou prem_valeur sont possibles, mais pas 1ere_valeur. En C, les minuscules sont différentes des majuscules (SURFace et surFACE désignent deux objets différents). Le blanc est donc interdit dans un identificateur (utilisez _). Les lettres accentuées sont également interdites. La plupart des compilateurs acceptent n'importe quelle longueur d'identificateurs (tout en restant sur la même ligne) mais seuls les 32 premiers caractères sont significatifs.

J'appelle "blanc" : soit un espace, soit un retour à la ligne, soit une tabulation, soit un commentaire, soit plusieurs de ceux-ci. Les commentaires sont une portion de texte commençant par /* et finissant par le premier */ rencontré. Les commentaires ne peuvent donc pas être imbriqués. Mais un commentaire peut comporter n'importe quel autre texte, y compris sur plusieurs lignes. La plupart des compilateurs acceptent les commentaires commençant par // et se finissant à la fin de la ligne, qui eux peuvent être inclus dans un commentaire /*...*/ (c'est en fait une extension du C++).

Un identificateur se termine soit par un blanc, soit par un signe non autorisé dans les identificateurs (parenthèse, opérateur, ; ...). Le blanc est alors autorisé mais non obligatoire.

L'endroit où le compilateur a choisi de mettre la variable est appelé adresse de la variable (c'est en général un nombre, chaque mémoire d'un ordinateur étant numérotée de 0 à ? ). Cette adresse ne nous intéresse que rarement de manière explicite, mais souvent de manière indirecte. Par exemple, dans un tableau, composé d'éléments consécutifs en mémoire, en connaissant son adresse (son début), on retrouve facilement l'adresse des différentes composantes par une simple addition. On appelle pointeur une variable dans laquelle on place (mémorise) une adresse de variable (où elle est) plutôt qu'une valeur (ce qu'elle vaut).

Les types de variables scalaires simples que l'on utilise le plus couramment sont le char (un caractère), l'int (entier) et le float (réel). Le char est en fait un cas particulier des int, chaque caractère étant représenté par son numéro de code ASCII.

Expressions / opérateurs

Une expression est un calcul qui donne une valeur résultat (exemple : 8+5). Une expression comporte des variables, des appels de fonction et des constantes combinés entre eux par des opérateurs (ex : MaVariable*sin(VarAngle*PI/180) ).

Une expression de base peut donc être un appel à une fonction (exemple sin(3.1416). Une fonction est un bout de programme (que vous avez écrit ou faisant partie d'une bibliothèque) auquel on "donne" des valeurs (arguments), entre parenthèses et séparés par des virgules. La fonction fait un calcul sur ces arguments pour "retourner" un résultat. Ce résultat pourra servir, si nécessaire, dans une autre expression, voire comme argument d'une fonction exemple atan(tan(x)). Les arguments donnés à l'appel de la fonction (dits paramètres réels ou effectifs) sont recopiés dans le même ordre dans des copies (paramètres formels), qui elles ne pourront que modifier les copies (et pas les paramètres réels). Dans le cas de fonctions devant modifier une variable, il faut fournir en argument l'adresse (par l'opérateur &, voir plus bas), comme par exemple pour scanf.

Pour former une expression, les opérateurs possibles sont assez nombreux, nous allons les détailler suivant les types de variables qu'ils gèrent.

Arithmétiques

Ces opérateurs s'appliquent à des valeurs entières ou réelles.

unaires

Ce sont les opérateurs à un seul argument : - et + (ce dernier a été rajouté par la norme ANSI). Le résultat est du même type que l'argument.

deuxaires

Le terme "deuxaire" n'est pas standard, je l'utilise parce que binaire est pour moi associé à la base 2.

Ces opérateurs nécessitent deux arguments, placés de part et d'autre de l'opérateur. Ce sont + (addition), - (soustraction), * (produit), / (division), % (reste de la division). % nécessite obligatoirement deux arguments entiers, les autres utilisent soit des entiers, soit des réels. Les opérandes doivent être du même type, le résultat sera toujours du type des opérandes. Lorsque les deux opérandes sont de type différent (mais numérique évidement), le compilateur prévoit une conversion implicite (vous ne l'avez pas demandée mais il la fait néanmoins) suivant l'ordre : { char -> int -> long -> float -> double } et { signed -> unsigned }. On remarque qu'il considère les char comme des entiers, les opérations sont en fait faites sur les numéros de code (ASCII). Les calculs arithmétiques sont faits uniquement soit en long soit en double, pour éviter des dépassements de capacité.

exemples :

int a=1,b=2,c=32000;
float x=1,y=2;
a=(c*2)/1000; /* que des int, le résultat est 64, même si l'on est passé par un résultat intermédiaire (64000) qui dépassait la capacité des entiers (mais pas celle des long) */
b=7/b; /* signe = donc en premier calcul de l'argument à droite : 7 (entier) / 2 (entier) donne 3 (entier, reste 1, que l'on obtient par 5%2). donc b=3 */
x=7/b; /* 7 et b entiers => passage en réel inutile, calcul de 7/3 donne 2 (entier, reste 1) puis opérateur = (transformation du 2 en 2.0 puis transfert dans X qui vaut donc 2.0) */
x=7/y; /* un int et un float autour de / : transformation implicite de 7 en réel (7.0), division des deux réel (3.5), puis transfert dans x */
x=((float)(a+1))/b; /* calcul (entier) de a+1, puis transformation explicite en float, et donc implicite de b en float, division 65.0/3.0 -> 21.666... */

Relationnels

comparaisons

Ces opérateurs sont deuxaires : = = (égalité), != (différent), <, >, <=, >=. Des deux côtés du signe opératoire, il faut deux opérandes de même type (sinon, transformation implicite) mais numérique (les caractères sont classés suivant leur numéro de code ASCII). Le résultat de l'opération est 0 si faux, 1 si vrai (le résultat est de type int). Exemple : (5<7)+3*((1+1)= =2) donne 4. Attention, le compilateur ne vous prévient pas si vous avez mis = au lieu de = = (= est aussi un opérateur, voir plus loin), mais le résultat sera différent de celui prévu.

logique booléenne

Le résultat est toujours 0 (faux) ou 1 (vrai), les opérandes devant être de type entier (si char conversion implicite), 0 symbolisant faux, toute autre valeur étant considérée vraie.

Opérateur unaire : ! (non). !arg vaut 1 si arg vaut 0, et 0 sinon.

Opérateurs deuxaires : && (ET, vaut 1 si les 2 opérandes sont non nuls, 0 sinon) et || (OU, vaut 0 si les deux opérandes sont nuls, 1 sinon). Le deuxième opérande n'est évalué que si le premier n'a pas suffi pour conclure au résultat (ex (a= =0)&&(x++<0) incrémente x si a est nul, le laisse intact sinon).

binaires

Ces opérateurs ne fonctionnent qu'avec des entiers. Ils effectuent des opérations binaires bit à bit. On peut utiliser ~ (complément, unaire), & (et), | (ou inclusif), ^ (ou exclusif), >> (décalage à droite, le 2ème opérande est le nombre de décalages), << (décalage à gauche). Contrairement aux opérateurs relationnels, les résultats ne se limitent pas à 0 et 1.

exemples : 7&12 donne 4 (car 0111&1100 donne 0100); ~0 donne -1 (tous les bits à 1, y compris celui de signe); 8<<2 donne 32.

Affectation

affectation simple =

En C, l'affectation (signe =) est une opération comme une autre. Elle nécessite deux opérantes, un à droite, appelé Rvalue, qui doit être une expression donnant un résultat d'un type donné, et un à gauche (Lvalue) qui doit désigner l'endroit en mémoire où l'on veut stocker la Rvalue. Les deux opérandes doivent être de même type, dans le cas d'opérandes numériques si ce n'est pas le cas le compilateur effectuera une conversion implicite (la Lvalue doit être de type "plus fort" que la Rvalue). L'opération d'affectation rend une valeur, celle qui a été transférée, et peut donc servir de Rvalue.

Exemples : a=5 (met la valeur 5 dans la variable a. Si a est float, il y a conversion implicite en float); b=(a*5)/2 (calcule d'abord la Rvalue, puis met le résultat dans b); a=5+(b=2) (Le compilateur lit l'expression de gauche à droite. la première affectation nécessite le calcul d'une Rvalue : 5+(b=2). Celle ci comporte une addition, dont il évalue le premier opérande (5) puis le second (b=2). Il met donc 2 dans b, le résultat de l'opération est 2, qui sera donc ajouté à 5 pour être mis dans a. A vaut donc 7 et b, 2. Le résultat de l'expression est 7 (si l'on veut s'en servir).

Remarque : il ne faut pas confondre = et = =. Le compilateur ne peut pas remarquer une erreur (contrairement au Pascal ou Fortran) car les deux sont possibles. Exemple : if (a=0) est toujours faux car quelle que soit la valeur initiale de a, on l'écrase par la valeur 0, le résultat de l'opération vaut 0 et est donc interprété par IF comme faux.

incrémentation / décrémentation

++a : ajoute 1 à la variable a. Le résultat de l'expression est la valeur finale de a (c'est à dire après incrémentation). On l'appelle incrémentation préfixée.

a++ : ajoute 1 à la variable a. Le résultat de l'expression est la valeur initiale de a (c'est à dire avant incrémentation). C'est l'incrémentation postfixée.

de même, la décrémentation --a et a-- soustrait 1 à a.

exemple : j=++i est équivalent à j=(i=i+1). Je vous déconseille les imbrications du genre i=i++ + ++i difficilement compréhensibles.

affectation élargie

+= , -= , *= , /= , %= , <<= , >>= , &= , ^= , |=

a+=5 est équivalent à a=(a+5). Il faut encore ici une Rvalue à droite et une Lvalue à gauche.

Opérateurs d'adresses

Ces opérateurs sont utilisées avec des pointeurs. On utilise

exemple : supposons déclarer : int i1=1,i2=2; int *p1,*p2; i1 et i2 sont deux mémoires contenant un entier, alors que p1 et p2 sont des pointeurs, puisqu'ils contiennent une adresse d'entier. p1=&i1; met dans p1 l'adresse de i1. p2=p1; met la même adresse (celle de i1) dans p2. printf("%d\n",*p1); affiche ce qui est désigné (pointé) par p1 donc i1 donc 1. p2=&i2;*p2=*p1; à l'adresse pointée par p2 mettre ce qui est pointé par p1, donc copier la valeur de i1 dans i2. printf("%d\n",i2); affiche donc 1.

Autres

conditionnel ? :

C'est un (le seul) opérateur ternaire. L'expression a?b:c vaut la valeur de b si a est vrai (entier, différent de 0), et c si a est faux. Exemple : max=a>b?a:b

séquentiel ,

Cet opérateur permet de regrouper deux sous expressions en une seule. On effectue le premier opérande puis le second, la valeur finale de l'expression étant celle du second opérande. On l'utilise pour évaluer deux (ou plus) expressions là où la syntaxe du C ne nous permettait que d'en mettre une, exemple : for(i=j=0;i>10;i++,j++). Dans le cas d'une utilisation de cet opérateur dans une liste, utilisez les parenthèses pour distinguer les signes , : exemple (inutile) : printf("%d %d",(i++,j++),k) i est modifié mais sa valeur n'est pas affichée.

Ordre de priorité et associativité

opérateurs
associativité
description
() [] -> .
->

! ~ ++ -- - + & * (cast)
<-
unaires (* pointeurs)
* / %
->
multiplicatifs
+ -
->
addition
>> <<
->
décalages
< <= > >=
->
relations d'ordre
= = !=
->
égalité
&
->
binaire
^
->
binaire
|
->
binaire
&&
->
logique
| |
->
logique
? :
->
conditionnel (ternaire)
= += -= *= etc.
<-
affectation
,
<-
séquentiel

Dans ce tableau, les opérateurs sont classés par priorité décroissante (même priorité pour les opérateurs d'une même ligne). Les opérateurs les plus prioritaires seront évalués en premier. L'associativité définit l'ordre d'évaluation des opérandes. La plupart se font de gauche à droite ( 4/2/2 donne (4/2)/2 donc 1 (et pas 4/(2/2))).

Les seules exceptions sont :

Instructions

Une instruction peut être :

- soit une expression (pouvant comprendre une affectation, un appel de fonction...), terminé par un ; qui en fait signifie "on peut oublier le résultat de l'expression et passer à la suite",
- soit une structure de contrôle (boucle, branchement...),
- soit un bloc d'instructions : ensemble de déclarations et instructions délimités par des accolades {}. Un bloc sera utilisé à chaque fois que l'on désire mettre plusieurs instructions là où on ne peut en mettre qu'une.

Seule la première forme est terminée par un ;. Un cas particulier est l'instruction vide, qui se compose uniquement d'un ; (utilisé là où une instruction est nécessaire d'après la syntaxe).

Structures de contrôle

Normalement, les instructions s'effectuent séquentiellement, c'est à dire l'une après l'autre. Pour accéder à une autre instruction que la suivante, on a trois solutions : le branchement inconditionnel, le branchement conditionnel et la boucle.

Boucles

Une boucle permet de répéter plusieurs fois un bloc d'instructions.

While (tant que)

structure : while (expression) instruction

Tant que l'expression est vraie (!=0), on effectue l'instruction, qui peut être simple (terminée par ;), bloc (entre {}) ou vide (; seul). L'expression est au moins évaluée une fois. Tant qu'elle est vraie, on effectue l'instruction, dès qu'elle est fausse, on passe à l'instruction suivante (si elle est fausse dès le début, l'instruction n'est jamais effectuée).

exemple :

#include <stdio.h>
int main(void)
 {
  float nombre,racine=0;
  puts("entrez un nombre réel entre 0 et 10");
  scanf("%f",&nombre);
  while (racine*racine<nombre) racine+=0.01;
  printf("la racine de %f vaut %4.2f à 1%% près\n",
      nombre, racine);
 }
Exercice (while_puiss) : faire un programme qui affiche toutes les puissances de 2, jusqu'à une valeur maximale donnée par l'utilisateur. On calculera la puissance par multiplications successives par 2. Cliquez ici pour une solution.

Exercice (while_err) : que fait ce programme ?

#include <stdio.h>
#include <math.h>
#define debut 100
#define pas 0.01
int main(void)
 {
  float nombre=debut;
  int compte=0,tous_les;
  puts("afficher les résultats intermédiaires
	   tous les ? (333 par exemple) ?");
  scanf("%d",&tous_les);
  while (fabs(nombre-(debut+(compte*pas)))<pas)
   {
    nombre+=pas;
    if (!(++compte%tous_les))
       printf("valeur obtenue %12.8f, au lieu de %6.2f en %d calculs\n",
	     nombre,(float)(debut+(compte*pas)), compte);
   }
  printf("erreur de 100%% en %d calculs\n",compte);
 }
Cliquez ici pour une solution.

Do While (faire tant que)

structure : do instruction while (expression); (attention au ; final)

comme while, mais l'instruction est au moins faite une fois, avant la première évaluation de l'expression.

exemple :

#include <stdio.h>
int main(void)
 {
  int a;
  do
   {
    puts("veuillez entrer le nombre 482");
    scanf("%d",&a);
   }
  while (a!=482);
  puts("c'est gentil de m'avoir obéi");
 }
Les boucles sont la solution à employer pour effectuer plusieurs fois la même instruction (ou bloc d'instructions). L'exemple ci-dessus montre l'utilisation d'un do-while pour une action qu'on a prévu d'effectuer une seule fois normalement, mais que peut-être on effectuera plusieurs fois. Donc en C on ne dit jamais "faire X, si erreur recommencer X", mais "faire X tant que erreur".

Exercice (do_while) : écrivez un programme de jeu demandant de deviner un nombre entre 0 et 10 choisi par l'ordinateur. On ne donnera pas d'indications avant la découverte de la solution, où l'on indiquera le nombre d'essais. La solution sera choisie par l'ordinateur par la fonction rand() qui rend un entier aléatoire (déclarée dans stdlib.h). Cliquez ici pour une solution.

For (pour)

structure : for ( expr_initiale;expr_condition;expr_incrémentation) instruction

Cette boucle est surtout utilisée lorsque l'on connaît à l'avance le nombre d'itérations à effectuer. L'expr_initiale est effectuée une fois, en premier. Puis on teste la condition. On effectue l'instruction puis l'incrémentation tant que la condition est vraie. L'instruction et l'incrémentation peuvent ne jamais être effectuées. La boucle est équivalente à :

    expr_initiale;
    while (expr_condition)
     {
      instruction
      expr_incrémentation;
     }
Une ou plusieurs des trois expressions peuvent être omises, l'instruction peut être vide. for(;;); est donc une boucle infinie.

exemple :

{ char c; for(c='Z';c>='A';c--)putchar(c); }

Exercice (for) : faire un programme qui calcule la moyenne de N notes. N et les notes seront saisies par scanf. Le calcul de la moyenne s'effectue en initialisant une variable à 0, puis en y ajoutant progressivement les notes saisies puis division par N. Cliquez ici pour une solution.

Branchements conditionnels

On a souvent besoin de n'effectuer certaines instructions que dans certains cas. On dispose pour cela du IF et du SWITCH.

If - Else (Si - Sinon)

structure : if (expression) instruction1

ou : if (expression) instruction1 else instruction2

Si l'expression est vraie (!=0) on effectue l'instruction1, puis on passe à la suite. Sinon, on effectue l'instruction 2 puis on passe à la suite (dans le cas sans else on passe directement à la suite).

Exercice (jeu) : modifier le jeu de l'exercice (do_while) en précisant au joueur à chaque essai si sa proposition est trop grande ou trop petite. Cliquez ici pour une solution.

L'instruction d'un if peut être un autre if (imbriqué)

exemple :

	if(c1) i1;
	else if (c2) i2;
	else if (c3) i3;
	else i4;
	i5;
si c1 alors i1 puis i5, sinon mais si c2 alors i2 puis i5, ... Si ni c1 ni c2 ni c3 alors i4 puis i5.

Le else étant facultatif, il peut y avoir une ambiguïté s'il y a moins de else que de if. En fait, un else se rapporte toujours au if non terminé (c'est à dire à qui on n'a pas encore attribué de else) le plus proche. On peut aussi terminer un if sans else en l'entourant de {}.

exemple : if(c1) if(c2) i1; else i2; : si c1 et c2 alors i1, si c1 et pas c2 alors i2, si pas c1 alors (quel que soit c2) rien.
if (c1) {if (c2) i1;} else i2; : si c1 etx>=0) if (y>=0 c2 alors i1, si c1 et pas c2 alors rien, si pas c1 alors i2.

Un programmeur expérimenté utilisera toujours un maximum de "else" :
if(x>=0 && y>=0)....;
if(x<=0 && y>=0)....;
if(x>=0 && y<=0)....;
if(x<0 && y<0)....;
mauvais : toujours 8 tests quelques risques d'erreur (si nul)
if(x>=0) if (y>=0)....;
         else ....; /*x>=0 et y<0*/
else     if (y>=0)....; /*x<0 de toute façon*/
         else ....; /*x<0 et y<0*/
bon : toujours 2 tests et impossibilité de faire deux cas ou aucun
ou encore :

if(rep=='O').....;
else if(rep=='+'&& delta>0).....;
else if(rep=="A").....;
else if(z==0).....;
else printf("cas non prévu\n");
Quoi qu'il arrive, on ne fera qu'un cas. Dans le second inutile de rajouter rep!='O', on n'arrive au Nième cas que si tous les précédents sont faux. Tous les cas sont donc automatiquement exclusifs. Pour accélérer le programme il suffit de mettre en premier le cas le plus courant, on ne fera en majorité qu'un seul test.

Switch - Case (brancher - dans le cas)

Cette structure de contrôle correspond à un "goto calculé".

structure :

	switch (expression_entière)
	  {
	    case cste1:instructions
	    case cste2:instructions
		........
	    case csteN:instructions
	    default :instructions
	  }
L'expression ne peut être qu'entière (char, int, long). L'expression est évaluée, puis on passe directement au "case" correspondant à la valeur trouvée. Le cas default est facultatif, mais si il est prévu il doit être le dernier cas.

exemple : fonction vérifiant si son argument c est une voyelle.

int voyelle(char c)
 {
  switch(c)
   {
    case 'a':
    case 'e':
    case 'i':
    case 'o':
    case 'u':
    case 'y':return(1); /* 1=vrai */
    default :return(0);
   }
 }
Remarque : l'instruction break permet de passer directement à la fin d'un switch (au } ). Dans le cas de switch imbriqués on ne peut sortir que du switch intérieur.

Exemple :

	  switch (a)
	   {
	    case 1:inst1;inst2;....;break;
	    case 2:....;break;
	    default:.....
	   } 
	   /*endroit où l'on arrive après un break*/
Exercice (calcul) : faire un programme simulant une calculatrice 4 opérations. Cliquez ici pour une solution.

Branchements inconditionnels

Quand on arrive sur une telle instruction, on se branche obligatoirement sur une autre partie du programme. Ces instructions sont à éviter si possible, car ils rendent le programme plus complexe à maintenir, le fait d'être dans une ligne de programme ne suffisant plus pour connaître immédiatement quelle instruction on a fait auparavant, et donc ne permet plus d'assurer que ce qui est au dessus est correctement terminé. Il ne faut les utiliser que dans certains cas simples.

Break (interrompre)

Il provoque la sortie immédiate de la boucle ou switch en cours. Il est limité à un seul niveau d'imbrication.

exemples :
do {if(i==0)break;....}while (i!=0); /* un while aurait été mieux */
for (i=0;i<10;i++){....;if (erreur) break;} /* à remplacer par for(i=0;(i<10)&&(!erreur);i++){...} */

Continue (continuer)

Cette instruction provoque le passage à la prochaine itération d'une boucle. Dans le cas d'un while ou do while, saut vers l'évaluation du test de sortie de boucle. Dans le cas d'un for on passe à l'expression d'incrémentation puis seulement au test de bouclage. En cas de boucles imbriquées, permet uniquement de continuer la boucle la plus interne.

exemple :
for (i=0;i<10;i++) {if (i==j) continue; ...... }
peut être remplacé par :
for (i=0;i<10;i++) if (i!=j) { ...... }

Goto (aller à)

La pratique des informaticiens a montré que l'utilisation des goto donne souvent des programmes non maintenables (impossibles à corriger ou modifier). Les problèmes qu'ils posent ont amené les programmeurs expérimentés à ne s'en servir qu'exceptionnellement.

structure : goto label;

Label est un identificateur (non déclaré, mais non utilisé pour autre chose), suivi de deux points (:), et indiquant la destination du saut. Un goto permet de sortir d'un bloc depuis n'importe quel endroit. Mais on ne peut entrer dans un bloc que par son { (qui créera proprement les variables locales du bloc).

    {.....
      {.....
       goto truc;
       .....
      }
     .....
     truc:
     .....
    }

Return (retourner)

Permet de sortir de la fonction actuelle (y compris main), en se branchant à son dernier }. Return permet également (et surtout) de rendre la valeur résultat de la fonction.

structure : return; ou return(expression);

exemple :
int max(int a, int b) {if (a>b) return(a); else return(b);}

Exit (sortir)

Ceci n'est pas un mot clef du C mais une fonction disponible dans la plupart des compilateurs (définie par ANSI, dans STDLIB.H). Elle permet de quitter directement le programme (même depuis une fonction). On peut lui donner comme argument le code de sortie (celui que l'on aurait donné à return dans main). Cette fonction libère la mémoire utilisée par le programme (variables + alloc) et ferme (sur beaucoup de compilateurs) les fichiers ouverts.

structure : exit(); ou exit(valeur);

Déclaration et stockage des variables

Une variable doit être définie par le programmateur dans une déclaration, où l'on indique le nom que l'on désire lui donner, son type (int, float,...) pour que le compilateur sache combien de mémoire il doit lui réserver et les opérateurs qui peuvent lui être associés, mais aussi comment elle doit être gérée (visibilité, durée de vie,...).

Déclarations locales

Dans tout bloc d'instructions, avant la première instruction, on peut déclarer des variables. Elles seront alors "locales au bloc"  :elles n'existent qu'à l'intérieur du bloc. Ces variables sont mises en mémoire dans une zone de type "pile" : quand, à l'exécution, on arrive sur le début du bloc ({), on réserve la mémoire nécessaire aux variables locales au sommet de la pile (ce qui en augmente la hauteur), et on les retire en quittant le bloc. L'intérêt consiste à n'utiliser, à un instant donné, que la quantité nécessaire de mémoire, qui peut donc resservir par après pour d'autres variables. Le désavantage (rarement gênant et pouvant être contrecarré par la classe STATIC) est qu'en quittant le bloc (par } ou un branchement), et y entrant à nouveau plus tard (par son {), les variables locales ne sont plus nécessairement recréées au même endroit, et n'auront plus le même contenu. De plus la libération/réservation de la pile aura fait perdre un peu de temps. Par contre, lorsque l'on quitte temporairement un bloc (par appel à une fonction), les variables locales restent réservées. La sortie d'un bloc par un branchement gère la libération des variables locales, mais seule l'entrée dans un bloc par son { gère leur création.

Exemple :

  #include <stdio.h>
  int doubl(int b)
    {int c; c=2*b; b=0; return(c); }
  int main(void)
   {
    int a=5;
    printf("%d %d\n",doubl(a),a);
   }
A l'entrée du bloc main, création de a, à qui l'on donne la valeur 5. Puis appel de doubl : création de b au sommet de la pile, on lui donne la valeur de a. Puis entrée dans le bloc, création sur la pile de c, on lui donne la valeur b*2=10, on annule b (mais pas a), on rend 10 à la fonction appelante, et on libère le sommet de la pile (c et b n'existent plus) mais a reste (avec son ancienne valeur) jusqu'à la sortie de main. On affichera donc : 10 5.

Une variable locale est créée à l'entrée du bloc, et libérée à la sortie. Cette période est appelée sa durée de vie. Mais pendant sa durée de vie, une variable peut être visible ou non. Elle est visible : dans le texte source du bloc d'instruction à partir de sa déclaration jusqu'au }, mais tant qu'une autre variable locale de même nom ne la cache pas. Par contre elle n'est pas visible dans une fonction appelée par le bloc (puisque son code source est hors du bloc).

autre exemple :

int main(void);
 {int a=1;             [1]
   {int b=2;           [2]
     {int a=3;         [3]
      fonction(a);     [4]
     }                 [5]
    fonction(a);       [6]
   }                   [7]
 }                     [8]
int fonction (int b)   [a]
 {int c=0;             [b]
  c=b+8;               [c]
 }                     [d]
analysons progressivement l'évolution de la pile au cours du temps (en gras : variable visible) :

[1] a=1
[2] a=1 | b=2
[3] a=1 | b=2 | a=3 : seul le a le plus haut est visible (a=3), l'autre vit encore (valeur 1 gardée) mais n'est plus visible.
[4a] a=1 | b=2 | a=3 | b=3 : entrée dans la fonction, recopie de l'argument réel (a) dans l'argument formel (b). Mais a n'est plus visible.
[4b] a=1 | b=2 | a=3 | b=3 | c=0
[4c] a=1 | b=2 | a=3 | b=3 | c=11 : quand le compilateur cherche la valeur de b, il prend la plus haute de la pile donc 3 (c'est la seule visible), met le résultat dans le c le plus haut. L'autre b n'est pas modifié.
[4d] a=1 | b=2 | a=3 : suppression des variables locales b et c du sommet de la pile
[5] a=1 | b=2 : sortie de bloc donc libération de la pile
[6a] a=1 | b=2 | b=1 : l'argument réel (a) n'est plus le même qu'en [4a]
[6b] a=1 | b=2 | b=1 | c=0
[6c] a=1 | b=2 | b=1 | c=9
[6d] a=1 | b=2 : suppression b et c
[7] a=1
[8] la pile est vide, on quitte le programme

Notez que la réservation et l'initialisation prennent un peu de temps à chaque entrée du bloc. Mais ne présumez jamais retrouver une valeur sur la pile, même si votre programme n'a pas utilisé la pile entre temps (surtout sur système multitâche ou avec mémoire virtuelle).

Une déclaration a toujours la structure suivante :

[classe] type liste_variables [initialisateur]; (entre [] facultatif)

Le type peut être simple (char, int, float,...) ou composé (tableaux, structures..., voir plus loin).

La liste_variables est la liste des noms des variables désirées, séparées par des virgules s'il y en a plusieurs. Chaque nom de la liste peut être précédés d'une *, ceci spécifiant un pointeur.

L'initialisateur est un signe =, suivi de la valeur à donner à la variable lors de sa création (à chaque entrée du bloc par exemple). La valeur peut être une constante, mais aussi une expression avec des constantes voire des variables (visibles, déjà initialisées).

La classe peut être :

Déclarations globales

Une déclaration faite à l'extérieur d'un bloc d'instructions (en général en début du fichier) est dite globale. La variable est stockée en mémoire statique, sa durée de vie est celle du programme. Elle est visible de sa déclaration jusqu'à la fin du fichier. Elle sera initialisée une fois, à l'entrée du programme (initialisée à 0 si pas d'autre précision). Le format d'une déclaration globale est identique à une déclaration locale, seules les classes varient.

Par défaut, la variable est publique, c'est à dire qu'elle pourra même être visible dans des fichiers compilés séparément (et reliés au link).

La classe static, par contre, rend la visibilité de la variable limitée au fichier actuel.

La classe extern permet de déclarer une variable d'un autre fichier (et donc ne pas lui réserver de mémoire ici, mais la rendre visible). Elle ne doit pas être initialisée ici. Une variable commune à plusieurs fichiers devra donc être déclarée sans classe dans un fichier (et y être initialisée), extern dans les autres.

Toute fonction, pour pouvoir être utilisée, doit auparavant être soit déclarée, soit définie. On détaillera sa définition au paragraphe suivant. Une déclaration de fonction est généralement globale, et alors connue des autres fonctions. Une déclaration de fonction est appelée "prototype". Le prototype est de la forme :

[classe] type_retourné nom_fonction(liste_arguments);
elle est donc identique à l'entête de la fonction mais :
- est terminée par un ; comme toute déclaration
- les noms des arguments n'ont pas besoin d'être les mêmes, il peuvent même être omis (les types des arguments doivent être identiques).

Sans précision de classe, la fonction est publique. Sinon, la classe peut être extern (c'est ce que l'on trouve dans les fichiers .H) ou static (visibilité limitée au fichier). Le prototype peut être utilisé pour utiliser une fonction du même fichier, mais avant de l'avoir définie (par exemple si l'on veut main en début du fichier). En général, lorsque l'on crée une bibliothèque (groupe de fonctions et variables regroupées dans un fichier compilé séparément), on prépare un fichier regroupant toutes les déclarations extern, noté .H, qui pourra être inclus dans tout fichier utilisant la bibliothèque.

exemples de déclarations globales :
int i,j; /* publiques, initialisées à 0 */
static int k=1; /* privée, initialisée à 1 */
extern int z; /* déclarée (et initialisée) dans un autre fichier */
float produit(float,float); /* prototype d'une fonction définie plus loin dans ce fichier */
extern void échange(int *a, int *b); /* prototype d'une fonction définie dans un autre fichier */

Avant la norme ANSI, le prototype n'existait pas. Une fonction non définie auparavant était considérée comme rendant un int (il fallait utiliser un cast si ce n'était pas le cas).

Déclaration de type

La norme ANSI permet de définir de nouveaux types de variables par typedef.

structure : typedef type_de_base nouveau_nom;

Ceci permet de donner un nom à un type donné, mais ne crée aucune variable. Une déclaration typedef est normalement globale et publique.

exemple :
typedef long int entierlong; /* définition d'un nouveau type */
entierlong i; /* création d'une variable i de type entierlong */
typedef entierlong *pointeur; /* nouveau type : pointeur = pointeur d'entierlong */
pointeur p; /* création de p (qui contiendra une adresse), peut être initialisé par =&i */

Remarques : Le premier typedef pouvait être remplacé par un #define mais pas le second. L'utilisation du typedef permet de clarifier les programmes, puisqu'on peut définir un nom de type pour déclarer des variables dont la fonction sera clairement détaillée :

	typedef float prix;
	typedef float quantite;
	prix a,b,c;
	quantite x,y;
Une autre utilisation importante est pour définir un type complexe, où l'on définira petit à petit les composants (exemple tableau de pointeurs de structures, on définit d'abord la structure, puis le pointeur de structure, puis le tableau de tout cela).

Fonctions

Définitions générales

Une fonction est définie par son entête, suivie d'un bloc d'instructions

entête : type_retourné nom_fonction(liste_arguments) (pas de ;)

Avant la norme ANSI, le type_retourné pouvait être omis si int. Désormais il est obligatoire, si la fonction ne retourne rien on indique : void.

La liste_arguments doit être typée (ANSI), alors qu'auparavant les types étaient précisés entre l'entête et le bloc :
ANSI: float truc(int a, float b) {bloc}
K&R: float truc(a,b) int a;float b; {bloc}

Si la fonction n'utilise pas d'arguments il faut la déclarer (ANSI) nom(void) ou (K&R) nom(). L'appel se fera dans les deux cas par nom() (parenthèses obligatoires).

Les arguments (formels) sont des variables locales à la fonction. Les valeurs fournies à l'appel de la fonction (arguments réels) y sont recopiés à l'entrée dans la fonction. Les instructions de la fonction s'exécutent du début du bloc ({) jusqu'à return(valeur) ou la sortie du bloc (}). La valeur retournée par la fonction est indiquée en argument de return.

exemples :

1) fonction ne recevant aucun argument, et ne retournant rien. Ce n'est pas parce qu'elle ne retourne rien qu'elle ne fait rien, ici elle affiche un message à l'écran. Elle ne reçoit aucun argument, ici parce qu'elle n'en a pas besoin, quelquefois c'est parce qu'elle n'utilise que des variables globales (chose que je ne conseille pas).

	void message(void)
	 {
	  int i;
	  for(i=0;i<10;i++)printf("bonjour monde\n");
	 }
On appelle cette fonction par message();
Une fonction possède ses propres variables locales (ici i), mais n'a pas accès aux variables locales des autres fonctions, pas même celles de main (mais aux variables globales, que je déconseille fortement au débutant)

2) fonction recevant un (ou plusieurs) argument(s), et ne retournant rien. Une telle fonction a besoin d'informations pour effectuer sa tâche, ce qui est le cas le plus courant.

	void insiste(int combien_de_fois,char * compliment)
	 {
	  int i;
	  printf("Oh que tu es ");
	  for(i=0;i<combien_de_fois;i++)printf("%s ",compliment);
	  printf("!!!!! \n);
	 }
On appelle cette fonction par exemple par insiste(10,"belle"); ou int j=3; char i[]="fatiguant"; insiste(j*2,i); Tout ce qui importe à l'appel est qu'on donne en premier argument une valeur entière et en second une chaîne de caractères. Leurs noms n'ont aucun rapport avec ceux utilisés dans la fonction.

3) fonction recevant un (ou plusieurs, ou aucun) argument(s), et retournant une valeur. Une telle fonction a besoin (ou non) d'informations pour effectuer sa tâche, mais quand la tâche est terminée (en général c'était un calcul), elle rend (retourne) le résultat (une et une seule valeur). Je vous rapelle que les variables locales de la fonction ne sont pas visibles à l'extérieur de la fonction, sans cela les calculs auraient été inutiles.

	float produit(float a;float b)
	 {
	  float z;
	  z=a*b;
	  return(z);
	 }
On appelle cette fonction dans une expression nécessitant un float : x=produit(2,4.5); ou y=2+produit(sin(x)+produit(1.12,X),produit(2,2)) ou printf("le double de %f est %f\n",z,produit(z,2));

4) que fait-on pour retourner plusieurs valeurs ? C'est impossible directement. On peut retourner un pointeur (voir plus loin) qui permet de retourner l'adresse d'un ensemble de valeurs (tableau ou structure). On peut aussi transmettre des "récipients" pour les valeurs résultantes, gràce au passage d'arguments par adresse (voir plus loin). On pourait aussi utiliser des variables globales, mais ce qui prouve que vous êtes un programmeur expérimenté est que vous savez que c'est une très mauvaise solution.

Récursivité, gestion de la pile

Une fonction peut s'appeler elle-même :

int factorielle(int i)
 {
  if (i>1) return(i*factorielle(i-1));
  else return(1);
 }
analysons la pile en appelant factorielle(3) :


i=1




i=2
i=2
i=2

i=3
i=3
i=3
i=3
i=3
(a)
(b)
(c)
(d)
(e)
Attention, la récursivité est gourmande en temps et mémoire, il ne faut l'utiliser que si l'on ne sait pas facilement faire autrement :
int factorielle(int i)
 {
  int result;
  for(result=1;i>1;i--) result*=i;
  return(result);
 }

Arguments passés par adresse

Imaginons la fonction :

void échange(int i;int j)
{int k;k=i;i=j;j=k;}

Lors d'un appel à cette fonction par échange(x,y), les variables locales i,j,k sont créées sur la pile, i vaut la valeur de x, j celle de y. Les contenus de i et j sont échangés puis la pile est libérée, sans modifier x et y. Pour résoudre ce problème, il faut passer par des pointeurs. On utilisera les opérateurs unaires : & (adresse de) et * (contenu de). Définissons donc la fonction ainsi :

void échange(int *i;int *j)
{int k;k=*i;*i=*j;*j=k;}

On appelle la fonction par échange(&x,&y); les deux arguments formels de la fonction (i et j) sont des pointeurs sur des int, c'est à dire qu'à l'appel, on crée sur la pile des variables i et j pouvant contenir une adresse, dans i on recopie l'argument réel qui et l'adresse de x, et l'adresse de y dans j. en entrant dans le bloc, on crée une variable locale k pouvant contenir un entier. Puis on met dans k non pas la valeur de i mais le contenu pointé par i (donc ce qui se trouve à l'adresse marquée dans i, qui est l'adresse de x), donc le contenu de x. On place la valeur pointée par j (donc y) à l'adresse pointée par j (donc x). Puis on place la valeur de k à l'adresse pointée par j (y). On a donc échangé x et y.

On a tout intérêt à essayer cet exemple en se fixant des adresses et des valeurs, et voir l'évolution des contenus des variables.

En conclusion, pour effectuer un passage d'argument par adresse, il suffit d'ajouter l'opérateur & devant l'argument réel (à l'appel de la fonction), et l'opérateur * devant chaque apparition de l'argument formel, aussi bien dans l'entête que le bloc de la fonction.

La fonction main

Si on le désire, la fonction main peut rendre un entier (non signé) au système d'exploitation (sous MSDOS, on récupère cette valeur par ERRORLEVEL). Une valeur 0 signale en général une fin normale du programme, sinon elle représente un numéro d'erreur. L'arrivée sur le } final retourne la valeur 0, dans le cas où on n'a pas indiqué de return(code).

De même, le système d'exploitation peut transmettre des arguments au programme. La déclaration complète de l'entête de la fonction main est :

int main(int argc,char *argv[], char *env[])

Le dernier argument est optionnel.

On peut aussi utiliser char **argv, mais cela peut paraître moins clair. argc indique le nombre de mots de la ligne de commande du système d'exploitation, argv est un tableau de pointeurs sur chaque mot de la ligne de commande, env pointe sur les variables de l'environnement (sous MSDOS obtenues par SET, sous UNIX par env).

Si votre programme s'appelle COPIER, et que sous votre système vous ayez entré la commande COPIER TRUC MACHIN alors argc vaut 3, argv[0] pointe sur "COPIER", argv[1] sur "TRUC" et argv[2] sur "MACHIN". argv[3] vaut le pointeur NULL. env est un tableau de pointeurs sur les variables d'environnement, on n'en connaît pas le nombre mais le dernier vaut le pointeur NULL.

Fonction retournant un pointeur et pointeur de fonction

type*fonc(arguments) est une fonction qui renvoie un pointeur.

exemple :

int *max(int tableau[], int taille)
 {
  int i,*grand;
  for(grand=tableau,i=1;i<taille;i++)
	    if(tableau[i]>*grand) grand=tableau+i;
  return(grand);
 }
Cette fonction rend l'adresse du plus grand entier du tableau.

type (*fonc)(arguments) est un pointeur sur une fonction

exemple :

int max(int,int);
int min(int,int);
int main(void);
 {
  int (*calcul)(int,int);
  /* calcul est un pointeur donc une variable qui
			peut être locale */
  char c;
  puts("utiliser max (A) ou min (I) ?");
  do c=getchar(); while ((c!='A')&&(c!='I'));
  calcul=(c=='A')?&max:&min;
  printf("%d\n",(*calcul)(10,20));
 }
int max(int a,int b) {return(a>b?a:b);}
int min(int a,int b) {return(a<b?a:b);}
Cette fonctionnalité du C est assez peu utilisée, mais est nécessaire dans les langages orientés objets.

Les types de données du C

Nous allons définir les différents types de variables existantes en C. On verra les types scalaires (entiers,...) et les types agrégés (combinaisons de scalaires, tableaux par exemple).

Variables scalaires

On appelle variable scalaire une variable ne contenant qu'une seule valeur, sur laquelle on pourra faire un calcul arithmétique. On possède trois types de base (char, int, float) que l'on peut modifier par 3 spécificateurs (short, long, unsigned).

char : caractère (8 bits)

Une constante caractère est désignée entre apostrophes (simples quotes). 'a' correspond à un octet (alors que "a" à deux octets : 'a' et '\0', pour plus de détails voir le paragraphe chaînes de caractères). On peut définir certains caractères spéciaux, par le préfixe \ (antislash) :

Les char sont considérés dans les calculs comme des int (on considère leur code ASCII). Par défaut en C un char est signé donc peut varier de -128 à +127. Pour utiliser les caractères spéciaux du PC (non standard), il vaut mieux utiliser des unsigned char (de 0 à 255). Mais le comme C fait les calculs modulo 256, ça marche presque pareil.

int : entier

Si l'on désire une taille précise, utiliser short int (16 bits) ou long int (32 bits). Sans précision, int donnera les programmes les plus rapides pour une machine donnée (int = short sur PC, mais long sur les stations 32 bits). Par défaut, les int sont signés, mais on peut préciser unsigned int.

Désormais certains compilateurs considèrent short comme 16 bits, int comme 32 bits et long comme 64 bits.

float : réel

Un flottant est un nombre stocké en deux parties, une mantisse et un exposant. La taille de la mantisse définit le nombre de chiffres significatifs, alors que la taille de l'exposant définit le plus grand nombre acceptable par la machine. Les opérations sur les réels sont plus lents que sur les entiers. Pour une addition par exemple, il faut d'abord décaler la mantisse pour égaliser les exposants puis faire l'addition. Les réels sont toujours signés. On peut par contre utiliser le spécificateur long pour des réels avec une précision accrue. On peut également utiliser le nom double au lieu de long float. Certains compilateurs acceptent même des long double (quadruple précision).

Tailles et plages

type

taille (en bits)
plage de valeurs
char
8
-128 à +127
unsigned char
8
0 à 255
short (short int)
16
-32768 à 32767
unsigned short
16
0 à 65535
long (long int)
32
-2.147.483.648 à 2.147.483.647
unsigned long
32
0 à 4.294.967.295
float
32
-3.4e38 à 3.4e38 (7 chiffres significatifs)
double (long float)
64
-1.7e308 à 1.7e308 (15 chiffres significatifs)
long double (non standard)
80 ou 128
ça dépend

Conversions de type / cast

Dans les calculs, les char sont automatiquement transformés en int. Quand un opérateur possède des arguments de type différent, une transformation de type est effectuée automatiquement, suivant l'ordre :
char -> int -> long -> float -> double
signed -> unsigned

Attention la transformation n'est effectuée que le plus tard possible, si nécessaire. 5/2+3.5 donnera donc 5.5. De plus les opérations arithmétiques sont toujours effectuées sur des long ou double, pour une précision maximale quels que soient les résultats intermédiaires (voir exemples au chapitre expressions arithmétiques).

On peut forcer une transformation en utilisant le cast, qui est un opérateur unaire. La syntaxe est : (type_résultat) valeur_à_transformer

exemple : {float x;int a=5; x=(float)a;}

Un cast transformant un réel en entier prendra la partie entière. Cette transformation doit être explicite, elle est impossible implicitement. Pour obtenir l'entier le plus proche , utiliser (int)(réel_positif+0.5).

Il faut bien noter que le cast n'est une opération de transformation que pour les types scalaires, pour tous les autres types, le cast ne permet que de faire croire au compilateur que la variable est d'un autre type que ce qu'il attendait, pour qu'il n'émette pas de message d'erreur (à utiliser avec grande prudence).

Enumérations

On peut définir un nouveau type (d'entiers) sous la forme :
[classe] enum nomdutype {liste_valeurs} [liste_variables]; ([] facultatifs)

exemple : enum jour {lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche};

On a créé un nouveau type. toute variable de type jour pourra valoir soit lundi, soit mardi, etc... On peut directement mettre la liste des variables à créer (entre le "}" et le ";"), ou indiquer :
enum nomdutype liste_variables;

exemple : enum jour aujourd_hui=mardi;)

En fait le type jour est un type int, avec lundi=0, mardi=1,... On peut donc faire toutes les opérations entières (aujourd_hui++ par exemple). Il n'y a aucun test de validité (dimanche+1 donne 7). Ceci permet de rendre les programmes plus clairs. On obtiendrait un résultat équivalent avec #define. Attention, printf affichera un entier, mais on peut faire:

char *nom[7]={"lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi"," dimanche"};
puis printf("%s",nom[aujourd_hui]);

On peut aussi prévoir une codification non continue :
enum truc {a=4,b,c,d=2,e,f} : d=2,e=3,f=a=4,b=5,c=6

En utilisant typedef, on n'a pas besoin de répéter enum dans la déclaration de variables :
typedef enum {coeur,carreau,pique,trèfle}couleurs;
couleurs i,j,k;

Tableaux

Tableaux unidimensionnels

Un tableau est un regroupement, dans une même variable, de plusieurs variables simples, toutes de même type.

déclaration : [classe] type nom [nombre_d'éléments];

exemple : int tab[10];

Ceci réserve en mémoire un espace contigu pouvant contenir 10 entiers. Le premier est tab[0], jusqu'à tab[9]. Attention, en utilisant tab[10] ou plus, aucune erreur ne sera signalée et vous utiliserez une partie de mémoire qui a certainement été réservée pour autre chose. Il est possible de définir un tableau de n'importe quel type de composantes (scalaires, pointeurs, structures et même tableaux). Il est également possible de définir un type tableau par typedef :
typedef float vecteur[3];
vecteur x,y,z;

On peut aussi initialiser un tableau. Dans ce cas la dimension n'est pas nécessaire. Mais si elle est donnée, et est supérieure au nombre de valeurs données, les suivantes seront initialisées à 0 :
vecteur vect0={0,0,0};
int chiffres[]={0,1,2,3,4,5,6,7,8,9};
int tableau[20]={1,2,3}; /* les 17 autres à 0 */

On peut également déclarer un tableau sans en donner sa dimension. Dans ce cas là le compilateur ne lui réserve pas de place, elle aura du être réservée autre part (par exemple tableau externe ou argument formel d'une fonction).

Exercice (moyenne) : Ecrire le programme qui lit une liste de Nb nombres, calcule et affiche la moyenne puis l'écart entre chaque note et cette moyenne. Cliquez ici pour une solution.

Tableaux et pointeurs / arithmétique des pointeurs

En déclarant, par exemple, int TAB[10]; l'identificateur TAB correspond en fait à l'adresse du début du tableau. Les deux écritures TAB et &TAB[0] sont équivalentes (ainsi que TAB[0] et *TAB). On définit l'opération d'incrémentation pour les pointeurs par TAB+1=adresse de l'élément suivant du tableau. L'arithmétique des pointeurs en C a cette particularité que l'opération dépend du type de variable pointée, ajouter 1 consistant à ajouter à l'adresse la taille de l'objet pointé. On définit donc l'addition (pointeur+entier): TAB+i=&TAB[i], la soustraction (pointeur - entier), mais également la soustraction (pointeur - pointeur) qui donne un nombre d'éléments. Les opérations de comparaisons entre pointeurs sont donc également possibles.

Déclarons : int TAB[10],i,*ptr;

Ceci réserve en mémoire
- la place pour 10 entiers, l'adresse du début de cette zone est TAB,
- la place pour l'entier i,
- la place pour un pointeur d'entier (le type pointé est important pour définir l'addition).

Analysons les instructions suivantes :

ptr=TAB; /*met l'adresse du début du tableau dans ptr*/
for(i=0;i<10;i++)
 {
  printf("entrez la %dième valeur :\n",i+1);
  /* +1 pour commencer à 1*/
  scanf("%d",ptr+i);
  /* ou &TAB[i] puisque scanf veut une adresse*/
 }
puts("affichage du tableau");
for(ptr=TAB;ptr<TAB+10 /* ou &TAB[10] */;ptr++)
  printf("%d ",*ptr);
puts(" ");
/* attention actuellement on pointe derrière le tableau ! */
ptr-=10; /* ou plutôt ptr=TAB qui lui n'a pas changé */
printf("%d",*ptr+1); /* affiche (TAB[0])+1 */
printf("%d",*(ptr+1)); /* affiche TAB[1] */
printf("%d",*ptr++); /* affiche TAB[0] puis pointe sur TAB[1] */
printf("%d",(*ptr)++); /* affiche TAB[1] puis ajoute 1 à TAB[1]*/
TAB est une "constante pointeur", alors que ptr est une variable (donc TAB++ est impossible). La déclaration d'un tableau réserve la place qui lui est nécessaire, celle d'un pointeur uniquement la place d'une adresse.

Pour passer un tableau en argument d'une fonction, on ne peut que le passer par adresse (recopier le tableau prendrait de la place et du temps).

exemple utilisant ces deux écritures équivalentes :

#include <stdio.h>
void annule_tableau(int *t,int max)
 {
  for(;max>0;max--)*(t++)=0;
 }
void affiche_tableau(int t[], int max)
 {
  int i;
  for(i=0;i<max;i++) printf("%d : %d\n",i,t[i]);
 }
int main(void)
 {
  int tableau[10];
  annule_tableau(tableau,10);
  affiche_tableau(tableau,10);
 }
Exercice (rotation) : Ecrire un programme qui lit une liste de Nb nombres, la décale d'un cran vers le haut (le premier doit se retrouver en dernier), l'affiche puis la décale vers le bas. On pourra décomposer le programme en fonctions. Cliquez ici pour une solution.

Exercice (classer) : Classer automatiquement un tableau de Nb entiers puis l'afficher dans l'ordre croissant puis décroissant. On pourra utiliser des fonctions de l'exercice précédent. On pourra créer un (ou plusieurs) tableau temporaire (donc local). Si vous vous en sentez la force, prévoyez le cas de valeurs égales. Cliquez ici pour une solution.

Chaînes de caractères

En C, comme dans les autres langages, certaines fonctionnalités ont été ajoutées aux tableaux dans le cas des tableaux de caractères. En C, on représente les chaînes par un tableau de caractères, dont le dernier est un caractère de code nul (\0). Une constante caractères est identifiée par ses délimiteurs, les guillemets " (double quote).

exemples :
puts("salut");
char mess[]="bonjour"; /* évite de mettre ={'b','o',..,'r','\0'} */
puts (mess);

mess est un tableau de 8 caractères (\0 compris). On peut au cours du programme modifier le contenu de mess, à condition de ne pas dépasser 8 caractères (mais on peut en mettre moins, le \0 indiquant la fin de la chaîne). Mais on peut également initialiser un pointeur avec une chaîne de caractères :
char *strptr="bonjour";

Le compilateur crée la chaîne en mémoire de code (constante) et une variable strptr contenant l'adresse de la chaîne. Le programme pourra donc changer le contenu de strptr (et donc pointer sur une autre chaîne), mais pas changer le contenu de la chaîne initialement créée.

Exercice (chaînes) : écrire un programme qui détermine le nombre et la position d'une sous-chaîne dans une chaîne (exemple ON dans FONCTION : en position 1 et 6). Cliquez ici pour une solution.

Bibliothèques de fonctions pour tableaux et chaînes

Toutes les fonctions standard d'entrée / sortie de chaînes considèrent la chaîne terminée par un \0, c'est pourquoi en entrée elles rajoutent automatiquement le \0 (gets, scanf), en sortie elles affichent jusqu'au \0 (puts, printf). La bibliothèque de chaînes (inclure string.h) possède des fonctions utiles à la manipulation de chaînes :

Des fonctions similaires, mais pour tous tableaux (sans s'arrêter au \0) sont déclarées dans mem.h. La longueur est à donner en octets (on peut utiliser sizeof) : On possède également des fonctions de conversions entre scalaires et chaînes, déclarées dans stdlib.h J'utilise également sscanf et sprintf pour les conversions, qui offrent un maximum de possibilités.

Dans ctype.h, on trouve des fonctions utiles (limitées au caractères) :

Allocation dynamique de mémoire

La taille déclarée d'un tableau est définie à la compilation (alors que quand elle n'est pas constante il serait utile de la définir lors de l'exécution du programme). Dans le cas d'une taille inconnue à l'avance, il faut surdimensionner le tableau (et donc réserver des mémoires dont on ne servira que rarement, aux dépends d'autres variables ou tableaux). C'est pour cela qu'on les appelle des tableaux statiques.

En C, le lien entre les tableaux et pointeurs permet la notion de tableaux dynamiques : on peut définir la dimension d'un tableau lors de l'exécution. Il faut d'abord réserver une zone de mémoire contiguë, de la taille désirée (mais pas plus). Il faut avoir déclaré une variable pointeur qui contiendra l'adresse du début du tableau. A l'exécution, lorsque l'on connaît la taille désiré, on peut réserver une zone mémoire (dans la zone appelée "tas" ou "heap") par les fonctions :

- void *malloc(int taille) : réserve une zone mémoire contiguë de taille octets, et retourne un pointeur sur le début du bloc réservé. Retourne le pointeur NULL en cas d'erreur (en général car pas assez de mémoire).

- void *calloc(int nb, int taille) : équivalent à malloc(nb*taille).

exemple :

	float *tab;
	int nb;
	puts("taille désirée ?");
	scanf("%d",&nb);
	tab=(float*)calloc(nb,sizeof(float));
malloc et calloc nécessitent un cast pour que le compilateur ne signale pas d'erreur.

- void free(void *pointeur) libère la place réservée auparavant par malloc ou calloc. Pointeur est l'adresse retournée lors de l'allocation. En quittant proprement le programme, la mémoire allouée est automatiquement restituée même si on omet d'appeler free.

- void *realloc(void *pointeur,int taille) essaie, si possible, de réajuster la taille d'un bloc de mémoire déjà alloué (augmentation ou diminution de taille). Si nécessaire, le bloc est déplacé et son contenu recopié. En retour, l'adresse du bloc modifié (pas nécessairement la même qu'avant) ou le pointeur NULL en cas d'erreur.

Ces fonctions sont définies dans stdlib.h ou alloc.h (suivant votre compilateur).

Une fois la zone de mémoire réservée, et son adresse de début connue (supposons l'avoir stockée dans le pointeur nommé "tab" comme décrit dans l'exemple ci-dessus), on peut y accéder soit par "l'écriture pointeurs" soit par "l'écriture tableaux", puisqu'elles sont équivalentes :

On peut remarquer que ces tableaux ne sont pas totalement dynamiques : la dimension doit être connue (et l'allocation faite) avant la première utilisation du tableau. Elle est ensuite difficilement modifiable (du moins pour l'augmenter). On ne peut par exemple pas dire "entrez vos mots, terminez par une ligne vide", mais "combien de mots ?" puis "entrez vos mots".

Une erreur fréquente consiste à "perdre" l'adresse du début de la zone allouée (par tab=quelque chose, ou parce que tab était une variable locale qui ne vit plus) et donc il devient alors impossible d'accéder au début de la zone, ni de la libérer.

Tableaux multidimensionnels

On peut déclarer par exemple int tab[2][3] : matrice de 2 lignes de 3 éléments. Un tableau peut être initialisé : int t[2][3]={{1,2,3},{4,5,6}} mais cette écriture est équivalente à {1,2,3,4,5,6}, car il place dans l'ordre t[0][0], t[0][1], t[0][2], t[1][0], t[1][1], t[1][2], c'est à dire ligne après ligne. Dans un tableau multidimensionnel initialisé, la dimension la plus à gauche peut être omise (ici int t[][3]={...} était à la rigueur possible).

t correspond à l'adresse &t[0][0], mais t[1] est aussi un tableau (une ligne), donc désigne l'adresse &t[1][0]. En fait, une matrice est un tableau de lignes. On peut expliciter cela par typedef (c'est d'après moi la meilleure solution pour déclarer des tableaux multidimensionnels) :
typedef int ligne[3];
typedef ligne matrice[2];
matrice t; /* 3 lignes au lieu d'une mais tellement plus clair */

En utilisant pointeurs et allocation dynamique, pour gérer un tableau de NBLIG lignes de NBCOL éléments, on peut :

Exercice (matrices) : faire le calcul de multiplication d'une matrice (M lignes, L colonnes) par une matrice (L,N) : résultat (M,N).
Cliquez ici pour une solution.

Exercice (déterminant) : écrire un programme qui calcule le déterminant d'une matrice carrée (N,N), sachant qu'il vaut la somme (sur chaque ligne) de l'élément de la ligne en 1ère colonne par le déterminant de la sous-matrice obtenue en enlevant la ligne et la 1ère colonne (en changeant le signe à chaque fois). Le déterminant d'une matrice (1,1) est sont seul élément. On utilisera bien évidement la récursivité. Il existe (heureusement) d'autres méthodes plus rapides. Cliquez ici pour une solution.

Vous trouverez d'autres exercices sur les tableaux dans les TP d'IUP2, par exemple celui-ci.

Structures et unions

Dans un tableau, tous les constituants doivent obligatoirement être du même type. Ce n'est pas le cas des structures, qui sont des variables composées de plusieurs variables (ou CHAMPS) de types différents. Chaque champIl es n'est plus désigné par un numéro comme dans un tableau, mais par un identificateur.

Déclaration

déclaration : struct nom_type {déclaration des champs} liste_variables ;

exemple :

  struct identite { char nom[30];
		    char prenom[20];
		    short int age;
		  }jean,jacques,groupe[20];
Toute variable de type identité (jean, jacques, groupe[i]) comporte trois champs : nom, prenom et age. sizeof(jacques) retournera 52. Les champs peuvent être de n'importe quel type valable (scalaires, tableaux, pointeurs...), y compris une structure (à condition d'être déclaré plus haut). nom_type et liste_variables sont optionnels mais au moins l'un des deux doit être présent. Les noms de champs ont une portée limitée à la structure (c'est à dire qu'un autre objet peut avoir le même nom, s'il n'est pas cité dans cette structure). Nom_type (ici identite) est le nom d'un nouveau type, il peut être utilisé plus loin pour déclarer d'autres variables, voire d'autres types:
struct identite lui;
struct prisonnier {long numero; struct identite id;} moi;

Il est également possible d'utiliser typedef, et (pas sur tous les compilateurs) d'initialiser une structure :
typedef struct {int jour;int mois;int année;}date;
date aujourdhui={24,12,1992}; /*évite de répéter struct*/

Utilisation

On accède à une composante par NOM_VARIABLE . NOM_CHAMP , par l'opérateur unaire "."

gets(jean.nom);
printf("initiales : %c %c\n",lui.nom[0],lui.prenom[0]);
printf("nom %s \n",groupe[10].nom);
scanf("%d",&moi.id.age);

Une composante d'enregistrement s'utilise comme une variable du même type (avec les mêmes possibilités mais aussi les mêmes limitations). Depuis la norme ANSI, on peut utiliser l'affectation pour des structures (recopie de tous les champs), ainsi que le passage des structures en arguments de fonction passés par valeur. Sur les compilateurs non ANSI, il faut utiliser des pointeurs.

On utilise des pointeurs de structures comme des pointeurs sur n'importe quel autre type. L'opérateur -> permet une simplification d'écriture (il signifie champ pointé) :
date *ptr;
ptr=(struct date *)malloc(sizeof(date));
*ptr.jour=14;
ptr->mois=7;

Les structures sont tres importantes en C, et encore plus dans les langages plus récents, les objets en découlent.
Les champs d'une structure peuvent être relativement complexes (tableaux, autres structures), et on peut créer des tableaux de structures.

Exemple : déclarez le types et variables suivants : une date est composée de 3 entiers j, m et a. Une opération est une référence (entier long), une quantité et un prix unitaire. Une facture est une date, un numéro de client, un nombre d'opérations et au maximum 20 oprérations. Un client est un numéro, un nom et une adresse. Un produit est une référence, une désignation, un prix unitaire, une quantité en stock. Une compta est un tableau de 1000 factures. Un stock est un tableau (dynamique) de produits. Et l'on peut continuer ainsi longtemps. Vous trouverez d'autres questions de ce genre dans mes sujets d'examens, plutôt dans les dernières questions. En particulier IUP2 en 2003.

Champs de bits

En ne définissant que des champs entiers (signés ou non), on peut définir la taille (en bits) de chaque champ. Il suffit pour cela de préciser, derrière chaque champ, sa taille après un ":".
struct état{unsigned ReadOnly:1;int Crc:6;}

Les champs sont créés à partir des bits de poids faible. Le nom du champ est optionnel (dans le cas de champs réservés, non utilisés par le programme). Les champs n'ont alors pas d'adresse (impossible d'utiliser & sur un champ). On utilise ces structures comme les autres.

Unions

déclaration : union nom_type {déclaration des champs} liste_variables ;

Les différents champs commenceront tous à la même adresse (permet d'utiliser des variables pouvant avoir des types différents au cours du temps, mais un seul à un instant donné). Les champs peuvent être de tout type, y compris structures. On les utilise comme les structures, avec les opérateurs "." et "->".

Exercice (tel) A l'aide d'un tableau de personnes (nom, prénom, numéro dans la rue, rue, code postal, ville, numéro de téléphone), faire un programme de recherche automatique de toutes les informations sur les personnes répondant à une valeur d'une rubrique donnée (tous les PATRICK , tous ceux d'Obernai, travaillant à l'IPST, etc...). On suppose que le tableau est déjà initialisé. Cliquez ici pour une solution.

Structures chaînées

Le principal problème des données stockées sous forme de tableaux est que celles-ci doivent être ordonnées : le "suivant" doit toujours être stocké physiquement derrière. Imaginons gérer une association. Un tableau correspond à une gestion dans un cahier : un adhérent par page. Supposons désirer stocker les adhérents par ordre alphabétique. Si un nouvel adhérent se présente, il va falloir trouver où l'insérer, gommer toutes les pages suivantes pour les réécrire une page plus loin, puis insérer le nouvel adhérent. Une solution un peu plus simple serait de numéroter les pages, entrer les adhérents dans n'importe quel ordre et disposer d'un index : un feuille où sont indiqués les noms, dans l'ordre, associés à leur "adresse" : le numéro de page. Toute insertion ne nécessitera de décalages que dans l'index. Cette méthode permet l'utilisation de plusieurs index (par exemple un second par date de naissance). La troisième solution est la liste chaînée : les pages sont numérotées, sur chaque page est indiquée la page de l'adhérent suivant, sur le revers de couverture on indique l'adresse du premier. L'utilisation d'une telle liste nécessite un véritable "jeu de piste", mais l'insertion d'un nouvel adhérent se fera avec le minimum d'opérations.

Appliquons cela , de manière informatique, à une liste d'entiers, avec pour chaque valeur l'adresse (numéro de mémoire) du suivant :

liste

Si l'on veut insérer une valeur dans la liste, les modifications à apporter sont minimes :

insertion

En C on définira un type structure regroupant une valeur entière et un pointeur :
struct page {int val; struct page *suivant; };

Un pointeur (souvent global) nous indiquera toujours le début de la liste:
struct page *premier;

Au fur et à mesure des besoins on se crée une nouvelle page :
nouveau=(struct page *)malloc(sizeof(struct page));

En n'oubliant pas de préciser le lien avec le précédent :
precedent->suivant=nouveau;

le dernier élément ne doit pas pointer sur n'importe quoi, on choisit généralement soit le pointeur NULL, soit le premier (la liste est dite bouclée).

exemple :

#include <stdio.h>
#include <conio.h>
#include <ctype.h>
#include <alloc.h> /*ou stdlib.h*/
struct page {int val; struct page *suivant; };
struct page *premier;

int encore(void) /* demande si on en veut encore*/ { printf("encore (O/N) ? "); return(toupper(getche())= ='O'); } void lecture(void) { struct page *precedent,*nouveau; premier=(struct page *)malloc(sizeof(struct page)); puts("entrez votre premier entier"); scanf("%d",&premier->val); precedent=premier; while (encore()) { nouveau=(struct page *)malloc(sizeof(struct page)); precedent->suivant=nouveau; precedent=nouveau; puts("\nentrez votre entier"); scanf("%d",&nouveau->val); } precedent->suivant=NULL; } void affiche(struct page *debut) { printf("\nliste : "); while(debut!=NULL) { printf("%d ",debut->val); debut=debut->suivant; } printf("\n"); } int main(void) { lecture(); affiche(premier); }
Exercice (liste) : modifier la fonction lecture ci-dessus pour que la liste soit stockée dans l'ordre inverse de son introduction (chaque nouvel élément est placé devant la liste déjà existante).
Cliquez ici pour une solution de cet exercice (et du suivant).

Les modifications sont aisées, une fois que l'on a repéré l'endroit de la modification. Exemple : suppression d'un élément :

void suppression(void)
 {
  struct page *actu,*prec;
  actu=premier;
  while (actu!=NULL)
   {
    printf("\nvaleur : %d - supprimer celui_ci (O/N) ? ",
	    actu->val);
    if (toupper(getche())= ='O')
     {
      if(actu= =premier)premier=actu->suivant;
      else prec->suivant=actu->suivant;
      free(actu);
      break;
     }
    else
     {
      prec=actu;
      actu=prec->suivant;
     }
   }
 }
Exercice (insertion) : ajouter au programme précédent une procédure d'insertion d'une valeur dans la liste.
La solution de l'exercice précédent contient également cette insertion

Ce type de données (structure pointant sur un même type) est utilisé dans d'autres cas. Par exemple, pour représenter un arbre, il suffit pour chaque élément de connaître l'adresse de chaque fils :
arbre

Remarque : si le nombre de fils n'est pas constant, on a intérêt à stocker uniquement le fils aîné, ainsi que le frère suivant(voir partie algorithmique et structures de données).


précédent suivant haut Contents Index