Programmation en Langage c c++ - 107 Pages

download Programmation en Langage c c++ - 107 Pages

of 107

Transcript of Programmation en Langage c c++ - 107 Pages

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    1/107

    Programmation en Langage C/C++

    par Sylvain Ferey

    pour le Forum des Programmeurs Francophones

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    2/107

    Tables des matires

    Introduction............................................................................................................................. 5

    Ralisation de notre premier programme C............................................................................... 6

    Les types du C / C++.............................................................................................................. 9

    Le type caractre .................................................................................................................9

    Un signe de caractre ..............................................................................................................................................9

    Les types entiers.................................................................................................................13

    Les entiers courts ...................................................................................................................................................13

    Les entiers longs....................................................................................................................................................13

    Les types flottants...............................................................................................................15

    Conversion de types............................................................................................................15

    Le type Pointeur ........ ......... ........ ......... ........ ......... ........ ......... ......... ........ ......... ........ ......... ..17

    Le type Tableau..................................................................................................................23

    Les tableaux statiques ...........................................................................................................................................23

    Les tableaux dynamiques......................................................................................................................................25

    Les tableaux de caractres ....................................................................................................................................27

    Les oprateurs....................................................................................................................... 28

    Les oprateurs mathmatiques.............................................................................................28

    Les oprateurs logiques et relationnels....... ......... ........ ......... ........ ......... ........ ......... ........ ....... 30

    Les oprateurs dincrmentation et dcrmentation....... ........ ......... ........ ......... ........ ......... .....31

    Les oprateurs binaires ........ ......... ........ ......... ........ ......... ........ ......... ......... ........ ......... ........ .32

    Les oprateurs contracts ...................................................................................................33

    Les piges viter..............................................................................................................33

    Les instructions de tests.......................................................................................................... 35

    Linstruction if.................................................................................................................35

    Lexpression condition..........................................................................................................................................37

    Des conditions avec et et ou........................................................................................................................39

    Loprateur ternaire ?: ......... ........ ......... ......... ........ ......... ........ ......... ........ ......... ........ ....... 39

    Linstruction switch ......... ........ ......... ........ ......... ........ ......... ......... ........ ......... ........ ......... ..41

    Les instructions de boucles..................................................................................................... 43Linstruction while...........................................................................................................43

    Linstruction break...........................................................................................................43

    Linstruction do ... while( )...............................................................................................45

    Linstruction for...............................................................................................................47

    Lexpression dinitialisation .................................................................................................................................47

    Lexpression de test...............................................................................................................................................47

    Lexpression dincrmentation.............................................................................................................................49

    Linstruction continue.......................................................................................................51

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    3/107

    Tables des matires

    Les fonctions ......................................................................................................................... 53

    Dclaration.........................................................................................................................53

    Dfinition ........ ......... ........ ......... ........ ......... ........ ......... ......... ........ ......... ........ ......... ........ ....55

    Librairie .............................................................................................................................59

    La fonction main..............................................................................................................60

    Code de retour........................................................................................................................................................60

    Paramtres reus ....................................................................................................................................................61

    La sortie des donnes ............................................................................................................ 63

    La fonction printf.............................................................................................................63

    Dfinition des donnes .........................................................................................................................................63

    Modificateur de description.................................................................................................................................65

    Largeur daffichage................................................................................................................................................67

    Prcision daffichage.............................................................................................................................................69

    Modificateur de taille.............................................................................................................................................71

    Les fonctions ?printf........................................................................................................71

    La saisie des donnes............................................................................................................. 73

    La fonction scanf.............................................................................................................73

    Dfinition des donnes .........................................................................................................................................73

    Suppression daffectation ....................................................................................................................................75

    Largeur de lecture ..................................................................................................................................................77

    Modificateurs de taille...........................................................................................................................................77

    Les fonctions ?scanf........................................................................................................79

    Les chanes de caractres....................................................................................................... 80

    Un nombre sign ou non......................................................................................................80

    Les tableaux de caractres..................................................................................................82

    Les fonctions standards de manipulation de chanes...............................................................88

    Comparaison...........................................................................................................................................................88

    Concatnation ........................................................................................................................................................88

    Copie ........................................................................................................................................................................88

    Longueur.................................................................................................................................................................90

    Recherche................................................................................................................................................................90

    Les Fichiers........................................................................................................................... 91

    Le type FILE ..................................................................................................................91

    Dsignation du fichier..........................................................................................................93

    Ecriture de fichier...................................................................................................................................................94

    Lecture de fichier....................................................................................................................................................96

    Les fonctions gnriques dentre sortie ........ ......... ........ ......... ......... ........ ......... ........ ......... ..98

    Les fonctions orientes fichiers............................................................................................98

    Conclusion........................................................................................................................... 102

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    4/107

    Liste des programmes

    Code 1 : Hello world...............................................................................................................6

    Code 2 : Mauvais passage de paramtres variants ........ ......... ........ ......... ......... ........ ......... ........ .21

    Code 3 : Bon passage de paramtres variants........... ......... ........ ......... ........ ......... ........ ......... .....21

    Code 4 : Cration dun tableau de taille quelconque....................................................................25Code 5 : Boucle while(..) { ... }........ ......... ........ ......... ........ ......... ........ ......... ........ ......... ........ 43

    Code 6 : Boucle while(..) { ... } avec sortie par break..........................................................43

    Code 7 : Boucle do { ... } while(..) ......... ........ ......... ........ ......... ......... ........ ......... ........ ......... ..45

    Code 8 : Boucle for ........ ........ ......... ......... ........ ......... ........ ......... ........ ......... ........ ......... ........ 49

    Code 9 : Boucle for avec break et continue........ ........ ......... ......... ........ ......... ........ ......... ..51

    Code 10 : Fichier de dclaration : geometry.h ........ ......... ........ ......... ........ ......... ........ ......... .....55

    Code 11 : Fichier de dfinition : geometry.c............................................................................57

    Code 12 : Utilisation de la librairie : geometry.a.......................................................................59

    Code 13 : Valeur retourne par la fonction main ........ ......... ........ ......... ......... ........ ......... ........ .60

    Code 14 : Lecture du code retourn par la fonction main.........................................................60

    Code 15 : Paramtres reus par la fonction main ......... ........ ......... ........ ......... ........ ......... ........ 61Code 16 : Affichage format de nombres dcimaux........ ........ ......... ........ ......... ........ ......... ........ 69

    Code 17 : Stockage de donnes formates dans une chane ........ ......... ........ ......... ........ ......... .....71

    Code 18 : Saisie avec cho.......................................................................................................75

    Code 19 : Lecture de donnes formates depuis une chane........................................................79

    Code 20 : Table ASCII restreinte..............................................................................................80

    Code 21 : Table ASCII complte ......... ......... ........ ......... ........ ......... ........ ......... ........ ......... ........ 80

    Code 22 : Table ASCII vraiment complte ........ ........ ......... ......... ........ ......... ........ ......... ........ ....82

    Code 23 : Ecriture de fichier.....................................................................................................94

    Code 24 : Lecture de fichier.....................................................................................................96

    Code 25 : Carnet dadresses............. ......... ........ ......... ........ ......... ......... ........ ......... ........ ......... 102

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    5/107

    Sylvain Ferey ([email protected]) 5

    Forum des Programmeurs Francophones

    Introduction

    Ce document fait la synthse des cours de C proposs sur le Forum des Programmeurs

    Francophones de CompuServe.

    Cette synthse se veut un guide dapprentissage efficace du langage C ANSI.

    Tous les chapitres ont t peu ou prou rcrits pour tre les plus comprhensibles

    possibles et vous permettront de comprendre la mise en uvre et lutilisation du C.

    Dautres chapitres ont t ajouts par rapport la parution hebdomadaire initiale.

    Enfin de nouveaux exemples illustrent cette prsentation.

    Ce cours est destin aux dbutants, bien quil puisse servir de rfrence aux inities.

    Si vous ne disposez pas de compilateur C, vous trouverez, sur le Forum desProgrammeurs Francophones de CompuServe, une distribution du compilateur GNU

    adapte au processeur Intel par DJGPP; ce compilateur ligne de commande fournit du

    code binaire 32 bits de bonne qualit.

    Je tiens remercier Julien Hardelin pour sa relecture efficace, ainsi que tous ceux qui,

    par leurs remarques, ont contribu amliorer ce cours.

    Ce document est libre dutilisation et de diffusion non commerciale sous une forme

    imprime qui respecte lintgralit du document. Toute diffusion lectronique - autre

    que celles ralises par lauteur lui -mme - est interdite sans laccord de lauteur.

    Lauteur ne garantit pas que ce document ne contient aucune erreur ou inexactitude,

    malgr les diffrentes relectures. De mme, lauteur ne pourra tre tenu pour

    responsable de tout dommage, implicite ou explicite, survenant de lutilisation de ce

    document et des exemples de codes quil contient.

    Lauteur,

    Sylvain FEREY

    [email protected]

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    6/107

    Sylvain Ferey ([email protected]) 6

    Forum des Programmeurs Francophones

    Ralisation de notre premier programme C

    En C, plus quavec dautres langages, le premier programme traditionnel est :

    Code 1 : Hello world

    #include

    void main(){

    printf("hello world!\n");

    }

    Pour excuter ce premier programme C, enregistrez le source ci-dessus dans un fichier

    et sauvegardez le sous le nom hello.c (ou ce que vous souhaitez, mais si vous utilisez

    le compilateur GNU lextension doit tre .c); ensuite dans une fentre Dos - si vous

    tes sous Windows - ou avec votre shell prfr (zsh, csh, bash, ...), placez vous dans le

    rpertoire qui contient ce fichier et lancez la compilation et ldition de liens grce la

    commande, si vous tes sous Dos/Windows :

    G:\>gcc hello.c -o hello.exe

    ou si vous tes sous unix ou Linux.

    > gcc hello.c -o hello

    Par cette commande, nous demandons loutil gcc de compiler notre source hello.c et

    de crer un excutable nomm hello.exe (ou hello); loption -o (pour output)

    permettant de dfinir ce nom. Nous obtenons un programme que nous pouvons lancer,

    sur lcran (la console) saffiche :

    hello world!

    Dtaillons ce petit programme :

    ?? la premire ligne inclut le fichier nomm stdio.h.

    Ce fichier contient les dfinitions pour les oprations standards dentres (input)

    partir du clavier ou dun fichier, et de sorties (output) vers lcran ou dans un

    fichier.

    stdio.h dfinit notamment une fonction nomme printf(). Cette fonction peut

    tre appele avec une chane de caractres (entre guillemets - ou double quote)

    comme unique paramtre; cette chane est alors affiche lcran.

    ?? nous trouvons ensuite une unique fonction appele main.

    Cette fonction est le point dentre du programme; cest dire l o dbutera son

    excution; elle est appele fonction principale.

    Le nom de cette fonction - main - est impos, si vous en utilisez un autre,

    lditeur de liens (linkeur) vous dira quil na pas trouv de fonction main et la

    construction de lexcutable chouera.

    main est une fonction, nous devons donc placer une paire de parenthses

    ouvrante et fermante - ( et ) - aprs son nom. Dans cet exemple simple, la

    fonction ne reoit aucun paramtre, rien ne figure donc entre ces parenthses.

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    7/107

    Sylvain Ferey ([email protected]) 7

    Forum des Programmeurs Francophones

    Une fonction doit dfinir le type des informations quelle retourne, comme ici

    aucune valeur nest retourne par la fonction main, nous utilisons le mot cl

    void (littralement rien) plac devant le nom de la fonction.

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    8/107

    Sylvain Ferey ([email protected]) 8

    Forum des Programmeurs Francophones

    Enfin le corps dune fonction est toujours dfini entre accolades { et }. Ici, il est

    constitu dun simple appel la fonction printf() qui nous communiquons le

    texte afficher. Notez dans notre message que le caractre \n sert insrer un

    retour la ligne la fin du texte.

    Notez que la syntaxe est importante. Le C et le C++ distinguent les minuscules des

    majuscules. Dans ce source, seul le texte entre parenthses aurait pu avoir unesyntaxe diffrente, tout le reste doit tre tap en minuscule.

    En effet, include et void font parti des mots cl du langage et leur syntaxe est

    impose. La routine printf est dclare avec cette orthographe dans le fichier stdio.h

    et est implmente avec ce nom dans la librairie dentre/sortie. Enfin la librairie de

    dmarrage (le runtime) sattends trouver une fonction nomme main.

    Remarque: le systme Dos/Windows ne distinguant pas la casse des noms de fichiers

    stdio.h aurait pu tre saisi autrement. Cependant une des forces du C/C++ tant sa

    portabilit, il est trs recommand de respecter la syntaxe des noms de fichiers afin de

    pouvoir recompiler vos sources sur dautres plates-formes (sous unix, par exemple).

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    9/107

    Sylvain Ferey ([email protected]) 9

    Forum des Programmeurs Francophones

    Les types du C / C++

    Les langages C et C++ sont des langages typs.

    Cela signifie que pour utiliser une variable, vous devez, avant de pouvoir lutiliser,

    dclarer cette variable en prcisant son type.

    Il existe trois sortes de types fondamentaux : le type caractre, le type entier et le type

    rel ou flottant.

    Nous allons tudier chacun de ces types. Notons avant cela lexistence dun autre type

    particulier et que nous venons de rencontrer : le type void, ce type ne peut tre utilis

    que comme type dune fonction (qui ne renvoie rien); en effet il est impossible de

    dclarer une variable qui ne serait stock sur aucun octet et qui ne permettrait de

    stocker aucun nombre.

    Le type caractre

    Le type caractre permet de dfinir des variables stockant une lettre. Le nom de ce type

    est char; on dfinit donc ainsi une variable de type caractre :

    char maLettre;

    Nous pouvons ensuite fixer la valeur dune telle variable avec une lettre donne entre

    apostrophes (ou simple quote), voici un exemple :

    maLettre = 'a';

    Notez dans cet exemple que le signe = sert dfinir la valeur dune variable ( lui

    affecter une valeur). Nous dirons que = est loprateur daffectation.

    Nous pouvons galement dclarer une variable et fixer sa valeur en mme temps:

    char maLettre = 'A';

    Nous pouvons galement dfinir la valeur dune variable de type char avec une valeur

    numrique. En effet, dans le dernier exemple la lettre 'A' est un caractre appartenant

    au jeu de caractres ASCII a pour valeur le nombre 65. Nous pouvons donc coder la ligne

    ci-dessus :

    char maLettre = 65;

    Plus gnralement, le type char supporte in extenso larithmtique des nombres entiers;ceci est trs commode et vite les surcharges (modifications de types) ou appels des

    fonctions manipulant les caractres comme cest le cas en Pascal; par exemple le code

    suivant affecte un caractre le caractre suivant dans le jeu de caractres utilis :

    char uneLettre = 'A';

    uneLettre = uneLettre + 1; /* lettre contient 'B' */

    Notez que les symboles /* et */ permettent dinsrer des commentaires.

    Un signe de caractre

    Le type char stockant des caractres est cod sur un octet, il accepte donc 256 valeurs

    diffrentes, mais quelles valeurs ?

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    10/107

    Sylvain Ferey ([email protected]) 10

    Forum des Programmeurs Francophones

    Il existe en fait deux types char, lun est sign et peut contenir des valeurs comprises

    entre -128 et +127; le second est non sign et ne contient donc que des valeurs positives

    soit les nombres compris entre 0 et 255.

    Ces deux types sont dfinis par les noms signed char et unsigned char.

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    11/107

    Sylvain Ferey ([email protected]) 11

    Forum des Programmeurs Francophones

    Le type char (sans plus de prcision) comme nous lavons utilis prcdemment est

    gnralement quivalent au type signed char, mais cela peut changer selon la machine

    hte. En effet, ce type a en quelque chose t dfini pour reprsenter tous les caractres

    disponibles sur un systme donn.

    Cette dfinition date un peu; cette poque la plupart des systmes ne dfinissaient

    que les caractres dont la valeur est comprise entre 0 et 127, cest notamment le cas dujeu de caractres ASCII primordial et du jeu de caractres EBCDIC (des IBM 370, par

    exemple), le problme de la reprsentation du type char (sign ou non sign) ne se posait

    alors pas.

    Aujourdhui tous les compilateurs permettent de dfinir explicitement un type caractre

    sign (grce signed char) et non sign (grce unsigned char), le type char restant le

    format natif du systme hte. Cette distinction permet, grce aux contrles des types

    effectus par le compilateur de traiter ces types distinctement et ceci peut savrer trs

    utile.

    Illustrons ce point par un exemple: les chanes de caractres en C sont des tableaux de

    char. Ces chanes sont termines par un caractre de valeur nulle (ou encore de valeur

    ASCII zro, on parlera de chane ASCIIZ); imaginons un programme qui aurait besoin de

    stocker et manipuler de s chanes qui, comme en Pascal, contiennent la longueur de la

    chane comme premier caractre, nous pouvons reprsenter de telles chanes comme

    un tableau de unsigned char; grce cela le compilateur fera bien la diffrence entre

    ces deux sortes de chanes et il nous avertira dune ventuelle erreur si nous utilisons

    une chane ASCIIZ l o une chane Pascal est attendue et vice versa.

    La distinction entre une variable signe et non signe ninfluence pas le stockage de la

    valeur de cette variable, ainsi si nous codons :

    signed char lettreSigne = 'a';unsigned char lettreNonSigne = 'a';

    alors ces deux variables contiennent, du point de vue binaire, exactement les mmes

    donnes; par contre larithmtique applique ces variables sera diffrente; on

    distinguera ainsi une arithmtique signe et une autre non signe; expliquons cela :

    Soit la dfinition:

    signed char lettreSigne = 127;

    unsigned char lettreNonSigne = 127;

    si maintenant nous ralisons :

    lettreSigne = lettreSigne + 1;

    lettreNonSigne = lettreNonSigne + 1;

    alors la variable lettreSigne est maintenant interprte par une opration

    arithmtique comme -128, tandis que la variable lettreNonSigne serait interprte

    comme 128.

    Voici un autre exemple, nous dfinissons :

    signed char lettreSigne = 0;

    unsigned char lettreNonSigne = 0;

    si maintenant nous ralisons :

    lettreSigne = lettreSigne - 1;

    lettreNonSigne = lettreNonSigne - 1;

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    12/107

    Sylvain Ferey ([email protected]) 12

    Forum des Programmeurs Francophones

    alors la variable lettreSigne est interprte comme -1, tandis que lettreNonSigne est

    interprte comme +255.

    Notez enfin que le type char est bien un type distinct de signed char et de unsigned

    char; cette rgle ne sapplique pas aux types entiers que nous allons dtailler et pour

    lesquels si la spcification signed ou unsigned est omise, le type est considr comme

    signed.

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    13/107

    Sylvain Ferey ([email protected]) 13

    Forum des Programmeurs Francophones

    Les types entiers

    Les types entiers sont tous bass sur le type fondamental int; cependant le codage de ce

    type dpend de la machine et du compilateur utilis.

    Aussi, et bien que lemploi du mot cl int soit suffisante pour dclarer une variable

    entire, nous utiliserons les modificateurs de types short et long pour dfinir le formatdes nombres entiers dune manire qui ne dpende plus de lenvironnement

    Les entiers courts

    Le modificateur short, utilis en association avec int, permet de dfinir un entier cod

    sur 16 bits ou deux octets. Nous pouvons ici aussi utiliser en plus les modificateurs

    signed et unsigned, ceci nous conduit aux types suivants :

    signed short int nombres compris entre -32 768 et +32767

    unsigned short int nombres compris entre 0 et 65 535

    pour simplifier lcriture le symbole int peut tre omis; ainsi les deux dfinitions de

    types prcdentes sont quivalentes signed short et unsigned short; de plus, comme

    nous venons de le voir avec le type char, la reprsentation signed est implicite pour des

    entiers si rien nest prcis; nous utiliserons donc: short (nombre de -32 768 +32767)

    et unsigned short (nombre de 0 65 535).

    Voici des dfinitions valides de variables entires :

    short unEntier;

    signed short unNombre; /* quivalent short unNombre */

    signed short intunChiffre; /* quivalent short unChiffre */

    unsigned shortunEntierPositif;

    Les entiers longs

    Le modificateur long, utilis en association avec int, permet de dfinir un entier cod

    sur 32 bits ou quatre octets, cet entier peut galement tre sign ou non, soit les types :

    signed long int nombres compris entre -2 147 483 648 et 2 147 483 647

    unsigned long int nombres compris entre 0 et 4 294 967 295

    Comme prcdemment, les mots cl int et signed sont optionnels, nous utiliserons les

    dfinitions de type long et unsigned long.

    Voici des dfinitions valides de variables entires longues :

    long unGrandEntier;

    signed long unGrandNombre; /* quivalent long unGrandNombre */

    signed long int unGrandChiffre; /* quivalent long unGrandChiffre */

    unsigned long unGrandEntierPositif;

    Le modificateur long peut tre appliqu deux fois au type int, ainsi nous dfinissons un

    type entier cod sur 64 bits ou 8 octets, soit les types :

    signed long long int

    unsigned long long int

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    14/107

    Sylvain Ferey ([email protected]) 14

    Forum des Programmeurs Francophones

    que nous utiliserons comme long long et unsigned long long; le type long long accepte

    des valeurs comprises entre -9 223 372 036 854 775 808 et 9 223 372 036 854 775 807;

    soit presque de quoi compter le nombre de particules prsentes dans tout lunivers.

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    15/107

    Sylvain Ferey ([email protected]) 15

    Forum des Programmeurs Francophones

    Les types flottants

    Ces types servent reprsenter des nombres en virgule flottante, cest dire des rels.

    La prcision de telles variables (cest dire le nombre de chiffres significatifs) et leurs

    valeurs absolues minimale et maximale dpendent du processeur sur lequel tourne le

    code ainsi que, dans certains cas, du compilateur.

    Les types dfinis sont :

    float flottant simple prcision

    double flottant double prcision

    long double flottant quadruple prcision

    Le type float correspond gnralement la taille des registres du processeur, le type

    double est deux fois plus large (ncessite deux fois plus doctets) et le type long double

    quatre fois plus.

    Ainsi sur les processeurs Intel rcents, le type float est cod sur 4 octets et permet de

    stocker des nombre dont la valeur absolue est comprise entre 1.403e-45 et -3.403e+38.

    Le type double est lui cod sur 8 octets et reprsente une valeur absolue comprise entre

    4.941e-324 et 1.798e+308.

    Par contre, sur un Cray utilisant des processeurs 64 bits le type float est stock sur 8

    octets (et correspond donc au type double utilisable avec un processeur Intel) tandis que

    le type double est cod sur 16 octets.

    Enfin le type long double est totalement dpendant du compilateur (car certain ne le

    dfinisse pas) et du processeur utilis (il peut ainsi tre cod sur 10, 16 ou 32 octets).

    Notez que les modificateurs signed et unsigned ne sont pas applicables aux types

    flottants; ceux-ci dfinissent toujours des variables ayant un signe.

    Conversion de types

    Les langages C et C++ supportent la modification de types (typecasting) des valeurs.

    Cette modification est implicite (automatique) entre les types fondamentaux que nous

    venons dtudier; ainsi le code suivant est valide :

    float monReel = 97.85;

    short monEntier = monReel; /* monEntier vaut 97 */char maLettre = monEntier; /* maLettre est 'a' */

    cependant le compilateur risque dmettre des avertissements durant la compilation de

    ce code afin de nous avertir des risques de pertes de donnes.

    Pour viter ces messages et lorsque nous savons que le codage ralis est correct, nous

    pouvons raliser une conversion explicite (demande) des donnes, ainsi nous cririons:

    float monReel = 97.85;

    short monEntier = (short) monReel;

    char maLettre = (char) monEntier;

    avec une telle criture nous demandons une conversion du type de donnes de lavariable vers le type prcis. La variable dorigine et son type demeure inchangs

    (monReel est toujours une variable de type float) mais lexpression rsultat que

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    16/107

    Sylvain Ferey ([email protected]) 16

    Forum des Programmeurs Francophones

    reprsente son valuation (cest dire sa valeur) est convertie lors de la ralisation de

    laffectation. Rptons-le cest exactement ce que le compilateur a ralis lors dune

    conversion implicite mais maintenant la compilation est plus propre puisque quaucun

    avertissement ne sera affich pour ces lignes, ce qui nous aidera apporter plus

    dattention aux autres messages du compilateur.

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    17/107

    Sylvain Ferey ([email protected]) 17

    Forum des Programmeurs Francophones

    Le type Pointeur

    Les variables de type pointeur permettent de stocker non plus une donne (comme une

    lettre, un entier ou un nombre rel) mais ladresse dune autre variable.

    Pour utiliser une telle variable, nous dfinirons donc sa valeur avec ladresse dune

    variable existante; pour cela nous utiliserons loprateur & (oprateur rfrence) quiappliqu une variable fournit son adresse; cest dire lendroit o la valeur de cette

    variable est stocke en mmoire.

    Si nous avons dfini :

    short unEntier;

    alors :

    &unEntier

    fournit ladresse de cette variable.

    Notez que loprateur & ne peut pas tre appliqu sur des expressions values. Par

    exemple &(unEntier + 1) est interdit, de mme que &32; en effet, dans ces

    expressions (unEntier + 1 ou le nombre 32) nexistent pas comme des emplacements

    mmoires dfinis, il est donc impossible den valuer ladresse.

    La variable pointeur elle-mme sera dfinie en utilisant le symbole * qui associ un

    type dfinit le pointeur sur ce type. Nous dirons en effet que cette variable pointe sur

    une donne, car contrairement une variable non-pointeur, elle ne contient pas

    directement la donne mais seulement ladresse o cette donne est stocke.

    Voici des dfinitions de variables pointeurs :

    short* adresseDunEntier;

    char* adresseDunCaractere;

    unsigned long* adresseDunEntierPositif;

    Notez que le fait de coller le symbole * droite du nom du type est arbitraire, en effet

    les dclarations suivantes sont rigoureusement identiques aux prcdentes :

    short *adresseDunEntier;

    char *adresseDunCaractere;

    unsigned long *adresseDunEntierPositif;

    Selon votre propre prfrence vous utiliserez la premire en explicitant littralement

    linstruction short* adresseDunEntier comme adresseDunEntier est une variabledont le type est short* cest dire pointeur sur un short; ou bien considrant la forme

    short *adresseDunEntier vous pourrez vous dire *adresseDunEntier est une variable

    pointeur qui pointe sur une variable de type short; les deux sont tout fait quivalents.

    Pour stocker ladresse de notre variable unEntier nous faisons donc :

    short unEntier;

    short* adresseDunEntier;

    adresseDunEntier = &unEntier;

    Comme pour une variable non -pointeur, nous pouvons dclarer notre variable pointeuret fixer sa valeur en mme temps, soit :

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    18/107

    Sylvain Ferey ([email protected]) 18

    Forum des Programmeurs Francophones

    short unEntier;

    short* adresseDunEntier = &unEntier;

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    19/107

    Sylvain Ferey ([email protected]) 19

    Forum des Programmeurs Francophones

    Pour lire la valeur pointe par une variable pointeur, nous utiliserons le signe *

    gauche du nom de la variable pointeur; cette opration sappelle drfrencer le

    pointeur et le symbole * est loprateur dadressage.

    Ainsi pour obtenir la valeur pointe par adresseDunEntier nous utilisons :

    *adresseDunEntier

    cette criture est lorigine de la prfrence souvent rencontre pour la seconde forme

    de dfinitions des pointeurs vue ci-dessus.

    Appliquons cela :

    short unEntier; /* dclaration dun entier court */

    short unNombre; /* un autre entier court */

    short* unPointeur; /* un pointeur sur un entier court */

    unEntier = 5; /* fixe la valeur de unEntier */

    unPointeur = &unEntier; /* stocke ladresse de unEntier */

    unNombre = *unPointeur; /* rcupre la donne pointe: 5 */

    Notez que ce code est quivalent :

    short unEntier; /* dclaration dun entier court */

    short unNombre; /* un autre entier court */

    unEntier = 5; /* fixe la valeur de unEntier */

    unNombre = unEntier; /* prend directement la valeur */

    Cet exemple montre un cas o il semble inutile dutiliser un pointeur, dans un vrai code

    son usage se rvlerait indispensable; imaginez par exemple quau lieu daffecter la

    variable unPointeur avec ladresse de unEntier nous devons raliser un test pour

    choisir parmi plusieurs variables celle dont nous stockerons ladresse; lutilisation dunpointeur permet alors dutiliser la donne de la variable choisie sans devoir raliser ce

    test chaque fois.

    De plus nous pouvons utiliser la variable pointeur pour modifier le contenu de la variable

    pointe, par exemple :

    short entier1; /* dclaration dun entier court */

    short entier2; /* un autre entier court */

    short entier3; /* un autre entier court */

    etc...

    short* unPointeur; /* un pointeur sur un entier court */

    un test conduirait par exemple :

    unPointeur = &entier2; /* stocke ladresse de entier2 */

    *unPointeur = 5; /* fixe la donne pointe 5 */

    maintenant entier2 vaut 5

    Une autre mise en oeuvre incontournable des pointeurs est lutilisation de paramtres

    variants avec une fonction. Paramtre variant signifie que vous dsirez passer une

    variable une fonction et vous souhaitez que cette fonction puisse modifier le contenu

    de cette variable.

    Un exemple pourrait tre une fonction utilise lors dun tri; nous souhaitons crire une

    fonction qui reoit deux nombres a et b et le cas chant permute ces deux nombres

    afin que a soit infrieur ou gal b.

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    20/107

    Sylvain Ferey ([email protected]) 20

    Forum des Programmeurs Francophones

    Si nous dfinissons simplement le type des paramtres transmis cette routine comme

    tant des types non pointeur, nous ne recevrons que la valeur de la variable et le

    traitement effectu sera perdu la sortie de la fonction.

    Ainsi le programme suivant ne marche pas !

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    21/107

    Sylvain Ferey ([email protected]) 21

    Forum des Programmeurs Francophones

    Code 2 : Mauvais passage de paramtres variants

    #include

    voidpermute(short a, short b) {

    short temp;

    if (a > b){

    temp = a;a = b;

    b = temp;

    }

    }

    voidmain(){

    short x, y; /* dclaration de deux entiers courts */

    x = 5;

    y = 2;

    printf("%hd %hd\n", x, y); /* affiche les nombres */

    permute(x, y); /* appel de notre fonction */

    printf("%hd %hd\n", x, y); /* affiche les nombres */

    }

    A lexcution, nous obtenons deux fois laffichage de :

    5 2

    Remarque : ne vous effrayez pas de lexpression printf("%hd %hd\n", x, y). Cette

    commande permet dafficher les deux nombres x et y; nous tudierons cela plus loin.

    Pour obtenir, le rsultat souhait nous devons transmette notre fonction ladresse des

    variables afin que ce soit bien le contenu de ces variables qui soit chang.

    Pour cela notre routine dclare des paramtres de type short* et non plus short, nous

    sommes donc oblig de drfrencer ces variables afin de lire la valeur pointe et lors de

    lappel cette routine nous devons transmettre les adresses grce loprateur &.

    Voila la version corrige du programme :

    Code 3 : Bon passage de paramtres variants

    #include

    voidpermute(short* a, short* b) {

    short temp;

    if (*a > *b){

    temp = *a;

    *a = *b;

    *b = temp;

    }

    }

    voidmain(){

    short x, y; /* dclaration de deux entiers courts */

    x = 5;

    y = 2;

    printf("%hd %hd\n", x, y); /* affiche les nombres */

    permute(&x, &y); /* appel de notre fonction */

    printf("%hd %hd\n", x, y); /* affiche les nombres */

    }

    A lexcution, nous obtenons laffichage suivant :

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    22/107

    Sylvain Ferey ([email protected]) 22

    Forum des Programmeurs Francophones

    5 2

    2 5

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    23/107

    Sylvain Ferey ([email protected]) 23

    Forum des Programmeurs Francophones

    Le type Tableau

    Un tableau est une variable qui permet de stocker non plus une seule valeur mais un

    nombre fini et dtermin de valeurs.

    Il est possible de crer des tableaux dlments quelconques, par exemple des tableaux

    de caractres - nous y reviendrons en dtail plus loin - ou encore des tableaux dentiersou de rels; nous pouvons galement dfinir des tableaux de variables pointeurs et

    mme des tableaux de fonctions, mais commenons par le dbut.

    Les tableaux statiques

    Un tableau statique est un tableau dont la taille (le nombre dlments) est fige et

    dclare dans le source.

    Un tel tableau est dfini en utilisant les symboles [ et ] aprs le nom de la variable et

    en faisant figurer le nombre dlments dsirs entre ces crochets; par exemple :

    short tableau_d_entier[5];

    dfinit une variable nomme tableau_d_entier qui est un tableau de 5 entiers de type

    short. Les lments du tableau sont numrots de 0 (taille du tableau - 1); par exemple

    nous pouvons raliser :

    short tableau_d_entier[5];

    tableau_d_entier[0] = 1;

    tableau_d_entier[1] = 3;

    tableau_d_entier[2] = 5;

    tableau_d_entier[3] = 3;

    tableau_d_entier[4] = 1;

    Notez que nous pouvons dfinir les valeurs des lments du tableau lors de sa

    dclaration, pour cela nous placerons les diffrentes valeurs entre accolades en les

    sparant par des virgules; la dfinition suivante est identique au tableau prcdent :

    short tableau_d_entier[5] = {1, 3, 5, 3, 1};

    Nous pouvons galement dfinir des tableaux multi-dimensions en rptant la

    spcification de taille faites avec les crochets, par exemple voici une matrice 2*2 :

    float matrice[2][2];

    matrice[0][0] = 1.0;

    matrice[0][1] = 2.0;matrice[1][0] = 3.0;

    matrice[1][1] = 4.0;

    cette variable reprsente en quelque sorte la matrice :10 2 0

    3 0 4 0

    . .

    . .

    Notez quici aussi nous pouvons dfinir les valeurs des lments lors de la dclaration,

    nous imbriquerons simplement des accolades pour dfinir chacune des dimensions du

    tableau; ainsi la dfinition suivante est identique la matrice prcdente :

    short matrice[2][2] = {{1.0, 2.0}, {3.0, 4.0}};

    Il existe une forte similitude en C/C++ entre un type tableau et le type pointeur sur ce

    mme type. Ainsi tant dfini le tableau_d_entier ci -dessus nous pouvons raliser :

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    24/107

    Sylvain Ferey ([email protected]) 24

    Forum des Programmeurs Francophones

    short* ptr_entier = tableau_d_entier;

    ou encore, c est identique :

    short* ptr_entier = &tableau_d_entier[0];

    En effet une variable tableau contient ladresse du premier lment de ce tableau.

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    25/107

    Sylvain Ferey ([email protected]) 25

    Forum des Programmeurs Francophones

    Les tableaux dynamiques

    Un tableau dynamique est un tableau dont la taille nest pas fige dans le source.

    La remarque prcdente concernant la similitude entre une variable tableau et un

    pointeur sur un type quivalent nous permet de dclarer aisment un tel tableau de

    taille inconnue, nous utiliserons simplement un pointeur et stockerons ladresse de cetableau dans la variable pointeur.

    Pour illustrer cela, nous devons savoir que le fichier den-tte (ou header) stdlib.h

    dclare la fonction malloc() avec le prototype (lAPI) suivant :

    void* malloc(size_t size);

    cela signifie quelle attend un paramtre de type size_t (qui est galement dfini dans

    ce fichier stdlib.h comme lquivalent de unsigned long int) qui indique le nombre

    doctets allouer et quelle renvoie un pointeur void*.

    Nous connaissions le type void que signifie void* ? Littralement cest un pointeur sur

    rien du tout, dans la pratique cest le contraire : cela dcrit un pointeur sur nimporte

    quelle type de donne, un pointeur universel en quelque sorte.

    Il est important de noter que le paramtre tail le transmis malloc() (la variable nomme

    size dans le prototype) est une taille en octets. Ainsi si nous ne souhaitons pas un

    tableau doctets - de char - nous devrons prciser le nombre dlments multipli par la

    taille dun lment. Pour cela nous pouvons utiliser loprateur sizeof() - ce nest pas

    une fonction car le rsultat est valu la compilation - qui fournit la taille du type ou

    de la variable utilis comme paramtre. Par exemple, lexpression sizeof(short) est

    remplace par la valeur 2 durant la phase de compilation sur machine Intel.

    Enfin, pour stocker le rsultat (de type void*) de la fonction malloc() dans notre variable,

    nous devons raliser une conversion explicite de void* vers le type qui nous intresse.

    Voyons comment raliser tout cela :

    Code 4 : Cration dun tableau de taille quelconque

    #include /* pour la fonction printf() */

    #include /* pour la fonction malloc() */

    voidmain(){

    short i; /* une variable utilise pour une boucle */

    short taille; /* mmorise la taille du tableau */

    long* tableau; /* pointeur pour stocker ladresse du tableau */

    taille = 5; /* saisi par l'utilisateur dans un vrai code */

    /* allocation (dynamique) de notre tableau */

    tableau = (long*) malloc(taille * sizeof(long));

    /* remplissage du tableau, on utilise les indices 0 (taille -1) */

    for (i = 0; i < taille; i++)

    tableau[i] = i;

    /* affichage du contenu du tableau */

    for (i = 0; i < taille; i++)

    printf("%lu\n", tableau[i]);

    /* destruction du tableau : libration de la mmoire rserve */

    free(tableau);

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    26/107

    Sylvain Ferey ([email protected]) 26

    Forum des Programmeurs Francophones

    }

    Notez que tout bloc de mmoire allou avec malloc() doit tre libr par un appel free().

    Le prototype de free() est void free(void* ptr); ici il nest pas besoin de convertir

    explicitement notre tableau de type long* en void*. En effet, un type pointeur gnrique

    peut recevoir nimporte quel pointeur puisque cette conversion perd de linformation.

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    27/107

    Sylvain Ferey ([email protected]) 27

    Forum des Programmeurs Francophones

    Les tableaux de caractres

    Dans notre premier programme nous avons utilis la fonction printf() avec une chane

    de caractres; notez quen C/C++ il nexiste pas de type chane de caractres

    quivalent au type String du Pascal; ce type est obtenu en utilisant un tableau de

    caractres.

    Pour dclarer une chane statique, nous utiliserons donc un tableau - dont la taille sera

    ou non prcise. Si elle ne lest pas le compilateur rservera un tableau pour y stocker

    toute la chane, si par contre une taille N est prcis le compilateur ne retiendra que

    les N premiers caractres de cette chane; exemple :

    char chaine1[] = "hello"; /* dclaration correcte */

    char chaine2[5]= "bonjour"; /* correct mais chane2 contient "bonjo" */

    Que font ces instructions ?

    Lorsque nous dclarons char chaine1[] = "hello", le compilateur rserve dans une zone

    mmoire (gnralement dans le segment de donnes) six octets et il y range notre

    chane en y ajoutant un caractre ascii zro marquant la fin de cette chane :

    h e l l o 0

    ensuite il fixe la valeur de chaine1 avec ladresse du premier caractre de la chane.

    Notez que la dclaration :

    char* chaine1 = "hello";

    est compltement quivalente la dfinition de chaine1 prcdente.

    Except cet ajout automatique dun caractre ascii zro de terminaison de chanes, lestableaux de caractres sont semblables aux tableaux dautres types.

    Nous pourrons par exemple crer des chanes dynamiquement en utilisant malloc();

    nous devrons cependant dans ce cas tre vigilant ajouter nous mme le caractre zro

    lors de la construction de nos chanes.

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    28/107

    Sylvain Ferey ([email protected]) 28

    Forum des Programmeurs Francophones

    Les oprateurs

    Les oprateurs sont nombreux en C et C++, ceci est d au fait que certaines oprations

    ralises par des fonctions dans dautres langages sont faites ici par des oprateurs et

    galement au fait que le C et C++ permettent des formes dcritures doprations

    impossibles dans dautres langages.

    Les oprateurs mathmatiques

    les oprateurs disponibles sont :

    Oprateur Syntaxe Description

    + a + b calcule la somme de a et b

    - a - b calcule la diffrence de a moins b

    * a * b calcule la multiplication de a par b

    / a / b calcule la division de a par b

    % a % b calcule le reste de la division entire de a par b

    - - a value loppos de a

    Notez que le rsultat dune opration numrique dpend du type de la variable rsultat,

    en effet si ce nombre dpasse lintervalle de dfinition du type de la variable rsultat il

    sera tronqu, exemple:

    unsigned short a = 160, b = 500;

    unsigned shortc = a * b;

    printf("%hu\n", c); /* affiche 14464 soit 80000 - 65536 */

    cette opration aurait d tre code :

    unsigned short a = 160, b = 500;

    unsigned long c = a * b;

    printf("%u\n", c); /* affiche 80000 */

    De plus lutilisation de nombres signs ou non signs peut galement produire des

    rsultats diffrents, par exemple :

    signed short a = 80, b = 500;

    signed short c = a * b;

    unsigned short d = a * b;

    printf("%hd\n", c); /* affiche -25536 */

    printf("%hu\n", d); /* affiche 40000 */

    Dans cet exemple les variables c et d contiennent en fait exactement la mme valeur,

    cest linterprtation que lon en fait qui provoque la diffrence des rsultats.

    Enfin, le rsultats dpend du type des variables oprandes, ainsi le code :

    short a = 80, b = 500;

    float c = b / a;

    printf("%g\n", c); /* affiche 6 au lieu de 6.25 */

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    29/107

    Sylvain Ferey ([email protected]) 29

    Forum des Programmeurs Francophones

    naffiche pas le (vrai) rsultat de la division (non entire) de b par a; en effet a et b tant

    entiers, une division entire est ralise.

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    30/107

    Sylvain Ferey ([email protected]) 30

    Forum des Programmeurs Francophones

    Pour obtenir le rsultat correct il faut, soit introduire un nombre flottant dans les

    arguments de la division, exemple :

    short a = 80, b = 500;

    float c = 1.0 * b / a;

    printf("%g\n", c); /* affiche 6.25 */

    soit retyper une des variables signed short en float, ce changement de type est ralis

    en indiquant avant la variable altrer un nom de type entre parenthses :

    short a = 80, b = 500;

    float c = (float) b / a;

    printf("%g\n", c); /* affiche 6.25 */

    Les oprateurs logiques et relationnels

    Les oprateurs suivant produisent tous un rsultat logique vrai (gnralement cod 1)

    ou faux (cod 0).

    Oprateur Syntaxe Description

    == a == b value a gal b

    != a != b value a diffrent de b

    && a && b effectue un ET logique entre a et b

    || a || b effectue un OU logique entre a et b

    ! !a value la ngation logique de a

    > a > b value a plus grand que b

    >= a >= b value a plus grand ou gal b

    =, b && c < d)

    est quivalent :

    ( (a > b) && (c < d) )

    De plus tous les oprateurs ont une priorit infrieure aux oprateurs mathmatiques,

    ainsi :

    (a < b - 1 && c % d)

    est quivalent, puisque quun test logique est vrai pour toutes valeurs diffrentes de

    zro, :

    ( ( a < (b - 1) ) && ((c % d) != 0) )

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    31/107

    Sylvain Ferey ([email protected]) 31

    Forum des Programmeurs Francophones

    Loprateur unaire de ngation logique ! appliqu une valeur logique vrai ou faux

    renvoie son contraire; appliqu une valeur numrique ou une adresse non nulle il

    renvoie 0, enfin appliqu un oprande nul il renvoie 1; cet oprateur est couramment

    utilis dans des tests :

    long* a_ptr;

    ....a_ptr = (long*) malloc( 10 * sizeof(long) );

    if (!a_ptr) {

    /* lallocation a choue */

    /* a_ptr est un pointeur nul */

    }

    short c;

    ....

    if (!c){ /* quivalent : if (c == 0) */

    ....

    }

    Les oprateurs dincrmentation et dcrmentation

    Loprateur ++ est loprateur dincrmentation: il ajoute 1 la variable sur lequel il

    est appliqu. L'oprateur -- est loprateur de dcrmentation: il diminue de 1 la valeur

    de la variable sur lequel il est appliqu.

    Ces deux oprateurs produisent deux rsultats diffrents selon quils sont placs

    gauche ou droite dune expression.

    Placs gauche, ils agissent avant que la variable ne soit utilise dans linstruction qui

    la contient; placs droite, ils agiront aprs que la variable ait t utilise.

    Illustrons ceci :

    short a = 5; /* dclare a avec la valeur 5 */

    a++; /* fixe la valeur de a 6 */

    short b = a++; /* fixe b a soit 6 */

    /* PUIS incrmente a (a gal 7) */

    short c = ++a; /* incrmente a (soit 8) */

    /* PUIS affecte c (c gal 8) */

    La position de loprateur (avant ou aprs loprande) induit donc des effets de bord (ou

    effets rebond), ces effets peuvent tre trs sensibles et produiront un rsultat

    imprvisible lorsque loprande apparat plusieurs fois dans lexpression; par exemple

    linstruction suivante cherche remplir llment dindice i dun tableau avec cette

    valeur de i :

    short a[10]; /* un tableau de 10 entiers courts */

    ....

    short i = 3;

    a[ i ] = i++; /* qu'avons-nous ralis ??? */

    aprs cette dernire instruction, i vaut 4 mais a ton fix a[ 3 ] ou a[ 4 ] ?

    En fait cela dpend du compilateur et la seule rponse certaine est quil ne faut pasabuser des oprateurs ou pour le moins quune telle expression ne doit jamais tre

    code.

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    32/107

    Sylvain Ferey ([email protected]) 32

    Forum des Programmeurs Francophones

    Les oprateurs binaires

    Ces oprateurs oprent sur la reprsentation binaire des nombres, ils ne peuvent donc

    tre utiliss quavec des oprandes de type entiers.

    Oprateur Syntaxe Description

    & a & b effectue un ET bit bit

    | a | b effectue un OU inclusif bit bit

    ^ a ^ b effectue un OU exclusif bit bit (appel aussi XOR)

    a >> b effectue un dcalage droite de b bits sur le nombre a

    ~ ~a effectue un complment un (ngation binaire)

    Les oprateurs de dcalage de bits seront utiliss avec prudence sur les types signs, en

    effet lors dun dcalage droite les bits dcals seront remplis par des zros pour un

    oprande non sign alors quun nombre sign sera complt de bits de signe (dcalage

    arithmtique) ou par des zros (dcalage logique) en fonction de la machine utilise et /

    ou du compilateur.

    Rappel pour les personnes non rompues aux oprations binaires par une longue

    pratique dassembleur:

    un dcalage de bits gauche revient multiplier le nombre par une puissance de 2;

    formellement a

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    33/107

    Sylvain Ferey ([email protected]) 33

    Forum des Programmeurs Francophones

    Les oprateurs contracts

    La plupart des oprations de la forme a = a oprateur b peuvent tre crites de manire

    plus concise sous la forme a oprateur= b.

    Ainsi:

    a = a + b peut scrire a += b

    a = a - 5 peut scrire a += 5

    a = a * (b + 2) peut scrire a *= b + 2

    a = a & 0x0F peut scrire a &= 0x0F

    Remarque : il nexiste pas de forme contracte pour les oprateurs , ni,

    videmment, pour les oprateurs unaires.

    Les piges viter

    Lors de votre apprentissage du langage C et C++ vous risquez de rencontrer des bugs

    (incomprhensibles) ds des inversions entre diffrents oprateurs ressemblants.

    Le premier pige viter, surtout si vous avez lexprience du Pascal, est la confusion

    entre les oprateurs de tests (==) et daffectation (=), ainsi si vous crivez

    a == 5;

    au lieu de

    a = 5;

    le compilateur ne dtectera aucune erreur (sauf pour une expression comme short a ==

    5;) et votre initialisation se rsumera un test (dont le rsultat est ignor).

    Cette erreur est rarement commise, par contre linverse peut se produire, par exemplelors dun test :

    if (a = 2) ... /* possible erreur de codage */

    ici, non seulement le test sera toujours vrifi pour des valeurs diffrentes de zro, mais

    en plus vous altrez le contenu de la variable; certains compilateurs mettent un

    avertissement (affectation non dsire possible) pour ce type dcriture, dautres ne

    vous diront rien.

    Une solution pour contourner ce problme est dcrire, quand cela est possible, la

    constante gauche du signe, ainsi :

    if (2 = a) ... /* possible erreur de codage MAIS erreur de syntaxe */

    provoquera toujours une erreur de compilation; cependant vous comparerez souvent

    deux variables entre elles et dans ce cas cette astuce est inuti lisable; dans dautres cas

    vous voulez prcisment raliser cette affectation et tester si la valeur transmise est

    non nulle, cest le cas notamment lorsque vous stockez le rsultat dune fonction

    retournant un code derreur, on crirait alors :

    if ( err = maFonction() ) ...

    ceci est valide et pour le coup on sera peut tre agac par les avertissement mis par le

    compilateur, la meilleure faon dcrire une telle instruction serait :

    if ( ( err = maFonction() ) == noErr ) ...

    /* o noErr est une constante */

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    34/107

    Sylvain Ferey ([email protected]) 34

    Forum des Programmeurs Francophones

    Lautre erreur souvent commise et linversion entre les oprateurs ET et OU logiques

    versus binaires, ainsi:

    short a = 5, b = 3;

    if (a & 4 && b & 1) ...

    est valu comme if ( 4 et 1 ) soit if ( vrai et vrai ), donc le test est vrifi. Par

    contre :

    short a = 5, b = 3;

    if (a && 4 & b && 1) ...

    est valu comme if ( 5 et (4 et binaire b) et 1 ) soit if ( 5 et 0 et 1), donc le test

    nest pas vrifi.

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    35/107

    Sylvain Ferey ([email protected]) 35

    Forum des Programmeurs Francophones

    Les instructions de tests

    Linstruction if

    Linstruction de test if ... else ... sert adapter un traitement toutes sortes de

    conditions pouvant se ramener une expression vrai ou faux; notez que les mots cls

    if et else doivent tre saisis en minuscule, comme tous les mots cls.

    La syntaxe de linstruction if est :

    if ( condition )

    instruction ;

    else

    instruction ;

    Remarque :

    ?? la condition test est toujours place entre parenthses.

    ?? la clause else et le bloc dinstruction li sont optionnels.

    ?? toute instruction se termine par un point virgule, y compris celle prcdant

    linstruction else (contrairement la syntaxe du Pascal).

    Nous supposons dans les exemples suivants que A, B et C dsignent des valeurs

    boolennes. Voici un premier exemple de test simple :

    if( A )

    printf("A est vrai\n");

    else

    printf("A est faux\n");

    Les blocs dinstructions excuts si le test est vrifi ou non peuvent tre constitus de

    plusieurs instructions, nous utiliserons alors des accolades pour dlimiter ces blocs;

    exemple :

    if( A ) {

    printf("A\n");

    printf("est vrai\n");

    }

    else {

    printf("A\n");

    printf("est faux\n");

    }

    Souvent nous aurons dterminer le traitement raliser parmi plus de deux choix,

    pour cela nous pouvons enchaner les tests if... else; exemple :

    if( A )

    printf("A est vrai\n");

    else if ( B )

    printf("B est vrai\n");

    else

    printf("A et B sont faux\n");

    Lorsque nous enchanons plusieurs tests, il est important dtre vigilant sur la porte de

    la clause else, considrons par exemple le bloc suivant :

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    36/107

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    37/107

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    38/107

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    39/107

    Sylvain Ferey ([email protected]) 39

    Forum des Programmeurs Francophones

    est quivalent :

    short n;

    .......

    if( n != 0 )

    printf("n est non nul\n");

    else

    printf("n est nul\n");

    Des conditions avec et et ou

    La condition test peut galement tre constitue de plusieurs conditions associes par

    des critres et logique et ou logique.

    Loprateur et logique scrit &&; loprateur ou logique scrit || ([Alt Gr] + 6);

    exemple :

    if( A && B )

    printf("A et B sont vrais\n");

    else if ( A || C )

    printf("A ou C ou les deux sont vrais\n");

    else

    printf("A et C sont faux, B est peut tre vrai\n");

    Loprateur ternaire ?:

    On parle doprateur ternaire car celui-ci ncessite trois arguments, contrairement

    aux oprateurs binaires qui prennent deux arguments (exemple loprateur de test ==,

    on crit: arg1 == arg2) et aux oprateurs unaires qui nutilisent quun argument(exemple loprateur de ngation -, on crit: -arg).

    Cet oprateur scrit: (condition) ? (instruction_1) : (instruction_2)

    si la condition est vrifie le bloc instruction_1 est excut, sinon cest le bloc

    instruction_2 qui lest.

    Cet oprateur se prte bien aux affectations conditionnelles, par exemple nous

    voudrions crire :

    short choix;

    if( A )choix = 1;

    else

    choix = 2;

    ce code peut tre crit grce l oprateur ? : :

    short choix = ( A ) ? 1 : 2;

    Pour des raisons de lisibilit, on vitera son emploi dans des blocs de codes trop

    compliqus. Retenez cependant que partout o nous utilisons une squence :

    if( condition ) {

    expression 1}

    else {

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    40/107

    Sylvain Ferey ([email protected]) 40

    Forum des Programmeurs Francophones

    expression 2

    }

    nous pouvons crire :

    ( condition ) ? { expression 1} : { expression 2}

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    41/107

    Sylvain Ferey ([email protected]) 41

    Forum des Programmeurs Francophones

    Linstruction switch

    Imaginons que nous souhaitons crire un bloc de tests portant de nombreuses

    conditions, avec des critres ou logique et des tests imbriqus, par exemple :

    short X;

    ...

    if( X == 1 )

    [instruction A];else if( X == 2 || X == 3 )

    [instruction B];else if( X == 4 || X == 5) {

    [instruction C];

    if( X == 4 )

    [instruction D];

    }

    else

    [instruction E];

    pour simplifier lcriture de tel bloc nous utiliserons linstruction switch( ... ) { ... }

    associe plusieurs tiquettes case.

    Nous utilisons comme argument de la clause switch lexpression dont nous aurions

    teste la valeur; chaque valeur-test fait lobjet dune tiquette case suivie dun bloc

    dinstructions et du mot cl break ds que le traitement raliser pour cette valeur-

    test est effectu; enfin ltiquette default permet de grer tous les cas nayant pas t

    traits.

    Cela conduit :

    short X;

    ...

    switch( X ) {

    case 1:

    [instruction A];

    break;

    case 2:

    case 3:

    [instruction B];

    break;

    case 4:

    [instruction C];

    /* et continue avec l'instruction suivante */

    case 5:

    [instruction D];

    break;

    default:

    [instruction E];

    }

    /* linstruction break nous mne ici */

    Explications :

    ?? notez la prsence dun : (deux points) aprs la valeur des tiquettes case

    ?? ltiquette case 1: intercepte le cas o X est gal la valeur 1, le bloc [instruction A]

    est alors excut puis linstruction break nous fait sortir du bloc switch. Cette

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    42/107

    Sylvain Ferey ([email protected]) 42

    Forum des Programmeurs Francophones

    instruction break est indispensable, sans elle lexcution continuerait linairement

    avec le bloc [instruction B].

    ?? ltiquette case 2: atteinte si X est gal 2 ne ralise aucune opration si ce nest

    de poursuivre avec les instructions suivantes.

    ?? ltiquette case 3: est atteinte si X est gal 3 mais galement pour X gal 2

    puisqu ltiquette prcdente nous navons pas effectu de break.

    ?? ltiquette case 4: provoque lexcution de l [instruction C]; nous ne faisons pas

    suivre ce bloc dinstruction du mot cl break, lexcution se poursuit donc avec le bloc

    [instruction D].

    ?? ltiquette case 5: est atteinte directement si X est gal 5 et par poursuite du

    traitement si X tait gal 4; nous ralisons lexcution de l [instruction D] et nous

    quittons le bloc switch.

    ?? enfin, tous les cas non traits (cest dire dans tous les cas o X est plus petit que 1

    ou plus grand que 5) nous effectuons le bloc [instruction E].

    Remarques :

    ?? ltiquette default est optionnelle.

    ?? une tiquette ne peut pas dfinir un intervalle de valeur, par exemple case 1..3: est

    interdit; on crira la place plusieurs case comme pour les valeurs 2 et 3 dans

    lexemple ci -dessus.

    ?? la valeur dune tiquette doit pouvoir tre value au moment de la compilation et

    tre une valeur entire. Cest donc une valeur immdiate (comme une constante),

    une opration sur des constantes (exemple: maConstante + 2), mais cela ne peut

    pas tre le rsultat dune fonction ou tout autre expression value lexcutionuniquement.

    ?? les valeurs numriques des tiquettes nexigent ni dtre ordonnes (de la plus petite

    valeur la plus grande) ni de former une srie discrte (1 puis 2 puis 3 ...).

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    43/107

    Sylvain Ferey ([email protected]) 43

    Forum des Programmeurs Francophones

    Les instructions de boucles

    Linstruction while

    Linstruction de boucle while permet de raliser un traitement tant quune condition

    boolenne est vraie.

    La syntaxe de linstruction while est :

    while( condition )

    instruction ;

    Remarque : la condition test est toujours place entre parenthses.

    Si le bloc instruction est compos de plusieurs instructions, on placera ces instructions

    entre les symboles de dbut et de fin de bloc: { et } soit :

    while( condition ) {

    instruction 1;instruction 2;

    ...

    }

    Exemple de boucle :

    Code 5 : Boucle while(..) { ... }

    #include

    /* Saisie d'un nombre avec cho de ce nombre sur la console */

    voidmain() {

    short nombre = 1;while( nombre != 0 ){

    printf("Tapez un nombre (0 pour sortir) : ");

    scanf("%hd", &nombre);

    printf("Votre nombre est %hd\n", nombre);

    }

    }

    Le contenu de la boucle (affichage du message, saisie du nombre et raffichage du

    nombre) est rpt tant que lutilisateur ne rentre pas la valeur zro.

    Linstruction break

    Linstruction de sortie de boucle break permet de quitter la boucle en cours. Ceci peut

    tre utile si le traitement est irralisable ou si une erreur se produit dans la boucle.

    Notez cependant que linstruction break quitte la boucle immdiatement parente; mais

    en cas de boucle imbrique il reste dans la boucle prcdente.

    Rcrivons le code prcdent pour limiter le traitement des nombres infrieurs 100 :

    Code 6 : Boucle while(..) { ... } avec sortie par break

    #include

    voidmain() {

    short nombre = 1;

    while( nombre != 0 ){

    printf("Tapez un nombre (0 pour sortir) : ");

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    44/107

    Sylvain Ferey ([email protected]) 44

    Forum des Programmeurs Francophones

    scanf("%hd", &nombre);

    if (nombre > 100)

    break;

    printf("Votre nombre est %hd\n", nombre);

    }

    }

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    45/107

    Sylvain Ferey ([email protected]) 45

    Forum des Programmeurs Francophones

    Bien sr, nous aurions pu crire while ( nombre != 0 && nombre

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    46/107

    Sylvain Ferey ([email protected]) 46

    Forum des Programmeurs Francophones

    ces boucles (avec contrle la fin) sont moins utilises, cependant il existera toujours

    un problme pour lequel le meilleur algorithme utilisera cette forme de boucle.

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    47/107

    Sylvain Ferey ([email protected]) 47

    Forum des Programmeurs Francophones

    Linstruction for

    Linstruction de boucle for est peut tre la plus souple du langage C, on dit couramment

    que nimporte quel programme C peut se ramener une boucle for; la syntaxe de

    linstruction for est :

    for ( initialisation ; test ; incrmentation )

    instruction ;

    Au nouveau, si plusieurs instructions doivent tre excutes chaque itration, on

    crira :

    for ( initialisation ; test ; incrmentation ) {

    instruction 1;

    instruction 2;

    ...

    }

    Les trois expressions dinitialisation, de tests et dincrmentation sont facultatives,

    ainsi le bloc :

    for ( ; ; ){}

    est un bloc dinstruction valide, vide et rpt linfini.

    Lexpression dinitialisation

    La premire instruction sert initialiser des variables, vous pouvez aussi dfinir une

    variable lors de cette initialisation (en C++ et sous certaines conditions en C), par

    exemple une boucle contrle par une variable compteur commencerait par :

    for ( short compteur = 0 ; . . .

    Remarque : dans le cas o la variable est dfinie dans linstruction for, celle-ci nest

    plus visible ds que lon sort de la boucle (son utilisation provoquera une erreur signale

    par le compilateur). De plus les dernires normes du langage C++ recommandent ou

    imposent lemploi dune variable locale comme variable de contrle de linstruction for et

    la visibilit de cette variable est rduite cette boucle; ainsi dans :

    for ( short compteur = 0 ; . . .) {

    quelque chose;

    }

    for ( short compteur = 0 ; . . .) {

    autre chose

    }

    lidentificateur compteur dcrit bien deux variables diffrentes, chacune ntant

    utilisable que dans son instruction for; cependant encore de nombreux compilateurs

    ignorent cette norme et signaleraient, par un avertissement ou une erreur, que

    lidentificateur compteur est dj dclar lors de la compilation de la seconde boucle.

    Lexpression de test

    La condition de test est vrifie au dbut de lexcution du bloc, comme ctait le cas

    pour linstruction while, ainsi si notre boucle commence par :

    for ( short compteur = 0 ; compteur < 0 ; . . .

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    48/107

    Sylvain Ferey ([email protected]) 48

    Forum des Programmeurs Francophones

    le corps de la boucle ne sera jamais excut car compteur (initialis zro) ne vrifie

    pas la condition test (zro nest pas strictement infrieur zro).

    De plus le test peut tre complexe et mettre en jeu des oprateurs logiques, par exemple

    nous pouvons dfinir :

    for ( short compteur = 0 ; compteur < ValeurMax && variableLogique ; . .

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    49/107

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    50/107

    Sylvain Ferey ([email protected]) 50

    Forum des Programmeurs Francophones

    De mme, lexpression dincrmentation incrmente compteur (compteur++) et, selon

    le rsultat du test nombre % 2 qui calcule nombre modulo 2 et donc retourne 0 si

    nombre est pair et 1 sil est impair, incrmente pairs ou impairs.

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    51/107

    Sylvain Ferey ([email protected]) 51

    Forum des Programmeurs Francophones

    Revenons notre exemple dorigine, avec une boucle for nous crivons :

    void main() {

    short nombre = 1

    for( ; nombre != 0 ; ){

    printf("Tapez votre nombre (0 pour sortir) : ");

    scanf("%hd", &nombre);

    printf("Votre nombre est %hd\n", nombre);}

    }

    ici nous navons aucune opration dinitialisation ou dincrmentation raliser, seule

    lexpression de test est alors dfinie.

    Pour illustrer la polyvalence de la boucle for, remarquons que lexpression :

    for ( expression 1 ; .expression 2 ; expression 3 ) {

    instructions;

    ...

    }

    est quivalente lexpression :

    expression 1;

    while ( expression 2 ) {

    instructions;

    ...

    expression 3;

    }

    Linstruction continue

    Nous avons vu tout lheure que linstruction break quittait la boucle en cours

    dexcution; si en fait nous souhaitions de pas appliquer un traitement pour certainesvaleurs mais autoriser la poursuite de la boucle, nous pouvons utiliser linstruction

    continue pour forcer valuer litration suivante sans quitter la boucle (dans lexemple

    prsent ici, nous pouvions certes utiliser un test), exemple :

    Code 9 : Boucle for avec break et continue

    #include

    /* Saisie de 10 nombres maximum avec cho de ce nombre sur la console */

    /* si le nombre saisi est suprieur 10, il nest pas affich */

    /* si le nombre saisi est suprieur 100, la boucle est interrompue */

    void main() {short compteur;

    short nombre = 1;

    for( compteur = 0; compteur < 10 ; compteur++ ){

    printf("Tapez votre nombre (0 pour sortir) : ");

    scanf("%hd", &nombre);

    if (nombre > 100)

    break; /* finit le programme pour une valeur > 100 */

    if (nombre > 10)

    continue; /* finit cette itration pour une valeur > 10 */

    printf("Votre nombre est %hd\n", nombre);

    /* linstruction "continue" nous mne ici, compteur++ va tre

    excut, le test compteur < 10 sera valu et le cas chant

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    52/107

    Sylvain Ferey ([email protected]) 52

    Forum des Programmeurs Francophones

    litration suivante sera excute. */

    }

    /* linstruction "break" nous mne ici */

    }

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    53/107

    Sylvain Ferey ([email protected]) 53

    Forum des Programmeurs Francophones

    Les fonctions

    Les fonctions sont omniprsentes en C; elles prsentent le moyen de diviser des taches

    complexes en oprations plus simples et, avec le temps, les bibliothques de fonctions

    que vous aurez crites constitueront votre capital-codage qui vous permettra de

    construire de nouveaux programmes sans passer votre temps tout reconstruire

    chaque fois.

    Pour grer efficacement vos bibliothques de fonctions, nous vous conseillons de

    maintenir des fichiers pas trop volumineux o les fonctions sont regroupes par thme.

    Pour construire une bibliothque, vous devrez crer deux fichiers:

    1. Un fichier den-tte (avec lextension .h) sera utilis pour stocker les dclarations -

    ou prototypes - des fonctions.

    2. Un fichier de dfinition (ayant le mme nom mais utilisant lextension .c sil sagit

    de C pur et .cpp sil sagit de C++) contiendra limplmentation de ces fonctions.

    Cette organisation assurera, vos bibliothques, une compatibilit maximale avec le

    plus grand nombre de compilateurs.

    Dclaration

    La dclaration gnrique dune fonction est :

    type_resultat nom_de_fonction ( type_parametre [nom_parametre] );

    1. le type_resultat est un type fondamental, un type utilisateur ou un type pointeur sur

    lun de ces types. Sil sagit dun type utilisateur il doit tre connu - cest dire avoir

    t dclar - au moment de la dfinition de la fonction. La valeur void prcise que la

    fonction ne renvoie rien (cest alors une procdure au sens pascalien du terme); ce

    type_resultat dfinit le type de la fonction.

    2. le type des paramtres reus est quelconque mais doit galement tre connu au

    moment de la dfinition; on ne peut pas transmettre void mais void* est valide et

    dcrit un pointeur universel.

    3. le nom des paramtres est facultatif dans la dclaration de la fonction : vous pouvez

    vous contenter de fournir uniquement leur type. De plus le nom que vous utiliserez

    votre dcrire ce paramtre dans la dfinition de la fonction (son codage) peut tre

    diffrent du nom que vous utiliseriez ici. Une bonne rgle est de choisir un nom

    dcrivant au mieux ce que reprsente ce paramtre.

    Le fichier de dclaration que vous allez crer sera inclus dans tous les fichiers de

    codages (les .c ou .cpp) qui auront besoin dappeler ces fonctions; pour viter quun

    fichier ne soit inclus plusieurs fois - par suite dinclusion en cascade de fichiers

    utilisant les mmes dfinitions - ce qui pourrait provoquer des erreurs de redfinition de

    symboles, nous utilisons une dfinition de constantes dcrivant ce fichier.

    Pour cela nous utiliserons #ifndef (if not defined) afin de tester si un symbole - une

    directive - est dfini, #define pour dfinir un symbole et #endif pour finir le #ifndef.

    Remarque: il existe aussi #ifdef pour tester lexistence dune directive.

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    54/107

    Sylvain Ferey ([email protected]) 54

    Forum des Programmeurs Francophones

    Grce ces instructions nommes pragma, nous pourrons en quelque sorte signer

    notre fichier de dfinition en dfinissant une constante dont lexistence ne dure que le

    temps de la compilation dun fichier, lhabitude veut que cette signature soit le nom du

    fichier en majuscules avec un double soulign au dbut et la fin de ce nom.

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    55/107

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    56/107

    Sylvain Ferey ([email protected]) 56

    Forum des Programmeurs Francophones

    Nous pouvons galement inclure dautres fichiers de dfinitions si cela est ncessaire.

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    57/107

    Sylvain Ferey ([email protected]) 57

    Forum des Programmeurs Francophones

    Le fichier doit dfinir toutes les fonctions dclares, dans le cas contraire il demeurera

    parfaitement compilable mais si un programme utilise ce fichier il risque de ne pas

    pouvoir tre construit du fait du manque de nos fonctions; dans un tel cas, il est

    prfrable de ne pas inclure les fonctions non encore codes dans le fichier dclaration;

    elles y seront ajoutes lorsque leur codage sera ralis.

    Voici notre fichier dfinition pour notre librairie gomtrique :

    Code 11 : Fichier de dfinition : geometry.c

    /* Dclaration de la bibliothque gomtrique */

    #ifndef __GEOMETRY__

    #include "geometry.h"

    /* les fichiers utilisateurs sont prciss entre guillemets */

    #endif

    #include /* les fichiers de systme sont prciss entre symboles < et > */

    /* Dfinition des fonctions non exportes */

    /* calcul du carr d'un nombre */

    inline float sqr(const float x)

    /* inline signifie que la fonction ne sera pas rellement appele

    mais que son code sera recopie l o la fonction est appele,

    cela acclre le traitement pour des petites fonctions */

    {

    return ( x * x );

    }

    /* Dfinition des fonctions publiques */

    float surface_cercle( const float rayon )

    {

    /* M_PI est dfini dans math.h */

    return M_PI * sqr( rayon );

    }

    float surface_carre( const float cote )

    {

    return sqr( cote );

    }

    float surface_forme( const float taille, forme_t forme )

    {

    switch ( forme ){

    case CERCLE:

    return surface_cercle( taille );

    case CARRE:

    return surface_carre( taille );

    default:

    return 0.0;

    }

    }

    Ces deux fichiers dfinissent notre bibliothque. Le fichier geometry.h sera inclus partout fichier ayant besoin de ses fonctions, tandis que geometry.c devra tre inclus dans

    la liste des fichiers du projet. Cest dire prsent sur la ligne de commande lors de

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    58/107

    Sylvain Ferey ([email protected]) 58

    Forum des Programmeurs Francophones

    lappel au compilateur GNU ou insr dans votre projet si vous utilisez un gestionnaire

    de projets.

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    59/107

    Sylvain Ferey ([email protected]) 59

    Forum des Programmeurs Francophones

    Librairie

    Nous pouvons simplifier un peu cela en construisant une vritable librairie.

    Pour cela, nous compilons (une fois pour toute - jusqu sa prochaine modification) le

    fichier geometry.c en utilisant loption -c de GNU gcc afin de demander seulement la

    compilation du fichier (et non la cration dun excutable) :

    > gcc -c geometry.c -o geometry.o

    ceci cr un fichier geometry.o; loption -o geometry utilise pour lancer gcc est

    optionnelle selon lenvironnement; nous convertissons maintenant ce fichier binaire au

    format objet en une librairie :

    > ar -rc geometry.a geometry.o

    Sur systme unix et Linux, vous devrez peut tre excuter en plus :

    > ranlib geometry.a

    Ceci a cr notre librairie, voyons comment lutiliser, pour cela nous crons un petit

    programme - ce sera un programme et non plus une bibliothque car il contiendra une

    fonction main - ce fichier doit inclure geometry.h et utiliser geometry.a durant sa

    construction.

    Voici le programme, enregistrez-le sous test-geo.c :

    Code 12 : Utilisation de la librairie : geometry.a

    /* Utilisation de la bibliothque gomtrique */

    #include

    #include "geometry.h"

    voidmain()

    {

    float carre = surface_forme ( 10.0, CARRE );

    float cercle = surface_forme ( 5.0, CERCLE );

    float rapport= cercle / carre;

    printf( "un cercle inscrit dans un carre "

    "occupe %g %% de sa surface\n", rapport );

    }

    Notez que la diffrenciation selon la casse permet de dfinir une variable carre qui est

    bien un symbole diffrent de la constante CARRE dfinie dans geometry.h.

    Nous compilons ce programme en incluant notre librairie dans la liste des fichiers :

    > gcc test-geo.c geometry.a -o test-geo.exe

    Nous pouvons alors lancer ce programme et nous obtenons :

    > un cercle inscrit dans un carre occupe 0.7854 % de sa surface

    Notez que notre programme aurait pu appeler directement les fonctions surface_cercle

    et surface_carre puisque celles-ci sont exportes par le fichier de dclaration. Par

    contre la fonction sqr, implmente dans geometry.c, mais non dfinie dans len-tte

    reste cache et ne peut tre utilise qu lintrieur de geometry.c.

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    60/107

    Sylvain Ferey ([email protected]) 60

    Forum des Programmeurs Francophones

    La fonction main

    La fonction principale main est obligatoire pour crer un programme. Elle doit tre

    unique et ce nom (ainsi que la casse) est impos.

    Code de retour

    La valeur retourne par la fonction main est soit de type int soit de type void.

    En fait main retourne toujours une valeur car le systme qui a lanc votre programme

    attend cette valeur de compte rendu dexcution; si vous avez dclar void, la valeur

    retourne est imprvisible ou dpend de votre compilateur.

    Sous Dos vous pouvez tester la valeur retourne avec la variable Dos errorlevel, en

    voici un exemple :

    Code 13 : Valeur retourne par la fonction main

    int main()

    {return 1;

    }

    Enregistrez ce fichier sous testmain.c et compilez-le pour crer testmain.exe.

    Nous utilisons ensuite ce programme dans un fichier batch :

    Code 14 : Lecture du code retourn par la fonction main

    @echo off

    testmain

    if errorlevel 2 goto option2

    if errorlevel 1 goto option1

    if errorlevel 0 goto option0

    :option0

    echo l'option 0 est atteinte

    goto fin

    :option1

    echo l'option 1 est atteinte

    goto fin

    :option2

    echo l'option 2 est atteinte

    goto fin

    :fin

    Enregistrez ce fichier sous testIt.bat et lancez-le, nous obtenons :

    > l'option 1 est atteinte

    Cette fonctionnalit permet de faire des programmes de type menu ou de construire des

    systmes de traitement qui excutent leurs tapes via plusieurs programmes spars.

    On testera alors le code de sortie de chaque programme avant de lancer le suivant; la

    valeur zro est gnralement utilise pour signifier une excution correcte.

    Remarque: ce principe existe galement sur unix et Linux, reportez-vous la

    documentation du shell utilis pour savoir comment utiliser ce code retour.

  • 7/27/2019 Programmation en Langage c c++ - 107 Pages

    61/107

    Sylvain Ferey ([email protected]) 61

    Forum des Programmeurs Francophones

    Paramtres reus

    La fonction main accepte plusieurs interfaces (prototypes) permettant ou non de recevoir