Cours de C/C++


précédentsommairesuivant

1. Première approche du C/C++

Le C/C++ est un langage procédural, du même type que le Pascal par exemple. Cela signifie que les instructions sont exécutées linéairement et regroupées en blocs : les fonctions et les procédures (les procédures n'existent pas en C/C++, ce sont des fonctions qui ne retournent pas de valeur).

Tout programme a pour but d'effectuer des opérations sur des données. La structure fondamentale est donc la suivante :

 
Sélectionnez

                        ENTRÉE DES DONNÉES
          (clavier, souris, fichier, autres périphériques)
                                |
                      TRAITEMENT DES DONNÉES
                                |
                        SORTIE DES DONNÉES
         (écran, imprimante, fichier, autres périphériques)
 

Ces diverses étapes peuvent être dispersées dans le programme. Par exemple, les entrées peuvent se trouver dans le programme même (l'utilisateur n'a dans ce cas pas besoin de les saisir). Pour la plupart des programmes, les données en entrée proviennent du flux d'entrée standard, et les données émises en sortie sont dirigées vers le flux de sortie standard. Toutefois, le processus d'entrée des données peut être répété autant de fois que nécessaire pendant l'exécution d'un programme, et les données traitées au fur et à mesure qu'elles apparaissent. Par exemple, pour les programmes graphiques, les données sont reçues de la part du système sous forme de messages caractérisant les événements générés par l'utilisateur ou par le système lui-même (déplacement de souris, fermeture d'une fenêtre, appui sur une touche, etc.). Le traitement des programmes graphiques est donc une boucle infinie (que l'on appelle la boucle des messages), qui permet de récupérer les messages et de prendre les actions en conséquence. Dans ce cas, la sortie des données correspond au comportement que le programme adopte en réponse à ces messages. Cela peut être tout simplement d'afficher les données saisies, ou, plus généralement, d'appliquer une commande aux données en cours de manipulation.

Les données manipulées sont stockées dans des variables, c'est-à-dire des zones de la mémoire. Comme leur nom l'indique, les variables peuvent être modifiées (par le traitement des données). Des opérations peuvent donc être effectuées sur les variables, mais pas n'importe lesquelles. Par exemple, on ne peut pas ajouter des pommes à des bananes, sauf à définir cette opération bien précisément. Les opérations dépendent donc de la nature des variables. Afin de réduire les risques d'erreurs de programmation, les langages comme le C/C++ donnent un type à chaque variable (par exemple : pomme et banane). Lors de la compilation (phase de traduction du texte source du programme en exécutable), ces types sont utilisés pour vérifier si les opérations effectuées sont autorisées. Le programmeur peut évidemment définir ses propres types.

Le langage fournit des types de base et des opérations prédéfinies sur ces types. Les opérations qui peuvent être faites sont soit l'application d'un opérateur, soit l'application d'une fonction sur les variables. Logiquement parlant, il n'y a pas de différence. Seule la syntaxe change :

a=2+3

est donc strictement équivalent à :

a=ajoute(2,3)

Évidemment, des fonctions utilisateur peuvent être définies. Les opérateurs ne peuvent être que surchargés : il est impossible d'en définir de nouveaux (de plus, la surcharge des opérateurs n'est faisable qu'en C++). La notion de surcharge de fonction sera décrite en détail ci-dessous, dans la Section 1.6.4.

Cette première partie est donc consacrée à la définition des types, la déclaration des variables, la construction et l'appel de fonctions, et aux entrées / sorties de base (flux d'entrée / sortie standards).

1.1. Les commentaires en C++

Les commentaires sont nécessaires et très simples à faire. Tout programme doit être commenté. Attention cependant, trop de commentaires tue le commentaire, parce que les choses importantes sont noyées dans les banalités.

Il existe deux types de commentaires en C++ : les commentaires de type C et les commentaires de fin de ligne (qui ne sont disponibles qu'en C++).

Les commentaires C commencent avec la séquence barre oblique - étoile. Les commentaires se terminent avec la séquence inverse : une étoile suivie d'une barre oblique.

Exemple 1-1. Commentaire C
Sélectionnez

/*   Ceci est un commentaire C   */
 

Ces commentaires peuvent s'étendre sur plusieurs lignes.

En revanche, les commentaires de fin de lignes s'arrêtent à la fin de la ligne courante, et pas avant. Ils permettent de commenter plus facilement les actions effectuées sur la ligne courante, avant le commentaire. Les commentaires de fin de ligne commencent par la séquence constituée de deux barres obliques (ils n'ont pas de séquence de terminaison, puisqu'ils ne se terminent qu'à la fin de la ligne courante). Par exemple :

Exemple 1-2. Commentaire C++
Sélectionnez

action quelconque     // Ceci est un commentaire C++
action suivante
 

1.2. Les types prédéfinis du C/C++

Le C, et encore plus le C++, est un langage typé. Cela signifie que chaque entité manipulée dans les programmes doit disposer d'un type de donnée grâce auquel le compilateur pourra vérifier la validité des opérations qu'on lui appliquera. La prise en compte du type des données peut apparaître comme une contrainte pour le programmeur, mais en réalité il s'agit surtout d'une aide à la détection des erreurs.

Il existe plusieurs types prédéfinis. Ce sont :
  • le type vide : void. Ce type est utilisé pour spécifier le fait qu'il n'y a pas de type. Cela a une utilité pour faire des procédures (fonctions ne renvoyant rien) et les pointeurs sur des données non typées (voir plus loin) ;
  • les booléens : bool, qui peuvent prendre les valeurs true et false (en C++ uniquement, ils n'existent pas en C) ;
  • les caractères : char ;
  • les caractères longs : wchar_t (ce n'est un type de base que pour le langage C++, mais il est également défini dans la bibliothèque standard C et est donc utilisable malgré tout en C) ;
  • les entiers : int ;
  • les réels : float ;
  • les réels en double précision : double ;
  • les tableaux à une dimension, dont les indices sont spécifiés par des crochets ('[' et ']'). Pour les tableaux de dimension supérieure ou égale à 2, on utilisera des tableaux de tableaux ;
  • les structures, unions et énumérations (voir plus loin).

Les types entiers (int) peuvent être caractérisés d'un des mots clés long ou short. Ces mots clés permettent de modifier la taille du type, c'est-à-dire la plage de valeurs qu'ils peuvent couvrir. De même, les réels en double précision peuvent être qualifiés du mot clé long, ce qui augmente leur plage de valeurs. On ne peut pas utiliser le mot clé short avec les double.

On dispose donc de types additionnels :
  • les entiers longs : long int, ou long (int est facultatif) ;
  • les entiers courts : short int, ou short ;
  • les réels en quadruple précision : long double.

Note : Attention ! Il n'y a pas de type de base permettant de manipuler les chaînes de caractères. En C/C++, les chaînes de caractères sont en réalité des tableaux de caractères. Vous trouverez plus loin pour de plus amples informations sur les chaînes de caractères et les tableaux.

La taille des types n'est spécifiée dans aucune norme. La seule chose qui est indiquée dans la norme C++, c'est que le plus petit type est le type char. Les tailles des autres types sont donc des multiples de celle du type char. De plus, les inégalités suivantes sont toujours vérifiées :

 
Sélectionnez

char = short int = int = long int
float = double = long double
 

où l'opérateur « = » signifie ici « a une plage de valeur plus petite ou égale que ». Cela dit, les tailles des types sont généralement les mêmes pour tous les environnements de développement. Le type char est généralement codé sur un octet (8 bits), le type short int sur deux octets et le type long int sur quatre octets. Le type int est celui qui permet de stocker les entiers au format natif du processeur utilisé. Il est donc codé sur deux octets sur les machines 16 bits et sur quatre octets sur les machines 32 bits. Enfin, la taille des caractères de type wchar_t n'est pas spécifiée et dépend de l'environnement de développement utilisé. Ils sont généralement codés sur deux ou sur quatre octets suivant la représentation utilisée pour les caractères larges.

Note : Remarquez que, d'après ce qui précède, le type int devrait être codé sur 64 bits sur les machines 64 bits. Le type long int devant lui être supérieur, il doit également être codé sur 64 bits ou plus. Le type short int peut alors être sur 16 ou sur 32 bits. Il n'existe donc pas, selon la norme, de type permettant de manipuler les valeurs 16 bits sur les machines 64 bits si le type short int est codé sur 32 bits, ou, inversement, de type permettant de manipuler les valeurs 32 bits si le type short int est codé sur 16 bits.

Afin de résoudre ces problèmes, la plupart des compilateurs brisent la règle selon laquelle le type int est le type des entiers natifs du processeur, et fixent sa taille à 32 bits quelle que soit l'architecture utilisée. Ainsi, le type short est toujours codé sur 16 bits, le type int sur 32 bits et le type long sur 32 ou 64 bits selon que l'architecture de la machine est 32 ou 64 bits. Autrement dit, le type qui représente les entiers nativement n'est plus le type int, mais le type long. Cela ne change pas les programmes 32 bits, puisque ces deux types sont identiques dans ce cas. Les programmes destinés aux machines 64 bits pourront quant à eux être optimisés en utilisant le type long à chaque fois que l'on voudra utiliser le type de données natif de la machine cible. Les programmes 16 bits en revanchent ne sont en revanche plus compatibles avec ces règles, mais la plupart des compilateurs actuels ne permettent plus de compiler des programmes 16 bits de toutes manières.

Les types char, wchar_t et int peuvent être signés ou non. Un nombre signé peut être négatif, pas un nombre non signé. Lorsqu'un nombre est signé, la valeur absolue du plus grand nombre représentable est plus petite. Par défaut, les nombres entiers sont signés. Le signe des types char et wchar_t dépend du compilateur utilisé, il est donc préférable de spécifier systématiquement si ces types sont signés ou non lorsqu'on les utilise en tant que type entier. Pour préciser qu'un nombre n'est pas signé, il faut utiliser le mot clé unsigned. Pour préciser qu'un nombre est signé, on peut utiliser le mot clé signed. Ces mots clés peuvent être intervertis librement avec les mots clés long et short pour les types entiers.

Exemple 1-3. Types signés et non signés
Sélectionnez

unsigned char
signed char
unsigned wchar_t
signed wchar_t
unsigned int
signed int
unsigned long int
long unsigned int
 

Note : Le C++ (et le C++ uniquement) considère les types char et wchar_t comme les types de base des caractères. Le langage C++ distingue donc les versions signées et non signées de ces types de la version dont le signe n'est pas spécifié, puisque les caractères n'ont pas de notion de signe associée. Cela signifie que les compilateurs C++ traitent les types char, unsigned char et signed char comme des types différents, et il en est de même pour les types wchar_t, signed wchar_t et unsigned wchar_t. Cette distinction n'a pas lieu d'être au niveau des plages de valeurs si l'on connaît le signe du type utilisé en interne pour représenter les types char et wchar_t, mais elle est très importante dans la détermination de la signature des fonctions, en particulier au niveau du mécanisme de surcharge des fonctions. Les notions de signature et de surcharge des fonctions seront détaillées plus loin dans ce cours.

Les valeurs accessibles avec les nombres signés ne sont pas les mêmes que celles accessibles avec les nombres non signés. En effet, un bit est utilisé pour le signe dans les nombres signés. Par exemple, si le type char est codé sur 8 bits, on peut coder les nombres allant de 0 à 255 avec ce type en non signé (il y a 8 chiffres binaires, chacun peut valoir 0 ou 1, on a donc 2 puissance 8 combinaisons possibles, ce qui fait 256). En signé, les valeurs s'étendent de -128 à 127 (un des chiffres binaires est utilisé pour le signe, il en reste 7 pour coder le nombre, donc il reste 128 possibilités dans les positifs comme dans les négatifs. 0 est considéré comme positif. En tout, il y a autant de possibilités.).

De même, si le type int est codé sur 16 bits (cas des machines 16 bits), les valeurs accessibles vont de -32768 à 32767 ou de 0 à 65535 si l'entier n'est pas signé. C'est le cas sur les PC en mode réel (c'est-à-dire sous DOS) et sous Windows 3.x. Sur les machines fonctionnant en 32 bits, le type int est stocké sur 32 bits : l'espace des valeurs disponibles est donc 65536 fois plus large. C'est le cas sur les PC en mode protégé 32 bits (Windows 9x ou NT, DOS Extender, Linux) et sur les Macintosh. Sur les machines 64 bits, le type int devrait être 64 bits (DEC Alpha et la plupart des machines UNIX par exemple).

Enfin, le type float est généralement codé sur 4 octets, et les types double et long double sont souvent identiques et codés sur 8 octets.

Note : On constate donc que la portabilité des types de base est très aléatoire. Cela signifie qu'il faut faire extrêmement attention dans le choix des types si l'on veut faire du code portable (c'est-à-dire qui compilera et fonctionnera sans modification du programme sur tous les ordinateurs). Il est dans ce cas nécessaire d'utiliser des types de données qui donnent les mêmes intervalles de valeurs sur tous les ordinateurs. La norme ISO C99 impose de définir des types portables afin de régler ces problèmes sur toutes les architectures existantes. Ces types sont définis dans le fichier d'en-tête stdint.h. Il s'agit des types int8_t, int16_t, int32_t et int64_t, et de leurs versions non signées uint8_t, uint16_t, uint32_t et uint64_t. La taille de ces types en bits est indiquée dans leur nom et leur utilisation ne devrait pas poser de problème.

De la même manière, deux représentations d'un même type peuvent être différentes en mémoire sur deux machines d'architectures différentes, même à taille égale en nombre de bits. Le problème le plus courant est l'ordre de stockage des octets en mémoire pour les types qui sont stockés sur plus d'un octet (c'est-à-dire quasiment tous). Cela a une importance capitale lorsque des données doivent être échangées entre des machines d'architectures a priori différentes, par exemple dans le cadre d'une communication réseau, ou lors de la définition des formats de fichiers. Une solution simple est de toujours d'échanger les données au format texte, ou de choisir un mode de représentation de référence. Les bibliothèques réseau disposent généralement des méthodes permettant de convertir les données vers un format commun d'échange de données par un réseau et pourront par exemple être utilisées.

1.3. Notation des valeurs

Les entiers se notent de la manière suivante :
  • base 10 (décimale) : avec les chiffres de '0' à '9', et les signes '+' (facultatif) et '-'.
Exemple 1-4. Notation des entiers en base 10
Sélectionnez

12354, -2564
 
  • base 16 (hexadécimale) : avec les chiffres '0' à '9' et 'A' à 'F' ou a à f (A=a=10, B=b=11, ... F=f=15). Les entiers notés en hexadécimal devront toujours être précédés de « 0x » (qui indique la base). On ne peut pas utiliser le signe '-' avec les nombres hexadécimaux.
Exemple 1-5. Notation des entiers en base 16
Sélectionnez

0x1AE
 
  • base 8 (octale) : avec les chiffres de '0' à '7'. Les nombres octaux doivent être précédés d'un 0 (qui indique la base). Le signe '-' ne peut pas être utilisé.
Exemple 1-6. Notation des entiers en base 8
Sélectionnez

01, 0154
 

Les flottants (pseudo réels) se notent de la manière suivante :

[signe] chiffres [.[chiffres]][e|E [signe] exposant][f]

signe indique le signe. On emploie les signes '+' (facultatif) et '-' aussi bien pour la mantisse que pour l'exposant. 'e' ou 'E' permet de donner l'exposant du nombre flottant. L'exposant est facultatif. Si on ne donne pas d'exposant, on doit donner des chiffres derrière la virgule avec un point et ces chiffres. Le suffixe 'f' permet de préciser si le nombre est de type float ou non (auquel cas il s'agit d'un double).

Les chiffres après la virgule sont facultatifs, mais pas le point. Si on ne met ni le point, ni la mantisse, le nombre est un entier décimal.

Exemple 1-7. Notation des réels
Sélectionnez

-123.56f, 12e-12, 2
« 2 » est entier, « 2.f » est réel. 
 

Les caractères se notent entre guillemets simples :

 
Sélectionnez

'A', 'c', '('
 

On peut donner un caractère non accessible au clavier en donnant son code en octal, précédé du caractère '\'. Par exemple, le caractère 'A' peut aussi être noté '\101'. Remarquez que cette notation est semblable à la notation des nombres entiers en octal, et que le '0' initial est simplement remplacé par un '\'. Il est aussi possible de noter les caractères avec leur code en hexadécimal, à l'aide de la notation « \xNN », où NN est le code hexadécimal du caractère. Enfin, il existe des séquences d'échappement particulières qui permettent de coder certains caractères spéciaux plus facilement. Les principales séquences d'échappement sont les suivantes :

 
Sélectionnez

'\a'            Bip sonore
'\b'            Backspace
'\f'            Début de page suivante
'\r'            Retour à la ligne (sans saut de ligne)
'\n'            Passage à la ligne
'\t'            Tabulation
'\v'            Tabulation verticale
 

D'autres séquences d'échappement sont disponibles, afin de pouvoir représenter les caractères ayant une signification particulière en C :

 
Sélectionnez

'\\'            Le caractère \
'\"'            Le caractère "
'\''			Le caractère '
 

Bien qu'il n'existe pas à proprement parler de chaînes de caractères en C/C++, il est possible de définir des tableaux de caractères constants utilisables en tant que chaînes de caractères en donnant leur contenu entre doubles guillemets :

 
Sélectionnez

"Exemple de chaîne de caractères..."
 

Les caractères spéciaux peuvent être utilisés directement dans les chaînes de caractères constantes :

 
Sélectionnez

"Ceci est un saut de ligne :\nCeci est à la ligne suivante."
 

Si une chaîne de caractères constante est trop longue pour tenir sur une seule ligne, on peut concaténer plusieurs chaînes en les juxtaposant :

 
Sélectionnez

"Ceci est la première chaîne "   "ceci est la deuxième."
 

produit la chaîne de caractères complète suivante :

 
Sélectionnez

"Ceci est la première chaîne ceci est la deuxième."
 

Note : Attention : il ne faut pas mettre de caractère nul dans une chaîne de caractères. Ce caractère est en effet le caractère de terminaison de toute chaîne de caractères.

Enfin, les versions longues des différents types cités précédemment (wchar_t, long int et long double) peuvent être notées en faisant précéder ou suivre la valeur de la lettre 'L'. Cette lettre doit précéder la valeur dans le cas des caractères et des chaînes de caractères et la suivre quand il s'agit des entiers et des flottants. Par exemple :

 
Sélectionnez

L"Ceci est une chaîne de wchar_t."
2.3e5L
 

1.4. La définition des variables

Les variables simples peuvent être définies avec la syntaxe suivante :

 
Sélectionnez

type identificateur;
 

où type est le type de la variable et identificateur est son nom. Il est possible de créer et d'initialiser une série de variables dès leur création avec la syntaxe suivante :

 
Sélectionnez

type identificateur[=valeur][, identificateur[=valeur][...]];
 
Exemple 1-8. Définition de variables
Sélectionnez

int i=0, j=0;    /* Définit et initialise deux entiers à 0 */
double somme;    /* Déclare une variable réelle */
 

Les variables peuvent être définies quasiment n'importe où dans le programme. Cela permet de ne définir une variable temporaire que là où l'on en a besoin.

Note : Cela n'est vrai qu'en C++. En C pur, on est obligé de définir les variables au début des fonctions ou des instructions composées (voir plus loin). Il faut donc connaître les variables temporaires nécessaires à l'écriture du morceau de code qui suit leur définition.

La définition d'une variable ne suffit pas, en général, à l'initialiser. Les variables non initialisées contenant des valeurs aléatoires, il faut éviter de les utiliser avant une initialisation correcte. Initialiser les variables que l'on déclare à leur valeur par défaut est donc une bonne habitude à prendre. Cela est d'ailleurs obligatoire pour les variables « constantes » que l'on peut déclarer avec le mot clé const, car ces variables ne peuvent pas être modifiées après leur définition. Ce mot clé sera présenté en détail dans la Section 3.2.

Note : Si les variables utilisant les types simples ne sont pas initialisées lors de leur définition de manière générale, ce n'est pas le cas pour les objets dont le type est une classe définie par l'utilisateur. En effet, pour ces objets, le compilateur appelle automatiquement une fonction d'initialisation appelée le « constructeur » lors de leur définition. La manière de définir des classes d'objets ainsi que toutes les notions traitant de la programmation objet seront décrites dans le Chapitre 8.

La définition d'un tableau se fait en faisant suivre le nom de l'identificateur d'une paire de crochets, contenant le nombre d'élément du tableau :

 
Sélectionnez

type identificateur[taille]([taille](...));
 

Note : Attention ! Les caractères '[' et ']' étant utilisés par la syntaxe des tableaux, ils ne signifient plus les éléments facultatifs ici. Ici, et ici seulement, les éléments facultatifs sont donnés entre parenthèses.

Dans la syntaxe précédente, type représente le type des éléments du tableau.

Exemple 1-9. Définition d'un tableau
Sélectionnez

int MonTableau[100];

MonTableau est un tableau de 100 entiers. On référence les éléments des tableaux en donnant l'indice de l'élément entre crochet :

 
Sélectionnez

MonTableau[3]=0;

Note : La syntaxe permettant d'initialiser les tableaux dès leur création est un peu plus complexe que celle permettant d'initialiser les variables de type simple. Cette syntaxe est semblable à celle permettant d'initialiser les structures de données et sera donc décrite dans la section qui leur est dédiée.

En C/C++, les tableaux à plus d'une dimension sont des tableaux de tableaux. On prendra garde au fait que dans la définition d'un tableau à plusieurs dimensions, la dernière taille indiquée spécifie la taille du tableau dont on fait un tableau. Ainsi, dans l'exemple suivant :

 
Sélectionnez

int Matrice[5][4];
 

Matrice est un tableau de taille 5 dont les éléments sont eux-mêmes des tableaux de taille 4. L'ordre de déclaration des dimensions est donc inversé : 5 est la taille de la dernière dimension et 4 est la taille de la première dimension. L'élément suivant :

 
Sélectionnez

Matrice[2];
 

est donc le troisième élément de ce tableau de taille cinq, et est lui-même un tableau de quatre éléments.

En C/C++, les indices des tableaux varient de 0 à taille-1. Il y a donc bien taille éléments dans le tableau. Dans l'exemple donné ci-dessus, l'élément MonTableau[100] n'existe pas : y accéder plantera le programme. C'est au programmeur de vérifier que ses programmes n'utilisent jamais les tableaux avec des indices plus grands que leur taille ou négatifs.

Un autre point auquel il faudra faire attention est la taille des tableaux à utiliser pour les chaînes de caractères. Une chaîne de caractères se termine obligatoirement par le caractère nul ('\0'), il faut donc réserver de la place pour lui. Par exemple, pour créer une chaîne de caractères de 100 caractères au plus, il faut un tableau pour 101 caractères (déclaré avec « char chaine[101]; »).

1.5. Instructions et opérations

Les instructions sont généralement identifiées par le point virgule. C'est ce caractère qui marque la fin d'une instruction.

Exemple 1-10. Instruction vide
Sélectionnez

;    /* Instruction vide : ne fait rien ! */
 

Il existe plusieurs types d'instructions, qui permettent de réaliser des opérations variées. Les instructions les plus courantes sont sans doute les instructions qui effectuent des opérations, c'est-à-dire les instructions qui contiennent des expressions utilisant des opérateurs.

Les principales opérations utilisables en C/C++ sont les suivantes :
  • les affectations :
    variable = valeur

Note : Les affectations ne sont pas des instructions. Ce sont bien des opérations qui renvoient la valeur affectée. On peut donc effectuer des affectations multiples :

 
Sélectionnez

i=j=k=m=0;   /* Annule les variables i, j, k et m. */
 
  • les opérations de base du langage :
    valeur op valeur
    op est l'un des opérateurs suivants : +, -, *, /, %, &, |, ^, ~, <<, >>.

Note : '/' représente la division euclidienne pour les entiers et la division classique pour les flottants.

'%' représente la congruence (c'est-à-dire le reste de la division euclidienne). '|' et '&' représentent respectivement le ou et le et binaire (c'est-à-dire bit à bit : 1 et 1 = 1, 0 et x = 0, 1 ou x = 1 et 0 ou 0 = 0). '^' représente le ou exclusif (1 xor 1 = 0, 0 xor 0 = 0 et 1 xor 0 = 1). '~' représente la négation binaire (1 devient 0 et vice versa). '<<' et '>>' effectuent un décalage binaire vers la gauche et la droite respectivement, d'un nombre de bits égal à la valeur du second opérande.

  • les opérations des autres opérateurs du langage. Le C et le C++ disposent d'opérateurs un peu plus évolués que les opérateurs permettant de réaliser les opérations de base du langage. Ces opérateurs sont les opérateurs d'incrémentation et de décrémentation ++ et --, l'opérateur ternaire d'évaluation conditionnelle d'une expression (opérateur ?:) et l'opérateur virgule (opérateur ,). La syntaxe de ces opérateurs est décrite ci-dessous.
  • les appels de fonctions. Nous verrons comment écrire et appeler des fonctions dans les sections suivantes.

Bien entendu, la plupart des instructions contiendront des affectations. Ce sont donc sans doute les affectations qui sont les plus utilisées parmi les diverses opérations réalisables, aussi le C et le C++ permettent-ils l'utilisation d'affectations composées. Une affectation composée est une opération permettant de réaliser en une seule étape une opération normale et l'affectation de son résultat dans la variable servant de premier opérande. Les affectations composées utilisent la syntaxe suivante :

 
Sélectionnez

variable op_aff valeur
 

op_aff est l'un des opérateurs suivants : '+=', '-=', '*=', etc. Cette syntaxe est strictement équivalente à :

 
Sélectionnez

variable = variable op valeur
 

et permet donc de modifier la valeur de variable en lui appliquant l'opérateur op.

Exemple 1-11. Affectation composée
Sélectionnez

i*=2;        /* Multiplie i par 2 : i = i * 2. */
 

Les opérateurs d'incrémentation et de décrémentation ++ et -- s'appliquent comme des préfixes ou des suffixes sur les variables. Lorsqu'ils sont en préfixe, la variable est incrémentée ou décrémentée, puis sa valeur est renvoyée. S'ils sont en suffixe, la valeur de la variable est renvoyée, puis la variable est incrémentée ou décrémentée. Par exemple :

 
Sélectionnez

int i=2,j,k;
 
j=++i;   /* À la fin de cette instruction, i et j valent 3. */
k=j++;   /* À la fin de cette ligne, k vaut 3 et j vaut 4. */
 

Note : On prendra garde à n'utiliser les opérateurs d'incrémentation et de décrémentation postfixés que lorsque cela est réellement nécessaire. En effet, ces opérateurs doivent contruire un objet temporaire pour renvoyer la valeur de la variable avant incrémentation ou décrémentation. Si cet objet temporaire n'est pas utilisé, il est préférable d'utiliser les versions préfixées de ces opérateurs.

L'opérateur ternaire d'évaluation conditionnelle ?: est le seul opérateur qui demande 3 paramètres (à part l'opérateur fonctionnel () des fonctions, qui admet n paramètres, et que l'on décrira plus tard). Cet opérateur permet de réaliser un test sur une condition et de calculer une expression ou une autre selon le résultat de ce test. La syntaxe de cet opérateur est la suivante :

 
Sélectionnez

test ? expression1 : expression2
 

Dans cette syntaxe, test est évalué en premier. Son résultat doit être booléen ou entier. Si test est vrai (ou si sa valeur est non nulle), expression1 est calculée et sa valeur est renvoyée. Sinon, c'est la valeur de expression2 qui est renvoyée. Par exemple, l'expression :

 
Sélectionnez

Min=(i<j)?i:j;
 

calcule le minimum de i et de j.

L'opérateur virgule, quant à lui, permet d'évaluer plusieurs expressions successivement et de renvoyer la valeur de la dernière expression. La syntaxe de cet opérateur est la suivante :

 
Sélectionnez

expression1,expression2[,expression3[...]]
 

expression1, expression2, etc. sont les expressions à évaluer. Les expressions sont évaluées de gauche à droite, puis le type et la valeur de la dernière expression sont utilisés pour renvoyer le résultat. Par exemple, à l'issue des deux lignes suivantes :

 
Sélectionnez

double r = 5;
int i = r*3,1;
 

r vaut 5 et i vaut 1. r*3 est calculé pour rien.

Note : Ces deux derniers opérateurs peuvent nuire gravement à la lisibilité des programmes. Il est toujours possible de réécrire les lignes utilisant l'opérateur ternaire avec un test (voir la Section 2.1 pour la syntaxe des tests en C/C++). De même, on peut toujours décomposer une expression utilisant l'opérateur virgule en deux instructions distinctes. Ce dernier opérateur ne devra donc jamais être utilisé.

Il est possible de créer des instructions composées, constituées d'instructions plus simples. Les instructions composées se présentent sous la forme de bloc d'instructions où les instructions contenues sont encadrées d'accolades ouvrantes et fermantes (caractères '{ et '}').

Exemple 1-12. Instruction composée
Sélectionnez

{
    i=1;
    j=i+3*g;
}
 

Note : Un bloc d'instructions est considéré comme une instruction unique. Il est donc inutile de mettre un point virgule pour marquer l'instruction, puisque le bloc lui-même est une instruction.

Enfin, il existe tout un jeu d'instructions qui permettent de modifier le cours de l'exécution du programme, comme les tests, les boucles et les sauts. Ces instructions seront décrites en détail dans le chapitre traitant des structures de contrôle.

1.6. Les fonctions

Le C++ ne permet de faire que des fonctions, pas de procédures. Une procédure peut être faite en utilisant une fonction ne renvoyant pas de valeur ou en ignorant la valeur retournée.

1.6.1. Définition des fonctions

La définition des fonctions se fait comme suit :

 
Sélectionnez

type identificateur(paramètres)
{
    ...   /* Instructions de la fonction. */
}

type est le type de la valeur renvoyée, identificateur est le nom de la fonction, et paramètres est une liste de paramètres. La syntaxe de la liste de paramètres est la suivante :

 
Sélectionnez

type variable [= valeur] [, type variable [= valeur] [...]]
 

où type est le type du paramètre variable qui le suit et valeur sa valeur par défaut. La valeur par défaut d'un paramètre est la valeur que ce paramètre prend si aucune valeur ne lui est attribuée lors de l'appel de la fonction.

Note : L'initialisation des paramètres de fonctions n'est possible qu'en C++, le C n'accepte pas cette syntaxe.

La valeur de la fonction à renvoyer est spécifiée en utilisant la commande return, dont la syntaxe est :

return valeur;

Exemple 1-13. Définition de fonction
Sélectionnez

int somme(int i, int j)
{
    return i+j;
}
 

Si une fonction ne renvoie pas de valeur, on lui donnera le type void. Si elle n'attend pas de paramètres, sa liste de paramètres sera void ou n'existera pas. Il n'est pas nécessaire de mettre une instruction return à la fin d'une fonction qui ne renvoie pas de valeur.

Exemple 1-14. Définition de procédure
Sélectionnez

void rien()     /* Fonction n'attendant pas de paramètres */
{               /* et ne renvoyant pas de valeur. */
    return;     /* Cette ligne est facultative. */
}
 

1.6.2. Appel des fonctions

L'appel d'une fonction se fait en donnant son nom, puis les valeurs de ses paramètres entre parenthèses. Attention ! S'il n'y a pas de paramètres, il faut quand même mettre les parenthèses, sinon la fonction n'est pas appelée.

Exemple 1-15. Appel de fonction
Sélectionnez

int i=somme(2,3);
rien();
 

Si la déclaration comprend des valeurs par défaut pour des paramètres (C++ seulement), ces valeurs sont utilisées lorsque ces paramètres ne sont pas fournis lors de l'appel. Si un paramètre est manquant, alors tous les paramètres qui le suivent doivent eux aussi être omis. Il en résulte que seuls les derniers paramètres d'une fonction peuvent avoir des valeurs par défaut. Par exemple :

 
Sélectionnez

int test(int i = 0, int j = 2)
{
    return i/j;
}
 

L'appel de la fonction test(8) est valide. Comme on ne précise pas le dernier paramètre, j est initialisé à 2. Le résultat obtenu est donc 4. De même, l'appel test() est valide : dans ce cas i vaut 0 et j vaut 2. En revanche, il est impossible d'appeler la fonction test en ne précisant que la valeur de j. Enfin, l'expression « int test(int i=0, int j) {...} » serait invalide, car si on ne passait pas deux paramètres, j ne serait pas initialisé.

1.6.3. Déclaration des fonctions

Toute fonction doit être déclarée avant d'être appelée pour la première fois. La définition d'une fonction peut faire office de déclaration.

Il peut se trouver des situations où une fonction doit être appelée dans une autre fonction définie avant elle. Comme cette fonction n'est pas définie au moment de l'appel, elle doit être déclarée. De même, il est courant d'avoir à appeler une fonction définie dans un autre fichier que le fichier d'où se fait l'appel. Encore une fois, il est nécessaire de déclarer ces fonctions.

Le rôle des déclarations est donc de signaler l'existence des fonctions aux compilateurs afin de les utiliser, tout en reportant leur définition plus loin ou dans un autre fichier.

La syntaxe de la déclaration d'une fonction est la suivante :

type identificateur(paramètres);

où type est le type de la valeur renvoyée par la fonction, identificateur est son nom et paramètres la liste des types des paramètres que la fonction admet, éventuellement avec leurs valeurs par défaut, et séparés par des virgules.

Exemple 1-16. Déclaration de fonction
Sélectionnez

int Min(int, int);        /* Déclaration de la fonction minimum */
                          /* définie plus loin. */
/* Fonction principale. */
int main(void)
{
    int i = Min(2,3);     /* Appel à la fonction Min, déjà
                             déclarée. */
    return 0;
}
 
/* Définition de la fonction min. */
int Min(int i, int j)
{
    if (i<j) return i;
    else return j;
}
 

Si l'on donne des valeurs par défaut différentes aux paramètres d'une fonction dans plusieurs déclarations différentes, les valeurs par défaut utilisées sont celles de la déclaration visible lors de l'appel de la fonction. Si plusieurs déclarations sont visibles et entrent en conflit au niveau des valeurs par défaut des paramètres de la fonction, le compilateur ne saura pas quelle déclaration utiliser et signalera une erreur à la compilation. Enfin, il est possible de compléter la liste des valeurs par défaut de la déclaration d'une fonction dans sa définition. Dans ce cas, les valeurs par défaut spécifiées dans la définition ne doivent pas entrer en conflit avec celles spécifiées dans la déclaration visible au moment de la définition, faute de quoi le compilateur signalera une erreur.

1.6.4. Surcharge des fonctions

Il est interdit en C de définir plusieurs fonctions qui portent le même nom. En C++, cette interdiction est levée, moyennant quelques précautions. Le compilateur peut différencier deux fonctions en regardant le type des paramètres qu'elle reçoit. La liste de ces types s'appelle la signature de la fonction. En revanche, le type du résultat de la fonction ne permet pas de l'identifier, car le résultat peut ne pas être utilisé ou peut être converti en une valeur d'un autre type avant d'être utilisé après l'appel de cette fonction.

Il est donc possible de faire des fonctions de même nom (on les appelle alors des surcharges) si et seulement si toutes les fonctions portant ce nom peuvent être distinguées par leurs signatures. La surcharge qui sera appelée sera celle dont la signature est la plus proche des valeurs passées en paramètre lors de l'appel.

Exemple 1-17. Surcharge de fonctions
Sélectionnez

float test(int i, int j)
{
    return (float) i+j;
}
 
float test(float i, float j)
{
    return i*j;
}
 

Ces deux fonctions portent le même nom, et le compilateur les acceptera toutes les deux. Lors de l'appel de test(2,3), ce sera la première qui sera appelée, car 2 et 3 sont des entiers. Lors de l'appel de test(2.5,3.2), ce sera la deuxième, parce que 2.5 et 3.2 sont réels. Attention ! Dans un appel tel que test(2.5,3), le flottant 2.5 sera converti en entier et la première fonction sera appelée. Il convient donc de faire très attention aux mécanismes de surcharge du langage, et de vérifier les règles de priorité utilisées par le compilateur.

On veillera à ne pas utiliser des fonctions surchargées dont les paramètres ont des valeurs par défaut, car le compilateur ne pourrait pas faire la distinction entre ces fonctions. D'une manière générale, le compilateur dispose d'un ensemble de règles (dont la présentation dépasse le cadre de ce livre) qui lui permettent de déterminer la meilleure fonction à appeler étant donné un jeu de paramètres. Si, lors de la recherche de la fonction à utiliser, le compilateur trouve des ambiguïtés, il génére une erreur.

1.6.5. Fonctions inline

Le C++ dispose du mot clé inline, qui permet de modifier la méthode d'implémentation des fonctions. Placé devant la déclaration d'une fonction, il propose au compilateur de ne pas instancier cette fonction. Cela signifie que l'on désire que le compilateur remplace l'appel de la fonction par le code correspondant. Si la fonction est grosse ou si elle est appelée souvent, le programme devient plus gros, puisque la fonction est réécrite à chaque fois qu'elle est appelée. En revanche, il devient nettement plus rapide, puisque les mécanismes d'appel de fonctions, de passage des paramètres et de la valeur de retour sont ainsi évités. De plus, le compilateur peut effectuer des optimisations additionnelles qu'il n'aurait pas pu faire si la fonction n'était pas inlinée. En pratique, on réservera cette technique pour les petites fonctions appelées dans du code devant être rapide (à l'intérieur des boucles par exemple), ou pour les fonctions permettant de lire des valeurs dans des variables.

Cependant, il faut se méfier. Le mot clé inline est un indice indiquant au compilateur de faire des fonctions inline. Il n'y est pas obligé. La fonction peut donc très bien être implémentée classiquement. Pire, elle peut être implémentée des deux manières, selon les mécanismes d'optimisation du compilateur. De même, le compilateur peut également inliner les fonctions normales afin d'optimiser les performances du programme.

De plus, il faut connaître les restrictions des fonctions inline :

elles ne peuvent pas être récursives ;

elles ne sont pas instanciées, donc on ne peut pas faire de pointeur sur une fonction inline.

Si l'une de ces deux conditions n'est pas vérifiée pour une fonction, le compilateur l'implémentera classiquement (elle ne sera donc pas inline).

Enfin, du fait que les fonctions inline sont insérées telles quelles aux endroits où elles sont appelées, il est nécessaire qu'elles soient complètement définies avant leur appel. Cela signifie que, contrairement aux fonctions classiques, il n'est pas possible de se contenter de les déclarer pour les appeler, et de fournir leur définition dans un fichier séparé. Dans ce cas en effet, le compilateur générerait des références externes sur ces fonctions, et n'insérerait pas leur code. Ces références ne seraient pas résolues à l'édition de lien, car il ne génère également pas les fonctions inline, puisqu'elles sont supposées être insérées sur place lorsqu'on les utilise. Les notions de compilation dans des fichiers séparés et d'édition de liens seront présentées en détail dans le Chapitre 6.

Exemple 1-18. Fonction inline
Sélectionnez

inline int Max(int i, int j)
{
    if (i>j)
        return i;
    else
        return j;
}
 

Pour ce type de fonction, il est tout à fait justifié d'utiliser le mot clé inline.

1.6.6. Fonctions statiques

Par défaut, lorsqu'une fonction est définie dans un fichier C/C++, elle peut être utilisée dans tout autre fichier pourvu qu'elle soit déclarée avant son utilisation. Dans ce cas, la fonction est dite externe. Il peut cependant être intéressant de définir des fonctions locales à un fichier, soit afin de résoudre des conflits de noms (entre deux fonctions de même nom et de même signature mais dans deux fichiers différents), soit parce que la fonction est uniquement d'intérêt local. Le C et le C++ fournissent donc le mot clé static qui, une fois placé devant la définition et les éventuelles déclarations d'une fonction, la rend unique et utilisable uniquement dans ce fichier. À part ce détail, les fonctions statiques s'utilisent exactement comme des fonctions classiques.

Exemple 1-19. Fonction statique
Sélectionnez

// Déclaration de fonction statique :
static int locale1(void);
 
/* Définition de fonction statique : */
static int locale2(int i, float j)
{
    return i*i+j;
}
 

Les techniques permettant de découper un programme en plusieurs fichiers sources et de générer les fichiers binaires à partir de ces fichiers seront décrites dans le chapitre traitant de la modularité des programmes.

1.6.7. Fonctions prenant un nombre variable de paramètres

En général, les fonctions ont un nombre constant de paramètres. Pour les fonctions qui ont des paramètres par défaut en C++, le nombre de paramètres peut apparaître variable à l'appel de la fonction, mais en réalité, la fonction utilise toujours le même nombre de paramètres.

Le C et le C++ disposent toutefois d'un mécanisme qui permet au programmeur de réaliser des fonctions dont le nombre et le type des paramètres sont variables. Nous verrons plus loin que les fonctions d'entrée / sortie du C sont des fonctions dont la liste des arguments n'est pas fixée, cela afin de pouvoir réaliser un nombre arbitraire d'entrées / sorties, et ce sur n'importe quel type prédéfini.

En général, les fonctions dont la liste des paramètres est arbitrairement longue disposent d'un critère pour savoir quel est le dernier paramètre. Ce critère peut être le nombre de paramètres, qui peut être fourni en premier paramètre à la fonction, ou une valeur de paramètre particulière qui détermine la fin de la liste par exemple. On peut aussi définir les paramètres qui suivent le premier paramètre à l'aide d'une chaîne de caractères.

Pour indiquer au compilateur qu'une fonction peut accepter une liste de paramètres variable, il faut simplement utiliser des points de suspensions dans la liste des paramètres :

type identificateur(paramètres, ...)

dans les déclarations et la définition de la fonction. Dans tous les cas, il est nécessaire que la fonction ait au moins un paramètre classique. Les paramètres classiques doivent impérativement être avant les points de suspensions.

La difficulté apparaît en fait dans la manière de récupérer les paramètres de la liste de paramètres dans la définition de la fonction. Les mécanismes de passage des paramètres étant très dépendants de la machine (et du compilateur), un jeu de macros a été défini dans le fichier d'en-tête stdarg.h pour faciliter l'accès aux paramètres de la liste. Pour en savoir plus sur les macros et les fichiers d'en-tête, consulter le Chapitre 5. Pour l'instant, sachez seulement qu'il faut ajouter la ligne suivante :

 
Sélectionnez

#include <stdarg.h>
 

au début de votre programme. Cela permet d'utiliser le type va_list et les expressions va_start, va_arg et va_end pour récupérer les arguments de la liste de paramètres variable, un à un.

Le principe est simple. Dans la fonction, vous devez déclarer une variable de type va_list. Puis, vous devez initialiser cette variable avec la syntaxe suivante :

 
Sélectionnez

va_start(variable, paramètre);
 

variable est le nom de la variable de type va_list que vous venez de créer, et paramètre est le dernier paramètre classique de la fonction. Dès que variable est initialisée, vous pouvez récupérer un à un les paramètres à l'aide de l'expression suivante :

 
Sélectionnez

va_arg(variable, type)
 

qui renvoie le paramètre en cours avec le type type et met à jour variable pour passer au paramètre suivant. Vous pouvez utiliser cette expression autant de fois que vous le désirez, elle retourne à chaque fois un nouveau paramètre. Lorsque le nombre de paramètres correct a été récupéré, vous devez détruire la variable variable à l'aide de la syntaxe suivante :

 
Sélectionnez

va_end(variable);
 

Il est possible de recommencer ces étapes autant de fois que l'on veut, la seule chose qui compte est de bien faire l'initialisation avec va_start et de bien terminer la procédure avec va_end à chaque fois.

Note : Il existe une restriction sur les types des paramètres des listes variables d'arguments. Lors de l'appel des fonctions, un certain nombre de traitements a lieu sur les paramètres. En particulier, des promotions implicites ont lieu, ce qui se traduit par le fait que les paramètres réellement passés aux fonctions ne sont pas du type déclaré. Le compilateur continue de faire les vérifications de type, mais en interne, un type plus grand peut être utilisé pour passer les valeurs des paramètres. En particulier, les types char et short ne sont pas utilisés : les paramètres sont toujours promus aux type int ou long int. Cela implique que les seuls types que vous pouvez utiliser sont les types cibles des promotions et les types qui ne sont pas sujets aux promotions (pointeurs, structures et unions). Les types cibles dans les promotions sont déterminés comme suit :

  • les types char, signed char, unsigned char, short int ou unsigned short int sont promus en int si ce type est capable d'accepter toutes leurs valeurs. Si int est insuffisant, unsigned int est utilisé ;
  • les types des énumérations (voir plus loin pour la définition des énumérations) et wchar_t sont promus en int, unsigned int, long ou unsigned long selon leurs capacités. Le premier type capable de conserver la plage de valeur du type à promouvoir est utilisé ;
  • les valeurs des champs de bits sont converties en int ou unsigned int selon la taille du champ de bit (voir plus loin pour la définition des champs de bits) ;
  • les valeurs de type float sont converties en double.
Exemple 1-20. Fonction à nombre de paramètres variable
Sélectionnez

#include <stdarg.h>
 
/* Fonction effectuant la somme de "compte" paramètres : */
double somme(int compte, ...)
{
    double resultat=0;      /* Variable stockant la somme. */
    va_list varg;           /* Variable identifiant le prochain
                               paramètre. */
    va_start(varg, compte); /* Initialisation de la liste. */
    while (compte!=0)       /* Parcours de la liste. */
    {
        resultat=resultat+va_arg(varg, double);
        compte=compte-1;
    }
    va_end(varg);           /* Terminaison. */
    return resultat;
}

1.7. La fonction main

Lorsqu'un programme est chargé, son exécution commence par l'appel d'une fonction spéciale du programme. Cette fonction doit impérativement s'appeler « main » (principal en anglais) pour que le compilateur puisse savoir que c'est cette fonction qui marque le début du programme. La fonction main est appelée par le système d'exploitation, elle ne peut pas être appelée par le programme, c'est-à-dire qu'elle ne peut pas être récursive.

Exemple 1-21. Programme minimal
Sélectionnez

int main()   /* Plus petit programme C/C++. */
{
    return 0;
}
 

La fonction main doit renvoyer un code d'erreur d'exécution du programme, le type de ce code est int. Elle peut aussi recevoir des paramètres du système d'exploitation. Ceci sera expliqué plus loin. Pour l'instant, on se contentera d'une fonction main ne prenant pas de paramètre.

Note : Il est spécifié dans la norme du C++ que la fonction main ne doit pas renvoyer le type void. En pratique cependant, beaucoup de compilateurs l'acceptent également.

La valeur 0 retournée par la fonction main indique que tout s'est déroulé correctement. En réalité, la valeur du code de retour peut être interprétée différemment selon le système d'exploitation utilisé. La bibliothèque C définit donc les constantes EXIT_SUCCESS et EXIT_FAILURE, qui permettent de supprimer l'hypothèse sur la valeur à utiliser respectivement en cas de succès et en cas d'erreur.

1.8. Les fonctions d'entrée / sortie de base

Nous avons distingué au début de ce chapitre les programmes graphiques, qui traitent les événements qu'ils reçoivent du système sous la forme de messages, des autres programmes, qui reçoivent les données à traiter et écrivent leurs résultats sur les flux d'entrée / sortie standards. Les notions de flux d'entrée / sortie standards n'ont pas été définies plus en détail à ce moment, et il est temps à présent de pallier cette lacune.

1.8.1. Généralités sur les flux d'entrée / sortie en C

Un flux est une notion informatique qui permet de représenter un flot de données séquentielles en provenance d'une source de données ou à destination d'une autre partie du système. Les flux sont utilisés pour uniformiser la manière dont les programmes travaillent avec les données, et donc pour simplifier leur programmation. Les fichiers constituent un bon exemple de flux, mais ce n'est pas le seul type de flux existant : on peut traiter un flux de données provenant d'un réseau, d'un tampon mémoire ou de toute autre source de données ou partie du système permettant de traiter les données séquentiellement.

Sur quasiment tous les systèmes d'exploitation, les programmes disposent dès leur lancement de trois flux d'entrée / sortie standards. Généralement, le flux d'entrée standard est associé au flux de données provenant d'un terminal, et le flux de sortie standard à la console de ce terminal. Ainsi, les données que l'utilisateur saisit au clavier peuvent être lues par les programmes sur leur flux d'entrée standard, et ils peuvent afficher leurs résultats à l'écran en écrivant simplement sur leur flux de sortie standard. Le troisième flux standard est le flux d'erreur standard qui, par défaut, est également associé à l'écran, et sur lequel le programme peut écrire tous les messages d'erreur qu'il désire.

Note : La plupart des systèmes permettent de rediriger les flux standards des programmes afin de les faire travailler sur des données provenant d'une autre source de données que le clavier, ou, par exemple, de leur faire enregistrer leurs résultats dans un fichier. Il est même courant de réaliser des « pipelines » de programmes, où les résultats de l'un sont envoyés dans le flux d'entrée standard de l'autre, et ainsi de suite. Ces suites de programmes sont également appelés des tubes en français.

La manière de réaliser les redirections des flux standards dépend des systèmes d'exploitation et de leurs interfaces utilisateurs. De plus, les programmes doivent être capables de travailler avec leurs flux d'entrée / sortie standards de manière générique, que ceux-ci soient redirigés ou non. Les techniques de redirection ne seront donc pas décrites plus en détail ici.

Vous remarquerez l'intérêt d'avoir deux flux distincts pour les résultats des programmes et leurs messages d'erreur. Si, lors d'une utilisation normale, ces deux flux se mélangent à l'écran, ce n'est pas le cas lorsque l'on redirige le flux de sortie standard. Seul le flux d'erreur standard est affiché à l'écran dans ce cas, et les messages d'erreur ne se mélangent donc pas aux résultats du programme.

On pourrait penser que les programmes graphiques ne disposent pas de flux d'entrée / sortie standards. Pourtant, c'est généralement le cas. Les événements traités par les programmes graphiques dans leur boucle de messages ne proviennent généralement pas du flux d'entrée standard, mais d'une autre source de données spécifique à chaque système. En conséquence, les programmes graphiques peuvent toujours utiliser les flux d'entrée / sortie standard si cela s'avère nécessaire.

Afin de permettre aux programmes d'écrire sur leurs flux d'entrée / sortie standards, la bibliothèque C définit plusieurs fonctions extrêmement utiles. Les deux principales fonctions sont sans doute les fonctions printf et scanf. La fonction printf (« print formatted » en anglais) permet d'afficher des données à l'écran, et scanf (« scan formatted ») permet de les lire à partir du clavier.

En réalité, ces fonctions ne font rien d'autre que d'appeler deux autres fonctions permettant d'écrire et de lire des données sur un fichier : les fonctions fprintf et fscanf. Ces fonctions s'utilisent exactement de la même manière que les fonctions printf et scanf, à ceci près qu'elles prennent en premier paramètre une structure décrivant le fichier sur lequel elles travaillent. Pour les flux d'entrée / sortie standards, la bibliothèque C définit les pseudo-fichiers stdin, stdout et stderr, qui correspondent respectivement aux flux d'entrée, au flux de sortie et au flux d'erreur standards. Ainsi, tout appel à scanf se traduit par un appel à fscanf sur le pseudo-fichier stdin, et tout appel à printf par un appel à fprintf sur le pseudo-fichier stdout.

Note : Il n'existe pas de fonction permettant d'écrire directement sur le flux d'erreur standard. Par conséquent, pour effectuer de telles écritures, il faut impérativement passer par la fonction fprintf, en lui fournissant en paramètre le pseudo-fichier stderr.

La description des fonctions de la bibliothèque C standard dépasse de loin le cadre de ce cours. Aussi les fonctions de lecture et d'écriture sur les fichiers ne seront-elles pas décrites plus en détail ici. Seules les fonctions printf et scanf seront présentées, car elles sont réellement indispensable pour l'écriture d'un programme C. Consultez la bibliographie si vous désirez obtenir plus de détails sur la bibliothèque C et sur toutes les fonctions qu'elle contient.

Le C++ dispose également de mécanismes de gestion des flux d'entrée / sortie qui lui sont propres. Ces mécanismes permettent de contrôler plus finement les types des données écrites et lues de et à partir des flux d'entrée / sortie standards. De plus, ils permettent de réaliser les opérations d'écriture et de lecture des données formatées de manière beaucoup plus simple. Cependant, ces mécanismes requièrent des notions objets avancées et ne seront décrits que dans les chapitres dédiés au C++. Comme il est également possible d'utiliser les fonctions printf et scanf en C++ d'une part, et que, d'autre part, ces fonctions sont essentielles en C, la suite de cette section s'attachera à leur description. Un chapitre complet est dédié aux mécanismes de gestion des flux du C++ dans la deuxième partie de ce document.

Les fonctions printf et scanf sont toutes deux des fonctions à nombre de paramètres variables. Elles peuvent donc être utilisées pour effectuer des écritures et des lectures multiples en un seul appel. Afin de leur permettre de déterminer la nature des données passées dans les arguments variables, elles attendent toutes les deux en premier paramètre une chaîne de caractères descriptive des arguments suivants. Cette chaîne est appelée chaîne de format, et elle permet de spécifier avec précision le type, la position et les options de format (précision, etc.) des données à traiter. Les deux sections suivantes décrivent la manière d'utiliser ces chaînes de format pour chacune des deux fonctions printf et scanf.

1.8.2. La fonction printf

La fonction printf s'emploie comme suit :

 
Sélectionnez

printf(chaîne de format [, valeur [, valeur [...]]])
 

On peut passer autant de valeurs que l'on veut, pour peu qu'elles soient toutes référencées dans la chaîne de format. Elle renvoie le nombre de caractères affichés.

La chaîne de format peut contenir du texte, mais surtout elle doit contenir autant de formateurs que de variables à afficher. Si ce n'est pas le cas, le programme plantera. Les formateurs sont placés dans le texte là où les valeurs des variables doivent être affichées.

La syntaxe des formateurs est la suivante :

%[[indicateur]...][largeur][.précision][taille] type

Un formateur commence donc toujours par le caractère %. Pour afficher ce caractère sans faire un formateur, il faut le dédoubler (%%).

Le type de la variable à afficher est obligatoire lui aussi. Les types utilisables sont les suivants :

Tableau 1-1. Types pour les chaînes de format de printf

  Type de donnée à afficher Caractère de formatage
Numériques Entier décimal signé d
  Entier décimal non signé u ou i
  Entier octal non signé o
  Entier octal non signé x (avec les caractères 'a' à 'f') ou X (avec les caractères 'A' à 'F')
  Flottants de type double f, e, g, E ou G
Caractères Caractère isolé c
  Chaîne de caractères s
Pointeurs Pointeur p

Note : Voir le Chapitre 4 pour plus de détails sur les pointeurs. Le format des pointeurs dépend de la machine.

Les valeurs flottantes infinies sont remplacées par les mentions +INF et -INF. Un non-nombre IEEE (Not-A-Number) donne +NAN ou -NAN. Notez que le standard C ne permet de formater que des valeurs de type double. Les valeurs flottantes de type float devront donc être convertie en double avant affichage.

Les autres paramètres sont facultatifs.

Les valeurs disponibles pour le paramètre de taille sont les caractères suivants :

Tableau 1-2. Options pour les types des chaînes de format

Option Type utilisable Taille du type
F Pointeur Pointeur FAR (DOS uniquement)
N Pointeur Pointeur NEAR (DOS uniquement)
h Entier short int
l Entier, caractère ou chaîne de caractères long int ou wchar_t
L Flottant long double
Exemple 1-22. Utilisation de printf et fprintf
Sélectionnez

#include <stdio.h>  /* Ne pas chercher à comprendre cette ligne
                       pour l'instant. Elle est nécessaire pour utiliser
                       les fonctions printf et scanf.               */
int main(void)
{
    int i = 2;
    printf("Voici la valeur de i : %d.\n", i);
    /* Exemple d'écriture sur la sortie d'erreur standard : */
    fprintf(stderr, "Pas d'erreur jusqu'ici...\n");
    return 0;
}

Vous remarquerez dans cet exemple la présence d'une ligne #include <stdio.h>. Cette ligne est nécessaire pour permettre l'utilisation des fonctions printf et fprintf. Nous décrirons sa signification précise ultérieurement dans le chapitre sur le préprocesseur. Sans entrer dans les détails, disons simplement que cette ligne permet d'inclure un fichier contenant les déclarations de toutes les fonctions d'entrée / sortie de base.

Les paramètres indicateurs, largeur et précision sont moins utilisés. Il peut y avoir plusieurs paramètres indicateurs, ils permettent de modifier l'apparence de la sortie.

Les principales options sont :
  • '-' : justification à gauche de la sortie, avec remplissage à droite par des 0 ou des espaces ;
  • '+' : affichage du signe pour les nombres positifs ;
  • espace : les nombres positifs commencent tous par un espace.

Le paramètre largeur permet de spécifier la largeur minimale du champ de sortie, si la sortie est trop petite, on complète avec des 0 ou des espaces. Notez qu'il s'agit bien d'une largeur minimale ici et non d'une largeur maximale. Le résultat du formatage de la donnée à écrire peut donc dépasser la valeur indiquée pour la largeur du champ.

Enfin, le paramètre précision spécifie la précision maximale de la sortie (nombre de chiffres à afficher).

1.8.3. La fonction scanf

La fonction scanf permet de faire une ou plusieurs entrées. Comme la fonction printf, elle attend une chaîne de format en premier paramètre. Il faut ensuite passer les variables devant contenir les entrées dans les paramètres qui suivent. Sa syntaxe est la suivante :

 
Sélectionnez

scanf(chaîne de format, &variable [, &variable [...]]);

Elle renvoie le nombre de variables lues.

Ne cherchez pas à comprendre pour l'instant la signification du symbole & se trouvant devant chacune des variables. Sachez seulement que s'il est oublié, le programme plantera.

La chaîne de format peut contenir des chaînes de caractères. Toutefois, si elle contient autre chose que des formateurs, le texte saisi par l'utilisateur devra correspondre impérativement avec les chaînes de caractères indiquées dans la chaîne de format. scanf cherchera à reconnaître ces chaînes, et arrêtera l'analyse à la première erreur.

La syntaxe des formateurs pour scanf diffère un peu de celle de ceux de printf :

 
Sélectionnez

%[*][largeur][taille]type
 

Seul le paramètre largeur change par rapport à printf. Il permet de spécifier le nombre maximal de caractères à prendre en compte lors de l'analyse du paramètre. Le paramètre '*' est facultatif, il indique seulement de passer la donnée entrée et de ne pas la stocker dans la variable destination. Cette variable doit quand même être présente dans la liste des paramètres de scanf.

Note : Tout comme pour les fonctions printf et fprintf, il est nécessaire d'ajouter la ligne #include <stdio.h> en début de fichier pour pouvoir utiliser la fonction scanf. La signification de cette ligne sera donnée dans le chapitre traitant du préprocesseur.

En pratique, la fonction scanf n'analyse les caractères provenant du flux d'entrée que lorsqu'une ligne complète a été saisie. Toutefois, elle ne supprime pas du tampon de flux d'entrée le caractère de saut de ligne, si bien qu'il s'y trouvera toujours lors de l'entrée suivante. Cela n'est pas gênant si l'on n'utilise que la fonction scanf pour réaliser les entrées de données dans le programme, car cette fonction ignore tout simplement ces caractères de saut de ligne. En revanche, si l'on utilise une autre fonction après un appel à scanf, il faut s'attendre à trouver ce caractère de saut de ligne dans le flux d'entrée.

La fonction scanf n'est pas très adaptée à la lecture des chaînes de caractères, car il n'est pas facile de contrôler la taille maximale que l'utilisateur peut saisir. C'est pour cette raison que l'on a généralement recours à la fonction fgets, qui permet de lire une ligne sur le flux d'entrée standard et de stocker le résultat dans une chaîne de caractères fournie en premier paramètre et dont la longueur maximale est spécifiée en deuxième paramètre. Le troisième paramètre de la fonction fgets est le flux à partir duquel la lecture de la ligne doit être réalisée, c'est à dire généralement stdin. L'analyse de la chaîne de caractères ainsi lue peut alors être faite avec une fonction similaire à la fonction scanf, mais qui lit les caractères à analyser dans une chaîne de caractères au lieu de les lire directement depuis le flux d'entrée standard : la fonction sscanf. Cette fonction s'utilise exactement comme la fonction scanf, à ceci près qu'il faut lui fournir en premier paramètre la chaîne de caractères dans laquelle se trouvent les données à interpréter. La description de ces deux fonctions dépasse le cadre de ce document et ne sera donc pas faite ici. Veuillez vous référer à la documentation de votre environnement de développement ou à la bibliographie pour plus de détails à leur sujet.

1.9. Exemple de programme complet

Le programme suivant est donné à titre d'exemple. Il calcule la moyenne de deux nombres entrés au clavier et l'affiche :

Exemple 1-23. Programme complet simple
Sélectionnez

#include <stdio.h>  /* Autorise l'emploi de printf et de scanf. */
 
long double x, y;
 
int main(void)
{
    printf("Calcul de moyenne\n");   /* Affiche le titre. */
    printf("Entrez le premier nombre : ");
    scanf("%Lf", &x);            /* Entre le premier nombre. */
    printf("\nEntrez le deuxième nombre : ");
    scanf("%Lf", &y);            /* Entre le deuxième nombre. */
    printf("\nLa valeur moyenne de %Lf et de %Lf est %Lf.\n",
        x, y, (x+y)/2);
    return 0;
}

Dans cet exemple, les chaînes de format spécifient des flottants (f) en quadruple précision (L).


précédentsommairesuivant

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2012 developpez.com Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.