Vous êtes sur la page 1sur 55

Chapitre 1

Chapitre 1
Aperçu global du C++

YOUNES LAHBIB
YOUNES LAHBIB 
2010
younes.lahbib@gmail.com
lahbibyounes@eniso.rnu.tn

04/12/2009 1
PLAN DU COURS
PLAN DU COURS

Introduction
11 L
1.1. Les commentaires en C++
t i C++
1.2. Les types prédéfinis du C/C++
1.3. Notation des valeurs
1 4 La définition des variables
1.4. La définition des variables
1.5. Instructions et opérations
1.6. Les fonctions

04/12/2009 2
Partie 1
Partie 1

INTRODUCTION

04/12/2009 3
Introduction (Historique)

Langage C Langage C++
• Programmation structurée • Programmation
• B. Kernighan & D. Ritchie • orientée objet
• 1973 • B. Stroustrup
p
• ANSI/ISO • ~1980
– 1989 • ANSI/ISO
/
– (et 1999) – 1998

04/12/2009 4
Introduction : Spécificité du langage C++
p g g
ƒ Compatibilité avec le langage C (aussi bien pour les fichiers sources que pour 
les fichiers objets)

ƒ Ajout de techniques de programmation avancées
Ajout de techniques de programmation avancées
• Compilateur plus pointilleux que C

• Programmation orientée objet : langage à classes

• Meilleure gestion des erreurs : les exceptions

• Programmation générique : patrons (templates)

• Standard Template Library (STL)

ƒ La syntaxe générale de JAVA est directement inspirée de celle de C++ (qui 
elle même reprend en totalité celle du C).
elle‐même reprend en totalité celle du C). 

04/12/2009 5
Introduction: Premier Programme
g

04/12/2009 6
Introduction (Étapes de compilation)
( l l i
(plus loin en détail: chapitre environnement de développement)
dét il h it i t d dé l t)
• Le préprocesseur
– L'inclusion de fichiers (.h et parfois autres)
– Substitutions lexicales : les “macros”
• La compilation
– Vérification de la syntaxe
– Traduction dans le langage d
Traduction dans le langage d'assemblage
assemblage de la machine cible
de la machine cible
• L'assemblage
– Traduction finale en code machine
Traduction finale en code machine
– Production d'un fichier objet (.o ou.obj)
• L'édition de liens
– Unification des symboles internes
– Étude et vérification des symboles externes (.so ou.DLL)
– Production de l'exécutable
04/12/2009 7
1.1.

1.1. LES COMMENTAIRES EN C++

04/12/2009 8
1.1. Les commentaires en C++

Exemple 1‐1. Commentaire C Exemple 1‐2. Commentaire C++
/* Ceci est un commentaire C */ action quelconque // Ceci est 
• Peuvent s'étendre sur  //un commentaire C++ 
plusieurs lignes.  action suivante
• s'arrêtent à la fin de la ligne 
courante, et pas avant.

04/12/2009 9
1.2.

1.2. LES TYPES PRÉDÉFINIS DU 
C/C++

04/12/2009 10
1.2. Les types prédéfinis du C/C++ (1/2)
• le type vide : void. Pour procédures (fonctions ne renvoyant rien) et 
les pointeurs sur des données non typées (voir plus loin) ; 

• les booléens
les booléens : bool, prend les valeurs true
: bool prend les valeurs true et false
et false (en C++ 
(en C++
uniquement, ils n'existent pas en C) ; 

• les caractères : char ;

• les caractères longs
l è l : wchar_t
h (
(ce n'est un type de base que pour le 
' d b l
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 ; 
04/12/2009 11
1.2. Les types prédéfinis du C/C++ (2/2)

• les réels : float ; 

• les réels en double précision
les réels en double précision : double
: 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 ; ;
égale à 2, on utilisera des tableaux de tableaux

• les structures, unions et énumérations (voir plus loin). 

04/12/2009 12
1.2. Les types prédéfinis composites
yp p p

• LLes types entiers (int) peuvent être caractérisés d'un des mots clés 
t ti (i t) t êt té i é d' d t lé
long ou short pour modifier la taille du type
– les entiers longs
les entiers longs : long int, ou
: long int ou long (int est facultatif)
est facultatif) ; 
;
– les entiers courts : short int, ou short ; 

• De même, les réels en double précision peuvent être qualifiés du 
ê l é l d bl é ê lfé d
mot clé long, ce qui augmente leur plage de valeurs. On ne peut 
pas utiliser le mot clé short avec les double
pas utiliser le mot clé short avec les double. 
– les réels en quadruple précision : long double.

04/12/2009 13
1.2. Les types prédéfinis signés
yp p g

• Les types char, wchar_t et int peuvent être signés ou non. 

• Par défaut, les nombres entiers sont signés et Le signe des types 
Par défaut les nombres entiers sont signés et Le signe des types
char et wchar_t dépend du compilateur utilisé 

• Pour préciser qu'un nombre n'est pas signé, il faut utiliser le mot 
clé unsigned Pour préciser qu'un
clé unsigned. Pour préciser qu un nombre est signé, on peut 
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
clés long et short pour les types entiers. 
pour les types entiers
04/12/2009 14
Exemple 1‐3. Types signés et non signés

• unsigned char 
char • unsigned
g int

g
• signed char  • signed int
• unsigned
g wchar_t
_ • unsigned long int
long int
• signed wchar_t
• long unsigned
long unsigned int

04/12/2009 15
1.2. Portabilité des types: 
int8_t, int16_t, int32_t et int64_t
• LLa portabilité des types de base est très aléatoire. Le choix des types 
bili é d d b è lé i L h i d
est très important pour faire du code portable (c'est‐à‐dire 
fonctionnera sur tous les ordinateurs)
fonctionnera sur tous les ordinateurs). 
• Il est nécessaire d'utiliser des types de données qui donnent les 
mêmes intervalles de valeurs sur tous les ordinateurs.
mêmes intervalles de valeurs sur tous les ordinateurs. 
• La norme ISO C99 impose de définir des types portables sur toutes 
les architectures existantes. Ces types sont définis dans le fichier 
yp
d'en‐tête stdint.h. 
• Il s
Il s'agit
agit des types int8_t, int16_t, int32_t et int64_t, et de leurs 
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. 

04/12/2009 16
1.3.

1.3. NOTATION DES VALEURS

04/12/2009 17
Notation des entiers
Notation des entiers
• Exemple 1‐4. Notation des entiers en base 10
123
12354, ‐2564
2 6

• Exemple 1
Exemple 1‐5
5. Notation des entiers en base 16
Notation des entiers en base 16
0x1AE
• Exemple 1‐6. Notation des entiers en base 8
0154

04/12/2009 18
Notation des réels (1/2)
• Les flottants (pseudo réels) se notent de la manière suivante : 
• [signe] chiffres [.[chiffres]][e|E [signe] exposant][f]
• où signe
où signe indique le signe. On emploie les signes 
indique le signe On emploie les signes '+'
+  (facultatif) et 
(facultatif) et '‐' 
aussi bien pour la mantisse que pour l'exposant. 
• 'e' ou 'E' permet de donner l'exposant du nombre flottant. 
LL'exposant
exposant est facultatif. Si on ne donne pas d
est facultatif Si on ne donne pas d'exposant
exposant, on doit 
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
non (auquel cas il s agit d
d'un
un double). 
double).

04/12/2009 19
Notation des réels (2/2)
• 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. 
dé l
• Exemple 1‐7. Notation des réels
E l 1 7 N t ti d é l
‐123.56f, 12e‐12, 2
123 56f 12e 12 2
« 2 » est entier, «
» est entier, « 2.f » est réel. 
» est réel.
04/12/2009 20
Notation des caractères
• Les caractères se notent entre guillemets simples : 
'A', 'c', '(‘
• On peut donner un caractère non accessible au 
On peut donner un caractère non accessible au
clavier en donnant son code en octal, précédé du 
caractère '\'
caractère  \ . 
• Exemples:
• le caractère 'A' peut aussi être noté '\101‘
• le caractère ‘0' peut aussi être noté '\‘
le caractère ‘0' peut aussi être noté '\‘

04/12/2009 21
Notation des chaînes de caractères
• Bien qu'il n'existe pas de chaînes de caractères en 
C/C++ il t
C/C++, il est possible de définir des tableaux de 
ibl d défi i d t bl d
caractères constants en donnant leur contenu entre 
doubles guillemets : 
¾"Exemple de chaîne de caractères…"
p
• Les caractères spéciaux peuvent être utilisés 
directement dans les chaînes de caractères
directement dans les chaînes de caractères 
constantes : 
¾"Ceci est un saut de ligne :\nCeci est à la ligne 
suivante."

04/12/2009 22
1.4.

1.4. LA DÉFINITION DES VARIABLES

04/12/2009 23
Déclaration des variables
• Les variables peuvent être déclarés n’importe où dans le code 
(pas nécessairement au début du code)
ex. 1 ex 2
ex.
{
int a=0; /* the i counter is defined
a++; directly inside the block, and
// not allowed in C it is visible only inside it. */

float b;; for( int i=0; i<20; i++ )


... {
} ...;
}

04/12/2009 24
Syntaxe des définitions de variables
•Les variables simples peuvent être définies avec la syntaxe 
suivante : type identificateur;  où type est le type de la variable et 
identificateur est son nom. 
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 : 
¾ type identificateur[=valeur][, identificateur[=valeur][...]]; 

•Exemple 1‐8. Définition de variables
¾int i=0, j=0; /* Définit et initialise deux entiers à 0 */ 
i=0 j=0; /* Définit et initialise deux entiers à 0 */
¾double somme; /* Déclare une variable réelle */

04/12/2009 25
Déclaration des tableaux
• 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 : type identificateur[taille]([taille](...));
yp [ ]([ ]( ));

• Exemple 1‐9. Définition d'un tableau : int MonTableau[100];

• Note: Une chaîne de caractères se termine obligatoirement par le 
caractère nul ('\0')
caractère nul ( \0 ), il faut donc réserver de la place pour lui. 
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]; »). 
»)

04/12/2009 26
1.5

1.5. INSTRUCTIONS ET OPÉRATIONS

04/12/2009 27
Les opérateurs (1/3)
– Opérateurs arithmétiques: 
¾ +, ‐, *, /, ++, ‐‐, % (modulo) , =, +=, ‐=, *=, /=, %=
, , , /, , , ( ), , , , ,/ ,
– Opérateurs de comparaison: 
¾ <, <=, >, >=, ==, !=
– Opérateurs logiques: 
¾ &&, ||, ! ,  => il n’y a pas d’opérateur ou exclusif
– Opérateurs de lecture / écriture:
¾ <<, >>
–AAccès à un membre: 
è à b
¾ Objet.membre
Pointeur → membre
¾ Pointeur →
– Opérateurs d’allocation et de libération dynamique
¾new => new type ; ou bien new type [nbre cases]
¾new => new type ; ou bien     new type [nbre_cases]
¾delete => delete pointeur; ou bien    delete [] pointeur
04/12/2009 28
Les opérateurs (2/3)

– Opérateurs de conversion de type : 
• ( yp ) p
(type) expression
– Opérateurs de soulèvement d’exception:
• throw expression
– Expression Conditionnelle
• expr
p ? expr
p : expression
p
– Séquence d’expression
• expression, expression
p , p

04/12/2009 29
Les opérateurs (3/3)
„ Opérateurs de forçage (Cast ) : il y en a plusieurs, parmi lesquels
„ Dynamic_cast
Dynamic cast : convertit une expression en un pointeur ou une référence 
: convertit une expression en un pointeur ou une référence
d’une classe, ou un pointeur sur void. Effectue des vérifications de la validité 
de la conversion. 
„ static_cast
t ti t : static_cast<type>(expression)
i ( i )
„ const_cast : supprime les attributs de constances

Exemple 1:
void* malloc (size_t);
void main( )
{
{ int *
* p = static_cast<int*>malloc(20);
* ll ( )
//le pointeur retourné par malloc
//est interprété comme un pointeur sur un entier
}//‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
}//
Exemple 2:
// La classe B hérite de la classe A :
B *pb;
B *pb;
A *pA=dynamic_cast<A *>(pB);
04/12/2009 30
Opérateurs et priorité

04/12/2009 31
1.6: 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.
valeur ou en ignorant la valeur retournée.

1.6. LES FONCTIONS

04/12/2009 32
1.6.1. Définition des fonctions
• La définition des fonctions se fait comme suit : 
type 
type identificateur(paramètres) {
identificateur(paramètres)      {
... /* Instructions de la fonction. */   }

• La syntaxe de la liste de paramètres est la suivante
L t d l li t d èt tl i t : 
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 
p p q p
prend si aucune valeur ne lui est attribuée lors de l'appel de la fonction. 

• La valeur de la fonction à renvoyer est spécifiée en utilisant la 
L l d l f ti à t é ifié tili t l
commande return, dont la syntaxe est : return valeur;

04/12/2009 33
1.6.1. Définition des fonctions
• Exemple 1‐13. Définition de fonction
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
Si elle n attend pas de paramètres, sa liste de paramètres sera void
pas de paramètres sa liste de paramètres sera void ou n
ou n'existera
existera 
pas. 
• Il n'est pas nécessaire de mettre une instruction return à la fin d'une fonction qui 
ne renvoie pas de valeur. 
i d l
• Exemple 1‐14. Définition de procédure
void rien() /* Fonction n'attendant pas de paramètres */
{ /* et ne renvoyant pas de valeur. */
return; /* Cette ligne
g est facultative. */
}
04/12/2009 34
1.6.2. Appel des fonctions
int somme(int i,int j)
{
return i+j;
}
void rien() int i=somme(2,3);
{ rien();
return;
}

ƒ LL'appel
appel d
d'une
une fonction se fait en donnant son nom, puis les valeurs 
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
mettre les parenthèses, sinon la fonction n est pas appelée. 
pas appelée.

04/12/2009 35
Arguments par défaut
• 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
aussi être omis. Il en résulte que seuls les derniers paramètres d une fonction 
fonction
peuvent avoir des valeurs par défaut. Par exemple : 

int test(int i = 0
0, int j = 2)
{ int k= test(8);
return i/j; //Retourne 4
}

int test(int i = 0
0, int j)
int k= test(8);
{ //est invalide car
return i/j; aucun paramètre est
}
passé à j
04/12/2009 36
1.6.3. Déclaration des fonctions
• Toute fonction doit être déclarée avant d'être appelée pour la 
première fois
première fois.
• Lorsqu’une fonction F1 est appelée par une autre fonction F2 définie 
avant elle alors F1 doit être déclarée avant F2
avant elle, alors F1 doit être déclarée avant F2.
• Le rôle des déclarations (ou prototype) est de signaler l'existence des 
f ti
fonctions aux compilateurs afin de les utiliser, tout en reportant leur 
il t fi d l tili t t t tl
définition plus loin ou dans un autre fichier. La syntaxe de la 
déclaration d'une fonction est la suivante : 
déclaration d'une fonction est la suivante
type identificateur(paramètres);
Où paramètres est 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. 

04/12/2009 37
Exemple 1‐16. Déclaration de fonction

int Min(int int); /*Déclaration de la fonction minimum*/


Min(int,
/* 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)
j return i;
else return j;
}

04/12/2009 38
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. 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. 

• Il est donc possible de faire des fonctions de même nom (on les appelle 
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. 

04/12/2009 39
Exemple 1‐17. Surcharge de fonctions
float test(int i, int j)
ƒLors de l'appel de test(2,3), ce sera la 
{
première qui sera appelée, car 2 et 3
return (float) i+j;
sont des entiers.
}
ƒLors de l'appel de test(2.5,3.2), ce sera 
L d l' ld (2 5 3 2)
float test(float i, float j)
la deuxième, parce que 2.5 et 3.2 sont 
{
réels. 
j
return i*j;
}

ƒ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 
l d d f è é d h d l d
vérifier les règles de priorité utilisées par le compilateur.  

04/12/2009 40
1.6.5. Fonctions inline
ƒ Le compilateur remplace l'appel de la fonction par le code correspondant. 
9 Le programme devient plus gros, 
9En revanche, il devient nettement plus rapide, 
9 En pratique, on réservera cette technique pour les petites fonctions

ƒRestrictions des fonctions inline : 
9 elles ne peuvent pas être récursives ; 
9 elles ne sont pas instanciées, donc on ne peut pas faire de pointeur sur une 
p , p p p
fonction inline. 
ƒ Si l'une de ces deux conditions n'est pas vérifiée pour une fonction, le 
compilateur l'implémentera
compilateur l implémentera classiquement (elle ne sera donc pas inline). 
classiquement (elle ne sera donc pas inline).

ƒ Du fait que les fonctions inline sont insérées aux endroits où elles sont appelées, 
il est nécessaire qu'elles soient complètement définies avant leur appel. 
l é ' ll lè déf l l

ƒ Cela signifie que, 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é
04/12/2009 41
Exemple 1‐18. Fonction inline
p

inline int Max(int i, int j)


{
if (i>j) return i;
else return j;
}

04/12/2009 42
1.6.6. Fonctions statiques
ƒ static, une fois placé devant la définition et les éventuelles 
, p
déclarations d'une fonction, la rend unique et utilisable 
uniquement dans ce fichier.

ƒ Par défaut, toutes les fonctions sont externes. 

ƒ Quand utiliser les fonctions statiques? 
9soit 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), 
9
9soit parce que la fonction est uniquement d'intérêt local. 
l f d' é ê l l

04/12/2009 43
Exemple 1‐19.
Exemple 1 19. Fonction statique
Fonction statique
// 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;
}

04/12/2009 44
1.6.7. Fonctions prenant un nombre variable de 
paramètres
è
• En général, les fonctions ont un nombre constant de paramètres. 
• Ceux 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++ disposent toutefois d'un mécanisme qui permet de réaliser des fonctions 
dont le nombre et le type des paramètres sont variables. Ex: printf
yp p p

Pour indiquer au compilateur qu'une fonction peut accepter une liste de


paramètres variable,
variable il faut utiliser des points de suspensions dans la liste
des paramètres : type identificateur(paramètres, ...)

un jeu
j dde macros a été défi
définii d
dans lle fifichier
hi d' têt stdarg.h
d'en-tête td h pour faciliter
f ilit
l'accès aux paramètres de la liste

04/12/2009 45
stdarg.h #include <stdarg.h>

• 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. 
• Principe: 
1. Dans la fonction, déclarer une variable de type va_list. Puis, vous devez initialiser 
cette variable avec la syntaxe suivante : 
• va_start(variable, paramètre); où 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.
2.  Dès que variable est initialisée, vous pouvez récupérer un à un les paramètres à 
ll'aide
aide de l
de l'expression
expression suivante
suivante :
• 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
expression autant de fois que vous le désirez, elle retourne à chaque fois un nouveau 
paramètre.
3. Lorsque le nombre de paramètres correct a été récupéré, vous devez détruire la 
variable variable
i bl i bl à l'aide de la syntaxe suivante
à l' id d l t i t : va_end(variable); 
d( i bl )

04/12/2009 46
Exemple 1‐20. Fonction à nombre de 
p
paramètres variable
#include <stdarg.h>
/* Fonction effectuant la somme de "compte" paramètres : */
double somme(int compte, ...)
{
d bl resultat=0;
double l 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;
compte 1;
}
va_end(varg); /* Terminaison. */
return resultat;
} 04/12/2009 47
Fonctions avec nombre de paramètres multiples 
(UNIX et Windows)
(UNIX et Windows)

04/12/2009 48
Exemple Windows/UNIX(1/3)

04/12/2009 49
Exemple Windows/UNIX(2/3)

ListePar

Si  (cpt != 0 )retourne (Total/cpt) sinon retourne 0
( p ) ( /p)

04/12/2009 50
Exemple Windows/UNIX(3/3)
p / ( / )

04/12/2009 51
COMMANDES DU PRÉPROCESSEUR

04/12/2009 52
04/12/2009 53
04/12/2009 54
04/12/2009 55