Ait Mahjoub Langage C

Elabor par : Mr Mustapha AITMAHJOUB
OFPPT : ISTA HAY RIAD
SOMMAIRE
Page
INTRODUCTION AU LANGAGE C++ 1. ELEMENTS DU LANGAGE .... 2 1.1 Alphabet du langage...2 1.2 Mots rservs........2 1.3 Identificateurs...2 1.4 Constantes...3 1.5 Commentaire...3 1.6 Les sparateurs3 2. STRUCTURE DUN PROGRAMME C++.4 2.1 Structure de base.5 3. TYPES DE DONNEES FONDAMENTAUX6 3.1 Donnes de type entier...........................................................................................6 3.2 Donnes de type rel..6 4. VARIABLES ET CONSTANTES..7 4.1 Variables 7 4.2 Constantes..7 5. ENTREE/SORTIE DES DONNEES..8 5.1 Fonction printf ().8 5.1.1 Sortie formate..8 5.1.2 Largeur du champ.9 5.1.3 Squences dchappement..10 5.2 Fonction scanf ()..10 6. LES EXPRESSIONS11 6.1 Oprateurs arithmtiques.12 6.2 Oprateurs de manipulation.12 6.3 Oprateurs dincrmentation/decrmentation.12 6.4 Oprateurs sizeof ().12 7. EXPRESSION BOOLEENNE.13 7.1 Oprateurs de comparaison.13 7.2 Oprateurs logiques.13 7.3 Oprateurs conditionnels ternaire14 8. INSTRUCTIUONS DAFFECTATION..14 9. PRIORITE DES OPERATEURS..17 INSTRUCTION DE CONTROLE 1. STRUCTURE SEQUENTIELLE.17 2. STRUCTURE SELECTIVE.18 2.1 Structure if19 2.2 Structure if,,else21 2.3 Structures if imbriques24 2.4 Structure switch25 STRUCTURE REPETITIVE26 3.1 Structure while.28
3.2 Structure do..while...29 3.3 Structure for.30
INSTRUCTUION DE BRANHEMENT..30 4.1 Instruction break...31 4.2 Instruction continue.31 4.3 Instruction goto34 TYPES DE DONNEES COMPLEXES 1. LES TABLEAUX.34 1.1 Tableaux unidimensionnels 34 1.1.1 Dclaration dun tableau.34 1.1.2 Initialisation dun tableau36 1.2 Tableaux multidimensionnels..36 1.2.1 Dclaration dun tableau...36 1.2.2 Initialisation dun tableau..38 LES CHAINES DE CARACTERES38 2.1 Fonctions dentre/sortie des chanes..39 2.2 Fonctions de traitement des chanes.40 2. LES STRUCTURES.41 3.1 Dclarations dune structure41 3.2 Dclaration de variables dune structur41 3.3 Accs aux membres de la structure..42 3. LES POINTUERS43 4.1 Dclaration des pointeurs.45 4.2 Tableaux et pointeurs47 4.3 Pointeurs et chanes de caractres 47 4.3.1 Initialisation dune chane47 4.3.2 Traitement des chanes.49 4.4 Pointeurs et structures..50 4.5 Allocation dynamique de la mmoire..52 4. ENUMERATION..52 5.1 Utilisation des numrations 53 5. DEFINITION DE NOUVEAUX TYPES..54 LES FONCTIONS FONCTION NE RETOURNANT PAS DE VALEUR.57 1.1 Fonction ne prenant pas de paramtres.57 1.2 Fonction prenant des paramtres...59 FONCTION RETOURNANT UNE VALEUR.61 PASSAGE DE PARAMETRES63 3.1 Passage par valeur63 3.2 Passage par adresse..64 3.3 Passage par rfrence64
PASSAGE DUN TABLEAU UNE FONCTION .66 PASSAGE DUNE STRUCTURE NE FONCTION..69 1. CLASSE DE STOKAGE72 6.1 Dure de vie..72 6.1.1 Variables automatiques73 6.1.2 Variables statiques et externes73
6.2 Porte des variables..74 6.2.1 Porte bloc74 6.2.2 Porte fonction.74 6.2.3 Porte fichier75 1. 2. 3. LES FICHIERS DEFINITION77 PRINCIPE DACCES AUX FICHIERS..77 ENTREE/SORTIE STANDARD..78 3.1 E/S des caractres79 3.1.1 Ouverture dun fichier.80 3.1.2 Ecriture vers un fichier83 3.1.3 Fermer un fichier.83 3.1.4 Lecture dun fichier.83 3.1.5 Fin de fichier84 3.1.6 Erreur douverture dun fichier84 3.1.7 Application : compter le nombre de caractres86 3.2 E/S des chanes..87 3.3 E/S formates90 3.4 Mode binaire et mode texte..93 3.5 E/S des enregistrements95 3.5.1 Ecriture des structures avec fwrite()95 3.5.2 Lecture des structures avec fread()..97 3.6 Accs alatoire.98 E/S SYSTEME..101 4.1 Lecture des fichiers..102 4.1.1 Cration dun tampon..103 4.1.2 Ouverture dun fichier.103 4.1.3 Identificateur de fichier...104 4.1.4 Lecture du fichier dans le tampon...104 4.1.5 Fermeture du fichier...105 4.1.6 Message derreur105 4.2 Oprations sur le tampon105 4.3 Ecrire dans un fichier..109
4.
Language C++
P.1
Language C++
P.2
INTRODUCTION AU LANGAGE C
1. ELEMENTS DU LANGAGE C 1.1 Alphabet du langage Le langage C utilise les lettres A Z (majuscule et minuscule), les chiffres 0..9 et certains symboles spciaux comme lments de construction pour former les lments de base dun programme. Certains symboles spciaux se composent de deux caractres conscutifs, par exemple ++ >= /* ! = 1.2 Mots rservs Les mots rservs ou mots cls ont en langage C et pour le compilateur une signification standard prdfini. Les mots cls ne peuvent pas tre redfinis par lutilisateur. Asm _asm __asm auto cdecl _cdecl __cdecl char continue _cs __cs default double _ds __ds else __es _export __export extern __far _fastcall __fastcall float goto huge __huge if interrupt _interupt __interupt _loadds near _near __near new _pascal__pascal private protected public return _saveregs __savaregs _seg signed sizeof _ss __ss switch template this typedefunion virtual void volatilewhile break case class const delet do enum _es far _far for friend inline int __loadds long operator pascal register __seg short static struct unsigned
TABLEAU 1 : Mots rservs
1.3 Identificateurs Un identificateur se dfinit comme un nom donn un lment du programme tels que les variables, les types, fonctions et les labels. Lidentificateur est cre en le spcifiant dans la dclaration dune variable, type ou dune fonction. Dans lexemple suivant, Valeur1, Valeur 2 et Somme sont des identificateurs de variables entires, et main() et printf() sont des identificateurs de fonctions.
Language C++
P.3
#include<stdio.h> void main() { int Valeur 1 , Valeur 2, Somme ; Valeur 1 = 10 Valeur 2 = 20 Somme = Valeur 1 + Valeur 2 ; Printf ( Somme = %d, Somme) ; } Une fois dclar, on peut utiliser lidentificateur, plus tard, dans une instruction de programme pour se rfrer la valeur associ cet identificateur. Les identificateurs se composent de lettres, de chiffres ou du caractre soulign dans nimporte quel ordre, pourvu que le premier caractre soit une lettre ou le caractre soulign. Le compilateur C fait une distinction entre les majuscules et les minuscules, par exemple valeur et Valeur sont deux identificateurs diffrents. J, nombre_jour, ENTIER sont des identificateurs valides Valeur 1 : invalide contient la caractre espace 7 somme : invalide car le premier caractre est un chiffre 1.4 Constantes Il est souvent commode dassocier un lment de donne simple, tel quune valeur numrique, un caractre ou une chane de caractre, un identificateur, attribuant ainsi un nom llment de donne. On appelle lidentifcateur une constante si on lui attribue llment de donne de manire dfinitive (la valeur reste inchange tout au long du programme) 1.5 Le commentaire Les commentaires sont des textes servant annoter un programme. Ils ne prsentent dutilit que pour le programmeur, et ils sont supprims logiquement du fichier source avant la compilation. Il y a deux faons de dlimiter les commentaires, soit par la paire ** lorsque le commentaire est crit sur plusieurs lignes, soit // pour dbuter une ligne de commentaire jusqu la fin de la ligne. 1.6 Les sparateurs Crochets [] : les crochets ouvrants et fermants [ ] servant spcifier un indice daccs un tableau mono ou multi-dimensios. Char Ch, Str[]= Bonjour ; Int Mat[3] [4] ; //matrice 3x4 Ch=Str[3] ; //ch=n
Language C++
P.4
Parenthses () : Les parenthses permettent de grouper des expressions, disoler des expressions conditionnelles et dindiquer des appels de fonctions et des paramtres : X = (a+b)/c ; // remplace la priorit normal if (a= =0) ; // utilisation dans une instruction conditionnelle Fonc() ; // appel dune fonction Accolades {} : Le couple daccolades permet dindiquer le dbut et la fin dun bloc dinstruction. if (x !=5) { x++ ; fonct(x) ; } Virgule : La virgule spare les lments dune liste darguments dune fonction : Int somme (intx, int y) ; Point-virgule ; Le point-virgule est le terminateur dinstruction. Toute expression lgale en C (y compris lexpression vide) qui est suivie par le signe ; est interprte en tant quinstruction. Deux-points : Le signe deux-points permet une instruction avec label : Debut : x=0 ; . . goto Debut ; 2. STRUCTURE DUN PROGRAMME C++ Les deux principales parties des programmes C++ sont les fichiers sources et les fichiers en-tte. Les fichiers sources contiennent les paries principales du programme. Cest dans les fichiers sources quon dfinit les routines, les donnes et les instructions. Parfois, les fichiers sources empruntent les routines et fonctions dautres fichiers sources ou de bibliothque. Pour que ces routines soient reconnues par le compilateur, on doit dclarer dans le fichier principal des fichiers den-tte. Le fichier den-tte indique au compilateur les noms et caractristiques des routines. Par exemple pour calculer 510 , on doit faire appel la fonction pow qui est dclare dans le fichier inclure math.h
Language C++
P.5
2.1 Structure de base des programmes C++ Lexemple suivant est un programme C++ /*---------------------------------------------------------------------------------------------------------------------*PROGRAMME 1 *Fichier : affichev.cpp *Auteur : Mustapha AIT MAHJOUB *Date : 10/09/1999 *Description : Ce programme affiche un message sur lcran ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> void main() { // Affichage dune chane printf(Ce ci est un programme C++/n) ; } Regardons sa structure. Le texte entre /* et */ est un commentaire. Main() est une fonction. Tout programme C++ est un ensemble de fonctions dont une et une seule doit sappeler main(). Le mot cl void indique au compilateur que la fonction main ne renvoie aucune valeur. Si la programme doit renvoyer une valeur au systme dexploitation. Le programme prcdent scrira : /*---------------------------------------------------------------------------------------------------------------------*PROGRAMME 2 *Fichier : affichei.cpp *Auteur : Mustapha AIT MAHJOUB *Date : 10/09/1999 *Description : Ce programme affiche un message sur lcran et retourne une valeur au dos ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> int main() { // Affichage dune chane printf(Ce ci est un programme C++/n) ; return(0) ; } En effet, il se peut que le systme dexploitation sintresse la valeur renvoye par main(). Par convention, 0 signifie succs, et toute valeur de retour non nulle dsigne une erreur rencontre durant lexecution du programme. Les accolades { } marquent le dbut et la fin de la fonction main (). Les chanes de caractres comme Ce ci est un programme C++\n sont dlimites par des guillemets. \n est le caractre retour la ligne. La fonction printf ( )affichera la chane de caractres sur lcran. // dbute une zone de commentaire qui stendra jusqu la fin de la ligne. En fin, #include <stdio.h> donnera au prprocesseur lordre
Language C++
P.6
dinclure les lignes prsentes dans le fichier den-tte stdio.h lintention du compilateur. Ce fichier contient, entre beaucoup dautre, la dclaration de la fonction printf ().
Language C++
P.7
3. TYPES DE DONNEES FONDAMENTAUX Le type de donnes caractrisent des variables et des constantes en dfinissant leurs plages de valeurs et les oprations que lon peut faire dessus. Le type indique en plus le nombre doctets conscutifs sur les quelle stale la valeur. Une variable de type int (entier), par exemple occupe un mot de 2 octets sous DOS. Les types de donnes se dcomposent en deux catgories : les types prdfinis et les types personnaliss. Les principaux types de C++ sont : type entier type rel type structur type numratifs
3.1 Donnes de type entier Les donnes de type entier sont des objets avec un nombre complet (entier).Ces catgories incluent les constantes de type entier, les variables, les fonctions et expression. Le tableau suivant donne les types entiers prdfinis de C++, avec leurs tailles et leurs plages de valeurs relatives lenvironnement 16 bits. Type char unsigned char short unsigned short int unsigned int long Plage de valeurs -128 127 0 255 -215 +215-1 0 216 -215 215 1 0 216 1 -231 +231 Taille 1 octet 1 octet 2 octets 2octets 2 octets 2 octets 4 octets
TABLEAU 2 : Types entiers C++ permet de spcifier des valeurs octales ou hexadcimales. I = 20 I = 024 I = 0x14 Constante octale : elle commence par 0 (Zro) Constante Hexadcimale : elle commence par 0x // 20 en dcimal // 20 en octal // 20 en hexadcimal
3.2 Donnes de type rel
Language C++
P.8
Les donnes de type rel se rapportent aux lments de donnes qui reprsentent des objets numriques rels. Ceci inclut les constantes de type rel. Les variables, fonctions et expressions. Les types rels standards de C++ sont les suivants :
Language C++
P.9
Type Float Double Long double
Taille 4 octets 8 octets 10 octets
TABLEAU 3 : Types rels Les nombres rels peuvent scrire soit sous la forme classique (par exemple 3.14), soit sous la forme scientifique (par exemple 2.45 E-5). 4. VARIABLES et CONSTANTES 4.1 Variables Une variable est un identificateur qui permet de reprsenter une valeur modifiable. Une variable possde un nom qui doit tre unique dans un certain domaine (porte). Outre le nom, une variable doit possder un type de donne prcisant au compilateur, le nombre doctets allouer la variable. Une variable doit tre dclare, nimporte o dans le code, avant son utilisation dans le programme. Int Somme ; float x, Delta; Char c ; //dclaration dune variable qui a pour nom somme et //comme type, le type entier // dclaration de deux variables de type rel. // dclaration dune variable de type caractre
Lcriture des noms de variable doit respecter les rgles dcriture des identificateurs. Lorsqquon dfinit une variable, on peut lui fournir en mme temps une valeur initiale. Cest cette valeur que la variable aura lors de sa premire utilisation. Int Somme =0 ; Float x=10, Delta=12.3 ; Char c=0 ; 4.2 Constantes Il est souvent commode dassocier un lment de donne simple, tel quune valeur numrique, un identificateur, attribuant ainsi un nom llment de donne. On appelle lidentificateur une constante si on lui attribue un lment de donne de manire dfinitive (la valeur reste inchange tout au long du programme). On pourrait considrer une constante comme une variable qui, une fois, initialise, peut tre lue mais non modifie. Les dclarations des variables et des constantes se ressemblent. La seule diffrence consiste en la prsence du mot cl const. // dclaration et initialisation des variables
Language C++
P.10
Const int NombreMax= 100 ; Const float SalaireMin= 1500.00 ;
Language C++
P.11
/*---------------------------------------------------------------------------------------------------------------------*PROGRAMME 3 *Fichier : surface.cpp *Auteur : Mustapha AIT MAHJOUB *Date : 10/09/1999 *Description : Ce programme calcule et affiche la surface dun cercle ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> void main() { const Pi = 3.14 ; //Pi est une constante float Rayon = 10.0 ; //Rayon est une variable initialise 10 printf (surface = %.2f, Pi*Rayon) ; //affiche la surface du cercle } 5. ENTREE / SORTIE DES DONNEES 5.1 Fonction printf () On utilise la fonction printf() pour afficher des donnes sur lcran. Les lments de donnes de sortie peuvent tre des chanes de caractres, des constantes numriques ou les valeurs de variables et dexpressions. 5.1.1 Sortie formate Le spcificateur de format ou formateur (comme %d ou %c) sont utiliss pour contrler le format qui sera utilis par printf() pour afficher une variable particulire. En gnral, le formateur doit correspondre au type de la variable afficher. Nous utilisons, par exemple, le formateur %d pour afficher un entier et %c pour afficher un caractre. La liste suivante fournit les formateurs pour printf() et scanf() ; Formateur %c %s %d %f %e %g %u %x %o 1 Description Un seul caractre Chane de caractres Entier sign Rel (notation dcimale) Rel (notation exponentielle) Rel (notation dcimale) Entier non sign (dcimal) Entier non sign (hexadcimal) Entier non sign (octal) Prfixe utilis avec %d, %u, %x, %o pour spcifier un entier long Printf() X X X X X X X X X X Scan() X X X X
Language C++
P.12
TABLEAU 4 : Caractres formateurs Le programme suivant affiche lentier i et le rel x avec les diffrents formats /*---------------------------------------------------------------------------------------------------------------------*PROGRAMME 4 *Fichier : format.cpp *Auteur : Mustapha AIT MAHJOUB *Date : 10/09/1999 *Description : Ce programme affiche un entier et un rel sous diffrents formats ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> void main() { int i = 255 ; float x = 10.0 ; printf (%d %u %x %o\n,i,i,i,i) ; //affichage dun entier sous diffrents formats printf (%f %e %g \n,x,x,x) ; //affichage dun rel sous diffrents formats } 5.1.2 Largeur du champ Considrons le programme suivant : /*---------------------------------------------------------------------------------------------------------------------*PROGRAMME 5 *Fichier : champ.cpp *Auteur : Mustapha AIT MAHJOUB *Date : 10/09/1999 *Description : Ce programme affiche un rel sous diffrents longueur de champs ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> void main() { float x = 10.56 ; printf (x = %f\n ,x) ; //affiche 10.560000 printf (x = %5.2f\n,x) ; //affiche 10.56 printf (x = %8.3f\n ,x) ; //affiche 10.560 } Nous remarquons que la variable x est affiche, avec la premire fonction printf (), avec 6 chiffres aprs la virgule alors que deux seulement de ces chiffres sont significatifs. Pour supprimer les zros insignifiants, nous avons insr la chane 5.2 entre le caractre % et f (seconde fonction printf()). Le nombre aprs le point dcimal prcise le nombre de caractres qui seront affichs aprs le point dcimal. Le nombre qui prcde la point spcifie lespace utiliser pour contenir le nombre lorsquil sera affich. 5.1.3 Squences dchappement
Language C++
P.13
Dans les exemples prcdents, nous avons utilis le caractre /n dans la chane de format pour insrer un retour la ligne suivante. Le caractre nouvelle ligne /n est un exemple de squence dchappement. La liste suivante montre les principales squences dchapppement :
Language C++
P.14
Squence \n \t \b \r \ \ \\ \xdd \ddd
Description Nouvelle ligne Tabulation Retour en arrire avec effacement Retour chariot Caractre apostrophe Caractre guillemet Caractre anti-slash Code ASCII Hexadcimal Code ASCII dcimal
TABLEAU 5 : Squences dchappement 5.2 Fonction scanf() On utilise cette fonction pour lire des donnes, de diffrents types, partir du clavier. Voici un exemple utilisant la fonction scanf() : /*---------------------------------------------------------------------------------------------------------------------*PROGRAMME 6 *Fichier : var_con.cpp *Auteur : Mustapha AIT MAHJOUB *Date : 10/09/1999 *Description : Ce programme lit une valeur et calcule une expression ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> void main() { clrscr() ; const int JoursAn = 365 ; float Annees, NombreJours ; printff(Entrez votre age :) ; scanf(%f ,&Annees) ; NombreJours = Annees*JoursAn ; printf(Votre age en nombre de jours = %.1f jours\n ,Nombre Jours) ; getch() ; //attend que lutilisateur appuie sur une touche } Nous remarquons que le format de scanf () ressemble beaucoup celui de la fonction printf () (voir tableau 4). Comme pour printf () largument gauche est une chane qui contient le formateur %f et
Language C++
P.15
droite le nom de la variable &-annee. La fonction scanf () reoit comme paramtre ladresse de la variable annees do la prsence de loprateur dadresse &.
6. LES EXPRESSIONS Une expression est un groupe doprandes lis par certains oprateurs pour former un terme algbrique qui reprsente une valeur. Il y a deux sortes dexpression : numrique et logique. Une expression numrique donne comme rsultat une valeur numrique, alors quune expression logique reprsente une condition quest vraie ou fausse. 6.1 Oprateurs arithmtiques Ils sont utiliss pour effectuer des oprations de type numrique. Le tableau suivant dcrit cinq oprateurs trs courants quon peut utiliser pour crer des expressions numriques Oprateurs + * / % Signification Addition Soustraction Multiplication Division Reste de la division
TABLEAU 6 : Oprateurs arithmtiques Loprateur de division/ appliqu des entiers donne un rsultat entre de sorte que plusieurs divisions diffrentes peuvent donner le mme rsultat. int resultat ; resultat=3/3 ; //resultat = 1 resultat = 4/3 ; //resultat = 1 Si lon ne dsire pas perdre le reste, on peut employer loprateur %. Ce dernier, dont lutilisation est rserve aux entiers, calcule le reste de la division de deux nombres. int reste ; reste = 3 % 3 ; // reste = 0 reste = 4 % 3 ; // reste = 1 Le programme 7 calcule le polynme ax2 + bx + c /*---------------------------------------------------------------------------------------------------------------------*PROGRAMME 7 *Fichier : polyncpp
Language C++
P.16
*Auteur : Mustapha AIT MAHJOUB *Date : 10/09/1999 *Description : Ce programme calcule lexpression ax2 + bx + c ----------------------------------------------------------------------------------------------------------------------*/
#include<stdio.h> #include<conio.h> //pour clrscr() et getch() void main() { clrscr() ; float a,b,c,x,y ; scanf(%f %f %f %f , &a, &b, &c, &x) ; y = a* x* x + b* x + c ; printf (ax*x + bx + c = %g\n,y) ; getch() ; } 6.2 Oprateurs de manipulation Les oprateurs de bits agissent au niveau du bit. Les oprandes de ces oprateurs ne sont plus des entiers ou des caractres, mains tous simplement une suite de bits. Un oprateur de bits permet de manipuler les bits individuellement en les positionnant soit 1 soit 0. Les oprandes doivent tre de type entier. Les oprateurs du tableau 7 suivant permettent dagir sur des bits particulirement lintrieur dune variable. Oprateur ~ << >> & | ^ Signification Non(complment) Dcalage gauche Dcalage droite ET binaire OU binaire OU-Exclusif Exemple x = 15 ou x = 1111 ou x = 0xF y=x y = 0xfff0 Y = x <<2 y = 0x3c y = x >> 2 y=3 y = x & 0xa y =0xa y = x | 0xa y = 0xf y = x ^ 0xa y=5
TABLEAU 7 : Oprateurs de manipulation 6.3 Oprateurs dincrmentation / decrmentation Lexpression n++ utilise loprateur dincrmentation ++ qui a pour effet dajouter 1 n. Ces oprateurs regroupent deux fonctionnalits : leffet de bords qui est lincrmentation ou la decrmentation, et la valeur quils renvoient lorsquils sont utiliss dans des expressions. Cette dernire dpend de la position relative du ++ ou du par rapport son oprande, par exemple si a = 5
Language C++
P.17
b = 2*a++ b = 2*++a b = ++a-2 b = 10 (- -a) 6.4 Oprateur sizeof ()
// b =10, a = 6 // a =7, b =14 // a = 8, b = 6 // a = 7, b =3
Cet oprateur renvoie la taille , en nombre doctets, de lexpression au du type syntaxe :

seizeof< expression> Ou Sizeof( <type>)
Exemple : Sizeof (int) renvoie le nombre doctet quoccupe un entier
7. EXPRESSION BOOLEEENNE Les expressions boolennes prennent des valeurs de vrit vraies ou fausses. Bien que nous parlions de valeurs logiques vraie et fausse noubliant pas quen fait ce ne sont que des valeurs numriques entires. Si le rsultat de lexpression boolenne est 0, lexpression est fausse. Si le rsultat est diffrent de zro, lexpression est vrai. 7.1 Oprateurs de comparaison Les oprateurs de comparaison sont tous des oprateurs binaires : ils relient deux oprandes. Le rsultat de comparaison soit vrai(non nul), soit faux( nul). Le tableau suivant dcrit les oprateurs de comparaison. Oprateur < > <= >= = = != Signification Infrieur Suprieur Infrieur ou gal Suprieur ou gal Egal Diffrent
TABLEAU 8 : Oprateur de comparaison 7.2 Oprateurs logiques Le langage C contient trois oprateurs logiques. A linstar des oprateurs des comparaisons , de rsultat dune expression utilisant les oprateurs logiques soit vrai (non nul), soit faux (nul). Le type de rsultat est toujours int. Les oprateurs logiques sont toujours valus de la gauche vers la droite. Le tableau suivant dcrit les oprateurs logiques. Oprateur Signification Exemple a = 10, b =3
Language C++
P.18
&& || !
ET logique OU logique NON logique
(a>0) && (b<10) est vraie (a = = 4) || (b= = 3) est vraie ! (b = =3) est fausse
TABLEAU 9 : Oprateurs logiques 7.3 Oprateur conditionnel ternaire Jusqu' prsent nous avons rencontr des oprateurs unaires ((NON binaire, incrmentation, etc.) qui manipulent un seul oprande et des oprateurs binaires (addition, division, etc.) qui manipulent deux oprandes. Il existe un oprateur ternaire qui manipule trois oprandes : loprateur arithmtique conditionnel. Voici sa syntaxe : EXPRESSION 1 ;EXPRESSION 2 ; EXPRESSION 3 ; On commence par valuer Expression 1. Si elle est vrai (non nulle), alors on value Expression 2, si non on value Expression 3 Par exemple, pour calculer le maximum de deux nombres, on crit, Int a, b ; max ; a=5; b = 10 ; Max = (a>b) ; a :b ; // max = 10 car a nest pas suprieur b 8. INSTRUCTIONS D AFFECTATION Nous avons dj vu, dans les exemples prcdents, que linstruction dassignation (ou affectation) sert assigner un lment de donnes une variable. Considrons lexpression X= 10 ; Une fois laffectation effectue, la variable x vaut 10. Mais lexpression entire x = 10 possde aussi la valeur 10 de sorte quon peut crire en C ++ lexpression Y = x = 10 ; Aprs traitement de linstruction, x et y valent 10 tous les deux. En C++, outre loprateur =, il existe plusieurs oprateurs daffectation combins comme le montre le tableau suivant : Oprateur = *= Signification Affectation simple Affectation avec multiplication Exemple x=2 x*=2 Equivalent x = x *2
Language C++
P.19
/= %= += -= <<= >>= &= |= ^=
Affectation avec division Affectation avec modulo Affectation avec addition Affectation avec soustraction Affectation avec dcalage gauche Affectation avec dcalage droite Affectation avec ET binaire Affectation avec OU binaire Affectation avec OU exclusif binaire
x /= 2 x %= 2 x += 2 x-=2 x<< = 2 x >>= 2 x &= 2 x |= 2 x ^= 2
x = x /2 x = x %2 x = x +2 x = x -2 x = x <<2 x = x>> 2 x = x &2 x = x |2 x = x ^2
TABLEAU 10 : Oprateurs daffectation 9. PRIORITE DES OPERATEURS ET ORDRE DEVALUATION. Le tableau suivant rsume priorit de tous les oprateurs C++, incluant ceux non encore vus. Les oprateurs apparaissent dans un ordre de priorit dcroisante Les oprateurs sur une mme ligne ont la mme priorit et leurs oprandes sont valus dans lordre indiqu dans la colonne ordre.
Language C++
P.20
Oprateur () Sizeof ~ ! */% +<< >> < > <= >= == != & ^ | && || ?= =*=/=%+= -= <<= >>= & = ^= |=
Description Expression Oprateurs unaire Oprateurs multiplicatifs Oprateur additif Dcalage binaire Oprateurs rationnels Oprateurs dgalit ET binaire OU binaire exclusif OU binaire ET logique OU logique Oprateur ternaire Affectations combines
Ordre gauche droite gauche gauche gauche gauche gauche gauche gauche gauche gauche gauche droite droite
TABLEAU 11 : Priorit des oprateurs Quant on est pas certain de la priorit dun oprateur, on doit utiliser des parenthses pour assurer le bon ordre dvaluation des oprateurs. Les parenthses facilitent la comprhension des expressions.
Language C++
P.21
Language C++
P.22
STRUCTURES DE CONTRLE Le programme doit tre conu de telle sorte que les commandes sexcutent dans un ordre logique et progressif. Cest ce quon appelle le droulement dun programme. Toutefois, si on veut que le programme rpte plusieurs fois les mmes instructions ou bien quil excute une instruction que sous certaines conditions, lapproche squentielle nest pas pratique. On utilise des mcanismes de contrle permettant au programme de se brancher des sousprogrammes qui prendront en charge des tches rptitives, rpteront une srie dinstructions tant q une condition reste vraie ou dclencher une action en fonction dune condition. Ces trois types de mcanismes de contrle sont connus respectivement comme branchement, boucles et condition (slection). Les branchements, boucles et slection sont tous des dviations temporaire du droulement linaire du programme. Ils vous permettent de crer des programmes avec souplesse et puissance. 1. STRUCTURE SEQUENTIELLE Dans une structure squentielle, chaque instruction est excute une fois et seulement une fois, dans le mme ordre quelle apparat dans le programme. Les instructions sont excutes squentiellement. Les programmes vus aux chapitres prcdents sont de type squentiel.
Instruction 1 Instruction 2 Instruction 3
Instruction 4
Figure 1 : Ordinogramme dune structure squentielle 2. STRUCTURE SELECTIVE (ALTERNATIVE) Une structure de dcision est une structure de contrle conditionnelle qui autorise une action seulement si une condition donne une valeur non nulle (Vrai).
Language C++
P.23
2.1 Structure if
Entree
Cond/Exp
Faux (Non)
If <condition/expression> Instruction
Instruction
Sortie
Figure 2 : Ordinogramme et syntaxe de la structure if. Quand le programme atteint la condition ou lexpression, il lvalue. Si le rsultat est vrai (non nul), le programme excute Instruction, sinon (rsultat nul) Instruction est pas excute.
Dbut
Taux = 0.1
Lire Montant
Remise= 0 oui Montant>=1000 Remise= Montant
*Taux
Montant =Montant-remise Affiche Montant
Fin
Figure 3 : Exemple dordinogramme pour if
Language C++
P.24
/*---------------------------------------------------------------------------------------------------------------------*PROGRAMME 1 *Fichier : if.cpp *Auteur : Mustapha AIT MAHJOUB *Date :03/02/99 *Description : Calcule de la remise avec un seul taux ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> void main() { const float Taux=0.1 ; float Remise, Montant Remise=0.0 ; printf(Enter montant ;) ; scanf(%f, &Montant) ; if (Montant>=1000.0) Remise = Montant*Taux ; Montant =Montant-Remise ; printf(Montant..=%.2f\n, Montant) ; } Lexemple du programme 1 montre comment calculer le montant payer par un client en lui accordant une remise. Lutilisateur saisit le montant. Si ce montant est suprieur 1000, une remise avec un taux de 10% est faite (Remise Montant*taux), sinon pas de remise (Remise = 0). Aprs, le montant est calcul (Montant = Montant Remise) puis afficher. 2.2 Structure if..else Lordinogramme et la forme de cette structure sont
Entree If ( <Condition/expression> ) Cond/ exp

Faux (Non)
Instruction 1 Else Instruction 2
Instruction 1
Instruction 2
Sortie
Language C++
P.25
Figure 4 : Ordinogramme et syntaxe de la structure if..else
Quand le programme atteint la condition, il lvalue. Si la condition est vraie (expression non nulle), instruction 1 est excute, sinon Instruction 2 est excute. Lune des instructions sexcute toujours (mais jamais les deux).
Dbut
Taux 1 = 0.1 Taux 2=0.05
Lire Montant
Montant>=1000 Remise= Montant *taux **t*Taux Montant =Montant-remise Affiche Montant
oui Remise= Montant *taux 1 **t*Taux
Fin
Figure 5: Exemple dordinogramme pour if..else /*---------------------------------------------------------------------------------------------------------------------*PROGRAMME 2 *Fichier : ifelse.cpp *Auteur : Mustapha AIT MAHJOUB *Date :03/02/99 *Description : Calcule de la remise avec deux taux ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include <conio.h> void main() { const float Taux 1=0.1, Taux 2=0,05 ; float Remise, Montant printf(Enter montant ;) ; scan(%f ,&Montant :) ;
Language C++
P.26
if (Montant>=1000.0) Remise = Montant*Taux 1; else Remise = Montant*Taux 2; Montant =Montant-Remise ; printf(Montant..=%.2f\n, Montant) ; getch() ; } Lexemple du programme 2 montre comment calculer le montant payer par un client en lui accordant une remise. Lutilisateur saisit le montant. Si ce montant est suprieur 1000, une remise avec un taux de 10% (Taux 1) est faite. Sinon on accorde une remise avec un taux de 5% (Taux2). Aprs, on calcule le montant (Montant = Montant Remise) puis on laffiche. 2.3 Structures if imbriques Les structures if peuvent simbriquer lune dans lautre, tout comme nimporte quelle autre structure de contrle. Limbrication des structures if doit tre manipuler avec beaucoup dattention afin dviter toute ambigut possible. Lexemple suivant montre la forme gnrale dimbrication deux niveaux que peuvent prendre les structures if imbriques.
Ou
i
Condition 1 Condition 3 Condition 2
If <Condition1> If <condition2> <Bloc 1>

Ou
else <Bloc 2>
Bloc 4
Bloc 3
Bloc 2
Bloc 1
else if <Condition3> <Bloc3> else <Bloc 4>
Figure 6 : Organigramme et syntaxe de la forme gnrale de structures if imbriques Dans cette forme dimbrication deux niveaux, Condition 1, Condition 2 et Condition 3 reprsentent des expressions, et Bloc 1, Bloc 2, Bloc 3 et Bloc 4 reprsentent des blocs dinstructions. Dans ce cas, une structure complte if..else sera excute si Condition 1 est vrai, et une autre si condition 1
Language C++
P.27
est fausse. IL est videmment possible que Bloc 1, Bloc 2, Bloc 3 et Bloc 4 contiennent dautres structures if..else. Nous aurions alors une imbrication plusieurs niveaux.
Programme 3 : Ecrivons un programme C qui rsout une quation du deuxime degr Ax2 + Bx + C = 0 La rsolution de lquation se droule de la manire suivante : 1. Lecture des coefficients A, B et C 2. Si la valeur attribue A est nulle (A = 0), il sagit dune quation de premier degr 2.1 Si la valeur de B et zro, deux cas se prsentent : 2.1.1 Si C = 0 : Lquation Ax2 + Bx + C = 0 quelle que soit la valeur de x Dans ce cas la solution est lensemble des valeurs relles. 2.1.2 Sinon (C <> 0) : exemple C = 2 Lquation Ax2 + Bx + C = 0 => 2 = 0 ce qui est impossible. Donc lquation na pas de solution. 2.2 Sinon (B <> 0) : Exemple B = 5 ; C = 10 Lquation une seule solution qui est X = -C/B = -2 3.Sinon (A<> 0) : 3.1 Calculer le dterminant delta = B2 4*A*C 3.2 Si delta est infrieur ou gale zro, lquation na pas de solution 3.3 Sinon (delta suprieur oudbut zro : delta >= 0), deux cas possible gale 3.3.1 Si delta = 0, dans ce cas on a une solution double X1 = X2 = -B/2*A 3.3.2 Sinon (Delta> 0), dans ce cas on a deux solutions distinctes : Lire A, B, C X1 = (-B- SQR (delta))/2*A X2 = (-B+ SQR (delta))/2*A Ou 4. Fin i
A=0
Ou i
Delta = B*B 4*A*C

Ou i
B=0
Delta <0 Affiche Pas de

Ou i
C =0
solution
Ou i
Delta = 0
X = -C /B
X1 = (-B + SQR(Delta))/2*A
X= -B /2*a
Affiche X = ;X
X1 = (-B + SQR(Delta))/2*A
Affiche X1 = X2 = ;X
Affiche Pas de Solution
Affiche X1 = ;X1 X2 = ;X2

Affiche Infinite de Solution
Fin
Language C++
P.28
Figure 7 : Ordinogramme de rsolution dune quation de deuxime ordre *----------------------------------------------------------------------------------------------------------------------*PROGRAMME 3 *Fichier : resoudre.cpp *Auteur : Mustapha AIT MAHJOUB *Date :03/02/99 *Description : rsolution dune quation de deuxime degr ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<math.h> //prototype de sqrt #include<conio.h> void main() { float A,B,C,Delta,X1,X2 ; clrscr() ; scan(%f ,&A) ; scan(%f ,&B) ; scan(%f ,&C) ; IF ( !A) { if ( !B) { if ( !C) printf(Infinit de solutions) ; else printf(Pas de solutions) ; } else
Language C++
P.29
{ X1 = -C/B ; Printf(X = %g ,X1) ; } } else { Delta = B*B 4*A*C ; if (Delta < 0) Printf(Pas de solutions relles) ; else if ( !Delta) Printf(Solution double X1 = X2 = %g ,-B/(2*A)) ; else { X1 =(-B sqrt(Delta))/(2*A) ; X2 =(-B +sqrt(Delta))/(2*A) ; Printf(X1 = %g\nX2 = %g ,X1,X2) ; } } }
Language C++
P.30
2.4 Structure switch La structure se dfinit comme une structure conditionnelle de contrle qui permet de slectionner un groupe particulier dinstructions parmi plusieurs groupes possible. La slection seffectue sur la base dune expression, appel slecteur. Voici la forme gnrale de la structure swich Switch <expression> { case <const-exp-1> : <bloc1> case <const-exp-2> : <bloc2> case <const-exp-3> : <bloc3> case <const-exp-N> : <blocN> default <bloc> } Forme de la structure switch Le slecteur <expression> peut appartenir nimporte quel type entier. Il prend souvent la forme dune seule variable de type entier. Chacune des rfrences de cas (cas <const-exp-1,case const-exp-2 ,) reprsente une des valeurs constante autorises du slecteur. Donc si lexpression du slecteur est de type entier, les rfrences de cas reprsentent des valeurs entires se situant dans la gamme des possibilits. Les rfrences de cas nont pas besoin de figurer dans un ordre particulier, mais chacune dentre elles demeure cependant unique. En cas de non-correspondance, et il existe un label default, le contrle passe au bloc dinstruction <Bloc>. Dans le programme suivant, le slecteur Choix est une variable de type char. Suivant la valeur fournie par lutilisateur cette variable, le traitement sera aiguill linstruction dans ltiquette correspond celle fournie. Si par exemple, lutilisateur a tap le caractre + linstruction Resultat = Valeur 1 + Valeur 2 sera excut puis le contrle passe linstruction qui suie le bloc le switch. Linstruction break permet de sortir du blos de linstruction switch.
Language C++
P.31
*----------------------------------------------------------------------------------------------------------------------*PROGRAMME 4 *Fichier : case.cpp *Auteur : Mustapha AIT MAHJOUB *Date :04/02/99 *Description : Calcul la somme, la diffrence , le produit ou le quotion de deux nombres ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> void main() { char Choix ; float Valeur 1 , Valeur 2, Resultat ; clrscr() ; printf(Addition(+)/n) ; printf(Soustraction(-)/n) ; printf(Multiplication (*)/n) ; printf(Division(/)/n) ; printf(Entrer votre choix : ) ; Choix = getche() ; printf(\nValeur 1 = ) ; scanf(%f,&Valeur 1) ; printf(\nValeur 2 = ) ; scanf(%f,&Valeur 2) ; switch(Choix) { case+ :{Resultat = Valeur 1 +Valeur 2 ; break ;} case- :{Resultat = Valeur 1 -Valeur 2 ; break ;} case* :{Resultat = Valeur 1 *Valeur 2 ; break ;} case/ : if (Valeur 2 = = 0) printf(\nDivision par zro) ; else Resultat = Valeur 1/Valeur 2 ; Break ; Default : printf(\n Oprateur incorrect) ; } printf(\n Resultat = %g, Resultat) ; getch() ; } 3. STRUCTURES ET REPETITIVE S (BOUCLES) Vous pouvez dsirer que votre programme excute les mmes instructions de faon rptitive tant quune certaine condition reste vraie.
Language C++
P.32
En programmation, ceci sappelle une boucle. Le programme rpte les mmes instructions dans une boucle jusquau moment o la condition nest plus vraie (ou nest plus fausse). C possde plusieurs formes de boucles qui seront prsents dans la suite.
3.1 Structure while La structure while correspond une instruction de contrle rptitive utilise pour la ralisation de boucles conditionnelles. Voici lorganigramme et le forme gnrale de cette structure :
Entree
Faux (Nom)
Cond/ex p
While ( <Condition/Expression> )
Instruction
instruction
Sortie
Figure 8 :Organigramme est form de la structure while Instruction sexcute continuellement aussi longtems que lexpression boolenne <Condition/Expression demeure vraie (non nulle). Ds que <condition/Expression> devienne fausse, on sort de la boucle. Servons nous de la structure while pour obtenir la moyenne dune liste de N nombres. Nous utilisons une variable Somme initialement mise zro et mise jour chaque lecture dun nombre nouveau dans la mmoire. Supposons que lutilisateur a donn la valeur 3 la variable N. En entrant dans la boucle la variable Compte a pour valeur 1 donc infrieur N. La condition Compte = N est vraie et les instructions continuent dans le bloc de while seront excutes. On lit un nombre(Nombre = 10) puis on lajoute lancienne somme (Compte = 0 + Nombre = 10) ensuite, la variable compte est incrmente de 1 (Compte = Compte + 1 = 1 + 1 = 2). La variable compte est compar une deuxime fois avec la variable N. Le rsultat de la comparaison est vrai(Compte<= N ou 2 <= 3) donc la boucle est excute une deuxime fois en lisant un nouveau nombre(Nombre = 1) suivi du calcul de la somme (Somme = Somme + Nombre = 10 + 20 = 30) et lincrmentation de compte (Compte = Compte + 1= 2 + 1 = 3). La condition est toujours vraie. La boucle sera excute une troisime fois. Un nombre est lu(Nombre = 60) puis ajout lancienne somme (Somme =30 + 60 = 90)suivi de lincrmentation de compte (Compte = Compte + 1 =
Language C++
P.33
3 + 1 = 4). La variable compte est compare avec N (4<= 3). Le rsultat de la comparaison est faux . On sort de la boucle pour calculer la moyenne et afficher la somme et la moyenne.
Language C++
P.34
Debut
Lire N
Compte = 1
Compte <= N
Vraie
Lire Nombre
Instruction
Somme = somme + Nombre
Affiche Somme Moyenne
Compte = Compte + 1
Fin
Figure 9 : Organigramme de calcul de la moyenne des nombres *----------------------------------------------------------------------------------------------------------------------*PROGRAMME 5 *Fichier : while.cpp *Auteur : Mustapha AIT MAHJOUB *Date :03/02/99 *Description : calcul de la moyenne en utilisant la boucle while ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> void main() { float Somme = 0.0, Nombre, Moyenne ; int Compte = 1,N ; printf(Nombre dlments :) ; scanf(%d,&N) ; while (Compte <= N)
Language C++
P.35
{ printf(Un nombre :) ; scanf(%f,&Nombre) ;
Somme +=Nombre ; Compte++ ; } Moyenne = Somme /N ; printf(Somme =%g\n ,Somme) ; printf(Moyenne = %g ,Moyenne) ; getch() ; } 3.1 Structure do..while Lorganigramme et la forme gnrale de cette structure sont
Entree
do
Instruction
instruction
While (<Condition/Expression)
Cond/ex p Vraie
Sortie
Figure 10 : Organigramme est forme de la structure do..while Instruction est excut continuellement jusqu ce que la condition <Condition/Expression> soit gale zro (fausse). La diffrence avec while est que <Condition/Express> est teste aprs, et non avant, chaque excution de la boucle. Le systme suppose quil y a au moins une excution du bloc dinstructions. Le programme suivant utilise la structure do..while pour calculer la moyenne des notes. *----------------------------------------------------------------------------------------------------------------------*PROGRAMME 6 *Fichier : do.cpp *Auteur : Mustapha AIT MAHJOUB
Language C++
P.36
*Date :03/02/99 *Description : calcul de la remise en utilisant la boucle do ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> void main() { float Somme = 0.0, Nombre, Moyenne ; in Compte = 1,N ; printf(Nombre dlments :) ; scanf(%d,&N) ; do { printf(Un nombre :) ; scanf(%f,&Nombre) ; Somme +=Nombre ; Compte++ ; } while (Compte <= N) ; Moyenne = Somme /N ; printf(Somme =%g\n ,Somme) ; printf(Moyenne = %g ,Moyenne) ; getch() ; } 3.2 Structure for La format de cette structure est for(<Init/Exp> ; <Test/Exp> ;<Incr/Exp>) <Bloc dinstruction> La squence dvnement est la suivante : 1. Lexpression dinitialisation <Init/exp> est excute. Comme son non lindique, il sagit dune instruction qui initialise un ou plusieurs compteurs de boucle mais la Syntaxe permet une expression dun quelconque degr de complexit(y compris des dclarations). Do laffirmation que tout programme C peut tre crit sous la forme dune seule boucle for. 2. Lexpression <Test/Exp est value suivant les rgles de la boucle while. Si <Test/Exp> ets diffrente de zro (vraie), la boucle est excute. Une expression vide est prise ici comme while (1 ou vrai) . Si <Test/Exp> est gal zro (fausse).L a boucle prend fin. <Incr/Exp>incrmente les compteurs
Language C++
P.37
Le Bloc dinstruction est excut et le contrle revient 2. Le programme suivant utilise la structure for pour calculer la moyenne des notes. *--------------------------------------------------------------------------------------------------------------------*PROGRAMME 7 *Fichier : for.cpp *Auteur : Mustapha AIT MAHJOUB *Date :03/02/99 *Description : calcul de la moyenne en utilisant la boucle for ----------------------------------------------------------------------------------------------------------------------*/
#include<stdio.h> #include<conio.h> void main() { float Somme = 0.0, Nombre, Moyenne ; in Compte = 1,N ; clrscr() ; printf(Nombre dlments :) ; scanf(%d,&N) ; for(Compte = 1 ; Compte <= N ; Compte ++) { printf(Un nombre :) ; scanf(%f,&Nombre) ; Somme +=Nombre ; } Moyenne = Somme /N ; Printf(Somme =%g\n ,Somme) ; Printf(Moyenne = %g ,Moyenne) ; getch() ; } Si dans cet exemple, lutilisateur a donn la valeur 3 la variable N. Compteur prendra successivement les valeurs 1,2 et 3, ce qui cause trois excutions de la boucle chaque fois, un nombre est lu puis ajouter Somme. La sortie de la boucle for est faite lorsque la variable compte aura atteint la valeur de N. 4. INSTRUCTIONS DE BRANCHEMENT Une instruction de branchement, lorsquelle est excute, passe le contrle la suivante. Il existe quatre instructions de branchement :break, continue, goto et return.
Language C++
P.38
4.1 Instruction break Une instruction break ne peut sutiliser que dans itration (while, do..while et for) ou un switch. Elle marque la fin dune instruction ditration ou de switch. Le programme suivant determine la valeur de N pour laquelle la somme 0 + 1+ 2 ++ N est suprieur ou gale une valeur donne. *----------------------------------------------------------------------------------------------------------------------*PROGRAMME 8 *Fichier : break.cpp *Auteur : Mustapha AIT MAHJOUB *Date :05/02/99 *Description : utilisation de break dans un boucle while ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h>
void main() { int Valeur, Somme, N ; Somme = N = 0 ; clrscr() ; scanf(%d,&Valeur ; while(1) //condition est toujours vraie { if (Somme >= Valeur) break ;//sortie force de la boucle Somme +=N++ ; } printf(%d\n ,N-1) ; getch() ; } 4.2 Instruction continue La syntaxe de cette instruction est Continue ; Elle nest utilisable que dans une instruction ditration.. Elle passe le contrle la condition de test pour les boucles while et do, et lexpression dincrmentation dans une boucle for. Dans le cas de boucles ditration imbriques, une instruction continue est considre comme appartenant litration la plus proche la contenant. *-----------------------------------------------------------------------------------------------------------------------
Language C++
P.39
*PROGRAMME 9 *Fichier : continue.cpp *Auteur : Mustapha AIT MAHJOUB *Date :05/02/99 *Description : utilisation de mot cl continue dans un boucle while ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> void main() { int Valeur, Somme, i, Nombre ; ; Somme = i = 0 ; Clrscr() ; While (i+ + <5) { Scanf(%d,&Nombre; If (Nombre< 0) continue ; Somme +=Nombre; } printf(%d\n ,Somme) ; Getch() ; }
4.3 Instruction goto La syntaxe est Goto label ; Linstruction goto passe le contrle linstruction label qui doit tre dans la mme fonction. Il est illgal de sauter une instruction de dclaration ayant une valeur dinitialisation implicite ou explicite moins que cette dclaration ne soit dans un bloc interne dj ignor.
Language C++
P.40
Language C++
P.41
TYPE DE DONNEES COMPLEXES 1. LES TABLEAUX 1.1 Tableaux unidimensionnels Un tableau unidimensionnel est une liste de donnes de mme type auxquels on se refaire collectivement par le mme le nom. On peut accder chaque lment individuel en spcifiant le nom du tableau, suivi par un indexe (ou indice) cern par des crochets. Donc si une liste de note dun tableau unidimensionnel contient N lments, les lments individuels du tableau sont Note [0], Note[1]Note [N-1] 1.1.1 Dclaration dun tableau La dclaration dun tableau comprend trois parties : - Lindication de type - Le nom du tableau. - Le nombre dlments (entre crochet) du tableau (ou taille).
<type> <non> [ <nombre dlment> ] ;

Lexemple suivant est une dclaration dun tableau de 25 notes :
Float Note [24] ; Ou Const int N = 24 ; Float Note [N] ;

La taille du tableau doit tre une expression constante (connu au moment de la compilation). 1.1.2 Initialisation des tableaux
On peut initialiser un tableau lors de sa dclaration. Il suffit de fournir la liste des valeurs des divers lments places entre accolades et spares entre elles par des virgules.
Int JoursMois [11] = {31,30,31,30,31,30,31,31,30,31,30,31} ;

Quand on initialise un tableau dans sa dclaration, on peut omettre la taille. Celle ci est dtermine par le compilateur par le nombre de valeurs dinitialisation. Le tableau JoursMois peut tre dclar par
Int JoursMois [] = {31,30,31,30,31,30,31,31,30,31,30,31} ;

Les points suivants doivent tre respecter lors de lutilisation des tableaux : On ne peut pas initialiser un tableau partir dun autre tableau. Les affectations entre tableaux dont interdites
Language C++
P.42
Float Vec1[10], Vec2[10] ; Vec 1 = Vec 2 ; // erreur

Toute expression donnant un rsultat entier peut tre utilise comme indice
Int i,j ; Float x = 1.0 ; Float Vect[10] ; Vec[5] = Vec[i + j] ; //correct i + j est un entier Vec[4] = Vec[x] ; //correct x nest pas un entier
Le compilateur ne vrifie pas si lindice d notes et en calculer la moyenne et lcart de chacune de ces notes par rapport la moyenne laide de la formule.
Ecart[i] = Note[i] Moyenne.

*----------------------------------------------------------------------------------------------------------------------*PROGRAMME 1 *Fichier : tab_moy.cpp *Auteur : Mustapha AIT MAHJOUB *Date :02/02/99 *Description : utilisation des tableaux pour calculer les carts simples ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> void main() { float Somme,Moyenne ; float Note[MAX_ELEMENT] ; Ecart[MAX_ELEMENT] ; Int i,N ; // Lecture des notes clrscr() ; printf(Nombre dlments :) ; scanf(%d,&N) ; for (i=0 ;i<N ; i++) { printf(Note[%d] i) ; scan(%f,&Note[i]) ; } //calcul de la somme des notes for (i=0, Somme =0 ; i<N i++) Somme +=Note[i] ; //calcul de la moyenne Moyenne = Somme /N ;
Language C++
P.43
//calcul des carts simples for (i=0 ; i<N ; ++) Ecart[i] = Note[i] Moyenne ; //Affichage des rsultats clrscr() ;
printf(Moyenne =%2f\n, Moyenne) ; printf(Note\t\tEcart\n) ; for (i=0 ; i<N ; i++) printf(%.2f\t\t%.2f n,Note[i],Ecart[i]) ; getch() ; } 1.2 Tableaux multidimensionnels Nous avons dj envisager un tableau unidimensionnel sous la forme dune liste (sur une seule colonne) de donnes de mme type . Les tableaux multidimensionnels constituent une extension de ce concept. On peut ainsi imaginer un tableau deux dimensions comme un tableau de donnes compos de lignes et de colonnes. Supposons, par exemple, que Matrice est tableau deux dimensions contenant M lignes et N colonnes. Les lments individuels du tableau sont Matrice [0] [0],..,Matrice[0] [N-1], ,Matrice[M-1] [0],,Matrice[M-1] [N-1]. Le tableau se visualise de la manire suivante : Matrice[0] [0].Matrice[0] [N-1] . . . . . . . . . . Matrice [M-1][0] Matrice [M-1][N-1]
Matrice =
1.2.1 type.
Dclaration dun tableau multidimensionnel Quelle que soit sa dimension, un tableau comprend toujours une collection de donnes de mme
On peut dfinir un tableau multidimensionnel dans une dclaration de variable, de la mme faon que pour chacune des dimensions du tableau <type> <nom> [nombre de ligne>][<nombre de colonne>] ; Par exemple, Float Matrice[3][3] ; Matrice est tableau deux dimensions. Il peut stocker 3x3=9 lments de type float.
Language C++
P.44
Laccs aux diffrents lments se fait comme avec les tableaux une dimension, ceci prs que lon a besoin de deux indices. Par exemple, pour calculer la somme des lments de la premire ligne
Somme = Matrice[0][0] + Matrice[0][1] + Matrice[0][2] ;

1.2.2 Initialisation dun tableau multidimensionnel
On peut initialiser un tableau multidimensionnel ds sa dclaration. Par exemple, pour initialiser Matrice zro
float Matrice [][] = { {0,0,0}, {0,0,0}, {0,0,0} } *----------------------------------------------------------------------------------------------------------------------*PROGRAMME 2 *Fichier : tab_mat.cpp *Auteur : Mustapha AIT MAHJOUB *Date :02/02/99 *Description : calcul la somme et le produit de deux matrices ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> #definie MAX_LIGNE 10 #definie MAX_COLONNE 10 // Dfinnition dun nouveau type MATRICE type de f float MATRICE[MAX_LIGNE][MAX_COLONNE] ; void main () { int ligne,colonne ; MATRICE Mat1,Mat2,MS,MP ; Clrscr() ; printf(Matrice1\n ) ; For (inti=o ;i<ligne ;i++) // boucle de lignes For (intj=o ;j<colonne ;i++) // boucle de colonnes { printf(Mat1 ![%d],[%d]=,i,j) ; scanff(%f,&Mat1[i][j] ; } //lecture de la deuxime matrice printf(Matrice2\n) ; for(i=0 ;i<ligne ;i++)
Language C++
P.45
for (int j=0 ;j<colonne ;j++) { printf(Mat2[%d],[%d]=,i,j) ; scanf(%f,&Mat2[i][j] ; } //somme de deux matrices for(i = 0 ;i<ligne ;i++) for (int j=0 ;j<colonne ;j++) MS[i][j] = Mat 1[i][j] + Mat2[i][j] ; //Produit de deux matrices for (i=0 ; i<ligne ; i++) for (int j=0 ; j<colonne ; j++) { MP [i][j] = 0.0 ; //produit dune ligne par colonne for (int k=0 ; k<ligne ; k++) { MP[i][j] =MP[i][j] + Mat1[i][k]*Mat2[k][j] ; } } //affichage matrice somme printf(Matrice Somme\n) ; for (i=0 ; i<ligne ; i++) for (int j=0 ; j<colonne ; j++) { printf(MS[%d][%d]=%g\n,i,j,ms[i][j] ; } //affiche matrice produit printf(Matrice Produit\n) ; for(i=0 ; i<ligne ;i++) for(int j=0 ; j<colonne ; j++) { printf (MP[%d][%d]=%g\n,i,j,MP[i][j]) ; } getch() ; } 2. LES CHAINES DE CARACTERES Les chanes de caractres sont des formes de donnes utilises pour stocker et manipuler le texte. En C++, il nexiste pas de type de donnes spcifique aux chanes de caractres. Pour grer des chanes de caractres, il faut donc passer par des tableaux de chair. Lexemple suivant dfinit une chane de caractres.
Char Nom[] = Nacer ; Ou
Language C++
P.46
Char Nom[6] = Nacer ;

On reserve ici, de lespace mmoire pour stocker 6caractres. Les 5 premiers sont initialiss avec les caractres N, a, c, e, r. Le dernier est initialis avec le caractre terminateur nul \o marquant la fin de la chane. On peut, aussi, initialiser une chane avec une liste de caractres
Char Nom[] = { N, a, c , e, r, -0} ;

2.1 Fonction d E / S des chanes de caractres La fonction, de la librairie C++, gets() permet de saisir une chane partir du clavier . Elle nest pas universelle comme scanf() ; elle est crite seulement pour lire une chane. Le caractre retour chariot indique la fin de la lecture dune chane. On peut ainsi inclure des espaces et des tabulations comme caractres de la chane. La fonction puts(), qui va en pair avec gets(), permet dafficher une chane sur lcran. Lexemple suivant lit une chane puis laffiche sur lcran : Char Nom[81] ; gets(Nom) ;// le nombre de caractre infrieur 81 puts(Nom) ; 2.2 Fonctions de traitement des chanes La bibliothque C++ fournit un ensemble de fonctions de traitement des chanes. Pour les utiliser, il suffit dinclure le fichier den tte string h dans votre programme, voici quelques unes de ces fonctions (pour plus de dtailles consulter laide) : strlen(chane) :calcul la longueur dune chane strcpy(destination,source) :copie une chane dans une autre strcpy(destination,source,N) :copie N caractres de la chane source dans la chane destination. Sttrcat(destination,source) :concatne destination et source. Strncat(destination,source,N) :concatne Ncaractre de la source avec destination Strcmp(destination,source) :compare destination et source. Les programmes 3 et 4 suivants montrent lutilisation de quelques fonctions de manipulation des chanes. *----------------------------------------------------------------------------------------------------------------------*PROGRAMME 3 *Fichier : chanes.cpp *Auteur : Mustapha AIT MAHJOUB *Date :02/02/99 *Description : manipulation des chanes ----------------------------------------------------------------------------------------------------------------------*/ #include<conio.h> #include<stdio.h>
Language C++
P.47
#include<string.h> void main () { char ch1[20]=Bon,ch2[20]=Jour ; int i ; printf(Longueur de chane 1 :%d,strlen(ch1)) ; strcpy(ch1,che) ; puts(ch1) ; //affiche Jour strcpy(ch1,Bon) ; strncpy(ch1,ch2,2) ;//les 2 caractres JO de ch2 remplace BO puts(ch1) ; strcpy(ch1,Bon) ; strcat(ch1,ch2) ; puts(ch1) ;//affiche BonJour strcpy(ch1,Bon) ; strncat(ch1,ch2,1) ; puts(ch1) ;//affiche BonJ strcpy(ch1,Jour) ; i= strcmp(ch1,ch2) ; printf(%d\n,i) ;//affiche 0 puisque ch 1 = ch 2 getch() }
*----------------------------------------------------------------------------------------------------------------------*PROGRAMME 4 *Fichier : inverse.cpp *Auteur : Mustapha AIT MAHJOUB *Date :02/02/99 *Description : inverse une chane, par exemple NACER devient RECNA ----------------------------------------------------------------------------------------------------------------------*/ #include<conio.h> #include<stdio.h> #include<string.h> void main () { char ch1[20],ch2[20] ; int L ; clrscr() printf(Enter une chane ;) ; gets(Ch1) ;//saisir abonjour L = strlen(Ch1) ;//L = 7 Strcpy(Ch2,Ch1) ;//Ch2 = BONJOUR For (int i=0 ; i<L ; i++) Ch2i = Ch1{L-i-1] ;
Language C++
P.48
puts(Ch2) ;//affiche RUOJNOB Getch() } 3. LES STRUCTURES Nous avons dj vu comment une variable simple peut contenir une seule information dun type donn et comment un tableau peut contenir une collection dinformation de mme type . Ces deux mcanismes de stockage des donnes peuvent rsoudre une grande varit de problmes. Mais, il arrive souvent quon dsire utiliser des ensembles dlments de donnes de diffrents types comme une seule entte dans ce cas, lutilisation des variables et des tableaux est inadquate. Supposons quon dsire stocker le nom dun employer, son salaire et le nombre de ses enfants. On peut stocker ces informations dans trois variables spares : une pour le nom, une autre pour le salaire et une autre pour le nombre denfants. Cette faon de faire nest pas pratique : dans la vie, il est naturel, de regrouper les lments (Nom, Salaire et Nombre Enfants) en une seule entit appele structure. Les structures sont une caractristiques trs puissante de C++, et facilite lorganisation et le traitement des informations. 3.2 Dclaration dune structure Pour dclarer une structure, on utilise le mot cl struct, puis le nom de la structure. En suite, entre accolades, les variables qui constituent la structure, par exemple :
Struct employe] ;] { char Nom[81] float Slaire ; int Nombre Enfants ; }; Cette instruction dfinit un nouveau type de donnes appel struct employer. Caque variable de ce type est constitue de 3 lments (ou membres) : une variable chane de caractres appele Nom, une variable de type rel Salaire, et une variable de type entier Nombre Enfants. Il faut noter que cette instruction ne dclare aucune variable donc il ny a pas de rservation mmoire. Il indique, simplement au compilateur les diffrents lments de la structure. 3.3 dclaration de variables dune structure Une fois, on a dfinit la structure, on peut dclarer une ou plusieurs variables qui ont pour type structure on tapant le nom de la structure, puis le nom de la variable. Pour dfinir une variable de la structure employe , on crit
Language C++
P.49
employe Salaire ; Cette instruction rserve de lespace mmoire, pour la variable Salaire pour contenir tous les lments de la structure : 81 octets pour Nom, 4 octets pour Salaire, et 2 octets pour Nombre Enfants. 3.3 Accs aux membres de la structure Aprs avoir cr une structure, puis une variable de cette structure, on accde aux membres en tapant le nom de la variable, puis un point, puis le nom du membre. Par exemple, pour affecter des valeurs aux diffrents membres de la variable Salaire, on crit : Salaire.Nom[] = Hassan ; Salaire.Salaire = 3000.0 ; Salaire.NombreEnfants = 2 ; Lopration point, connecte le nom de la variable structure avec les membres de cette structure. Le programme suivant utilise la structure employe *----------------------------------------------------------------------------------------------------------------------*PROGRAMME 5 *Fichier : structur.cpp *Auteur : Mustapha AIT MAHJOUB *Date :02/02/99 *Description : manipulation des structures ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> void main () { const float Allocation = 150.00 ; struct employe//declaration de la structure { char Nom[30] float Salaire Base ; int Nombre Enfants ; }; float Salaire ; employe Agent ;//dclaration dune variable de la structure clrscr() ; printf(Enter le nom) ; gest(Agent.Nom) ; printf(Enter salaire de base :) ; scanf(%f,&Agent.Salaire Base) ; printf(Enter Nombre denfants : ) Slaire = Agent.Salaire Base + Agent.Nombre Enfants*Allocation. printf(Salaire : %.2f, Salaire); getch();
Language C++
P.50
LES POINTEURS
Le pointeur fournit un autre moyen pour accder une variable sans se rferer directement celle ci. Plus les donnes deviennent complexes, pour grer laide des variables des informations dont la taille varie. La diffrence entre une variable et un pointeur est que la variable pointe toujours sur le mme emplacement mmore, alors que le pointeur peut tre modifier de faon quil pointe sur un autre emplacement en mmore. 4.1 Dclaration des pointeurs Pour crer un pointeur vers un type de donnes, crer une variable de ce type de donnes mais placer un astrisque devant son nom. La dclaration suivante: Int *p; Alloue une variable p pouvant contenir ladresse dun entier. Maintenant, *p est lentier dont ladresse est contenue dans p, par exemple: Int n= 5; P = &n;//stocke ladresse de n dans p *p + = 2;//incrmente n de 2 Dans linstruction p = &n, & est loprateur dadresse renvoyant de la variable n. Considrons le programme suivant :
------------------------------------------------------------------------------------------------------------------------------------------------*
*PROGRAMME 6 *Fichier : pointeur.cpp *Auteur : Mustapha AIT MAHJOUB *Date :02/02/99 *Description : manipulation des structures ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> void main () { int x = 4 float y = 10.0 ; int *px ;//pointeur sur un entier float *py ;//pointeur sur un rel clrscr() ; printf(x = %d\t,y = %g\n,x,y) ; px = &x ;//px contient ladresse de x py = &y ;//py contient ladresse de y *px = *px + 10 ;//ajoute 10 la valeur contenue dans x
Language C++
P.51
*py = *py / 5 ;//divise par 5 le contenu de y printf(x = %d\t,y = %g ,x,y) ; getch() ; } Aprs avoir afficher la valeur de x et de y, les adresses des variables x et y sont affectes aux pointeurs px et py. Px = &x ;//px contient ladresse de x Py =&y ;//py contient ladresse de y En suite, loprateur dinstruction * est utils dans les instructions dassignation *px = *px +10 ; *py = *py / 5 ; Dans linstruction *px = *py + 10, nous prenons le contenu de la variable pointe par px (x = 4), lui ajoutons 10. Le rsultat est retourn dans la variable pointe par px (x = x + 10 = 14). Le contenu de la variable y est divis par 5 dans linstruction *py = *py / 5. Remarques : La dclaration suivante : Int *p, q ; ne dclare pas deux pointeurs p et q, mais un pointeur p et entier q. Pour dclarer p et q comme pointeur, il faut crire Int *p, *q ; Ou Int*p ; Int *q ; Le mot cl const interagit de faon trange avec la dclaration des pointeurs : Const int*p ; dclare un pointeur sur une constante entire, et non pas un pointeur constant sur un entier. Cela veut dire que lon peut regarder la valeur de *p. mais que lon ne peut pas la modifie. Ecrire *p = 0 ;//erreur modification dune constante gnrera une erreur alors que p++ ;//p nest pas constant don peut tre modifi
Language C++
P.52
est autorise. Pour dclarer un pointeur constant, il faut placer le mot cl const ct du non du pointeur Int* const q = 10 ; q ne peut pas tre modifi, mais on peut modifier le contenu de la variable sur laquelle il pointe ; *q = 10 ;// est correct q++ ; //erreur 4.2 Tableaux et pointeurs Les tableaux et les pointeurs sont intimement lis en C++. Le compilateur translate la notation dun tableau en notation pointeur, puisque larchitecture interne dun microprocesseur comprend les pointeurs mais pas les tableaux. Lorsqu on dclare un tableau, comme par exemple : int v[10] ; Le nom du tableau v reprsente un pointeur constant pointant sur llment dindice 0 du tableau. De mme vecteur +1 reprsente ladresse de llment suivant et *(v+1) lentier stock cette adresse. Dans le cas gnral ou p, un pointeur et n, un entier on a : p[n] = (p+n) ; Si un pointeur pointe sur un tableau, on peut le faire se dplacer sur les lments en lui ajoutant ou retranchant des valeurs entires. Ce pointeur sur un entier ajoute en fait sizeof(int) ladresse contenue dans le pointeur. Pour voir la relation entre les tableaux et les pointeurs. Considrons le programme suivant . Le premier utilise la notation des tableaux et le second la notation des pointeurs. *----------------------------------------------------------------------------------------------------------------------*PROGRAMME 7 *Fichier : tab_tab.cpp *Auteur : Mustapha AIT MAHJOUB *Date :02/02/99 *Description : utilisation des tableaux ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> void main () { int Nombre[] = {10,20,30,40,50} ; clrscr()
Language C++
P.53
for (int i=0 ; i<5 ; ++) { Nombre[i] = Nombre[i]+5 ; Printf(Nombre[%d]=%d\n,i,Nombre[i] ; } getch() } Lexpression Nombre [i] est utilise pour accder chaque lment du tableau.
------------------------------------------------------------------------------------------------------------------------------------------------*
*PROGRAMME 8 *Fichier : tab_ptr.cpp *Auteur : Mustapha AIT MAHJOUB *Date :02/02/99 *Description : utilisation des pointeurs sur des tableaux ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> void main () { int Nombre[] = {10,20,30,40,50} ; clrscr() ; for (int i=0 ; i<5 ; i++) { *(Nombre+i) = *(Nombre +i)+5 ; printf(Nombre[%d]=%d\n,i,*(Nombre+i)) ; } getch(), } Cette version de programme est identique au prcdente, sauf pour lexpression *(Nombre +i)
------------------------------------------------------------------------------------------------------------------------------------------------*
*PROGRAMME 9 *Fichier : ptr_moy.cpp *Auteur : Mustapha AIT MAHJOUB *Date :02/02/99 *Description : Saisir des tempratures par jour, puis en calculer la moyenne. La saisie du nombre >=100 indique la fin de saisie ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> void main () {
Language C++
P.54
float Tempr[40], float Somme = 0.0, Moyenne ; int Nombre Jours, Jour =0 ; float *p ; clrscr() ; p = Tempr ; //initialise le pointeur avec ladresse du tableau do { printf(Temprature[%d] :, Jour ++) ; scanf(%f,p) ; } while (*(p++) <100) ; //r,p,ter tant temprature<100 p= Tempr ; //initialise le pointeur avec ladresse du tableau. Nombre Jours= Jour 1 ; //nombre de temp,ratures lues if (Nombre Jours >=1) { for(Jour = 0 ; Jour <Nombre Jours, Jour ++) Somme += *(p++) ;//calcul de la somme cumule des temp,rature Moyenne = Somme/Nombre Jours ; Printf(Moyenne des tempratures =%g.Moyenne) ; } getch() ; } 4.3 Pointeurs et chanes de caractres Les chanes de caractres sont des tableaux de caractres, termines par le caractre nul \0. Les deux instructions suivantes dclarent une chane s, et un tampon buf capable de contenir une chane de 10 caractres. Char s[ ] = Bonjour ; Char buf[10] ; 4.3.1 Initialisation dune chane comme pointeur Char *p = Bonjour ; dclare une variable de type pointeur, puis alloue 8 caractres contigus en mmoire, puis initialise p avec ladresse de cette chane de caractres. 4.3.2 Traitement des chanes de caractres
Linstruction
Le programme suivant calcul la longueur dune chane, cest dire le nombre de caractres non nul.
------------------------------------------------------------------------------------------------------------------------------------------------*
Language C++
P.55
*PROGRAMME 10 *Fichier : Cha_ptr.cpp *Auteur : Mustapha AIT MAHJOUB *Date :02/02/99 *Description : manipulation des structures ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h>
void main () { char Texte[30] ; char *p ; int Longueur ; clrscr() ; p= Texte ; Longueur = 0 ; Puts(Enter un texte :) ; Gets(texte) ; while (*p++ !=\0) Longueur++ ; Printf(la chane contient %d caractres, Longueur) ; getch() ; } Ce programme renvoie le nombre de caractres de la chane Texte saisie. Le pointeur p est initialis avec p est initialis avec ladresse de dbut de la chane P = Texte ; Dans le texte de continuation de la boucle, lexpression *p++, loprateur est excut avant loprateur *. P++ est excut en premier, ayant pour effet dincrmenter p pour passer au caractre suivant de la chane. Ce pendant la valeur renvoye par p++ est la valeur du caractre se trouvant ladresse p avant incrmentation. Considrons la dclaration suivante Char Source [ ] = Bonjour ; Char Destination[ 10] ; Peut-on crire Destination = Source pour copier la chane Bonjour dans Destination ? Nous avons vu prcdemment que Destination et Source qui sont crites sans crochets, sont des pointeurs, pointant sur ladresse de dbut du tableau. En particulier, Destination est une constante (le tableau est fix en mmoire ) et ne peut tre modifier donc lcriture Destination = Source est interdite Le programme suivant utilise les pointeurs pour copier une chane dans une autre chane.
Language C++
P.56
------------------------------------------------------------------------------------------------------------------------------------------------*
*PROGRAMME 11 *Fichier : cha_copy.cpp *Auteur : Mustapha AIT MAHJOUB *Date :02/02/99 *Description : copie une chane dans une autre ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> void main () { char Source [] =Chane source ; char Destination[81] = ; //chane vide char *ps ; char *pd ; clrscr() ; ps= Source ; pd = Destination ; printf(Source=%s\nDestination avant =%s\n, Source,Destination) ; while ((*pd++ = *ps++) !=\0) ;//instruction vide printf(Destination aprs%s, Destination) ; getch() ; } Les pointeurs pd et ps parcourent les tableaux de caractres. Linstruction pd++ =ps++ incrmente pd et ps, mais * sapplique aux valeurs des pointeurs avant incrmentation, et le contenu de ladresse pointe par lancien ps est copi ladresse de lancien pd.
------------------------------------------------------------------------------------------------------------------------------------------------*
*PROGRAMME 12 *Fichier : tab_ch.cpp *Auteur : Mustapha AIT MAHJOUB *Date :02/02/99 *Description : utilisation des tableaux de pointeurs vers des chanes ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> #define MAX 12 void main () {
Language C++
P.57
int i, drapeau=0 ; char Nom[10] ; static char * ListeNom[MAX]= {
Janvier, Fevrier, Mars, Avril, Mai, Juin, Juillet,Aout,Septembre, Octobre,Novembre,Decembre 31 30 31, 30,31,30, 31,31,30, 31,30,31
}; static int List Nombre[] = {
}; clrscr() ; printf(Enter le num,ro du mois :) ; scanf(%d ,&i) ; i -= 1 ;
if ( (i>=0) && (i<=11) ) printf(%s\t%d, ListeNom[i],ListeNombre[i]) ; getch() ; } 4.4 Pointeurs et structures Lorsquon dpose dun pointeur sur une structure, on a la possibilit de modifier la valeur dun membre de cette structure. Dans le programme suivant. ARTICLE est une structure et pArt est un pointeur sur cette structure. On peut utiliser *pArt tout endroit o on peut employer la structure.
------------------------------------------------------------------------------------------------------------------------------------------------*
*PROGRAMME 13 *Fichier : p_struct.cpp *Auteur : Mustapha AIT MAHJOUB *Date :03/02/99 *Description : utilisation des pointeurs vers structure ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> #include <string.h> void main() { typedef struct { char Designation[81] ;
Language C++
P.58
unsigned int Code ; float Prix ; float Stock ; }ARTICLE ; clrscr() ; ARTICLE Article ; //variable structure Strcpy(Aricle.Designation, Rsistance 10K 1/2w) ; //initialisation des membres Article.Code = 1234 ; //modification des membres Article.Prix = 80 ; Article.Stock = 200 ; ARTICLE*pArt ; //pointeur sur la structure PArt = &Article ; //fait pointer pArt sur la structure (*pArt).Prix = 60 ; //modification des membres (*pArt).Stock = 400 ; printf(Designation ;%s\n, Article.Designation) ; printf(Code :%u\n ,ARTICLE.Code) ; printf(Prix :%2f\n ,ARTICLE.Prix) ; printf(Stock :%2f\n ,ARTICLE.Stock) ; getch() ; } Comme lemploi de la syntaxe (*pointeur).membre nest pas pratique. C++ possde le raccourci quivalent pointeur-> membre Dans le programme prcdent, on peut remplacer (*pArt).Prix ; par pArt -> Prix ; et (*pArt).stock par Part -> Stock ; 4.5 Allocation dynamique de la mmoire Quand on dfinit une variable, ordinaire ou pointeur, on alloue une certaine quantit mmoire bien dfinie situe une adresse quivalente bien dfinie (connu du compilateur). En effet, un programme C++ compil utilise quatre rgions mmoires distinctes. Leur modle dorganisation est prsent par la figure suivante :
Language C++ Pile (STACK)
P.59
Donne s
Tas (HEAP) Mmoires Statiques Code programme
Organisation mmoire dun programme Zone de code : Elle contient les instructions machine pour toutes les fonctions. Zone de donnes statiques : Lallocation statique de la mmoire est faite ds le dbut du programme(si la variable est globale). Ou de la fonction (si la variable est locale). La mmoire alloue ne sera libre qu la fin du programme ou de la fonction. Zone pile : Elle contient toutes les donnes locales non statiques, y compris les paramtres des fonctions. Zone dallocation dynamique : Il existe une autre technique appele allocation dynamique de la mmoire qui consiste utiliser la mmoire disponible, en fonction des besoins des programmes. Il faut,
Pour cela, passer par un pointeur qui pointe vers un bloc de mmoire allou dynamiquement par loprateur new propre C. Par exemple : int*pEntier=new int ; Loprateur new prend une partie (ici la taille dun entier) de la mmoire libre alloue au programme (mmoire nomme Tas). Un pointeur, quil soit initialis statiquement ou dynamiquement, peut tre ensuite drfrenc : *pEntier) 100 ; Il faut explicitement librer la mmoire alloue dynamiquement quon en a plus besoin, pour cela, on fait appel loprateur delete : Delete pEntier ; Pour une structure par exemple, lallocation dynamique se fait de la faon suivante : Typedef struct {
Language C++
P.60
char Designation[81] ; unsigned int code ; float Prix ; float Stock ; } ARTICLE ; ARTICLE *pArt ; //pointeur sur structure PArt = new ARTICLE ; // allocation dynamique 5 ENUMERATION
Un type de donnes dnumration permet dobtenir des identifications mnmoniques pour un ensemble de valeurs entires. Par exemple, la dclaration suivante : enum categorie {ingnieur, technicien, ouvrier} Catgorie ; Les identificateurs utiliss dans une liste dnumration sont implicitement de type signed char, unsigned char ou int, selon la valeur de ces numrations 5.1 Initialisation des constantes dnumration Les numrateurs placs entre accolades sont appels constantes dnumration. Chacun reoit une valeur fixe entire. En labsence de valeurs dinitialisation explicites, le premier numrateur (ingnieur) est gal zro. Et chaque numration qui suit est incrment de un (technicien 1, ouvrier2). Lorsquil existe des valeurs dinitialisation, on peut attribuer ds valeurs spcifiques aux numrateurs. Ceux qui apparatront ensuite sans valeur dinitialisation seront incrments de un . Par exemple, dans la dclaration suivante enum categorie {ingnieur =100, technicien =ingnieur/2, ouvrier =technicien/2} Catgorie : La valeur dinitialisation est une expression ayant pour rsultat une valeur entire
5.2 Utilisation des numrations Les variables de type numration sont souvent utilises pour clarifier les oprations du programme. Si on a besoin, par exemple, dutiliser les catgories dun groupe demploy dans un programme source si on utilise des valeurs telle que ingnieur, technicien ou lieu des valeurs entires. Voici un exemple dutilisation des variables numrations
------------------------------------------------------------------------------------------------------------------------------------------------*
*PROGRAMME 14 *Fichier : enum.cpp *Auteur : Mustapha AIT MAHJOUB *Date :02/02/99 *Description : utilisation des variables numration
Language C++
P.61
----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> void main() { enum categorie {ingenieur =0, technicien, ouvrier} ; struct employe { char Nom[35] ; float Slaire ; catgorie Grade ; }; employe Slaire ; float Prime ; clrscr() ; printf(Nom..) ; scanf(%s ,Salaire.Nom) ; printf(Salaire..) ; scanf(%f ,&Salaire.Salaire) ; printf(Grade.(0/1/2) :) ; scanf(%d,&Salaire.Grade) ; //Salaire.Grade = ingnieur ; switch(Salaire.Grade) { case 0 : Prime = 1000.0 ;break case 1 : Prime = 600.0 ;break ; case 2 : Prime = 300.0 ;break ; } Salaire.Salaire + + Prime ; Printf(NOM.. :%s\n , Salaire.Nom ) ; Printf(Salaire.. :%g\n , Salaire.Salaire) ; Printf(Catgorie.. :%u\n , Salaire.Grade ) ; Return }
DEFINITION DE NOUVEAUX TYPES
Le mot rserv typedef indique la dfinition dun nouveau spcificateur de type de donnes. Comme exemple, considrons linstruction suivante dans laquelle le type unsigned char est redfini pour tre de type OCTET : Typedef unsigned char OCTET ;
Language C++
P.62
Maintenant on peut dclarer des variables de type unsigned char en crivant OCTET var1, var2 ; Ou lieu de Unsigned var1, var2 ; On peut, par exemple dans le programme 5, dfinir un nouveau type Typedef struct categorie { char Nom[35] ; float Salaire ; categorie Grade ; }AGENT ; Maintenant on peut dclarer des variables qui ont pour type AGENT AGENT Salaire1, Salaire2 ;//variables de type AGENT AGENT Salaire[50] ;//Tableau de structure de type AGENT AGENT* Salaire ;//pointeur vers une structure
Language C++
P.63
Language C++
P.64
LES FONCTIONS Les programmes sont souvent trs complexes et trs longs. Pour les crer, il est bon de les dcouper en sections facilement apprhendables. Dans cette optique, C++ autorise la cration de groupes dinstructions et lattribution de nom ces croupes. On appelle ces groupes des fonctions. Une fonction se prsente comme une espce doprateur personnalis, identifie par un nom et non par un symbole opratoire. Les oprandes dune fonction, appels arguments, sont spcifis par les biais dune liste dans laquelle les arguments sont spars les uns des autres par les virgules. Les dclarations des fonctions se prsentent typiquement de la faon suivante. <type> <nom de fonction> (<type> <arg1>, <type> arg2> ,) ; 1. FONCTION NE RETOURNANT PAS DE VALEUR 1.1 Fonction ne prenant pas des paramtres Une fonction qui ne retourne pas de valeur, donc qui se contente dexcuter une certaine action, a le type void. Le corps de la fonction, encadr daccolades contient les instructions excutes par la fonction. Voici un exemple simple de fonction de type void. /* FONCTION 1*/ void cadre() { int X0 = 1, Y0 = 80, Y1 = 24 ; int i ; gotoxy(X0, Y0) ;printf(\xDA) ; for (i = X0+1 ; i<X1, i++) {gotoxy(i,Y0) ; printf(\xC4) ;} gotoxy(X1, Y0) ;printf(\xBF) ; for (i = X0+1 ; i<Y1, i++) {gotoxy(X1,i);printf(\xB3) ;} gotoxy(X1, Y1) ;printf(\xD9) ; for (i = X0+1 ; i<X1, i++) {gotoxy(i,Y1) ; printf(\xC4) ;} gotoxy(X0, Y1) ;printf(\XC0) ; for (i = Y0+1 ; i<Y1, i++) {gotoxy(X0,i);printf(\xB3) ;} } La premire ligne constitue len-tte de la fonction, void indiquant ici que la fonction ne renvoie pas de valeur de retour. Le type de la fonction est suivi du nom, cadre, de celle ci. Vient ensuite, la liste des arguments, encadrs de parenthses. Ici, elle vide, ce qui signifie que la fonction nattend pas de paramtres.
Language C++
P.65
Len-tte de la fonction et suivi du corps de celle ci, compos dinstructions spcifiant ce que doit faire la fonction, instructions encadres par des accolades. Cette fonction affiche un cadre. Une fois, la fonction dfinie, on peut lappeler partir dune autre fonction. La fonction main(), de lexemple suivant appelle la fonction cadre(), sans lui transmettre de paramtres, pour dessiner un cadre. ------------------------------------------------------------------------------------------------------------------------------------------------* *PROGRAMME 1 *Fichier : fct_void.cpp *Auteur : Mustapha AIT MAHJOUB *Date :04/02/99 *Description : utilisation des variables numration ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> void cadre() ;//prototype de la fonction cadre() ; void main() { clrscr() ; cadre() ;//appelle la fonction pour dessiner uncadre getch() ; } /*---------------------------------------------------------------------------------------------------------------------------------------------* *FONCTION 1 *Description : Cette fonction dessine un cadre dont les coordonnes 1,1 :reprsente le coin haut gauche et 80,24 : reprsentent le coin bas droite. *Entree :aucune *Sortie :aucune ----------------------------------------------------------------------------------------------------------------------*/ void cadre()//aucun paramtre reu { int X0= 1, Y0= 1 , X1 =80, Y1 =24 ; int i ; gotoxy(X0, Y0) ;printf(\xDA) ; for (i = X0+1 ; i<X1, i++) {gotoxy(i,Y0) ; printf(\xC4) ;} gotoxy(X1, Y0) ;printf(\xBF) ; for (i = X0+1 ; i<Y1, i++) {gotoxy(X1,i);printf(\xB3) ;} gotoxy(X1, Y1) ;printf(\xD9) ; for (i = X0+1 ; i<X1, i++) {gotoxy(i,Y1) ; printf(\xC4) ;} gotoxy(X0, Y1) ;printf(\XC0) ; for (i = Y0+1 ; i<Y1, i++)
Language C++
P.66
{gotoxy(X0,i);printf(\xB3) ;} } Pour appeler une fonction ne prenant pas de paramtres impose de laisser les parenthses aprs le nom de la fonction. Un nom de fonction sans parenthses symbolise ladresse de dbut de la fonction, qui peut alors tre passe dautres fonctions.
Lemploi des fonctions prsente plusieurs avantages : - On peut regrouper en une entit structurelle homogne des actions connexes, que lon dsignera par un simple identificateur. On amliore ainsi lorganisation et la lisibilit du code source. Lire cadre() est plus clair que de lire les instructions constituant la fonction. - Une fonction permet de rpter une certaine squence daction frquemment excute, sans devoir recopier tout le code source. - Le dcoupage du code en fonction facilite la modularit du code source. 1.1.2 Fonction prenant des paramtres Nous allons maintenant regarder la fonction cadre() qui reoit des paramtres de la fonction appelante. Au lieu de dessiner un cadre fixe, la nouvelle version de la fonction cadre() une liste darguments X0, Y0, X1, et Y1 de type int. Les arguments X0 et Y0 reprsentent le coin suprieur gauche du cadre, alors que X1, Y1 reprsentent le coin bas droite du cadre. /*FONCTION 2*/ void cadre(int X0,int Y0,int X1, int Y1) { int i ; gotoxy(X0, Y0) ;printf(\xDA) ; for (i = X0+1 ; i<X1, i++) {gotoxy(i,Y0) ; printf(\xC4) ;} gotoxy(X1, Y0) ;printf(\xBF) ; for (i = X0+1 ; i<Y1, i++) {gotoxy(X1,i);printf(\xB3) ;} gotoxy(X1, Y1) ;printf(\xD9) ; for (i = X0+1 ; i<X1, i++) {gotoxy(i,Y1) ; printf(\xC4) ;} gotoxy(X0, Y1) ;printf(\xC0) ; for (i = Y0+1 ; i<Y1, i++) {gotoxy(X0,i);printf(\xB3) ;} } Le programme suivant dessine deux cadres en appelant deux fois la fonction cadre() avec des paramtres diffrents.
/*-----------------------------------------------------------------------------------------------------------------------------------------------
*PROGRAMME 2 *Fichier : cadvar.cpp
Language C++
P.67
*Auteur : Mustapha AIT MAHJOUB *Date :04/02/99 *Description : dessine deux cadres concentriques en faisant appel deux fois la fonction cadre. ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> void cadre(int X0,int Y0, int Y1) ;
void main() { int C0,L0,C1,L1 ; clrscr() ; C0= 1 ; L0 = 1 ; C1 = 80 ; L1 = 24 ; Cadre (C0, L0,C1,L1) ;//dessine le cadre extrieur C0 +=5 ; L0 +=5 ; C1 - =5 ; L1 - =5 ; Cadre(C0,L0,C01,L1) ;//dessine le cadre infrieur getch() ; }
/*-----------------------------------------------------------------------------------------------------------------------------------------------
*FONCTION 2 *Description : Cette fonction dessine un cadre dont les coordonnes X0, Y0 :reprsentent le coin haut gauche et X1, Y1 :reprsentent le coin bas droite. *Entree :Les coordonnees X0, Y0, X1, Y1 de type entier *Sortie :aucune ----------------------------------------------------------------------------------------------------------------------*/ void cadre(int X0,int Y0,int X1, int Y1) { int i ; gotoxy(X0, Y0) ;printf(\xDA) ; for (i = X0+1 ; i<X1, i++) {gotoxy(i,Y0) ; printf(\xC4) ;} gotoxy(X1, Y0) ;printf(\xBF) ; for (i = X0+1 ; i<Y1, i++) {gotoxy(X1,i);printf(\xB3) ;} gotoxy(X1, Y1) ;printf(\xD9) ; for (i = X0+1 ; i<X1, i++) {gotoxy(i,Y1) ; printf(\xC4) ;}
Language C++
P.68
gotoxy(X0, Y1) ;printf(\xC0) ; for (i = Y0+1 ; i<Y1, i++) {gotoxy(X0,i);printf(\xB3) ;} } 2. FONCTION RETOURNAT UNE VALEUR Une fonction, qui retourne une valeur, restitue la fonction appelante un rsultat dun type donn. Nous allons voir maintenant une fonction munie dune liste darguments et dune valeur de retour, savoir une fonction qui calcul la puissance. Notre fonction puissance() aura deux arguments, lun de type double et lautre de type int et retourne une valeur de type double.
/* FONCTION 3 */ double puissance(double x, int n) { double r= 1 ; if (n= = 0) return 1 ; if (n< 0) { if (x= =0) return 0 ;//mathmatiquement incorrect x = 1/x ; n = -n ; } while (n-- >0) r*= x ; return( r) ; } Le mot cl return termine lexcution de la fonction et redonne le contrle la fonction appelante. Lexemple suivant montre lappel de la fonction puissance() dans une instruction daffectation.
/*-----------------------------------------------------------------------------------------------------------------------------------------------
*PROGRAMME 3 *Fichier : fct_ret.cpp *Auteur : Mustapha AIT MAHJOUB *Date :04/02/99 *Description : calcul n2n laide de la fonction puissance() ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> double puissance (double x, int n) ; void main() { int n ; double y, x = 2.0 ;
Language C++
P.69
clrscr() ; n=3; y = n* puissance (x,n) ; printf(n2n = %g ,y) ; getch() ; }

/*-----------------------------------------------------------------------------------------------------------------------------------------------
*FONCTION 3 *Description : calcul de la puissance par multiplication successive. *Entre :largument x de type double et largument n de type int *Sortie :x puissance n ----------------------------------------------------------------------------------------------------------------------*/ double puissance(double x, int n) double r= 1 ; if (n= = 0) return 1 ;
if (n< 0) { if (x= =0) return 0 ;//mathmatiquement incorrect x = 1/x ; n = -n ; } while (n-- >0) r*= x ; return( r) ; } Le type de la valeur de retour peut tre un type standaard (int, float, etc), un type driv (int*, float*,etc), un type personnalis, ou bien void. Quand on ne prcise pas le type de la fonction, cest un int qui est pris par dfaut. 3. PASSAGE DE PARAMETRES 3.1 Passage par valeur Par dfaut, les paramtres sont passs par valeur. La fonction alloue une variable locale sur la pile pour chaque paramtre. Cette variable est initialise avec la valeur passe la fonction lors de lappel. Une fois initialise, la variable se comporte comme toute autre variable locale de la fonction. Les valeurs des variables alloues pour les paramtres peuvent tre modifies (comme n-dans la fonction puissance() ). Leur contenu est perdu lors de la sortie de la fonction, et elles ne sont en aucune faon recopies dans lenvironnement de la fonction appelante. Dans le programme 2.1, la fonction puissance est appele avec comme paramtres x et n Y = n*puissance(x,n) ;
Language C++
P.70
Le n dans lenvironnement dappel nest pas affect, alors que le n local la fonction est dcrmente jusqu 0. 3.2 Passage par adresse Quand on veut quune fonction puisse modifier les paramtres, transmis, dans lenvironnement appelant, il faut lui passer des pointeurs (passage par adresse) et non des variables ordinaires (passage par valeur). /*FONCTION 4*/ void echange (int *x, int *y) { int temp ;//variable temporaire temp = *x ; *x = *y ; *y = temp ; } Cette fonction devrait appele avec change (&x, &y). Le mcanisme de gestion de rfrence soccupe de placer les oprateurs * et & votre place.
3.3 Passage par rfrence Cette technique consiste dclarer les arguments formels en tant que rfrence. Passer des rfrences une fonction revient lui passer les adresses des arguments, et non pas des copies de leurs contenus. Pour cette raison on utilise souvent les rfrences pour retourner des rsultats : voici la fonction puissance avec un argument de style rfrence pour retourner le rsultat. /* FONCTION 5 */ void puissance(double x, int n, double&resultat) { resultat= 1 ; if (n= =0) return ; if (n <0) { if (x= =0) { resultat=0 ; ;//mathmatiquement incorrect return } x = 1/x ; n = -n ; } while (n- - > 0) resultat *= x ; }
Language C++
P.71
Quand on accde la fonction puissance qui contient un paramtre de style rfrence (variable resultat), on substitue un paramtre rel dans la rfrence de la fonction au paramtre formel lintrieur de la fonction elle-mme. Cest donc le paramtre rel lui-mme qui sera utilis pendant lexcution de la procdure. Les paramtres rels qui remplacent les paramtres de style rfrence doivent tre eux-mmes des variables ; ils ne peuvent pas prendre la fforme de constantes ou expressions comme pour le style de passage par valeur. Lappel de la fonction puissance, instruction puissance(x,n,y), dans le programme suivant entrane la substitution du paramtre rel y largument formel resultat de la fonction puissance. Si la valeur de resultat change lintrieur de la fonction, ce qui est le cas, un changement correspondant dans la valeur de y se produira dans la fonction main()
/*-----------------------------------------------------------------------------------------------------------------------------------------------
*PROGRAMME 4 *Fichier : pass_ref.cpp *Auteur : Mustapha AIT MAHJOUB *Date :04/02/99 *Description : calcul la puissance ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> void puissance(double x, int n, double&resultat) ;
void main() { double y, x = 2.0 ; clrscr() ; // les variables x et n sont passes par valeur // alors que y est passes par rfrence puissance(x, 3, y) ; printf(%g , y ) ; getch() ; }
/*-----------------------------------------------------------------------------------------------------------------------------------------------
*FONCTION 5 *Description : calcul de la puissance par multiplication successive. *Entre :largument x de type double et largument n de type int sont passs par valeur et largument resultat est pass par rfrence. *Sortie :x puissance n dans resultat ----------------------------------------------------------------------------------------------------------------------*/ void puissance(double x, int n, double& resultat) { resultat =1 ; if (n=0) return ;
Language C++
P.72
if (n < 0) { if (x= =0){ resultat=0 ; ;//mathmatiquement incorrect return } x= 1/x ; n = -n ; } while (n--> 0) resultat *= x ; } Au niveau de la transmission des arguments, les rfrences combinent les avantages des pointeurs (possibilit de modifier les arguments) et ceux des variables ordinaires (simplicit de la syntaxe dappel). Autre avantage des rfrences (et aussi des pointeurs) : quand les arguments sont gros (structure par exemple), le passage par valeur est pnalisant car il fait recopier les arguments dans la pile (prend du temps). 4. PASSAGE DUN TABLEAU A UNE FONCTION Les paramtres par valeur ne peuvent jamais tre modifis par une fonction, cependant les tableaux passs enparamtres peuvent tre modifis. La fonction suivante, par exemple, lit un vecteur /* FONCTION 6 */ void Lire Tab(float t[],int n) { for (int i=o ; i<n ; i++) { printf(t[%d] :,i) scanf(%f,&t[i] ;//le vecteur t est modifi par la fonction } } La fonction Lire Tab() peut lire des tableaux de nimporte quelle longueur. Le nombre dlments Lire est pass explicitement dans le second paramtre. Le tableau nest pas copi dans la fonction avant dtre recopi lors du retour de la fonction, comme pour les variables simples, mais la fonction alloue un pointeur local initialis avec ladresse de dbut du tableau. Du fait que cest ladresse du tableau qui est pass, et non pas le contenu, les lments du tableau peuvent tre modifis. Si lon veut protger un tableau pass en paramtre de toute modification , par la fonction appele, il doit tre dclar const, par exemple
Language C++
P.73
/* FONCTION 7 */ float Produit Slaire (const t[],int n) { float r= 1.0 ; for (int i=0 ; i<n ; i++) r* t[i] ; return r ; } La fonction ProduitSalaire ne pourra pas modifier t puisquil est dclar constant.
/*-----------------------------------------------------------------------------------------------------------------------------------------------
*PROGRAMME 5 *Fichier : pass_vec.cpp *Auteur : Mustapha AIT MAHJOUB *Date :08/02/99 *Description : utilisation des vecteurs. ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> void Lire Tab(float[],int) ; void Efface Tab(float[],int) ; void Affiche Tab(float[] , int) ; float Produit Scalaire(const float[] ,int) ; void main() { float Produit, Vecteur[40] ; int n ; clrscr() ; printf(Dimension des tableaux :) ; scanf(%d ,&n) ; Lire Tab(Vecteur,n) ; Produit =ProduitScalaire(Vecteur,n) ;
Affiche Tab(Vecteur,n) ; Printf(Produit scalaire =%g\n ,Produit) ; Getch() ; }

/*-----------------------------------------------------------------------------------------------------------------------------------------------
*FONCTION 6 *Description : lecture des lments dun tableau *Entre :le tableau t et sa dimension n *Sortie :valeur des lment du tableau ----------------------------------------------------------------------------------------------------------------------*/ void Lire Tab(float t[],int n) { for (int i=o ; i<n ; i++)
Language C++
P.74
{ printf(t[%d] :,i) scanf(%f,&t[i] ; } } void Efface Tab(float t[],int n) { int i=0 ; while(i<n) t[i++] =0 ; } void Affiche Tab(float t[],int n) { int i=0 while (i<n) printf(t[%d]=%g\n ,i,t[i++] ; }
/*-----------------------------------------------------------------------------------------------------------------------------------------------
*FONCTION 7 *Description : calcul du produit scalaire par la formule p = t[0]*t[1}* t[n-1] *Entre : tableau t et sa dimension, le tableau t nest pas modifi *Retour :produit scalaire de type float ----------------------------------------------------------------------------------------------------------------------*/ float Produit scalaire( const float t[],int n) { float r= 1.0 ; for (int i=0 ; i<n ; i++) r *= t[i] ; return ; }
5. PASSAGE DUNE STRUCTURE A UNE FONCTION Les structures peuvent tre passes en paramtres des fonctions, ainsi que renvoes par des fonctions, par exemple, si on dfinit la structure Struct Article { unsigned int Code ; char Designation[81] ;
Language C++
P.75
float PrixUnitaire ; float Stock ; }; on peut crire des fonctions telles que Article LireFiche() ; //renvoie une structure de type Article Void AfficheFiche(Article x) ;// accepte comme paramtre une structure Lorsque lon passe une structure une fonction, le paramtre est une variable locale de la fonction, initialise par une copie membre membre de la variable passe. Lorsquune fonction renvoie une structure par une instruction return (ou r) est une variable de type structure locale la fonction, une copie membre membre de r est effectue. Ces copies membre membre prennent du temps si la structure est importante. Il est donc prfrable de passer une rfrence constante, par exemple float Calcul|Montant(const Article& x, float Quantite) du fait de const, la fonction CalculMontant () ne peut modifier la structure x. Elle reoit un pointeur vers cette structure et non la valeur elle- mme. La copie membre membre des paramtres de la fonction ets vite. On peut aussi crire une fonction pour quelle reoive explicitement ladresse de la structure : Void ModifieStock(Article* x) On doit lappeler ainsi : ModifieStock(&Comp) ;//reoit ladresse de la structure
/*-----------------------------------------------------------------------------------------------------------------------------------------------
*PROGRAMME 6 *Fichier : pass_str.cpp *Auteur : Mustapha AIT MAHJOUB *Date :08/02/99 *Description : utilisation des structures. ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> struct Article //dfinition de la structure unsigned int Code ; char Designation[81] ; float Prix Unitaire ; float Stock ; };
Language C++
P.76
//prototype des fonctions Article Lire Fiche() ; Void Afficher Fiche(Article x) ; Float CalculMontant(const Article& x,float Quantite ) ; Void ModifieStock(Article* x) ; //programme principale void main() { Article Comp ; Float M,Q ; Comp = LireFiche() ; Printf(\Enter quantit :) ; Scanf(%f ,&Q) ; M= CalaculMontant(Comp, Q) ; AfficheFiche(Comp) ; Printf(\ n ---------------> Montant =%.2f ,M) ; ModifieStock(&Comp) ; AfficheFiche(Comp) ; Getch() ; }
/*-----------------------------------------------------------------------------------------------------------------------------------------------
*Cette fonction reoit comme paramtre ladresse de l article pour modifier le membre Stock. *Aucune valeur nest retourne ----------------------------------------------------------------------------------------------------------------------*/ .void ModifieStock(Article* x) { printf(\nEntrer le nouveau stock :) ; scanf(%f ,&x->Stock). }
/*-----------------------------------------------------------------------------------------------------------------------------------------------
*Cette fonction ne reoit aucun paramtre et renvoie une structure Article ----------------------------------------------------------------------------------------------------------------------*/ Article Lire Fiche() { Article x ; Clrscr() ; Printf(Lecture dune fiche\n) ; Printf(Code..) ; Scanf(%d ,&x.Code) ; Printf(Dsignation..) ; Scanf(%s ,x.Designation) ; Printf(Prix unitaire) ;
Scanf(%f ,&x.PrixUnitaire) ;
Language C++
P.77
Printf(Stock.) ; Scanf(%f ,&x.Stock) ; Return x ; }

/*-----------------------------------------------------------------------------------------------------------------------------------------------
*Cette fonction reoit comme paramtre une structure Article puis affiche ses membres ----------------------------------------------------------------------------------------------------------------------*/ void AfficheFiche(Article x) { clrscr() ; printf(Affichage dune fiche\n ) ; printf(Code..%u\n , x.Code) ; printf(Designation..%s\n ,x.Designation) ; printf(Prix unitaire..%2f\n,x.PrixUnitaire) ; printf(Stock%.4f ,x.Stock) : }
/*-----------------------------------------------------------------------------------------------------------------------------------------------
*Cette fonction reoit la rfrence dune structure et un rel puis renvoie le montant ----------------------------------------------------------------------------------------------------------------------*/ float CalculMontant(const Article& x,float Quantit) { float m ; m = x.PrixUnitaire *Quantit ; return m ; } 6. CLASSE DE STOCKAGE Lassociation des identificateurs avec des objets ncessite que chaque identificateur possde au moins deux attributs : une classe de stockage et un type. La classe de stockage dtermine lemplacement dun objet (segment de donnes, registre, pile) et sa dure de vie Classe de stockage
- auto - register - static - extern
Type
- Int - Float - char
Objet
Language C++
P.78
6.1 Dure de vie La dure de vie, en relation troite avec la classe de stockage, dfinit la priode pendant la quelle les identificateurs dclars ont des objets physiques rels affects en mmoire. 6.1.1 Dure de vie des variables automatiques Le spcificateur de classe de stockage auto nest utilis que dans des dclarations de variables porte locale, pour une dure du vie locale (automatique). Auto est rarement employ puisque la valeur par dfaut de ces dclarations est justement auto . Le mot cl register est similaire au mot cl auto. Il demande au compilateur de maintenir l4objet dans un registre de microprocesseur sil y a un de disponible. Si aucun registre nest disponible, le compilateur traite lobjet comme un objet automatique. Les variables auto et register sont cres (allocation mmoire ) lorsque la fonction auquel elles appartiennent est appele, et dtruites (dsallocation de la mmoire lorsque la fonction est termine. Dans la fonction suivante : Void fonction1 () { int a ; //automatique par dfaut auto int b ; //automatique register int c ; } Les variables a, b et c sont cres lappel de fonction 1 () et d truites lorsque le contrle est redu la fonction appelante. 6.1.2 Dure de vie des variables statiques et externes Le spcificateur de classe de stockage static est utilisable avec les dclarations de fonctions et de variables porte locale et porte fichier. Static signale aussi que la variable a une dure de vie statique. Dans la fonction suivante : Void fonction 2() { static float delta ; }
Language C++
P.79
La variable static delta est connue seulement dans la fonction ou elle est dfinie, fonction2 (), mais, contrairement aux variables automatiques, elle ne disparat pas lorsque la fonction est termine.
Le spcificateur externe est utilisable avec les dclarations de fonctions et de variables porte locale et porte fichier, pour indiquer un lien externe. Avec les variables porte fichier, le spcificateur par dfaut est externe. Utilis avec des variables, externe indique que la variable a une dure de vie static 6.2 Porte des variables (visibilit) Chaque variable possde une certaine porte bien dfinie, domaine de validit au sein duquel on peut accder la variable. Si on essaye daccder une variable hors de sa porte, le compilateur ne laccepte pas. 6.2.1 Porte Bloc La porte bloc, ou porte local, dun identificateur commence au point de dclaration et se termine la fin du bloc contenant la dclaration. Voici un exemple de bloc lintrieur dune fonction : Void main() {//bloc 1 int x= 10 ; {//bloc 2 int y= 20 ; printf( %d %d\n , x, y) ;//coorect } y = y+ 10 ; //erreur } Linstruction y = y+ 10 gnrera un message derreur puisque la variable y est dfinie dans le bloc 2, donc ne peut pas tre utilise dans le bloc 1. 6.2.2 Porte fonction Les seuls identicateurs qui ont une porte de fonction sont les labels dinstructions. Void fonction()
Language C++
P.80
{ int x ; while(1) { scan( %d ,&x) ;
if (x <0) goto fin ; } fin : printf(le label fin est accesssible dans toute la fonction) ; } 6.2.3 Porte fichier Les identificateurs ayant une porte fichier, appel s identificateurs globaux, sont dclars en dehors des blocs. Leur porte part du point de leur dclaration et se termine la fin du fichier source. Voici un exemple : int X ; Void main() { x = x+ 20 ;//correct, x est dj dfinie y = y +30 ;//errreur, y nest pas encore dfinie } int y ; void fonct() { x = x+20 ;//correct y = y+ 30 ;//correct } La variable x est visible aux fonctions main() et fonct(), alors que y nest visible qu la fonction fonct().
Crer un projet
Princip-cp
Fich1.cpp
Fich.cpp
Language C++
P.81
Language C++
P.82
LES FICHIERS 1. DEFINITION Un fichier est une structure de donne. Tout comme un tableau, un fichier est constitu dune collection de donnes de mme type. A la diffrence dun tableau, il est possible demmagasiner un fichier sur un disque pour conserver linformation dune faon permanente. 2. PRINCIPE DACCES AUX FICHIERS SUR DISQUE Laccs au disque est une procdure complexes et relativement long puisque le lecteur du disque contient une parie mxanique. Lenvoie des donnes caractre par caractre est impraticables. Le systme dexploitation qui soccupe des transferts utilise une mmoire tampon o les donnes a enregistr sur le disque seront stockes temporairement en attendant que le tampon soit plein ou lorsquon ferme un fichier.
Programme
Tampon
Disque
Figure 1 : mcanisme de transfert La gestion de la mmoire tampon implique plusieurs taches : Resever lespace mmoire dans la RAM Grer cette mmoire laide dun pointeur sur celle ci Librer cette mmoire lorsque lon na pas besoin delle. Le langage C nous fournit deus alternatives : soit grer le tampon nous mme en utilisant la mthode dentre/sortie de bas niveau (ou systme) soit confier la tache au systme dexploitation en utilisant la mthode dentre sortie standard. Chacune des deux mthodes est plus au moins complte pour effectuer des E/S sur disque. Ils ont toutes les deux des fonctions pour lire et crire un fichier ou raliser dautres taches. Mais il ya des diffrences importantes entre les deux mthodes. La mthode d E/S standard comme son nom lindique, et la mthode la plus simple et utilise pour effectuer des E/S dans un programme C. Il possde une large gamme de commande assez facile utiliser et vite au programmeur les dtails des oprations lmentaires d E/S tel que la gestion du tampon et la conversion automatique des donnes.
Language C++
P.83
La mthode dE/S de bas niveau fournit moins de choix que la mthode standard, il peut tre considrer comme un systme primitif. Les techniques utiliss sont proches de celle du systme dexploitation. Le programmmeur doit crer et grer le tampon utilis pour le transfert des donnes. La mthode dE/S systme et plus difficile utiliser que la mthode standard mais plus efficace en terme de vitesse et doccupation mmoire. 3. ENTREE/SORTIE STANDARD La mthode dE/S standard est utilise de quatre faons pour lire et crire des donnes. Trois parmi ses quatres faons pour transfrer les donnes correspondent aux mthodes, dj vues, pour lire les donnes partir du clavier et leur affichage sur lcran. Premirement, les donnes peuvent tre lues ou crites un caractre la fois. Ceci est analogue au travail ralis par la fonction getche() pour lire un caractre partir du clavier et putchar() pour afficher un caractre Deuximement, les donnes peuvent tre lues ou crites sous forme dune chane, comme pour les fonctions gets() et puts(). Troisimement, des donnes peuvent tre lues et crites dans un format donn analogue celui gnr par les fonctions printf() et scan() : comme une collection de valeurs mixtes de type caractre, chane, rel ou entier. Quatrimement, les donnes peuvent tre lues et crites dans un nouveau format appel enregistrement ou bloc. Lenregistrement est un groupe de donnes de longueur fixe et gnralement utilis, par exemple, poue stocker les tableaux et las structures. Le tableau suivant montre les fonctions utilises pour lire et crire des donnes dans un fichier pour la mthode dE/S systme et la mthode standard avec ses quatre possibilits. E/S standard E/S systme Caractre getc() putc() Chane fgets() fputs() Format fscan() fprint() Enregistrement fread() fwrite() read() write()
3.1 E/S des caractres Notre premier exemple prend les caractres taps au clavier, et un la fois, sont envoys sur le disque (tampon). Le programme est le suivant et essayant de voir ce quil fait. /*----------------------------------------------------------------------------------------------------------------------
Language C++
P.84
*PROGRAMME 1 *Fichier : ecri_car.cpp *Auteur : Mustapha AIT MAHJOUB *Date :11/02/99 *Description : crit des caractres taps au clavier, vers un fichier ----------------------------------------------------------------------------------------------------------------------*/
#include<stdio.h> #include<conio.h> void main() { FILE *fptr ;//pointeur vers fichier char car ; char fichier[81] ; puts(Nom du fichier :) ; gets(fichier) ; fptr =fopen(fichier, w) ;//ouvrir fichier en criture while ( (car=getche()) != \r)//saisie des caractres Putc(car,fptr) ;//ecrire caractre vers fichier fclose(fptr) ; //fermer fichier } Lors de lexcution du programme, celui ci demande lutilisateur de taper le chemin et le nom du fichier (par exemple C: \TEXTE.txt) puis attend quune ligne de texte soit saisie (par exemple, ENTREE SORTIE DES CARACTERS CEST FACILE.). Le programme sarrte lorsque la touche [ENTREE] est appuye. On peut utiliser la commande TYPE du DOS pour voir le contenu du fichier TEXTE.TXT. C:\> TYPE TEXTE.TXT ENTREE SORTIE DES CARACTERES CEST FACILE 3.1.1 Ouverture dun fichier
Avant dcrire un fichier vers un disque, ou le lire, on doit louvrir. Louverture dun fichier tablit une communication entre le programme et le systme dexploitation pour prciser le fichier auquel on veut accder et comment on va lutiliser. On doit fournir, au systme dexploitation, le nom du fichier et dautres informations (lire, crire, tec). La communication entre le systme d exploitation et le programme se fait travers une structure C qui contient les informations concernant le fichier . Cette structure, qui est dfinie par struct FILE dans le fichier stdio.h. est le point de contact . Lorsque on demande douvrir un fichier, on reoit au retour, cest la demande est satisfaite, un pointeur vers une structure d type File. Chaque fichier ouvert doit avoir sa propre structure FILE, avec un pointeur vers elle. La figure 2 montre ce processus
Language C++
P.85
Language C++
P.86
Nom du fichier Lire, crire, etc. Pointeur vers FILE Numro ID pour ce fichier
Programme
Systme dexploitation
Disque
Figure 2 : Ouverture dun fichier La structure FILE contient les informations sur le fichier qui vient dtre ouvert, comme exemple sa taille courante et ladresse de son tampon. Cette structure est dfinie dans stdio.h de la faon suivante : Typedef struct { Short level ; Unsigned flags ; Char fd ; Unsigned char hold ; Short bsize ; Unsigned char *buffer, *curp ; Unsigned istemp ; Short token ; } FILE ; En examinant le dtail de cette structure, on remarque lexistence de deux pointeurs : buffer et curp. Le rle de buffer est de contenir ladresse de la premire case de la mmoire tampon. Celui de curp est de se dplacer dans la mmoire tampon pour lire ou crire les caractres un par un. Un autre membre de cette structure est bsize qui contient la taille du tampon qui est de 512 octets. Dans le programme 1, nous avons dclar, en premier, une variable de type pointeur vers FILE, dans linstruction : FILE *fptr ; Puis, on a ouvert le fichier avec linstruction
Language C++
P.87
Fptr =fopen(fichier, w) ; Cette instruction demande au systme dexploitation douvrir un fichier dont le nom est saisi par linstruction gets(fichier) ; Le caractre w indique quon dsire crire vers le fichier. La fonction fopen() retourne un pointeur vers la structure FILE, pour le fichier, et quon stocke dans la variable fptr. Le prototype de la fonction fopen() est dclar dans stdio.h comme suit : FILE *fopen(const char *filename, const char *mode) ; La chane de mode prend lune des valeurs ci-dessous : Chane de mode r w a r+ w+ a+ Desvription Ouverture en lecture seule Cration pour criture Ajout :ouvert en criture en fin de fichier ou cration pour criture si inexistant Ouverture de fichier prexistant pour mise jour (lecture/criture). Cration pour mise jour (lecture/criture). Si un tel fichier prexiste, le contenu est perdu Ouverture pour ajout ; ouverture pour mise jour en fin de fichier ou cration si inexistant. Pour indiquer quun fichier doit tre ouvert ou cre en mode texte, on ajoute t la chane de mode (par exemple, rt , w + t ). Pour le mode binaire, on ajoute b (par exemple, wb , a +b ). 3.1.2 Ecriture vers un fichier
Une fois, on a tablit une ligne de communication avec le fichier en louvrant, on peut crire dans ce fichier. Dans le programme 1 nous crivons les caractres, un la fois, en utilisant linstruction : Putc(car, fptr) ; Cette instruction crit le caractre car dans le fichier point par la variable fptr. Le processus dcriture, vers le fichier, continue dans la boucle while jusqu ce que lutilisateur tape la touche ENTREE.
Language C++
P.88
3.1.3
Fermer un fichier
Lorsquon a termin lcriture vers le fichier, on doit fermer celui ci. La fermeture du fichier se fait par linstruction fclose(fptr) ; Normalement, les caractres envoys par putc() sont stocks temporairement dans le tampon. Lorsque le tampon est plein (512 octets), sont contenu est alors envoy automatiquement au disque. La fermeture du fichier par la fonction fclose() fait en sorte que les caractres du tampon sont envoys vers le disque mme si celui ci nest pas plein. Une autre raison pour fermer le fichier est de librer lespace de communication utilis par un fichier pour tre utiliser par dautres fichiers. Cet espace contient la structure FILE et le tampon lui-mme. 3.1.4 Lecture dun fichier
Si on peut crire un fichier, on doit tre capable de le lire. Voici un programme qui lit un fichier en utilisant la fonction getc() : /*---------------------------------------------------------------------------------------------------------------------*PROGRAMME 2 *Fichier : lire_car.cpp *Auteur : Mustapha AIT MAHJOUB *Date :11/02/99 *Description : lit des caractres dun fichier puis les affiche ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> void main() { FILE* fptr ;//pointeur vers fichier int car ; char fichier[81] ; puts(Nom du fichier :) ; gets(fichier) ; fptr =fopen(fichier,r) ;//ouvrir fichier en lecture while ( (car=getc(fptr)) !=EOF)//lecture des caract7res du fichier printf(%c ,car)://affichage du caractre lu fclose(fptr) ; //fermer fichier }
Language C++
P.89
Ce programme est similaire au programme 1. Le pointeur vers FILE est dclar de la mme faon, et la fichier est ouvert et ferm de la mme faon. La fonction getc() lit un caractre partir du fichier (par exemple , TEXTE.TXT) ; cette fonction est complmentaire la fonction putc(). 3.1.5 Fin de fichier
La diffrence majeur entre ce programme et PROGRAMME 1 est que PROGRAMME 2 doit savoir la consultation de lindicateur de fin de fichier EOF qui est envoy par le systme dexploitation. Lindicateur EOF nest pas un caractre mais un entier de valeur 1. 3.1.6 Erreur douverture dun fichier
Dans le programme 1 ou 2 si le fichier spcifi dans la fonction fopen() na pas pu tre ouvert , le programme ne pourra pas tre excut. En effet, la fonction fopen() renvoie une valeur nulle si par exemple : - Le disque est plein pour criture - Fichier inexistant - Disque ou fichier protg contre lcriture. Le programme suivant est une version amliore du programme2. /*---------------------------------------------------------------------------------------------------------------------*PROGRAMME 3 *Fichier : lir_car2.cpp *Auteur : Mustapha AIT MAHJOUB *Date :11/02/99 *Description : lit des caractres dun fichier puis les affiche sil npas derreurs douverture de fichier. ----------------------------------------------------------------------------------------------------------------------*/ void AfficheErreur (FILE*fptr, char* ptr) ; #include<stdio.h> #include<conio.h> #include<stdib.h> void main() { FILE* fptr ;//pointeur vers fichier int car ; char fichier[81] ; puts(Nom du fichier :) ; gets(fichier) ; fptr =fopen(fichier,r) ;//ouvrir fichier en lecture if (fptr = = NULL) { printf(Impossible douvrir le fichier %s en lecture\n , fichier) ; exit(1) ; //sortie du programme } while ( (car =getc(fptr)) ! = EOF)//lecture des caractres du fichier {
Language C++
P.90
if (ferror(fptr)) { AfficheErreur(fptr,fichier) ; Fclose(fptr) ; Exit(1) ; } printf(%c ,car) ;//affichage du caractre lu } fclose(fptr) ; //fermer fichier } void AfficheErreur(FILE* fptr, char* ptr) { perror(ptr) ; clearerr(fptr) ; } Mme si le fichier a t ouvert correctement, il se peut que dautres erreurs de lecture ou dcriture surviennent lors dun accs au disque. Un secteur pourrait tre dfectueux, par exemple. La fonction ferror() dtecte ce genre derreurs, perror() affiche un message correspondant cette erreur et clearer() remet zro un indicateur derreur pour permettre de continuer les oprations sur le fichier. 3.1.7 Application : Compter le nombre de caractres dans un fichier
La possibilit de lire et dcrire ves un fichier caractre par caractre peut avoir beaucoup dapplications. Comme exemple, voici un programme qui compte le nombre de caractres dans un fichier : /*---------------------------------------------------------------------------------------------------------------------*PROGRAMME 4 *Fichier : compteC.cpp *Auteur : Mustapha AIT MAHJOUB *Date :12/02/99 *Description : compte le nombre de caract7res dans un fichier ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> #include<stdib.h> #include<dos.h> void main(int_argc,char*_argv[])) { FILE* fptr ;//pointeur vers fichier
Language C++
P.91
int car ; char fichier[81] ; int compte=0 ; clrsc() ; if (_argc != 2) { printf(Format : >comptec NomFichier) ; exit(0) ; } fptr =fopen(_argv[1],r) ;//ouvrir fichier en lecture if (fptr = = NULL) { printf(Fichier %s ne peut pas tre ouvert\n_argv[1] ; exit(0) ;//fin du programme } while ( (getc(fptr) ) != EOF)//lire caractre du fichier compte++ ; fclose(fptr) ; //ferme fichier printf(le fichier %s contient %d caractres.,_argv[1],compte) ; getch() } Dans de programme nous avons utiliss une ligne de commande avec arguments pour obtenir le nom du fichier. On commence par chaercher le nombre darguments ; sil yen a deux, alors le deuxime, arg[1], est le nom du fichier. Le programme ouvre le fichier en lecture tout en sassurant de son existence, puis entre dans une boucle de lecture, pour lire les caractres un la fois. A chaque lecture dun caractre la variable compte est incrmente de 1. Le programme compte peut tre excut partir du DOS, par exemple : C :>compte TEXTEE.txt 3.2 E/S des chanes Lire et crire des chanes de caractres partir ou vers un fichier est aussi facile que lire et crire des caractres individuels. Voici un programme qui crit des chanes vers un fichier en utilisant la fonction dE/S de chane fputs(). /*---------------------------------------------------------------------------------------------------------------------*PROGRAMME 5 *Fichier : ecri_ch.cpp *Auteur : Mustapha AIT MAHJOUB *Date :05/03/99 *Description : crit des chanes de caractres, tapes au clavier vers un fichier
Language C++
P.92
----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> #include<string.h> #include<process.h> void main() { FILE* fptr ;//pointeur vers fichier char car ; char fichier[81] ; char chane[81] ; puts(Nom du fichier :) ; gets(fichier) ; fptr =fopen(fichier,w) ;//ouvrir fichier en ecriture if (fptr = = NULL) { printf(Fichier %s ne peut pas tre ouvert\n , fichier) ; exit(0) ;//fin du programme } while ( strlen(gets(chane)) > 0) { fputs(chaine,fptr) ; fputs(\n ,fptr) ; } fclose(fptr) ; //ferme fichier } Lutilisateur tape une srie de chanes en terminant chacune delles par[ ENTREE]. Pour terminer le programme, lutilisateur tape la touche [ENTREE] au dbut d4une ligne pour crer une chane de longueur nulle (condition de sortie de la boucle). Nous avons dclar un tableau de caractres pour stocker une chane fputs() crit le contenu de ce tableau vers le disque, mais elle najoute pas automatiquement le caractre nouvelle ligne \n la fin de la chane, on doit le faire explicitement (fputs(\n ,fptr) pour rendre facile la lecture des chanes partir du fichier. Voici le programme qui lit des chanes partir dun fichier : /*---------------------------------------------------------------------------------------------------------------------*PROGRAMME 6 *Fichier : lit_ch.cpp *Auteur : Mustapha AIT MAHJOUB *Date :05/03/99 *Description : lit des chanes de caractres, partir dun fichier puis les affiche
Language C++
P.93
----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> #include<string.h> #include<process.h> void main() { FILE* fptr ;//pointeur vers fichier char car ; char fichier[81] ; char chane[81] ; puts(Nom du fichier :) ; gets(fichier) ; fptr =fopen(fichier,w) ;//ouvrir fichier en ecriture if (fptr = = NULL) { printf(Fichier %s ne peut pas tre ouvert\n , fichier) ; exit(0) ;//fin du programme } while (fgets(chaine,80,fptr) != NULL) printf(%s,chaine) ; fclose(fptr) ; //ferme fichier }
La fonction fgets() est dclare dans le stdio.h par : Char *fgets(char *s, int n, FILE *stream) Nous remarquons que cette fonction prends trois paramtres. Le premier est ladresse o la chane est stocke, le second est la longueur maximale de la chane. La fonction cesse la lecture soit lorsque n-1 caractres ont t lus soit suite la lecture de saut de ligne (\n) (ce caractre est copi dans s). la fin de la chane de caractres est marque par lajout dun caractre nul (\0). Le troisime est le pointeur sur la structure FILE pour ce fichier. 3.3 E/S Formates Les programmes prcdents nous ont permet de lire et crire des caractres et du texte. Nous allons voir maintenant comment manipuler les nombres. Le programme 7 lit les donnes partir du clavier, puis les envoie vers un fichier. /*---------------------------------------------------------------------------------------------------------------------*PROGRAMME 7 *Fichier : ecrifo_ch.cpp *Auteur : Mustapha AIT MAHJOUB *Date :05/03/99 *Description : crit des donnes formates, tapes au clavier vers un fichier ----------------------------------------------------------------------------------------------------------------------*/
Language C++
P.94
#include<stdio.h> #include<conio.h> #include<string.h> #include<process.h> void main() { FILE* fptr ;//pointeur vers fichier char car ; char fichier[81] ; char Designation[41] ; int Code ; float Prix ; float Stock ; clrscr() ; puts(Nom du fichier :) ; gets(fichier) ; fptr =fopen(fichier,w) ;//ouvrir fichier en ecriture if (fptr = = NULL) { printf(Fichier %s ne peut pas tre ouvert\n , fichier) ; exit(0) ;//fin du programme } do { printf (Code :) ; scanf(%d ,&Code) ; if (Code < = 0) break ; printf(Dsignation :) ; scanf(%s ,Designation) ; printf(Prix Unitaire :) ; scanf(%f ,&Prix) ; printf(Stock :) ; scanf(%f ,&Stock) ; fprintf (fptr, %s %d %f %f , Designation, Code, Prix, Stock) ; } while ( 1) ; fclose(fptr) ; //ferme fichier } La cl de ce programme est la fonction fprintf(), qui crit les valeurs des quatre variables vers le fichier . Cette fonction est similaire printf(), sauf que le pointeur FILE est inclus comme premier paramtre. Comme pour printf(), nous pouvons formater une donne de plusieurs faon ; en dautre terme, les conventions dcriture avec printf() reste valable pour fprintf() Dans la boucle do, lutilisateur saisie les donnes Code, Dsignation, Prix et Stock tant que code est suprieur 0.
Language C++
P.95
Le programme suivant permet de lire les donnes enregistres avec la programme 7. /*---------------------------------------------------------------------------------------------------------------------*PROGRAMME 8 *Fichier : litfo_ch.cpp *Auteur : Mustapha AIT MAHJOUB *Date :05/03/99 *Description : lecturedes donnes formates, partir du disque, et leurs affichage ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> #include<string.h> #include<process.h> void main() { FILE* fptr ;//pointeur vers fichier char car ; char fichier[81] ; char Designation[41] ; int Code ; float Prix ; float Stock ; clrscr() ; puts(Nom du fichier :) ; gets(fichier) ; fptr =fopen(fichier,w) ;//ouvrir fichier en lecture if (fptr = = NULL) { printf(Fichier %s ne peut pas tre ouvert\n , fichier) ; exit(0) ;//fin du programme } while (fscanf(fptr, %s %d %f %f , Designation,&Code,&Prix,&Stock) !=EOF) { printf (Code :%d\n,Code) ; printf(Dsignation : %s\n ,Designation) ; printf(Prix Unitaire : %.2f\n Prix) ; printf(Stock : %2f\n ,Stock) ;) ; } fclose(fptr) ; //ferme fichier getch() ; }
Language C++
P.96
Le programme 8 utilise la fonction fscan() pour lire les donnes partir dun fichier. Cette fonction est similaire scanf(), sauf que, comme pour fprintf() , le pointeur vers FILE est inclus comme premier paramtre. Le texte et les caractres sont stocks un caractre par octet. Les entiers sont stocks, en mmoire, sous forme de deux octets et les rels sur quatre octets alors que sur le disque, ils sont enregistrs sous forme dun texte. Ainsi, lentier 999 est stock en mmoire sur deux octets, mais il a besoin de trois octets pour tre stock sur disque sous la forme 999. Le nombre rel 45.36 occupe 4 octets en mmoire et 5 octets sur disque ; un octet pour cahaque chiffre et un octet pour le point dcimal. 3.4 Mode binaire et mode texte Le langage C a t dvelopp initialement pour le systme dexploitation UNIX , en utilisant videmment les conventions de traitement de fichier correspondantes UNIX. Lorsque le langage C a t transport sur MSDOS , on a ddcid que C suppoterait les conventions des deux systmes dexploitation. Ainsi le mode texte est conforme au systme UNIX et le mode binaire, au systme MSDOS. La distinction entre les deux modes rside dans linterprtation du caractre \n de code x0A (ligne suivante) et du caractre ctrl-Z, de code x/A La figure suivante dcrit linteraction entre un programme C et le DOS pour un fichier ouvert en mode texte.
Dos Programme C \n (x0A) Fin du fichier CR/LF (x0D,x0A) Tous les octets du fichier ont t lus Ctrl-Z
(x/A)
Figure 3 : Interaction C et DOS en mode texte
Pour un fichier ouvert en mode texte et en criture, le caractre n est converti et sauv par le DOS sous forme de deux octets : CR/LF (x0D/x0A). lors dune opration de lecture, le DOS transmet au programme C le code x0A lorsquil rencontre la squence x0D et x0A Normalement, la fin du fichier est reconnue lorsque tous les octets lus. Le dos connat le nombre doctets de chaque fichier. Si le caractre ctrl-Z se trouve dans le fichier ouvert en mode texte, le DOS linterprte comme fin de fichier. Le reste du fichier sera ignor.
Language C++
P.97
Programme C \n (x0A) \r \n (x0D, x0A) LF (x0A)
Dos
CR/LF (x0D, x0A) Tous les caractres ont t lus X|A (ctrl-Z)
Fin du fichier
Un nombre
Figure 5 : Interaction Cet DOS en mode binaire Pour un fichier ouvert en mode binaire : Les caractres \n et \r sont enregistrs et relus tels quels par le DOS La fin du fichier est reconnue lorsque tous les octets ont t lus. Le code ctrl-Z est un code binaire comme les autres. Il nest donc pas interprt par le DOS comme fin de fichier. 3.5 E/S des enregistrements Nous avons vu, prcdemment, comment les nombres peuvent tre stocks en utilisant les fonctions dE/S formates fscan() et fprintf(). Nous avons aussi vu que la sauvegarde des nombres occupe beaucoup despace disque, car chaque chiffre est stock comme caractre. LE/S des donnes formates prsente un autre problme : il ny a pas de moyen direct pour stocker des donnes de type complexe tels que les tableaux et les structures. La solution ces problmes est les des enregistrements (ou block). LE/S des enregistrements crit, vers le disque, les nombres dans un format binaire ce que rduit lespace occup sur le disque. 3.5.1 Ecriture des structures avec fwrite()
Nous allons rcrire lexemple du programme 7 en utilisant la structure ARTICLE. Le programme suivant accepte les entres concernant, le nombre de la structure ARTICLE, Dsignation, Code, Prix et stock puis crit ces donnes vers le fichier disque. Le fichier est ouvert en mode binaire et les informations obtenues de lutilisateur sont places dans la structureart. Puis, linstruction suivante crit la structure vers le fichier :
Language C++
P.98
Fwrite(&art, sizof(art), 1, fptr ; Le premier argument de cette fonction est ladresse de la structure qui va tre crite. Le second argument est la taille de la structure en nombre doctets. Le troisime argument est le nombre de structure crire en mme temps. Le dernier argument est le pointeur vers le fichier dans lequel en va crire. /*---------------------------------------------------------------------------------------------------------------------*PROGRAMME 9 *Fichier : ecristru_ch.cpp *Auteur : Mustapha AIT MAHJOUB *Date :09/03/99 *Description : crit des structures vers un fichier ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> #include<string.h> #include<process.h> typedef struct { char Designation[41] ; int Code ; float Prix ; float Stock ; }ARTICLE ; void main() { FILE * fptr ;//pointeur vers fichier Char car ; Char fichier[81] ; ARTICLE art ; clrscr() ; puts(Nom du fichier :) ; gets(fichier) ; fptr =fopen(fichier,wb) ;//ouvrir fichier en criture,mode binaire if (fptr = = NULL) { printf(Impossible douvrir le fichier %s en criture\n ,fichier) ;) ; exit(1) ;//fin du programme } do { printf (Code :) ; scanf(%d ,&art.code) ; if (aer.Code <0) break ; printf(Dsignation : ) ; scanf(%s,art.Designation) ;
Language C++
P.99
printf(Prix Unitaire :) ; scanf(%f ,&art.Prix) ; printf(Stock : ) ; scanf(%f ,&art.Stock) ; fwrite (&art,sizeof(art),1,fptr) ; } while(1) ; fclose(fptr) ; //ferme fichier } 3.5.2 Lecture des structures avec fread()
Le programme suivant permet de lire la structure crite avec la programme 9 : /*---------------------------------------------------------------------------------------------------------------------*PROGRAMME 10 *Fichier : litstru_ch.cpp *Auteur : Mustapha AIT MAHJOUB *Date :09/03/99 *Description : lit des enregistrements partir dun fichier ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> #include<string.h> #include<process.h> typedef struct { char Designation[41] ; int Code ; float Prix ; float Stock ; }ARTICLE ; void main() { FILE * fptr ;//pointeur vers fichier char car ; char fichier[81] ; ARTICLE art ; clrscr() ; puts(Nom du fichier :) ; gets(fichier) ; fptr =fopen(fichier,rb) ;//ouvrir fichier en lecture,mode binaire if (fptr = = NULL) {
Language C++
P.100
printf(Impossible douvrir le fichier %s en lecture\n,fichier) ;) ; exit(0) ;//fin du programme }
while (fread(&art,sizeof(art),fptr) = =1= { printf (Code :%d\n ,art.Code) ; printf(Dsignation : %s\n ,art.Designatio) ; printf(Prix Unitaire :%.2f\n ,art.Prix) ; printf(Stock : %.2f\n ,art.Stock) ; } fclose(fptr) ; //ferme fichier getch() ; } La principale instruction du programme 10 est lexpression Fread(&art, sizeof(art), 1, fptr) ; Celle ci lit la donne partir du disque pour la placer dans la structure art : le format est similaire fwrite(). La fonction fread() retourne le nombre dlments lu qui correspond normalement au troisime argument de la fonction. La lecture des enregistrements continue jusqu que fread() retourne une valeur infrieure 1. 3.6 Accs alatoire Tous les fichiers peuvent tre organiss dune ou de deux manires diffrentes, squentielle ou alatoire (on appelle aussi cette dernire fichier accs direct). Dans un fichier squentiel, toutes les composantes dun fichier sont stockes de faon squentielle, lune aprs lautre. Pour accder une composante particulire, il faut commencer au dbut du fichier et chercher travers le fichier entier pour trouver la composante qui nous intresse. Ce type daccs peut prendre beaucoup de temps, particulirement si on travaille avec des fichiers volumineux. Cependant, les fichiers squentiels sont relativement faciles crer. Dans un fichier alatoire, on accde directement nimporte quelle composante, sans traiter le fichier en entier partir du dbut. Ce type daccs est plus rapide mais difficile crer et maintenir. Laccs aux donnes, dans les programmes prcdents, se faisait dune manire squentielle. Le programme suivant autorise laccs alatoire aux donnes du fichier cre par le programme 9. /*---------------------------------------------------------------------------------------------------------------------*PROGRAMME 11 *Fichier : alea.cpp *Auteur : Mustapha AIT MAHJOUB *Date :05/03/99 *Description : lit lenregistrement dun article, slectionn par lutilisateur ----------------------------------------------------------------------------------------------------------------------*/
Language C++
P.101
#include<stdio.h> #include<conio.h> #include<string.h> #include<process.h> typedef struct { char Designation[41] ; int Code ; float Prix ; float Stock ; }ARTICLE ; void main() { FILE * fptr ;//pointeur vers fichier char fichier[81] ; int NumeroEnreg ; long int Deplacement ; ARTICLE art ; clrscr() ; puts(Nom du fichier :) ; gets(fichier) ; fptr =fopen(fichier,rb) ;//ouvrir fichier en lecture,mode binaire if (fptr = = NULL) { printf(Impossible douvrir le fichier %s en lecture\n,fichier) ;) ; exit(0) ;//fin du programme } printf(Enregistrement actuel :%d\n, ftell(fptr)/sizeof(art)) ; printf(Enter le numro denregistrement :) ; scanf(%d ,&NumeroEnreg) ;//lit le numro denregistrement Deplacement = NumeroEnrg * sizeof(art) ;//calcul son dplacement if (fseek(fptr,Deplacement,0) !=0) //par rapport au dbut du fichier { printf(Le pointeur du fichier ne peut tre dplac :) ; exit(0) ; } fread(&art,sizeof(art), 1 ,fptr) ; printf (Code : %d ,&art.code) ; printf(Dsignation : %s\n ,art.Designation) ; printf(Prix Unitaire : %.2f\n ,art.Prix) ; printf(Stock : %.2f\n ,art.Stock) ; fclose(fptr) ; //ferme fichier getch() ;
Language C++
P.102
} Le pointeur de lecture du fichier est un pointeur vers des octets particuliers du fichier. Les programmes quon a vus font usage du pointeur. Chaque fois quon crit des donnes vers un fichier, le pointeur est dplac vers la fin. Lorsquon ouvre un fichier en lecture, le pointeur est positionn au dbut du fichier. Si le fichier est ouvert pour ajout, en utilisant loption a, le pointeur est plac la fin du fichier. La fonction ftell() permet de connatre la position courante du pointeur : Long ftell(FILE *fptr) ;
La fonction fseek() permet de dplacer le pointeur sur une donne particulire en lui fournissant un dplacement par rapport lemplacement spcifi. Cette fonction est dclare par nt fssek(FILE *fptr, long Deplacement , int origine) Fptr : fichier point, Deplacement : Diffrence en octets entre origine (position pointeur fichier) et la nouvelle position. En mode texte, offset doit tre 0 ou une valeur envoye par ftell. Origine : Une des trois origines de pointeurs fichier (0, 1, ou 2) 0 : dbut du fichier 1 : position courante du pointeur 2 : fin de fichier Valeur Renvoye par fseek() Si succs, (pointeur repositionn), 0. Si chec, non-zro. fseek renvoie un code erreur uniquement sur un fichier non ouvert ou un priphrique. 4 ENTRE/SORTIE SYSTEME
LE/S systme (ou E/S de bas niveau) est semblable celle utilise par MS DOS pour lire et crire un fichier. Avec lE/S systme, les donnes ne peuvent pas tre crites comme des caractres individuels ou comme chanes de caractres ou encore comme donnes formates comme pour les E//S standards. Il y a un seul moyen pour crire les donnes : comme un tampon plein de caractres. Ecrire un tampon de caractres ressemble aux E/S des enregistrements avec les E/S standards. Contrairement aux E/S standards, le programmeur doit crer le tampon pour ces donnes, le remplir avec des valeurs appropries avant lcriture. La figure suivante montre que le tampon pour une E/S systme est une partie du programme, alors que celui ci tait invisible pour une E/S standard.
Programme C
Les donnes sont places dans le tampon par le programme
Tampon
Disqu e
La fonction write() envoie le contenu du tampon vers le fichier sur disque
Language C++
P.103
Figure3 : E/S systme
LE/S de bas niveau a plusieurs avantages : Le code utilis par les routines de la bibliothque est plus court que celui de lE/S standard Plus rapide, car il utilise moins de routines. 4.1 Lecture des fichiers Le programme suivant lit un fichier disque et affiche son contenu sur lcran. /*---------------------------------------------------------------------------------------------------------------------*PROGRAMME 12 *Fichier : litsys.cpp *Auteur : Mustapha AIT MAHJOUB *Date :16/03/99 *Description : lit un fichier avec la mthode dE/S systme ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> #include<fcntl.h> //constantes symboliques pour open #include<process.h> #include<io.h> #define Long Tampon 512 //taille du tampon en nombre doctets char Tampon[Long Tampon] ; // dclaration tampon void main(int argc,char *argv[]) { int Handle, Octets, i ; if(argc !=2) { printf(Format : c:\>liresys fichier.xxx) ;
Language C++
P.104
exit(0) ; } if ( (Handle =open(argv[1], O_RDONLY | O_BINARY)) < 0) { printf(Impossible douvrir le fichier %s ,argv[1]) ; exit(0) ; } while( (Octets = read(Handle, Tampon, Long Tampon)) >0) for( j=0 ; j < octets ; j++) putch(Tampon[j]) ; close (Handle) ; } 4.1.1 Cration dun tampon
La premire tape consiste en la cration dun tampon avec les instructions : #define Long Tampon 512 char Tampon[Long Tampon] ;
Le tampon est la zone mmoire o les donnes lues partir du disque seront places. La taille du tampon est importante pour des oprations efficaces. Suivant le systme dexploitation, les tampons avec une certaine taille seront grs plus efficacement que dautres. Avec MSDOS, la valeur optimale est de 512 octets. Dans dautre cas un tampon plus grand peut tre utilis en choisissant des multiples de 512 octets. 4.1.2 Ouverture dun fichier
Comme pour les E/S standards, on doit ouvrir un fichier avant accder. Ceci est ralis par linstruction Handle = open(argv[1], O_RDONLY | O_BINARY) Louverture dun fichier consiste tablir une communication avec le systme dexploitation . On fournit au systme travers la fonction open() - le nom du fichier quon veut ouvrir. accs en lecture ou en criture. le fichier est ouvert en mode binaire ou en mode texte.
La mthode utilise pour indiquer ces caractristiques est diffrente de celle utilise par la mthode dE/S standard. Chaque caractristique est indique par une constante. La liste de ces constantes symboliques est fournie dans le tableau suivant :
Language C++
P.105
Constantes O_APPEND O_CREAT O_RDONLY O_RDWR O_TRUNC O_WRONLY O_BINARY O_TEXT
Signification Place le pointeur la fin du fichier Cre un nouveau fichier pou criture (na pas deffet si le fichier existe dj) Ouvre le fichier en lecture seulement Ouvre le fichier en lecture et en criture Ouvre le fichier avec troncature. Si le fichier sa longueur est ramene zro. les attributs restent identiques Ouvre le fichier pour criture seulement Ouvre le fichier en mode binaire Ouvre le fichier en mode texte
Dans lexemple du programme 10, on a ouvert le fichier avec les constantes O_RDONLY et O_BINARY cest dire en lecture avec le mode binaire. Lorsque plusieurs constantes sont utilises ensembles, elles sont combines avec loprateur de bits OU (\).
4.1.3
Identification de fichier (Handle)
Au lieu de retourner un pointeur, comme pour la fonction fopen () le fait, la fonction open() retourne une valeur entire appel identificateur (handle). Ce nombre qui est assign un fichier sera utilis pour se rfrer celui ci. Si open() retourne la valeur 1, elle signale une erreur douverture 4.1.4 Lecture du fichier dans le tampon
Linstruction suivante lit le contenu du fichier : Octets = read(Handle, Tampon, Long Tampon) ; La fonction read() prend trois paramtres. Le premier est lindicateur du fichier. Le second est ladresse du tampon. Le troisime est le nombre maximum doctets quon veut lire(dans lexemple, la totalit du tampon). La fonction read() retourne le nombre doctets mis dans le tampon. Si ce nombre gale zro, elle indique la fin de fichier. 4.1.5 Fermeture du fichier
Un fichier doit ferm aprs utilisation. On utilise la fonction close() pour fermer un fichier. La fonction close() prend comme paramtre lidentificateur du fichier fermer. Close(Handle) ;
Language C++
P.106
4.1.6
Messages derreur
Comme pour lE/S standard, pour dterminer lorigine dune erreur lorsquon ouvre un fichier ou lorsquon lui accde, on peut utiliser la fonction perror(). Cette fonction prend comme paramtre une chane de caractres. Par exemple, on peut remplacer les instructions suivantes dans le programme 12 : Printf(Impossible douvrir le fichier %s ,argv[1] ; Exit(0) ; par linstruction perror(Impossible douvrir le fichier :) ; 4.2 Opration sur le tampon Mettre le contenu dun fichier dans un tampon a beaucoup davantage ; on peut faire diffrentes oprations sur le contenu du tampon sans le besoin daccder nouveau au fichier. Le programme suivant cherche, dans le fichier, un texte ou une phrase saisie par lutilisateur. /*---------------------------------------------------------------------------------------------------------------------*PROGRAMME 13 *Fichier : fcherche.cpp *Auteur : Mustapha AIT MAHJOUB *Date :5/03/99 *Description : cherche une phrase dans un fichier ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> #include<fcntl.h> #include<process.h> #include<io.h> #include<string.h> #define Long Tampon 1024 void cherche(char* phrase, int Ltampon) ; char Tampon[Long Tampon] ; void main(int argc,char *argv[]) { int Handle, Octets, j; if(argc !=3) { printf(Format : c:\>liresys fichier.xxx phrase) ; exit(0) ; } if ( (Handle =open(argv[1], O_RDONLY | O_BINARY)) < 0)
Language C++
P.107
{ printf(Impossible douvrir le fichier %s,argv[1]) ; exit(0) ; } while( (Octets = read(Handle, Tampon, Long Tampon)) >0) cherche(argv[2], Octets) ; close (Handle) ; } void cherche(char* phrase,int Ltampon) { char* ptr, *p ; ptr = Tampon ; while ( (ptr =(char*) memchr(ptr, phrase[0], Ltampon )) != NULL) if (memcmp(ptr,phrase, strlen(phrase)) = = 0) { printf(Premire occurrencede la phrase:\n) ; for (p =ptr 10; p<ptr + 10;p++) putchar(*p) ; exit(0) ; } else ptr++ ; } Le programme suggre de lutilisateur de taper deux arguments dans la ligne de commande : la nom du fichier et la phrase chercher, par exemple C:\>fcherche fcherche.cpp main
La fonction cherche(), appele par le programme principale, utilise plusieurs fonctions de manipulation du tampon, la premire est la fonction memchr(). Cette fonction cherche, dans le tampon, un caractre spcifique. Dans le programme 13, lexpression Ptr = (char*) memchr(ptr, phrase[0], Ltampon) montre trois arguments ncessaires pour memchr(). Le premier est ladresse du tampon. Le second est le caractre chercher (le premier caractre de la phrase chercher). Le troisime est la plage de recherche (taille du tampon). La fonction memchr() renvoie NULL si le caractre nest pas trouv dans le tampon. Sinon, elle retourne un pointeur vers le caractre trouv. La fonction cherche() entre dans une instruction if pour vrifier si la phrase dbutant par le caractre trouv est identique la phrase recherche. Cette comparaison est faite avec la fonction memcmp() dans lexpression if (memcmp(ptr,phrase, strlen(phrase)) = = 0)
Language C++
P.108
La fonction memcmp() prend trois paramtres : un pointeur vers un emplacement du tampon o la comparaison doit dbuter, ladresse de la phrase chercher et la longueur de la phrase. Si la phrase existe, la fonction memcmp() retourne la valeur zro. 4.3 Ecrire dans un fichier Comme exemple, essayons de voir le programme suivant qui copie un fichier vers un autre ; il limite le commande COPY du DOS. Pour utiliser cette fonction, lutilisateur tape le nom du fichier source (qui existe dj) et le fichier de destination (qui va tre cre) dans la ligne de commande. C:\>fcopie source.txt desti.txt /*---------------------------------------------------------------------------------------------------------------------*PROGRAMME 14 *Fichier : fcopie.cpp *Auteur : Mustapha AIT MAHJOUB *Date :5/03/99 *Description : Copie un fichier ----------------------------------------------------------------------------------------------------------------------*/ #include<stdio.h> #include<conio.h> #include<fcntl.h> #include c : \borlandc\include\sys\stat.h #include<process.h> #include<io.h> #include<string.h> #define Long Tampon 4096 char Tampon[Long Tampon] ; void main(int argc,char *argv[]) { int E_ Handle, S_Handle , Octets;
if(argc !=3) { printf(Format : c:\>fcopie source.xxx desti.xxx) ; exit(0) ; } if ( (E_Handle =open(argv[1], O_RDWR | O_BINARY)) < 0) { printf(Impossible douvrir le fichier %s,argv[1]) ; exit(0) ; }
Language C++
P.109
if ((S_Handle =open(argv[2], O_CREAT | O_WRONLY| O_BINARY, S_IWRITE )) < 0) { printf(Impossible douvrir le fichier %s ,argv[2]) ; exit(0) ; } while( (Octets = read(E_Handle, Tampon, Long Tampon)) >0) write (S_Handle, Tampon,Octets) ; close (E_Handle) ; close (S_Handle) ; } Les deux fichiers sont ouverts. Lun est la source qui on assigne lidentificateur E_Handle. Lautre est le fichier de destination dont lidentificateur est S_Handle. Lexpression qui ouvre le fichier de destination est If ( (S_Handle =open(argv[2], O_CREAT | O_WRONLY| O_BINARY, S_IWRITE )) < 0 ) Pour crer un nouveau fichier, on utilise la constante symbolique O_CREAT. Nous voulons crire ce fichier et ne pas le lire, pour le faire, nous utilisons la constante O_WRONLY . La constante O_BINARY indique que le fichier est ouvert en mode binaire. Lorsque la constante O_CREATest utilise, une autre variable doit tre ajouter la fonction open() pour indiquer ltat de la lecture/Ecriture du fichier qui va tre cre. Ces options sont appeles arguments de permission (droit daccs). Il existe trois possibilits : S_IWRITE S_IREAD S_IREAD | S_IWRITE : Ecriture permise : Lecture permise : Lecture et criture permises
Pour utiliser ces possibilits, il faut inclure le fichier sys-stat.h dans le fichier source du programme. La fonction write() est similaire read(). Elle prend trois arguments : lidentificateur du fichier, ladresse du tampon et le nombre doctets crire.

Ait Mahjoub Langage C

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Ait Mahjoub Langage C

Transféré par

Droits d'auteur :

Formats disponibles

Elabor par : Mr Mustapha AITMAHJOUB

OFPPT : ISTA HAY RIAD

OFPPT : ISTA HAY RIAD

3.2 Structure do..while...29 3.3 Structure for.30

OFPPT : ISTA HAY RIAD

OFPPT : ISTA HAY RIAD

OFPPT : ISTA HAY RIAD

OFPPT : ISTA HAY RIAD

TABLEAU 1 : Mots rservs

OFPPT : ISTA HAY RIAD

OFPPT : ISTA HAY RIAD

OFPPT : ISTA HAY RIAD

OFPPT : ISTA HAY RIAD

OFPPT : ISTA HAY RIAD

3.2 Donnes de type rel

OFPPT : ISTA HAY RIAD

OFPPT : ISTA HAY RIAD

Type Float Double Long double

Taille 4 octets 8 octets 10 octets

OFPPT : ISTA HAY RIAD

Const int NombreMax= 100 ; Const float SalaireMin= 1500.00 ;

OFPPT : ISTA HAY RIAD

OFPPT : ISTA HAY RIAD

OFPPT : ISTA HAY RIAD

OFPPT : ISTA HAY RIAD

Squence \n \t \b \r \ \ \\ \xdd \ddd

OFPPT : ISTA HAY RIAD

OFPPT : ISTA HAY RIAD

OFPPT : ISTA HAY RIAD

b = 2*a++ b = 2*++a b = ++a-2 b = 10 (- -a) 6.4 Oprateur sizeof ()

// b =10, a = 6 // a =7, b =14 // a = 8, b = 6 // a = 7, b =3

Cet oprateur renvoie la taille , en nombre doctets, de lexpression au du type syntaxe :

Exemple : Sizeof (int) renvoie le nombre doctet quoccupe un entier

OFPPT : ISTA HAY RIAD

ET logique OU logique NON logique

OFPPT : ISTA HAY RIAD

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

x /= 2 x %= 2 x += 2 x-=2 x<< = 2 x >>= 2 x &= 2 x |= 2 x ^= 2

x = x /2 x = x %2 x = x +2 x = x -2 x = x <<2 x = x>> 2 x = x &2 x = x |2 x = x ^2

OFPPT : ISTA HAY RIAD

OFPPT : ISTA HAY RIAD

OFPPT : ISTA HAY RIAD

Instruction 1 Instruction 2 Instruction 3

OFPPT : ISTA HAY RIAD

Remise= 0 oui Montant>=1000 Remise= Montant

Figure 3 : Exemple dordinogramme pour if

OFPPT : ISTA HAY RIAD

Entree If ( <Condition/expression> ) Cond/ exp

Instruction 1 Else Instruction 2

OFPPT : ISTA HAY RIAD

Figure 4 : Ordinogramme et syntaxe de la structure if..else

Taux 1 = 0.1 Taux 2=0.05

Montant>=1000 Remise= Montant *taux **t*Taux Montant =Montant-remise Affiche Montant

oui Remise= Montant *taux 1 **t*Taux

OFPPT : ISTA HAY RIAD

If <Condition1> If <condition2> <Bloc 1>

else <Bloc 2>

else if <Condition3> <Bloc3> else <Bloc 4>

OFPPT : ISTA HAY RIAD

Delta = B*B 4*A*C

Delta <0 Affiche Pas de

Affiche X1 = ;X1 X2 = ;X2

OFPPT : ISTA HAY RIAD

b = 2a++ b = 2++a b = ++a-2 b = 10 (- -a) 6.4 Oprateur sizeof ()

Delta = BB 4A*C

PROGRAMME 2 Fichier : cadvar.cpp