c++00
DESCRIPTION
C++00TRANSCRIPT
Eléments de langage C++
Pierre Puiseux
Université de Pau et des Pays de l'Adour Département de mathématiques
1
Contents
1 Historique 5
2 Notions de base 62.1 Structure d'un programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.2 Premières instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.3 Compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.4 Compilation séparée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82.5 Syntaxe, éléments de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82.6 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102.7 Mots réservés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.8 Constantes chiffres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122.9 Constantes de type caractère . . . . . . . . . . . . . . . . . . . . . . . . . . 132.10 Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132.11 Conversions de type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152.12 Déclarations de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162.13 Portée d'une variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172.14 Durée de vie d'une variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182.15 Récapitulatif, variables globales . . . . . . . . . . . . . . . . . . . . . . . . 192.16 Récapitulatif, variables locales . . . . . . . . . . . . . . . . . . . . . . . . . 192.17 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3 Les opérateurs 213.1 Opérateurs arithmétiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223.2 Opérateurs relationnels et logiques . . . . . . . . . . . . . . . . . . . . . . 233.3 Opérateurs d'incrémentation et de décrémentation . . . . . . . . . . . . . 243.4 Opérateur conditionnel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253.5 Opérateurs d'affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
4 Les structures de contrôle 274.1 Structure if()...else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284.2 Structure switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294.3 Strucrures while et for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304.4 Structure do ...while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314.5 Instructions break et continue . . . . . . . . . . . . . . . . . . . . . . . . . . . 324.6 Instructions goto etiquette . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5 Les fonctions 345.1 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355.2 Déclaration d'une fonction (ou prototypage) . . . . . . . . . . . . . . . . 365.3 Définition d'une fonction (ou implémentation) . . . . . . . . . . . . . . . . 375.4 Transmission des arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385.5 Récursivité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395.6 Surcharge de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
6 Les entrées-sorties, les �ux 416.1 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426.2 flots standards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436.3 Ouverture et fermeture des flots . . . . . . . . . . . . . . . . . . . . . . . . 446.4 Ouverture et fermeture des flots (suite) . . . . . . . . . . . . . . . . . . . 456.5 Ecriture : opérateur << (insertion) . . . . . . . . . . . . . . . . . . . . . . 466.6 Formatage des opérations d'écriture, manipulateurs . . . . . . . . . . . . 476.7 Lecture : opérateur >> (extraction) . . . . . . . . . . . . . . . . . . . . . 486.8 Lecture : autres méthodes disponibles . . . . . . . . . . . . . . . . . . . . . 48
2
6.9 Etat d'un flot en lecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 486.10 Positionnement dans un flot en lecture . . . . . . . . . . . . . . . . . . . . 496.11 Autres fonctions de lecture/écriture . . . . . . . . . . . . . . . . . . . . . 506.12 Autres fonctions de gestion de flot . . . . . . . . . . . . . . . . . . . . . . 51
7 Pointeurs, références, alias et tableaux 527.1 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537.2 Pointeurs et tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547.3 Chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557.4 Tableaux multidimensionels, matrices . . . . . . . . . . . . . . . . . . . . . . 567.5 Remarques sur les pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 577.6 Pointeurs de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 587.7 Allocation dynamique de mémoire . . . . . . . . . . . . . . . . . . . . . . . . 59
8 Les classes, les objets 608.1 Les classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 618.2 Les objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 628.3 Accès aux membres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 628.4 Attributs de membres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638.5 Opérateur de résolution de portée :: . . . . . . . . . . . . . . . . . . . . . . 648.6 Héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 658.7 Constructeurs, recopie et initialisation ; destructeurs . . . . . . . . . . 668.8 Constructeur et héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 668.9 Héritage multiple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 668.10 Méthodes virtuelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 678.11 Fonctions amies (friend) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
9 La classe string 689.1 Constructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 699.2 Méthodes de la classe string . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
10 La bibliothèque standard 7110.1 Fichiers d'en-tête standards en C
(norme ANSI) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7210.2 Fichiers d'en-tête spécifiques Linux . . . . . . . . . . . . . . . . . . . . . . . 73
11 C++ Notions avancées 7411.1 Polymorphisme : les templates ou patrons . . . . . . . . . . . . . . . . . . . . . . . 7411.2 Support des exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7511.3 Exceptions : exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
12 La STL (Standard Template Library) 7712.1 Organisation de la STL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7712.2 Le conteneur vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
13 Le préprocesseur 84
14 Premiers pas en Linux 8614.1 Bref historique Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8614.2 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8614.3 Arborescence sous Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8714.4 Commandes fondamentales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8814.5 Les tubes ou pipes, les redirections, les jobs . . . . . . . . . . . . . . . . . . . . . . 9114.6 TP1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
3
4
1 Historique
1969 création du système Unix en assembleur aux laboratoires Bell (K. Thompson, D.Ritchie)
1970 création du langage B, réécriture d'Unix en B, par Kernighan et Ritchie
1972 dé�nition du C
1973 réécriture d'Unix en C version 5
1975 première version commerciale : UNIX V6
1978 UNIX V7
1981 UNIX SYSTEM III (AT T)
1983 UNIX SYSTEM V (AT T) et UNIX 4.2 BSD (Berkeley). Premier compilateur C++par B.Stroustrup
1988 Mise en place d'une norme C par l'ANSI, premiers compilateurs C++ pour PC
1991 (92 ?) Mise en place d'un comité de normalisation ANSI/ISO C++
1995 Edition d'une norme ISO/ANSI
5
2 Notions de base
6
2.1 Structure d'un programmeLe langage C++ contient le langage C : tout programme écrit en C à la norme ANSI doit pouvoirêtre compilé par un compilateur C++.
C++ fait la di�érence entre Majuscules et minuscules : par exemple les variables Allo et allosont distinctes
En C++ on ne parle pas de type mais de classe (la classe int, la classe char...)En C++ on ne parle pas de variables mais d'objets ou d'instances (int i=0; déclare ou instancie
un objet de classe int)Dans la pratique, sourtout pour les classes de base, on utilisera souvent la terminologie variable
de type xx au lieu de objet (ou instance) de classe xxProgramme C++ = ensemble de fonctions comprenant une seule fonction main() (point
d'entrée).
2.2 Premières instructionsUne instruction = la plus petite unité indépendante de C++, délimitée par un ; (point virgule)⇔une phrase du langage naturel.
#include <stdlib.h>#include <iostream>int main(void){int age = 21; //reservation memoire pour agefloat x[5]={1.0,0,0,2,-1.5};
/* Autre commentaire */char Nom[25]="Etudiant", prenom[20] = "Lambda";float note_partiel, note_exam, note_finale;note_partiel = note_exam = note_finale = 0.0;//C'est l'initialisation !cout < < endl < < "entrer notes part et exam";cin > > note_partiel > > note_exam;note_finale = 0.3*note_partiel + 0.7*note_exam;//affectationcout < < note_finale;
}
2.3 CompilationPour pouvoir etre utilisé, un programme doit etre compilé :
. Compilation par l'instruction> g++ -c gourette.cxx
1. Appelle cpp (C pré-processeur) pour traiter les lignes commençant par #. Productiond'un �chier texte temporaire tmp.c
2. Appelle gcc (compilateur) pour traduction de tmp.c en langage machine. Productiond'un �chier objet gourette.o
. Edition des liens (link)> g++ gourette.o -o artousteedition des liens entre gourette.o et les di�érentes bibliothèques système ou autre utilisées(implicitement ou explicitement). Production d'un exécutable artouste
7
. Raccourci : compilation + édition des liens> g++ gourette.cxx -o artouste
. Exécution> artouste
2.4 Compilation séparéeCes fonctions peuvent (doivent) être réparties dans plusieurs �chiers ; par exemple
. �chier main.cxx#include <stdlib.h>#include �util.h�int main(){
int i=doubler(3);double x = tripler(0.0);//etc...
}. �chier util.h
#ifndef UTIL_H#define UTIL_Hvoid doubler(int);void tripler(float);#endif
. �chier util.cxx
#include �util.h�//ici des utilitaires et//fonctions utilisés par main()void tripler(int y){
cout< <endl< <3*y;y=3*y;
};double doubler(float x){
x*=2;};
. Compilationg++ -c main.cxx util.cxx
. Edition des liens (link)g++ main.o util.o -o mon_prog
. Raccourci : compilation + édition des liensg++ main.cxx util.cxx -o mon_prog
2.5 Syntaxe, éléments de baseC++ fait la di�érence entre Majuscules et minuscules : par exemple les variables Allo et allo sontdistinctes
. Identi�cateurs : noms et types de variables, noms de fonctions, nom des constantes, nomdes macros-instructions
. Mots réservés : jeu de mots clés du langage
. Constantes :
. Opérateurs : +,*,-,/,% etc...
. Séparateurs :
� caractères spéciaux (espace, tabulation,cr/lf..)� ; terminaison d'instruction ou de déclaration� , séparation d'éléments� () liste d'arguments ou de paramètres� [] dimension ou indice d'un tableau
8
� {} bloc d'instructions, liste ou initialisation de tableau� Commentaires : /* ceci est un commentaire (les commentaires imbriqués sont inter-
dits)*/� Commentaires : // ceci est un autre commentaire
9
2.6 Variablescaractérisées par :
. un nom
. un type
. une classe de stockage (précise la durée de vie, la visibilité, et l'emplacement mémoire)
le nom :
. Séquence de chi�res et de lettres
. Premièr caractère = caractère alphabétique
. _ (underscore) est une lettre
. di�érencie majuscule et minuscule
. les 32 premiers caractères sont signi�catifs
. les mots clés ou réservés sont interdits
10
2.7 Mots réservés. Types : int, char, short, long, double, float,
unsigned, struct, enum, union, void, signed. Classe de stockage : auto, extern, static, register, typedef, const, volatile. Instructions : if, else, while, do, for, switch, break, continue, goto, return. Opérateurs : sizeof. Etiquette : case, default
. mots réservés C++ : asm, friend, virtual, class, catch, delete, inline, new,operator, private, protected, public, template, this, throw, try.
11
2.8 Constantes chiffres
type exempleentier décimal séquence de chi�res ne commençant pas par 0 125entier octal séquence de chi�res commençant par 0 016
entier hexadécimal séquence de digits commençant par 0x ou 0X 0xFFA33entier long séquence de digits �nissant par l ou L 1450L
réel (double précision) séquence de chi�res en notation décimale 1.25séquence de chi�res en notation scienti�que 1.2E+3
réel (long double) réel, �nissant par l ou L 1.78L
12
2.9 Constantes de type caractère1. caractère : encadré par deux apostrophes (`) exemple `a'
2. caractère non imprimable ou séquence d'échappements :
. newline `\n'
. tabulation `\t'
. backspace `\b'
. antislash `\\'
. NULL `\0'
3. chaîne de caractères : séquence de caractères délimitée par des guillemets (double cote) ex :"ceci est une chaine \n"
. Une chaine de caractères se termine par le caractère NULL '\0' ajouté par le compilateur.
. Une chaîne de caractères est un tableau de type caractères à 1 dimension.
2.10 Types. types de base :
� char caractère (un seul caractère)� int entier� float réel, �ottant� double double précision
. modi�cateurs : short, long, signed, unsigned
. tailles : dépend de la machine. Pour le compilateur gcc (linux), on a (voir �chiers limits.het �oat.h)
Type Taille (bits/octets) valeursunsigned char 8 0. . . 255
char 8 -128. . . 127short int 16 -32768. . . 32767int/long 32 -2147483648. . . 2147483647
unsigned int/long 32 0. . . 4294967295float 32/4 1.18e-38. . . 3.40e+38double 68 2.23e-308. . . 1.80e+308
long double ?
L'usage du modi�cateur unsigned est vivement déconseillé pour les indices de tableaux.Exemple :
#include <iostream>using namespace std;int main(void){
unsigned int ui=0;cout < <endl< <--ui;int i=0;
13
cout < <endl< <--i;}$ g++ unsigned.cxx$ ./a.out4294967295-1
14
2.11 Conversions de typeconversions automatiques
. règle de base : après évaluation, le type du résultat est celui de l'opérande de type le plusélevé.
. exemple :int i;double x;x = x+i; //i est converti (promu) en double.
. La hiérarchie des types est la suivante :char,short > int > unsigned > long > double > long double < float
conversions explicites (cast)
. pour forcer ou empêcher une conversion
. syntaxe : (type) expression
. exemple : x = sqrt ((double) 23);
15
2.12 Déclarations de variables
Toute variable doit être déclarée avant son utilisation.
. déclaration : permet au reste du programme de connaître l'existence et les propriétés de lavariable.
. allocation : réserve et alloue une place en mémoire (à la compilation ou à l'exécution).
. la classe de stockage : détermine l'emplacement en mémoire et la durée de vie d'une variable.Elle est déduite de la déclaration et de l'emplacement de la déclaration.
. syntaxe : type nom (initialisation)
. exemple :
int i(12);extern double x ;long double vect [] = {1.0L, 1.0L, 2.1L, 0.0L};
16
2.13 Portée d'une variablela portée d'une variable est la région du programme où elle est connue. Elle dépend du mode etdu lieu de sa déclaration :
portée �chier ou portée globale : variables déclarées en début de �chier hors des blocs.Elles sont connues de leur point de déclaration à la �n du �chier.
portée prototype de fonction : variables déclarées et connues entre le nom de la fonctionet le début du bloc des instructions. Ce sont les arguments de la fonction. Par exemple : int max(int a, int b);
portée bloc ou portée locale : commence à son point de déclaration et se termine à la �ndu bloc englobant la déclaration.
portée fonction : ce sont les étiquettes ou labels. Leur portée s'étend du début à la �n dela fonction.
17
2.14 Durée de vie d'une variableEn relation étroite avec la classe de stockage.
durée de vie statique :
. mémoire allouée en début d'exécution, dure jusqu'à la �n d'exécution du programme.
. Ce sont les variables à portée �chier et les variables déclarées extern ou static.
. Elles sont initialisées à 0.
. Par défaut, une variable à portée �chier a la classe extern.
durée de vie locale : la plupart des variables que vous utiliserez sont de ce type.
. mémoire allouée à l'entrée dans un bloc ou une fonction, désallouée à la sortie du bloc ou dela fonction.
. On parle aussi de variables automatiques.
. Ce sont les variables à portée bloc et les variables déclarées auto ou register (registre àaccès rapide; par exemple les indices de boucles).
. Elles ne sont pas initialisés automatiquement.
. Par défaut les variables déclarées dans un bloc ont la classe auto.
durée de vie dynamique :
. variables créées et détruites par l'utilisateur.
. (L'allocation se fait par les fonctions de la famille malloc()la destruction par free())
. ou bien par les opérateurs new() et delete()
18
2.15 Récapitulatif, variables globales
classe de stockage extern extern staticportée �chier autres �chiers �chier
instant d'allocation compilation aucune compilationzone mémoire données donnéesdurée de vie le programme le programmeinitialisation autorisée interdite autorisée
2.16 Récapitulatif, variables locales
classe destockage extern static auto register
portée bloc bloc bloc blocinstant
d'allocation aucune compilation entrée dans le bloc entrée dans le bloczone mémoire données pile un registredurée de vie le programme bloc blocinitialisation interdite autorisée,
0 par défautautorisée
sauf tableaux autorisée
19
2.17 Tableaux. déclaration : type nom [taille][...]. exemple : double mat [10][2];
. les indices varient de 0 à taille-1.
. Pour un tableau multidimensionnel, seule la dernière dimension n'a pas besoin d'être précisée.
. pas de contrôle e�ectué par le compilateur sur les références hors limites.
. Initialisation : par exemple int indice [5]={4, 8, 1, 2, 9}; dans ce cas il n'est pas nécessaired'indiquer la dimension (n=5).
. Un tableau est un pointeur : dans double x [100]; x est un pointeur sur un double.
. Les tableaux peuvent être alloués dynamiquement grâce à la fonction : void *malloc(size_tsize) de la bibliothèque standard <stdlib.h> (déconseillé)
. et aussi par l'opérateur new(): double*x=new double[10] déclare et alloue un tableau x de 10réels (à privilégier par rapport à la fonction malloc)
.
20
3 Les opérateurs
21
3.1 Opérateurs arithmétiques. + addition : a+b
. - soustraction : x-y
. * multiplication : 2*s
. / division : 12/4.0
. % modulo : a%b est le reste de la division euclidienne de a par b.
. modulo ne s'utilise qu'avec a et b entiers les conversions de type standard s'appliquent. 12%3vaut 0; 12%5 vaut 2.
. Par ordre de priorité décroissante : * / % puis + -
. donc a*b+c vaut (a*b)+c.
. Les opérations s'e�ectuent de gauche à droite.
22
3.2 Opérateurs relationnels et logiquesont une priorité inférieure à celle des opérateurs arithmétiques.
Relationnels :
. >strictement supérieur
. >= supérieur ou égal
. < strictement inférieur
. <= inférieur ou égal
. == égal
. != di�érent
. Le résultat est 1 (vrai) ou 0 (faux)
. par exemple 1>2 vaut 0; 0==0 vaut 1.
Logiques :
! négation&& et|| oupour toute expression donnant un résultat numérique, if (expression) est équivalentà if (expression!=0).
23
3.3 Opérateurs d'incrémentation et de décrémentation. l'incrémentation et la décrémentation sont symbolisées par ++ et --
. s'appliquent à des entiers uniquement
. notation post�xée : i++, i-- : la variable i est incrémentée (décrémentée) de 1 une fois quesa valeur a été utilisée.
. Exemple : if (i++ != 0) test l'égalité de i à 0, puis incrémente i.
. notation pré�xée : ++i incrémente d'abord i avant de l'utiliser.
. Remarque : i++ est équivalent à i = i+1;
24
3.4 Opérateur conditionnel. syntaxe : expression0 ? expression1 : expression2 ;
. donne le même résultat que
if (expression0)expression1
elseexpression2;
. utilisation typique pour dé�nir la macro instruction (obsolete en C++)
#define max(a,b) (a>b) ? a : b
25
3.5 Opérateurs d'affectation. l'a�ectation est symbolisée par =,
� syntaxe : expression1=expression2� exemples : i = 8 ; j = ((a >= b) && (k == 0)) ; c = getchar();
. le résultat de l'expression "expression1=expression2" est la valeur de expression2.
� exemples : i = j = 0; s'évalue comme i = (j = 0); et met i et j à la valeur 0
. si e1 et e2 sont des expressions et si op est un opérateur de l'ensemble {+,-,*,/,%} alorse1 = e1 op e2 est équivalent à e1 op= e2.
� exemples : i += 2; incrémente i de 2.
26
4 Les structures de contrôle
27
4.1 Structure if()...else. syntaxe :
if (expression)instruction1;
elseinstruction2;
. instruction simple :
if (n>0) x = a;if (n>0)
x = a ;else
x = b ;
. instruction avec blocs :
if (n>0){
x = a;i++;
}else
{x = b ;}//accolades facultatives
. instruction à cas multiples :
if (n>0){
x = a;i++;
}else if (truc){
x = b ;}elseprintf(�i = %d�,i);
28
4.2 Structure switchsyntaxe : sur un exemple
switch (expression_entiere){
case '0' : /*rien*/;case '1' : /*rien*/;case '4' :
nb++;break;
case � : /*rien*/;case '\n' : /*rien*/;case '\t' :
nblancs++;break;
default :autres++;break;
}
. expression_entiere doit être une expression entière (ou caractère) à évaluer.
. chaque case doit avoir une expression constante entière (ou caractère).
. break est facultatif. S'il n'y est pas, le programme se poursuit par l'évaluation de l'instructiondu case suivant.
. Lorsque break est rencontré, le programme e�ectue un branchement en dehors de la liste, àl'instruction suivante.
. default est facultatif. Si aucun des case n'est satisfait, il y a branchement sur le labeldefault.
29
4.3 Strucrures while et forsyntaxe de while :
while (condition)instruction;
. correspond à :
tant que (expression) faireinstruction
�n tant que
. exemples
while ((c=getchar())==� || c=='\n'); //ne rien faire
syntaxe de for :
for (e1 ; e2 ; e3) instruction
. correspond à:
exexuter e1; /*initialisation*/tant que (e2 est vrai) faire
instruction;e3;
�n tant que
. exemple, initialisation d'un tableau :
for (i = 1 ; i == n; i++) x [i] = 0.0;
. exemple, boucle in�nie
for(;;);
30
4.4 Structure do ...while. syntaxe
doinstruction;
while (condition)
. correspond au pseudo code :
répéterinstruction
jusqu'à (non condition) (ou tant que (condition))
. exemple : recopie de caractères
char source[10], dest[10];i = 0 ;dodest[i] = source[i] ;
while (i++!='\0');
31
4.5 Instructions break et continue. break : pour sortir d'une boucle for, while, ou do. . . while, inconditionnellement.
. exemple :
for (i=0; i <= n ; i++){
x = t[i];if (traitement(x)=MAUVAIS)
break;};/*ici traitement des erreurs*/
. continue passe à l'itération suivante de la boucle
. exemple :
for (i=0; i <= n ; i++){
x = t[i];if (traitement(x)=MAUVAIS)
continue; //on va au i suivant};
32
4.6 Instructions goto etiquette. à ne pas utiliser si possible
. syntaxe :
goto etiquette ;instructions.......etiquette : instruction ;
. exemple
for (i=0; i <= n ; i++){
x = t[i];if (traitement(x)=MAUVAIS)
goto erreur;};erreur : cout< <� mauvais traitement pour i =�< <i;
33
5 Les fonctions
34
5.1 Généralités. Ce sont les éléments de base d'un programme.
. C ne distingue pas les fonctions des subroutines ou procédures.
. Toute fonction doit être déclarée par un prototype puis dé�nie.
. Ne pas confondre
. prototype ou déclaration : qui indique le type de l'objet retourné et les arguments
. dé�nition : qui indique le traitement à e�ectuer. (C'est le corps de la fonction)
. usuellement, on déclare la fonction (f) dans un �chier entête (util.h, qui sera inclus dansles �chiers utilisant f) et on la dé�nit dans un autre �chier (util.cpp par exemple).
. Une fonction ne peut pas être dé�nie à l'intérieur d'un bloc :
float f(float x){
int f1(int i){/*....*/} //implémentation illégale
//instructions f1}
35
5.2 Déclaration d'une fonction (ou prototypage)syntaxe :
type nom_fonction (type param1, type param2, ...);
param1, param2 ... sont optionnels; par contre les types sont obligatoires
exemple1 :
//Deux écritures équivalentesint Ind_Max (double x [] ; int n);
int Ind_Max (double * ; int);
indique que Ind_Max est une fonction retournant un int et prenant en arguments un tableau dedouble (ou un pointeur sur double ce qui revient au même), et une variable de type int.
exemple 2 :
double Integrale (double (*f) (), double a, double b);
indique que Integrale() est une fonction retournant un double et prenant en arguments unefonction de type double, et deux variables de type double.
exemple 3 :
void Swap (int *a; int *b); //ne retourne rien.
La classe d'une fonction est extern ou static par defaut
36
5.3 Définition d'une fonction (ou implémentation)syntaxe :
type nom_fonction (type param1, type param2, ...){
instructions;return var ;//où var est du type retourne par la fonction
}
exemples fonction qui renvoit un objet :
double Max_Abs (double* x , int n)
{double amax (0.0) ;for (int i=0 ; i<n ; i++)
if(abs(x[i])>amax)amax=x[i] ;//sinon rien
return (amax) ;
};
. return peut se trouver n'importe où, il peut y en avoir plusieurs ou aucun.
. return rend le contrôle à la fonction appelante
. Aucun contrôle sur le type et le nombre des arguments n'est e�ectué par le compilateur.
Fonction qui ne renvoit rien :
void Max_Abs (double * ; int n){
double amax (0.0) ;for (i=0 ; i<=n ; i++)
if (abs(x[i]>amax) amax=x[i] ; //rien sinoncout < < � le max est : �< <amax ;
};
. Pas de return
37
5.4 Transmission des argumentsTransmission par référence : f(type & x) c'est l'adresse de la variable x qui est
transmise à la fonction appelée f.La fonction f peut alors modi�er la variable x.exemple :void f(float & x){x=2.0;}Dans le programme appelant, la séquence d'instructionsfloat y=0.0;f(y);modi�e e�ectivement la valeur de y qui vaut maintenant 2.0
Transmission par valeur : f(type x) C'est une copie de la variable x qui est transmiseà la fonction appelée f.
La fonction f ne peut pas modi�er la variable x.exemple :void f(float x){x=2.0;}Dans le programme appelant, la séquence d'instructionsfloat y=0.0;f(y);ne modi�e pas la valeur de y qui vaut toujours 0.0
38
5.5 Récursivité« la récurrence est humaine, la récursivité est d'essence divine »
En C++, la récursivité est autorisée, mais toujours coûteuse (à éviter)exemple :
version récursivelong Factorielle (short n){(n == 1) ? return 1 : return (n*Factorielle(n-1));
};
version récurrentelong Factorielle (short n){
long temp = 1;short i ;for (i = 2 ; i <= n ; i++)
temp *= i ;return temp ;
};
5.6 Surcharge de fonctionsEvite les noms de fonctions baroques
En C++, les fonctions sont identi�ées par leur signature c'est à dire leur nom et la classe deleurs arguments. On peut dé�nir deux fonctions distinctes portant le même nom, à condition queles deux listes des arguments soit distinctes.
void swap (int& a, int& b){int t = a;a = b;b = t;
}void swap (complex& a, complex& b){complex t = a;a = b;b = t;
}void swap (double a, double b){double t = a;a = b;b = t;
}
Le compilateur di�érentie les di�érentes versions par les arguments passés aux fonctions :
complex u,v;double x,y;int i,j;
39
swap(u,v); //permute les complexes u et v
swap(i,j); // permute les entiers i et j
swap(x,y); // ne fait rien (pourquoi ?)
40
6 Les entrées-sorties, les �ux
41
6.1 Généralités. les fonctions d'entrée/sortie n'appartiennent pas au langage C++ mais à la bibliothèquestandard
. Les fonctions d'entrée/sortie sont déclarées dans le �chier include <iostream.h> ou <iostream>pour les �ots ou standard (cin, cout, cerr, clog) et dans <fstream.h> ou <fstream>pour les �ots utilisateurs.
. En C++, on parle de �ux ou �ots plutôt que de �chiers.
. La marque de �n de �ot est le caractère spécial EOF.
42
6.2 flots standards. 4 �ots sont automatiquement ouverts par le système au début du programme et refermés àla �n :
. cin, lié à l'entrée standard : par défaut le clavier
� c'est un objet de la classe istream� Flot ouvert en lecture uniquement.� Les données lues sont disponibles après la frappe de la touche return.� Les données, une fois lues, ne sont plus disponibles.� cin est bu�erisé
. cout, lié à la sortie standard, par défaut l'écran.
� C'est un objet de la classe ostream� Flot ouvert en écriture uniquement.
. cerr, lié à la sortie erreur standard
� c'est un objet de la classe ostream� Flot ouvert en écriture uniquement.� non bu�erisé
. clog, lié à la sortie erreur standard
� c'est un objet de la classe ostream� Flot ouvert en écriture uniquement.� bu�erisé
43
6.3 Ouverture et fermeture des flots. Pour ouvrir un �ot en sortie (écriture), dé�nir un objet ofstream, puis l'ouvrir: par exemple
. Pour ouvrir un �ot en ecriture, s'il existe déjà, il est écrasé.
ofstream fichier_sortie;//déclarationfichier_sortie.open(�toto.out�);//ouverture
. On peut simultanément déclarer et ouvrir le �ot:
ofstream fichier_sortie(�toto.out�);
. Pour ouvrir un �ot en ecriture, en mode �append �. S'il existe déjà, les nouvelles écrituressont faites à la �n du �ot.
ofstream fichier_sortie(�toto.out�,ios::app);
. l'ouverture d'un �ot renvoie 0 si tout c'est bien passé, un entier non nul si une conditiond'erreur existe.
if (!fichier_sortie){cerr< <�impossible d'ouvrir fichier_sortie�;exit(-1);
}
. fermeture du �ot par la méthode close() : fichier_entree.close();
44
6.4 Ouverture et fermeture des flots (suite). pour ouvrir un �ot en entrée (lecture), dé�nir un objet ifstream puis l'ouvir : par exemple
ifstream fichier_entree;fichier_entree.open(�toto.in�); // ouvre le flot existant en lecture.
. On peut résumer l'ouverture en une instruction :
ifstream fichier_entree(toto.in);
. l'ouverture d'un �ot renvoie 0 si tout c'est bien passé, un entier non nul si une conditiond'erreur existe.
if (!fichier_entree){cerr< <�impossible d'ouvrir fichier_entree �;exit(-1);
}
. fermeture du �ot par la méthode close() :
fichier_entree.close();
45
6.5 Ecriture : opérateur << (insertion). en C++ on parle d'insertion plutôt que d'écriture
. L'opérateur < < est le principal opérateur d'insertion. Exemple :
fstream fout(�toto.out�,ios::out);fout< <�hello�< <endl;
. Cette dernière ligne équivaut à fout.(operator < <)(�hello�);
. endl est un indicateur de saut de ligne (équivalent à au caractère '\n')
. l'opérateur operator < < renvoie un pointeur sur le �ot lui-même. On peut donc enchaînerles opérations d'insertion :
fout< <�x = �< <x< <endl;
. write(const char* str,int length)est une méthode de ofstream qui permet d'insérerles length caractères de la chaîne str sur le �ot de sortie. Exemple cout.write(�Hello,world�,11);
. put(char) fournit une alternative à << pour insérer un caractère dans le �ot. Exemplecout.put('\n') insère un saut de ligne;
. L'utilisation de l'opérateur d'insertion < < est préférable aux méthodes write() et put().
46
6.6 Formatage des opérations d'écriture, manipulateursméthodes de iostream : setf() et unsetf() sont des méthodes de iostream. Modi�ca-
tions permanentes des attributs de formattage (jusqu'au prochain unsetf()).
. setf(long) et setf(long,long) sont deux méthodes de iostream permettant de �xer desattributs de formattage
� setf(ios::showbase) a�che la base (decimale, octale, hexadécimale)� setf(ios::showpoint) impose l'a�chage du point décimal pour les réels� setf(ios::dec) a�chage en decimal (oct en octal, hex en hexadécimal)� setf(ios::scientific) a�chage des �ottants en notation scienti�que
. unsetf(long) désactive les attributs de formattage (retour aux attributs par défaut)
. exemple
cout< <10.0;//affiche 10cout.setf(ios::showpoint);cout< <10.0;//affiche 10.0cout< <5.0;//affiche 5.0
Manipulateurs On dispose aussi de manipulateurs pour activer certaines options �a la volée�.Inclure le �chier <iomanip.h> ou <iomanip> pour disposer de ces manipulateurs
. setw(int w); �xe la largeur du champ à insérer.
. setfill(char c); �xe le caractère de remplissage (blanc par défaut)
. setprecision(int p); �xe la précision du champ à insérer (défaut 6)
. exemple
cout< <setw(4)< <setfill('#')< <12; //produit ##12cout< <setprecision(3)< <sqrt(2); //produit 1.41
47
6.7 Lecture : opérateur >> (extraction). en C++ on parle d'extraction plutôt que de lecture.. L'opérateur >> est le principal opérateur d'extraction. Exemple :
istream fin(�toto.in�,ios::in);char car;fin> >car;//met le premier caractère de fin dans la variable car
. les deux instructions fin> >car et fin.(operator > >)(car); sont équivalentes
. l'opérateur operator> > renvoie un pointeur sur le �ot lui-même. On peut donc enchaînerles opérations d'extraction :
fin> >car> >car> >car;//car contient le 3ieme caractère du flot fin
. Le caractère spécial EOF est le caractère de �n de �chier.
6.8 Lecture : autres méthodes disponiblesles fonctions suivantes sont des méthodes de ifstream
. read(const char* str,int length)est une méthode de ifstream qui permet d'extrairelength caractères de la chaîne str du �ot d'entrée. Exemple char[20] str; cin.read(str,11);
. get(char) fournit une alternative à >> pour extraire un caractère du �ot. Exemplecin.get(char x) ;
. getline (char * buf,int limit,char delim='\n') permet de lire et a�ecter à buf uneligne entière, jusqu'au caratère '\n' (par défaut) lorsque l'on ne veut pas sauter de blancs.getline() extrait au plus limit-1 caractères et ajoute un caractère NULL à la �n.
. L'opérateur d'extraction > > est préférable aux méthodes read() et get() et getline()
. peek() retourne le caractère suivant, (éventuellement EOF, sans l'extraire. (i.e. le curseurreste positionné au caractère courant)
. ignore(int limit=1,int delim=EOF)déplace le curseur de limit caractère mais arrète lecurseur si rencontre le caractère delim.
. putback(char c) remet en position courante le caractère c.
. seekg(int pos) positionne le curseur à la position pos
. gcount(), tellg()...
6.9 Etat d'un flot en lectureVoici quelque méthodes utiles de la classe ifstream
. int eof() : �n de �chier trouvée
. bad() : le �ot est altéré
. fail() : la prochaine opération échouera
. good() : la prochaine opération peut réussir
. clear() : remet l'état du �ot à good()
48
6.10 Positionnement dans un flot en lecture
49
6.11 Autres fonctions de lecture/écriture
50
6.12 Autres fonctions de gestion de flotcaser quelque part l'exemple /home/puiseux/docs/tic/tic032.html
51
7 Pointeurs, références, alias et tableaux
52
7.1 Définitions
p
iou (*p)
2
. Un pointeur est une variable contenant l'adresse d'un objet en mémoire.
. Un pointeur est dé�ni par le couple (type, adresse) de l'objet pointé.
. déclaration : type *identificateur;
. exemple : p est un pointeur sur un entier, i.e. p contient l'adresse d'une case mémoirecontenant un entier.
int *p;
. Si p est un pointeur sur le type Type alors on accède à la valeur pointée par *p
. exemple
float *p;*p=2.0;
. si x est une variable de type Type, alors &x est l'adresse de x, c'est donc un pointeur surType
. exemple
float x;float *px;px = &x;
. si x est un float, alors float &xalias = x est une déclaration légale, xalias est un aliasde x.
. exemple
float x;float &y = x; // initialisation obligatoire
53
7.2 Pointeurs et tableaux
p
iou (*p)
2
. en C++, pointeurs et tableaux sont très liés :
int T[5] ;int *p ;
. Attention, l'indice d'un tableau à n élément varie de 0 à n-1
. l'instruction p = T ; est autorisée car T est aussi un pointeur d'entiers ; équivaut à p =&T[0];
. p pointe sur le premier élément de T
. p+i pointe sur le ième élément suivant; *(p+i) est égal à T[i].
. Le nom d'un tableau est un pointeur constant sur le premier élément du tableau.
. Allocation dynamique d'un tableau de n éléments de type Type :
Type *a;a = new Type[n]; //allocation memoiredelete[]a; //liberation memoire
. si l'allocation réussit, new retourne un pointeur sur le premier élément de la mémoire allouée,sinon il retourne NULL.
. Le programmeur qui alloue de la mémoire dynamiquement a en charge la libération demémoire qui n'est en aucun cas automatique au cours du déroulement du programme.
54
7.3 Chaînes de caractères. une chaîne de caractères est un tableau de caractères
. Certaines fonctions sont disponibles. Ces fonctions sur chaînes de caractères sont déclaréesdans <string.h>. Sous UNIX, une aide en ligne est disponible via la commande �manstring�.
. La �n d'une chaîne de caractère est signalée par un caractère NULL (ou '\0'), inséré par lecompilateur.
. on accède aux constantes de type chaîne de caractères au moyen d'un pointeur de type char,pointant sur le premier élément de la chaîne, par exemple char *s;
. lors de l'instruction char * s=�ceci est un message�; la chaîne n'est pas recopiée danss mais s contient l'adresse du premier élément de cette chaîne.
Les fonctions les plus utiles :
. char *strcpy(char *dest, const char *src); recopie src dans dest (la place mémoirede dest doit avoir été réservée)
. char *strcat(char *dest, const char *src); recopie src à la �n de dest (la placemémoire de dest doit avoir été réservée)
. size_t strlen(const char *s); retourne la taille de la chaîne s
La classe string permet une manipulation plus intuitive et e�cace des chaines de caractères. Parexemple :
# include <iostream># include <string>using namespace std;int main(void) {string S("Puiseux");cout < < endl < < S +" Pierre"< < flush;return 0;
}
55
7.4 Tableaux multidimensionels, matrices. déclaration : type identificateur [dim1][dim2];
. exemple :
const int MAXDIM=100 ;long double a[MAXDIM][MAXDIM] ;
. les éléments sont rangés par lignes :a[i] est (l'adresse du premier élément de) la ligne numéro i*a[i] est le premier élément de la ligne numéro i.a[i]+j est l'adresse du jème élément de la ligne ia[i][j] est l'élément ième ligne, jème colonne*a[i]+j est l'élément ième ligne, jème colonne aussi
. Allocation dynamique d'une matrice de taille n*n :
double **a;//allocationa = new (double *)[n];for (i=0;i<n;i++) a[i] = new double[n];
//liberationfor (i=0;i<n;i++) delete []a[i];delete[]a;
. si l'allocation réussit, new retourne un pointeur sur le premier élément de la mémoire allouée,sinon il retourne NULL
56
7.5 Remarques sur les pointeurs. le C++ n'e�ectue pas de véri�cation sur les indices de tableau. C'est au programmeur deprendre ses précautions.
. a[i] est évalué par le C++ comme *(a+i)
. dans le cas de transmission de tableau en paramètre d'une fonction, seule l'adresse du premierélément est transmise.
. La valeur NULL (en fait 0) pour un pointeur est caractéristique d'un pointeur mal initialiséou mal déclaré.
. L'incrémentation d'un pointeur p++ (ou p--) a pour e�et d'incrémenter p de sizeof(p)octets.
. Int T[10][5][2]; est un tableau à 10 éléments, chaque élément étant une matrice à 5lignes, 2 colonnes.
� T[i] désigne donc une matrice (deux dimensions) ;� T[i][j] désigne un tableau à une dimension (ou vecteur) d'entiers ;� T[i][j][k] désigne un entier.
57
7.6 Pointeurs de fonctionsune fonction n'est pas une variable. Néanmoins, elle a une adresse en mémoire. On peut doncdé�nir une variable qui pointe sur une fonction.
. Déclaration :
double (*f) (int,float);int (*g) ();
. f est un pointeur sur une fonction prenant un int et un float en arguments et dont lerésultat est de type double.
. g est un pointeur sur une fonction sans arguments dont le résultat est de type int.
. A distinguer de double *f(); qui désigne une fonction renvoyant un pointeur sur double.
. Peut s'utiliser lorsque la fonction à utiliser peut varier, par exemple pour une méthode deNewton générique (1d), on dé�nira par exemple :
double Newton(double(*f)(double);int itmax);{/*ici, on peut utiliser la fonction fcomme on le désire*/
};//appel :double solution ;double f(double x) ;solution = Newton(f,ITMAX);
58
7.7 Allocation dynamique de mémoire. Opérateurs new et delete exemple : voir ([7.2] et [7.4]). A privilégier par rapport à lasolution suivante (malloc).
. On peut trouver aussi des fonctions de la famille malloc (langage C):
� void *malloc(size_t size) ; aloue un bloc de mémoire de size octets dans la zonede mémoire appelée tas (heap).
� NB : l'instruction calloc(n,s) est équivalente à malloc(n*s).� Si l'allocation réussit, malloc renvoie un pointeur sur le bloc nouvellement alloué.� Si la place disponible est insu�sante ou si size vaut 0, malloc renvoie NULL. Le contenudu bloc n'est pas modi�é.
� Si l'argument size vaut 0, alors malloc renvoie NULL.� exemple : allocation mémoire pour une matrice n*n (produit un résultat analogue à[7.2] et [7.4]):
/*tableau de n pointeurs 0-->n-1 */if ((a = (double * *) malloc (n*sizeof(double *))) == NULL)
FatalWarning ("Memoire insuffisante \n");for (i=0; i<n; i++)
if ( (a[i] = (double *) malloc(n*sizeof(double)))== NULL)FatalWarning ("Memoire insuffisante \n");
/* Après utilisation, libérer la mémoire par free */for (i=0; i<n; i++) free(a[i]);free(a);
59
8 Les classes, les objets
60
8.1 Les classes. Dé�nition : une classe est un type dé�ni par l'utilisateur (au même titre qu'un float ouun int). Une classe se déclare à l'aide du mot clé class et regroupe des données et desméthodes (ou fonctions membres) agissant sur ces données
. Déclaration d'une classe :
class Nom_de_Classe{public :déclaration_donnees_publiques ;declarations_methodes_publiques ;
protected :déclaration_donnees_protegees ;declarations_methodes_protegees ;
private :déclaration_donnees_privees ;declarations_methodes_privees ;
};
. Exemple :
class Etudiant{private :char nom_[20];int age_;float note_exam_,note_partiel_,note_finale_;
public : //methodes et données publiquesfloat rien;
//calcul note finale, implementé ailleursfloat Set_Note_Finale(void);
//retourne la note finale implémentation �inline�float Get_Note_Finale(void)
{return note_finale_;}};
61
8.2 Les objets. Un objet est une instance d'une classe, c'est à dire un emplacement mémoire adressable dontle type est celui de la classe. De même que int n'est pas un objet mais un type, �int i;�déclare un objet de type int, ou encore une instance d'int.
. Exemple :
// déclaration d'objets de la classe EtudiantEtudiant a, b, c;//donne la taille en octets de la classeint size=sizeof (Etudiant)
. Pour les types prédé�nis (int, �oat,...) on parle de type et de variables.
. Pour les types dé�nis par l'utilisateur, on parle de classe et d'instances (ou objets).
. On peut créer dynamiquement des instances de classe en faisant appel au (à un des) con-structeur(s) de la classe (cf : 8.7). Le compilateur génère un constructeur par défaut
Etudiant *a;a = new Etudiant();...delete() a;
8.3 Accès aux membres. par l'intermédiaire des opérateurs unaires & et -> et .
. exemples :
Etudiant e, *pe ;pe = &e ;//pe prend pour valeur l'adresse de ee.rien = 0.0 ; //e.rien accède au champ rien de e*pe.rien = 1.0 ;pe->rien = 19.00;// pe->rien et *pe.rien identiquesfloat x = e.Get_Note_Finale();x = pe->Get_Note_Finale();
62
8.4 Attributs de membres. les di�érents membres d'une classe peuvent être à accès protégé, privé ou public
private les membres privés ne peuvent être utilisés (modi�és pour les données, appeléspour les méthodes) que par les méthodes de la classe
protected les membres protégés ne peuvent être utilisés que par les méthodes de la classeet des classes dérivées.
public les membres publics peuvent être utilisés et modi�és par tous
. Les variables sont le plus souvent private ou protected, tandis que les méthodes sontusuellement public.
. par convention le nom des membres private ou protected se termine par '_'. exemple :nom_
. Soit a une variable de type Etudiant (voir 8.1)..L'instruction a.age_ = 21; produit une erreur de compilation car age_ est a accès privé..L'instruction a.rien = 0.0 est licite.
63
8.5 Opérateur de résolution de portée ::Usuellement :
. Une classe toto est déclarée (ou prototypée) dans �chier toto.h
. elle est dé�nie (ou implémentée) dans le �chier toto.cxx
. dans le �chier toto.cxx, l'accès aux membres de la classe toto se fait grâce à l'opérateurde résolution de portée ::
. exemple
� �chier toto.hclass toto{
private : float x;public : void FaireQuelqueChose(void);
};
� �chier toto.cxx#include �toto.h�void toto::FaireQuelqueChose(void){
cout< <endl< <�justement, je ne fais rien!!�;
}
64
8.6 HéritageUne classe B peut dériver (ou hériter) d'une autre classe.
déclaration :class B : public A{/*...*/}
Dans cet exemple, le mode de dérivation de la classe A est public. Certaines méthodes et donnéesde la classe de base (A) sont disponibles dans la classe dérivée (B).
Mode de dérivation Un membre dont le statut dansla classe de base (A) est :
a pour statut dansla classe dérivée (B) :
publicpublic
protectedprivate
publicprotectedinaccessible
protectedpublic
protectedprivate
protectedprotectedinaccessible
privatepublic
protectedprivate
privateprivateprivate
65
8.7 Constructeurs, recopie et initialisation ; destructeurs. Toute classe possède un constructeur. Soit un constructeur par défaut généré par le compi-lateur, soit un constructeur dé�ni par le créateur de la classe.
. Exemple :
class Vecteur{private :float * v_;int n_;
public :void Vecteur(int ); //constructeur1void Vecteur(istream&); //constructeur2void Vecteur(); //constructeur3/* ici, d'autres methodes */~Vecteur; //destructeur
}
. ces constructeurs pourront etre implémentés sur le modèle suivant :
Vecteur::Vecteur(int n){n_=n; v_=new float[n_];}Vecteur::Vecteur(istream& filin){/*lecture et initialisation sur le flot filin*/}
Vecteur::Vecteur(){//vecteur vide}
. Les instructions pour créer un Vecteur seront du type :
Vecteur a(10); //appel du constructeur1Vecteur b(cin); //appel constructeur2Vecteur c; //appel constructeur3//le destructeur sera appelé implicitement
Vecteur *pv;pv = new Vecteur(15); //appel constructeur1delete pv; //appel explicite destructeur
//obligatoire car *pv créé dynamiquement
8.8 Constructeur et héritageSi une classe b hérite de la classe a :
class b : public a{b(...);//constructeur
};
La syntaxe d'appel au constructeur de la classe de base est :
8.9 Héritage multiple. Une classe peut hériter de plusieurs classes.
66
class a : public b,public c //a hérite de b et de c{...}
. le constructeur de a doit appeler les constructeurs de b et c dans le même ordre qu'ils sontdéclarés suivant la syntaxe :
a::a(liste_arguments_a) : b(liste_arguments_b): c(liste_arguments_c);
. Les destructeurs sont appelés dans l'ordre inverse
. Si b et c ont chacun une variable de même nom, disons x, elle seront di�érenciées dans aà l'aide de l'opérateur de résolution de portée. b::x et a::x désigneront respectrivement lavariable x de a et celle de b.
8.10 Méthodes virtuelles
8.11 Fonctions amies (friend)
67
9 La classe string
68
9.1 ConstructeursLa classe string permet une manipulation aisée des chaînes de caractères.
. Les déclarations de la classe string se trouvent dans <string.h>
. Construction. Les syntaxes suivantes sont autorisées :
string ch1; //chaine videstring ch2(�bonjour�);char *str=�salut� //ancienne syntaxe, toujours valablestring mess(str); //construction a partir de strstring mess1(mess); //constructeur recopie
69
9.2 Méthodes de la classe string. concaténation :
string ch1(�bon�);string ch2(�jour�);string ch3 = ch1 + ch2; //ch3 contient �bonjour�
. Les opérateurs d'insertion (< <) et d'extraction (> >) sont surchargés de manière naturellepour la classe string.
. La fonction find permet la recherche d'une chaine ou d'un caractère dans une chaine :
string s(�bonjour�);string ch(�onj�);int i = s.find(ch); // i=1i = s.find(�ur�); //i=5
. Il existe d'autres méthodes de recherche, remplacement suppression et insertion :
� rfind(�toto�) : recherche la dernière occurence de la chaine �toto�� find_first_of(�aeisw�): recherche la première occurence d'un des caractères 'a','e','i','s',ou
'w'� insert(4,�toto�) : permet d'insérér la chaine �toto� en position 4� replace(...) pour remplacer une partie de la chaine� remove(...) pour supprimer une partie de la chaine
. Un string peut contenir un ou plusieurs caractères '\n' ou '\0' ou autre.
. exemple d'utilisation : lire un �chier complet dans un string
#include <string>#include <iostream>#include <fstream>int main(){ifstream in("FillString.cpp");string s, line;while(getline(in, line))s += line + "\n";
cout < < s;}
70
10 La bibliothèque standard
71
10.1 Fichiers d'en-tête standards en C(norme ANSI)
Fichier Description
assert.h Macro de débogage assert
ctype.h Information pour les macros de classi�cation et conversion de caractères
errno.h Constantes symboliques de codes erreurs
float.h Paramètres des routines de �ottants.
limits.h Paramètres d'environnement, limitations de domaines des entiers
locale.h Fonctions des informations spéci�ques aux pays et aux langues
math.h Prototypes des fonctions math
signal.h Constantes et déclarations pour signal et raise
stdarg.h Macros pour lire la liste d'arguments des fonctions prévues avec un nombre d'argumentsvariable
stddef.h Types de données et macros diverses
stdio.h Types et macros pour le "Standard I/O Package" ANSI
stdlib.h Routines de base : conversion recherches/tris et autres
string.h Manipulation de chaînes et de données en mémoire
time.h Structure renseignée par les conversions temporelles
72
10.2 Fichiers d'en-tête spécifiques LinuxFichier Description
alloc.h Fonctions de gestion mémoire (réservation, libération, etc.)
bios.h Appels de routines PC ROM BIOS
complex.h Mathématique des complexes du C++
conio.h Appels de routines d'entrées/sorties DOS console
dir.h Structures, macros et fonctions de gestion de répertoires et de chemins
direct.h Structures, macros et fonctions de gestion de répertoires et de chemins
dos.h Constantes et déclarations pour des appels DOS et 8086
errno.h Constantes symboliques de codes erreurs
mem.h Gestion mémoire (voir aussi string.h.)
memory.h Gestion mémoire
search.h Recherches et tris
values.h Constantes essentielles, et notamment de dépendance machine
73
11 C++ Notions avancées
11.1 Polymorphisme : les templates ou patronsPermet de dé�nir des classes et des fonctions dans lesquelles la classe est variable
inline double Max (double a, double b);inline int Max (int a, int b);inline unsigned int Max (int a, int b);inline Complex (Complex a, Complex b);
etc...sera remplacé par
template <class T>inline T max(T a, T b){return (a>b ? a : b); /***/
}
On peut alors appeler Max() avec n'importe quelle paire de variables de meme classe (pourvu qu'ilexiste une relation d'ordre dans T a�n que a>b ait un sens dans ***).
i = Max(1, 5); //appel de int Max(int,int)x = Max(5.6, 4.2) //appel de double Max (double, double)c = Max('a', '\t') //appel char Max(char, char)w = Max (3.1, 4); //Pourquoi cela ne compile-t-il pas ?
74
11.2 Support des exceptionsLes trois attitudes usuelles faces aux erreurs potentielles :
. Existentialiste : cool, cool, Albert, çà va gazer
. Bureaucratique :
1. lister toutes les erreurs possibles2. prévoir le traitement approprié
. Autoritaire : exit(-1);
C++ propose un mécanisme plus élaboré : trois nouveaux mots clé : try, catch, throw
throw signale une erreur
catch traite l'erreur
try regroupe les instructions traitées par une instruction catch
try{/*instructions parmi lesquelles peuventetre jetées (throw) des exceptionsde classes diverses*/classe1 Y; throw Y;
}catch(classe1 x){/*...*/}catch(classe2 x){/*...*/}
75
11.3 Exceptions : exemple#include <iostream.h>int main(){try{/*...*/if (toto)
throw (�ca va pas du tout�);throw 17;cout < < "cette instruction ne sera jamais executee"
}catch (int i){cout < < "\nL'erreur numero
< <i< < " vient de me parvenir ; que faire ?";
}catch (char * message){cout < < endl < < message;
}}
. Si toto est faux, cette séquence d'instructions produira la sortie :
L'erreur numero 17 vient de me parvenir ; que faire ?
. Si toto est vrai, on obtient :
ca va pas du tout
Il est possible d'écrire un programme, des classes, fonctions... sans utiliser les exceptions. Letraitement des exceptions peut être rajouter par la suite, avec un nombre minimum de modi�ca-tions.
76
12 La STL (Standard Template Library)
. Fait partie de C++
. permet de manipuler les structures de données standards et les algorithmes s'y rattachant.
. Un exemple : lire un �chier d'entiers, les trier et a�cher sur cout
#include <stdlib.h>#include <iostream>#include <fstream>#include <vector>#include <iterator>#include <algorithm>int main(void){ typedef vector<int> vector_int;
ifstream source("input.txt");vector<int> v;istream_iterator<int> start(source);istream_iterator<int> end;back_insert_iterator<vector_int> dest(v);copy(start,end,dest);sort(v.begin(),v.end());copy(v.begin(),v.end(),ostream_iterator<int>(cout,"-"));cout < < endl < < "Fin du test !" < < endl;return 0;
}
12.1 Organisation de la STL. les conteneurs : permettent de contenir des éléments
� tableaux (classes vector et deque)� listes (list)� piles (stack)� �les (queue)� ensembles (set)� ensembles multiples (multiset)� cartes (map)� multicartes (multimap)
. Les itérateurs : permettent aux algorithmes de manipuler les conteneurs. Un itérateur peutêtre vu comme un pointeur sur un élément d'un conteneur.
. Les algorithmes : permettent de manipuler les données d'un conteneur. (tri, ...)
. Les allocateurs : permettent de choisir entre plusieurs possibilités d'allocation de mémoire(a�n de contenir les données).
77
12.2 Le conteneur vectorDé�nition dans le �chier d'entête #include <vector>. Un vector connait 2 valeurs:
* sa taille : le nombre d'éléments qu'il contient,* sa capacité : le nombre d'éléments qu'il peut contenir.#include <vector>#include <iostream>using namespace std;int main(void){vector<int> v;v.push_back(3); // le tableau vaut [3], de taille 1v.push_front(4); // le tableau vaut [4,3], taille 2cout< <v[0]; // renvoie 4v[1] = 5;cout< <v[1]; // renvoie 5return 0;
}Attention, pas de contrôle de dépassement d'indice
. Exemple de lecture d'un �chier de données#include <vector>#include <iostream>#include <iterator>#include <fstream>int main(void){ifstream file;file.open("input.txt");int nb;file> >nb> >ws;vector<int> x;datas.reserve(nb);for (;nb>0;--nb){int d;file> >d> >ws;x.push_back(d);
}copy(x.begin(),x.end(),ostream_iterator<int>(cout,"-"));return 0;
}Autres méthodes :
. T& back(); retourne le dernier élément de la collection.
. void pop_back(); supprime le dernier élément de la collection.
. iterator insert(iterator,const T &); insert un élément à une position précise.
. iterator erase(iterator); supprime un élément à une position précise.
. void clear(); vide le conteneur
. int size(); vetourne le nombre d'éléments
. bool empty(); teste si le conteneur est vide
78
Ouvrages de référence
References
[1] Comprendre et utiliser C++ pour programmer objet, G.Clavel, I.Trillaud, L.Veillon ed. Masson1994.
[2] L'essentiel du C++, S.B. Lippman, ed. Addison-Wesley, seconde édition, 1992.
[3] Le langage C++, Bjarne Stroustrup, ed. Addison-Wesley, seconde édition, 1992.
[4] Programmer en langage C++, C.Delannoy, ed. Eyrolles, 1998.
[5] La bibliothèque standard STL du C++, A.B. Fontaine, ed. InterEditions, Masson 1997.
79
Tutoriaux, documentation
References[1] http://gustavo.net/programming/c_tutorials.html[2] http://math.nist.gov/acmd/Staff/RPozo/[3] http://w3imagis.imag.fr/Membres/Xavier.Decoret/STL_TUTORIAL/sommaire.html[4] http://www.infini-fr.com/Sciences/Informatique/Langages/Imperatifs/CPlusPlus/STL
80
Librairies et outils numériques en C++ une recherche sur internet avec les mots clé indiquésdoit permettre de retrouver aisément tous ces packages
References
[1] algebre linéaire : LAPACK++
[2] matrices creuses : SparseLib++
[3] méthodes itératives : IML++
[4] éléments �nis : Diffpack, deal-II
[5] mathématiques générales : Math.h++
[6] vecteurs, matrices : M++
[7] algèbre linéaire : tnt (R. Pozo)
81
La documentation d'un programme, d'une classe, d'une fonction ou de tout source C++ faitpartie intégrante de la phase de programmation. Grosso-modo, on doit trouver autant de docu-mentation que de code. Les �chiers en-tête doivent être particulièrement bien documentés, puisquece sont les seuls délivrables lisibles en clair dans un projet industriel. Un utilitaire très puissant,doxygen, permet d'extraire du code et des �chiers en-tête toute la documentation incluse, pourvuqu'elle respecte une certaine syntaxe dont les éléments essentiels sont donnés ici. 1
. Style JavaDoc :
/*** ... text ...*/
. style Qt
/*!* ... text ...*/
. style court (documentation inline)
/// ... text ...
. autre style court
//!... text ...
Particularités
. Les caractères '@' et '\' ont un signi�cation particulière pour doxygen. Il introduisent unebalise. Par exemple si vous placez la ligne @param i description du parametre i dans un com-mentaire doxygen elle sera interprété comme la description d'un certain paramètre i etprésentée de manière adhoc dans la documentation. D'autres balises existent : @author,@date, @return @em (emphasis)...
. Doxygen peut interpréter certaines balises html comme <b>, <h1>, <p>, <br>, <ul>, <ol>, <li>etc... la documentation sera présentée suivant la description html que vous en faites.
. Doxygen interprète également les formules latex. elles doivent être encadrée par \f$ ... \f$.Par exemple
/**@return le ieme element du vecteur : \f$ u_i \f$
Un �chier de con�guration, en général nommé Doxyfile doit se trouver dans le répertoire depuislequel est passée la commande doxygen.
Un �chier avec des valeurs par défaut peut être généré par doxygen lui-même, puis édité etmodi�é par vos soins. Il su�t de passer la commande :
$ doxygen -g
Les ligne de documentation d'une fonction ou variable doivent se trouver avant la fonction ouvariable concernée.
Exemple :
. Documentation de la classe Matrice :1pour plus de précision, voir http://www.stack.nl/~dimitri/doxygen/
82
/** une classe qui traite des matrices pleines.*\author Pierre Puiseux*\version 1.0-limitee*\date Novembre 1999*\sa MatVirt MatMorse MatTriDiag*/
. Déclaration de la classe elle même :
class Matrice : public MatVirt{
protected:public :
. Documentation �inline� ou courte (une seule ligne) :
/// Constructeurs vide : la matrice est dimensionnee a 0.Matrice();
. Documentation d'une méthode sur plusieurs lignes
/**Constructeur recopie.*Pour une raison pas tres claire, si l'on supprime le present*consructeur, en esperant que Matrice(const MatVirt&); sera appele,*ca n'est pas le cas. Ainsi, si l'on ecrit une instruction du*type <tt>Matrice A(n,n);Matrice B(A); </tt> c'est*MatVirt::MatVirt(const MatVirt&) qui est appele.*Et puis ca va pas !*/Matrice(const Matrice&);
. Un commentaire ignoré par doxygen
//operateurs methodes
. Paramètres, valeur de retour, liste à puces ...
/***@param k un indice, dans le vecteur v_ de stockage.*@return w une structure IJ telle que :*@li w.i est le numero de ligne de v_(k).*@li w.j est le numero de colonne de v_(k).*@li w.aij est la valeur v_(k).*/
inline IJ WhoIs(const int k);
83
13 Le préprocesseur
traite les lignes commençant par # (en colone 1), avant la compilation.
#include
. syntaxe : #include <nom_fichier> ou bien #include �nom_fichier�
. demande au préprocesseur d'inclure le �chier nom_fichier en lieu et place de la ligneprésente.
. <nom_fichier> sera recherché dans les �chiers include système, tandis que �nom_fichier�sera d'abord recherché dans les �chiers include utilisateur.
. Essentiellement utilisé pour les déclarations de variables globales et prototypes de fonctionsutilisés par plusieurs �chiers.
#define et #undef
. syntaxe :
#define NOM [chaine_carac]...
#undef NOM
. #define demande au préprocesseur de remplacer toutes les occurences de la macro NOM parchaine_carac dans le reste du �chier source.
. chaine_carac est optionnel, dans ce cas, la macro NOM sera simplement déclarée commedé�nie, mais vide.
. #undef stoppe la substitution.
. Exemples : voir aussi #ifdef (13)
#define DEBUG 1if (DEBUG)//DEBUG vaut 1cout< <�valeur de x =�< <x;//x est imprimé
#undef DEBUG#define PI 3.14159#undef PI
#ifndef et #ifdef
. syntaxe :
#ifdef NOM #ifndef NOM... ou bien ...#endif #endif
Si la macro NOM a été précédement dé�ni par une directive #define, alors #ifdef NOM aura lavaleur vraie et la séquence comprise entre #ifdef et #endif sera prise en compte par le compilateur(ou le préprocesseur). Dans le cas contraire, les lignes comprises entre les directives #ifdef et#endif seront ignorées. La directive #ifndef renvoie vrai si et seulement si la directive #ifdefrenvoie faux.
84
. exemple : en tête d'un �chier foo.h, on aura typiquement
#ifndef FOO_H#define FOO_H....#endif
de sorte que si le �chier foo.h a déja été inclus, il ne sera pas inclus une seconde fois.
85
Contents
14 Premiers pas en Linux
14.1 Bref historique LinuxLINUX est un système d'exploitation créé en 1991 par un étudiant �nlandais, Linus Torvalds.Depuis, il a été développé et amélioré par des centaines de spécialistes dans le monde. La par-ticularité de ce système c'est qu'il est librement disponible avec son code source sur Internet. Ilexiste des sociétés commerciales qui le distribuent et ils facturent alors soit le prix du support (CDROM) et de la documentation sur papier, soit ils facturent le service de maintenance et de supporttéléphonique. En 1998, Linux et les logiciels libres ont acquis une notoriété et une consécrationcomme le montre la chronologie suivante:
* Avril 1998, Netscape le numéro 1 mondial des navigateurs Internet annonce qu'elle trans-forme son logiciel Communicator en logiciel libre * Mai 1998, Corel Computer annonce la sor-tie de Netwinder, Un NC fonctionnant sous Linux * Juin 1998, IBM l'ex numéro 1 mondial del'informatique abandonne son propre logiciel serveur Web et commence à distribuer et à supporterle logiciel APACHE qui est un logiciel libre serveur Web * Juillet 1998 Informix et surtout Oracle,le numéro 1 mondial des SGBD annoncent le portage de leurs SGBD vers Linux * Septembre 1998,Intel le numéro 1 mondial des microprocsseurs entre dans le capital de RedHat un distributeurcommercial de Linux
on supposera dans toute cette partie que l'utilisateur se nomme puiseux, et appartient augroupe recherche.
14.2 GénéralitésLINUX est un système d'exploitation (au même titre que DOS,Windows, MacOS) qui satisfaità la norme UNIX et qui permet de "dialoguer" avec l'ordinateur. Ceci se fait dans une fenêtrexterm (on dit aussi en mode console) via un langage : le shell. Il existe, sous UNIX, 3 principauxshell : le Bourne shell (sh) qui est le plus ancien, le C shell (csh) et le Korn shell (ksh) qui estun peu un mélange des deux autres. Il existe aussi des versions un peu plus conviviales : ce sontpar exemple le tcsh (csh amélioré) et le bash (sh amélioré). C'est principalement avec ce dernierque nous travaillerons.
Pour vous connecter sur une machine UNIX vous avez besoin d'un nom d'utilisateur, (ou userIdou login) et un mot de passe ou password. Chaque utilisateur appartient à un groupe, ce qui luidonne certains privilèges (possibilité d'écrire, lire ou exécuter un programme dans une certainezone) communs à tous les utilisateurs de ce groupe. Il existe cependant un utilisateur particulier,nommé root qui a tous les privilèges.
Les �chiers sont classés dans l'ordinateur (sur le disque) selon une structure arborescente.
86
fileSystem.ps not found!
Chaque noeud de l'arborescence s'appelle un répertoire ou directory (en anglais). Dans cesrépertoires se trouvent des �chiers (ou �le en anglais).
Les répertoires et �chiers de l'arborescence peuvent être désignés par leur chemin d'accès(path) absolu ou relatif. Par exemple /home/puiseux/sources/zorro.c (chemin absolu) sig-ni�e que le �chier zorro.c se trouve dans le répertoire sources qui se trouve lui même dansle répertoire puiseux, qui se trouve lui même dans... Supposons maintenant que le répertoirecourant est /home/puiseux/sources (chemin absolu). Alors le répertoire /home/puiseux/lib,peut être également désigné par ../lib (chemin relatif). Lors de la connexion, chaque utilisateurest connecté dans son répertoire personnel (ou répertoire home), en général /home/puiseux. Lerépertoire personnel d'un utilisateur est aussi désigné par ~, ou $HOME.
'.' (point) désigne le répertoire courant, '..' désigne le répertoire parent du répertoirecourant.
Cette partie vous explique les principales commandes de UNIX qu'il faut connaître : les com-mandes de gestion des �chiers, les commandes concernant l'environnement, les commandes pourl'édition ou pour la compilation des programmes que vous écrirez.
Pour interrompre une commande, utiliser les touches : Ctrl c
14.3 Arborescence sous Linux(d'après �Premiers pas sous Linux Auteur : Armand Delcros�) Voici l'arborescence d'un systèmeUNIX classique :
/ est le répertoire racine, tous les autres répertoires en dépendent. Par exemple le répertoire oùest "monté" mon CD-ROM est sur /mnt/cdrom. On n'a donc pas comme sous MS-DOS,di�érentes lettres qui correspondent à di�érents lecteurs disctincts physiquement.
/bin contient les binaires fondamentaux à la gestion de Linux. On y retrouve par exemple lescommandes étudiées plus loin.
/dev contient une multitudes de �chiers dits spéciaux. /dev/hda1 correspond à la première par-tition de mon disque dur IDE, si mon disque dur est un SCSI, son nom sera /dev/sda1. Undernière exemple : /dev/fd0 correspond à mon lecteur de disquettes.
/etc contient tous les �chiers de con�guration de linux. On y retrouve par exemple le �chier/etc/passwd, qui dé�nit les mots de passe des utilisateurs.
/sbin contient les binaires du système. On y trouve par exemple la commande shutdown quipermet d'arrêter l'ordinateur.
87
/home est le répertoire qui contient les répertoires des utilisateurs du système.
/lost+found est le répertoire des �chiers perdus. Des �chiers qui, du fait d'erreur disque, seretrouvent sans chemin d'accès.
/tmp est un répertoire accessible par tous les utilisateurs du système, il permet de ne pas encombrerson répertoire personnel par des �chiers que l'on souhaite de toute manière rapidemmentdétruire ou modi�er.
/var/spool est le répertoire des �chiers qui servent de �le d'attente. Par exemple, les �lesd'attente de l'imprimante se trouvent sous ce répertoire.
/usr contient grosso modo tout ce qui concerne les binaires utiles à tous les utilisateurs et quelquescommandes d'administration. On y trouve cependant d'autres choses :
/usr/bin contient donc les binaires disponibles pour les utilisateurs et les scripts./usr/X11R6 contient tout ce qui concerne Xfree86 (les bibliothèques, les binaires, la docu-
mentation)./usr/include contient tous les "headers" nécessaires à la programmation dans les di�érents
languages./usr/lib contient toutes les bibliothèques nécessaires au fontionnement des logiciels. (comme
par exemple la bibliothèque C ou C++ ou tcl/tk)./usr/local on y met ce qu'on veut, mais surtout les �chiers d'usage local et des logiciels
qui ne sont pas propres à Unix.
14.4 Commandes fondamentalesEn général, les noms des commandes sont des abbréviations de mots anglais. Par exemple cdsigni�e Change Directory. A vous de faire marcher votre imagination pour déterminer le ou lesmots à l'origine d'une commande.
man, info, apropos pour obtenir de l'aide sur une commande ou un mot clé. Exemples :
$ info ls$ apropos float$ man cd
cd Pour se déplacer dans les répertoires. Exemples :
$ cd /home/puiseux/sources (chemin ou path absolu)$ cd ~/sources$ cd .. (chemin relatif )$ cd est équivalent à cd ~
pwd Où suis-je ?
ls Lister les �chiers d'un répertoire.
. option -l pour une liste détaillée par exemple
$ ls -l
88
total 40-rwxrwxr-x 1 puiseux puiseux 16557 aoû 29 17:20 a.out*-rw-rw-r-- 1 puiseux puiseux 491 aoû 29 17:20 copie-rw-rw-r-- 1 puiseux puiseux 519 aoû 29 17:11 monfichier-rw-rw-r-- 1 puiseux puiseux 519 aoû 29 17:11 toto.cxx
. option -a pour lister aussi les �chiers cachés (ceux dont le nom commence par un point).Par exemple
$ ls -a
./ ../ a.out* copie .fichierCache monfichier toto.cxx
chmod pour changer les droits d'un �chier ou d'un répertoire en lecture, écriture ou exécution.
. Syntaxe chmod [options] mode fichier.
. Les options sont à choisir dans[ugoa][+-][rwx]
� u=user, g=groupe, o=other, a=all� +=ajouter les droits, -=supprimer les droits� r=lecture, w=écriture, x=exécution
. Exemples
$ chmod a-x a.out : change le �chier a.out en �chier non-exécutable (-x) pour tous lesutilisateurs (a).
$ chmod g-w toto.cxx : change le �chier toto.cxx en �chier non-modi�able (-w) pour tousles utilisateurs du groupe (g).
less Voir le contenu d'un �chier texte. Exemple :
$ less toto.cxx
emacs Éditer un �chier (autre éditeurs : vi, nedit ...)
cp Copier un �chier. Exemples :
$ cp toto.cxx sauvegarde/toto.cxx.bak$ cp toto.cxx sauvegarde (recopie dans le sous répertoire sauvegarde, sous le même
nom)
rm Supprimer un �chier. Exemples :
$ rm toto.cxx.bak (avec con�rmation)$ rm -f toto.cxx.bak (sans con�rmation)$ rm -r sauvegarde/ (suppression récursive de tous les sous répertoires et �chiers)$ rm -rf sauvegarde/ (idem, sans con�rmation, danger)
mkdir Créer un répertoire :
$ mkdir toto
mv Déplacer ou renommer un �chier ou un répertoire
$ mv toto.cxx toto.cxx.bak
89
$ mv toto.cxx ..
locate Retrouver un �chier
$ locate toto : liste tous les �chiers contenant la chaîne �toto�, locate est indi�érent à lacasse.
which et whereis localise une commande :
$ which ls
/bin/ls
grep Trouver du texte dans un �chier et a�che la ligne correspondante
. syntaxe : grep [-il] reg_exp fichiers où :
� reg_exp est la chaine de caractères à trouver (en réalité, il s'agit d'une expressionrégulière, dont la description nécessite plusieurs pages ! Consulter $ man perlretutpour en savoir plus).
� fichiers : la liste des �chiers où chercher,� l'option -i pour ignorer les di�érences majuscules/minuscules,� l'option -l pour n'a�cher que les noms des �chiers contenant reg_exp sans a�cher laligne correspondante.
. Exemple :
$ grep main *.cxx
ln Créer des liens entre �chiers. (L'équivalent des raccourcis de windows). Syntaxe ln -s source[dest] ou bien ln -s source... repertoire. Exemple.
$ ln -s toto.cxx toto.cc crée un lien symbolique entre toto.cxx et toto.cc
gzip Le compactage et le décompactage des �chiers au format .gz
$ gzip toto.cxx remplace toto.cxx par toto.cxx.gz, la version compactée.$ gunzip toto.cxx.gz permet de décompacter le �chier.
tar Archivage de données. tar [options] archive [fichiers]
$ tar -czvf rep.tgz rep crée une archive compactée au format gzip de tout le répertoirerep et la place dans le �chier rep.tgz
$ tar -xzvf rep.tgz pour �détarer�, i.e. extraire les �chiers de l'archive et reconstituer lerépertoire.
df du Connaître l'espace disque restant (df, du)
$ df-h
Filesystem Size Used Avail Use% Mounted on/dev/sda2 99M 66M 28M 70% //dev/sdb2 8.2G 6.8G 1.5G 82% /home/dev/scd0 72M 72M 0 100% /mnt/cdrom
ps et kill La gestion des processus. Si un processus (ou job) bloque ou ralentit la machine (parexemple mozilla ici) il est possible de le tuer :
90
$ ps -u puiseux
PID TTY TIME CMD16457 pts/4 00:00:00 bash27547 pts/4 02:19:10 vmware30904 pts/4 00:00:00 mozilla-bin31146 pts/4 00:00:00 ps$ kill -9 309042
14.5 Les tubes ou pipes, les redirections, les jobs| Les pipes : pour chaîner plusieurs commandes, la sortie de l'une étant l'entrée de la suivante
$ ls | less$ cat toto | sort
> > > Les redirections : pour rediriger la sortie standard (écran) vers un �chier
$ ls > list.txt : le �chier list.txt est créé et contient le résultat de la commande ls.$ df > > list.txt : ajoute le résultat de la commande df à la suite du �chier list.txt
& lancer un job en background :
$ toto& : pour lancer la commande toto et récupérer la main durant son exécution.
14.6 TP1A l'aide des commandes décrites ci-dessus:
1. Placez vous dans votre répertoire. Véri�ez que vous y êtes bien. (pwd)
2. Regardez la liste des �chiers : (ls)
3. Regardez la liste des �chiers cachés : (ls)
4. Visualiser le contenu du �chier .bashrc (less)
5. Créer un répertoire essai. Véri�er son existence. (mkdir, ls)
6. Aller dans ce répertoire. Véri�er que vous y êtes. (cd)
7. Créer 3 �chiers vides fic1, fic2 et fic3 (touch)
8. Revenir dans le répertoire principal. Véri�ez que vous y êtes. Créer un répertoire exemplecontenant 4 �chiers vides ex1, ex2, fic1, fic2
9. Revenir dans votre home directory. Taper les commandes ls, puis ls exemple, ls exemple/fic*et en�n ls *.
10. Rediriger la sortie de la commande ls vers un �chier nommé liste1. Visualiser le contenude liste1. (>)
11. Copier le �chier liste1 dans un �chier nommé copie. (cp)
12. Renommer le �chier liste1 en �chier liste2. Véri�er avec la commande ls.2Si l'écran graphique est gelé, il est possible de passer en mode non graphique : Ctl+Alt+F1. Puis se connecter
et tuer le job fautif.Ctl+Alt+F7 vous permet ensuite de repasser en mode graphique.
91
13. Copier le �chier liste2 dans le répertoire exemple. Véri�er.
14. Déplacer le �chier liste2 dans le répertoire exemple . Véri�er le résultat.
15. Détruire le �chier liste2 du répertoire essai puis tous les �chiers de essai.
16. Récréer 4 �chiers vides ex1, ex2, fic1, fic2 dans essai. (touch)
17. Revenir dans votre home directory copier le répertoire exemple et ses �chier dans un réper-toire exemple1. (cp -r)
18. E�acer le répertoire exemple et son contenu.
19. Créer trois répertoires : bin, lib et include. Ces répertoires vous seront utiles pour lasuite et vous permettront de mettre des exécutables (bin), vos librairies (lib) ou des �chiersinclude (include).
20. Trouver un �chier dans votre home directory contenant le mot 'alias'. (grep)
21. Trouver tous les �chiers de votre ordinateur dont le nom contient la chaine de caractère'include'. (locate)
22. Lancer l'éditeur emacs, ouvrez le �chier copie.
23. En mode console, tuer le job emacs.(ctl c)
24. Lancer l'éditeur emacs, en background. (&)
25. En mode console, tuer le job emacs.(ps et kill)
26. Lister le contenu du répertoire /usr/bin.
27. Idem en utilisant un pipe : ls /usr/bin | less
28. Archiver-compacter le répertoire essai sous le nom essai.tgz, comparer la taille de essai/et essai.tgz (commandes tar, du, ls)
29. Où se trouve le �chier manuel de la commande ls (i.e. le �chier utilisé par la commandeman ls) ? (whereis)
Bibliographie
. Ouvrages de référence
� Le Système Linux, Matt Welsh & Lar Kaufman, ed. O'Reilly&Associate, inc.,1999.� Linux in a nutshell, Manuel de référence, J.P.Hekman et l'équipe de O'Reilly&Associates,1997.
. Tutoriaux, apprentissage en ligne :
� http://linux.uhp-nancy.fr/gs-french-2.1.1/gs2/html/gs.html� http://www.linux-kheops.com/doc/bien-debuter/html/gs.html� http://www.ee.surrey.ac.uk/Teaching/Unix/index.html
92