7 Les ﬁchiers et la compilation

(1)

Peter Schlagheck Universit ´e de Li `ege

Ces notes ont pour seule vocation d’ être utilis ées par les étudiants dans le cadre de leur cursus au sein de l’Universit é de Li ège. Aucun autre usage ni diffusion n’est autoris é, sous peine de constituer une violation de la Loi du 30 juin 1994

relative au droit d’auteur.

(2)

7.1 Les fichiers

7.2 Le processus de la compilation 7.3 D éclaration et d éfinition des fonctions 7.4 La pr é-initialisation des arguments 7.5 Les headers

7.6 Les directives du compilateur

(3)

Un fichier est une collection de donn ées informatiques, repr ésent ées en octets, qui se trouve sur le disque dur (ou sur une cl é USB / un CD . . . ):

/home/peter/cours/prog/prog1.cpp

/home/peter/cours/prog/prog1

(4)

Un fichier est une collection de donn ées informatiques, repr ésent ées en octets, qui se trouve sur le disque dur (ou sur une cl é USB / un CD . . . ):

/home/peter/cours/prog/prog1.cpp /home/peter/cours/prog/prog1 rm prog1

−→ enlever des fichiers fait toujours laisser des traces sur le

−→ disque (que les professionnels pourront acc ´eder . . . )

(5)

Un fichier ASCII est un fichier qui contient de l’information lexicale, c. à.d., des caract ères encod és selon le code ASCII.

Le fichier prog1.cpp . . .

#include <iostream>

using namespace std;

main() {

focout << ''hi'' << endl;

}

. . . enregistr ´e sur le disque dur :

(6)

Un fichier ASCII est un fichier qui contient de l’information lexicale, c. à.d., des caract ères encod és selon le code ASCII.

Le fichier prog1.cpp . . .

#include <iostream>

using namespace std;

main() {

focout << ''hi'' << endl;

}

. . . enregistr ´e sur le disque dur :

−→ un fichier ASCII contient des octets entre 32 et 126

−→ (et ´eventuellement quelques “octets de contr ˆole”,

−→ comme 10 = \n)

(7)

#include <iostream>

#include <fstream>

using namespace std;

int puissance( int k, int n ) {

foint kn = 1;

fofor ( int i = 1; i <= n; i++ ) fofokn *= k;

foreturn kn;

} main() {

foint n, Nmax;

focout << ''exposant:'';

focin >> n;

focout << ''nombre maximal:'';

focin >> Nmax;

foofstream out( ''fichier.dat'' );

fofor ( int k = 1; k <= Nmax; k++ ) fofor ( int l = 1; l <= Nmax; l++ ) fofor ( int m = 1; m <= Nmax; m++ ) fofoif ( puissance( k, n ) + fofoif (puissance( l, n ) ==

fofoif (puissance( m, n ) ) fofofoout << k << ''ˆ'' << n << '' + '' fofofocout<< l << ''ˆ'' << n << '' = '' fofofocout<< m << ''ˆ'' << n << endl;

}

Ex ´ecution:

exposant: 2

nombre maximal: 20

−→ cr ´eation d’un fichier

−→ fichier.dat

−→ dans le r ´epertoire actuel

(8)

#include <iostream>

#include <fstream>

foint kn = 1;

foreturn kn;

} main() {

foint n, Nmax;

focout << ''exposant:'';

focin >> n;

focout << ''nombre maximal:'';

focin >> Nmax;

}

Le contenu de fichier.dat:

3ˆ2 + 4ˆ2 = 5ˆ2

4ˆ2 + 3ˆ2 = 5ˆ2

5ˆ2 + 12ˆ2 = 13ˆ2

6ˆ2 + 8ˆ2 = 10ˆ2

8ˆ2 + 6ˆ2 = 10ˆ2

8ˆ2 + 15ˆ2 = 17ˆ2

9ˆ2 + 12ˆ2 = 15ˆ2

12ˆ2 + 5ˆ2 = 13ˆ2

12ˆ2 + 9ˆ2 = 15ˆ2

12ˆ2 + 16ˆ2 = 20ˆ2

15ˆ2 + 8ˆ2 = 17ˆ2

16ˆ2 + 12ˆ2 = 20ˆ2

(9)

#include <iostream>

#include <fstream>

foint kn = 1;

foreturn kn;

} main() {

foint n, Nmax;

foifstream inp( ''param.inp'');

foinp >> n;

foinp >> Nmax;

}

−→ lecture des param `etres

−→ n et Nmax depuis

−→ le fichier param.inp ceci pourrait contenir 2

20 −→ sortie dans fichier.dat

(10)

disponible avec #include <fstream>

ifstream hnomi ( hstringi );

−→ d ´efinition d’une “variable” hnomi du type ifstream

−→ pour la lecture depuis le fichier hstringi (entre guillemets) ofstream hnomi ( hstringi );

−→ d ´efinition d’une “variable” hnomi du type ofstream

−→ pour l’ ´ecriture dans le fichier hstringi

−→ utilisation comme cin et cout

(11)

Fichier “binaire” = fichier qui contient de l’information binaire g én érique, sans la restriction aux caract ères ASCII.

−→ fichiers d’ex ´ecution de programme (prog1)

−→ fichiers Word, Excel, PowerPoint, pdf, . . .

(12)

Fichier “binaire” = fichier qui contient de l’information binaire g én érique, sans la restriction aux caract ères ASCII.

Lecture d’un fichier binaire :

ifstream inp( ''file.dat'' );

char c;

inp.get( c );

−→ lecture d’un caract `ere (contenu entre 0 et 255)

−→ depuis le fichier file.dat

(13)

Fichier “binaire” = fichier qui contient de l’information binaire g én érique, sans la restriction aux caract ères ASCII.

Ecriture dans un fichier binaire :

ofstream out( ''file.dat'' );

char c = 'A';

out.put( c );

out.put( c + 100 );

out.put( 27 );

out.put( 'e' );

−→ ´ecriture des caract `eres 65 (’A’), 165, 27, 99 (’e’)

−→ dans le fichier file.dat

(14)

Affichage du contenu d’un fichier binaire :

#include <iostream>

#include <fstream>

main() {

foifstream inp( ''prog1.cpp'' );

fochar c;

fowhile ( inp.get( c ) ) fofocout << int( c ) << '' '';

}

Le contenu de prog1.cpp :

#include<iostream>

main() {

focout << ''hi'' << endl;

}

(15)

Affichage du contenu d’un fichier binaire :

#include <iostream>

#include <fstream>

main() {

foifstream inp( ''prog1.cpp'' );

fochar c;

}

Le contenu de prog1.cpp :

Ex ´ecution:

35 105 110 99 108 117 100 101 32 60 105 111 115 116 114

101 97 109 62 10 117 115 105 110 103 32 110 97 109 101

115 112 97 99 101 32 115 116 100 59 10 10 109 97 105 110

40 41 10 123 10 32 32 99 111 117 116 32 60 60 32 34 104

105 34 32 60 60 32 101 110 100 108 59 10 125 10

(16)

Affichage du contenu d’un fichier binaire :

#include <iostream>

#include <fstream>

main() {

foifstream inp( ''prog1'' );

fochar c;

}

Le contenu de prog1.cpp :

#include<iostream>

main() {

focout << ''hi'' << endl;

}

c++ prog1.cpp -o prog1

Ex ´ecution:

127 69 76 70 1 1 1 0 0 0 0 0 0 0 0 0 2 0 3 0 1 0 0 0 0

-122 4 8 52 0 0 0 112 11 0 0 0 0 0 0 52 0 32 0 8 0 40 0

31 0 28 0 6 0 0 0 52 0 0 0 52 -128 4 8 52 -128 4 8 0 1 0

0 0 1 0 0 5 0 0 0 4 0 0 0 3 0 0 0 52 1 0 0 52 -127 4 8

52 -127 4 8 19 0 0 0 19 0 0 0 4 0 0 0 1 0 0 0 1 0 0 0 0

0 0 0 0 -128 4 8 0 -128 4 8 -32 8 0 0 -32 8 0 0 5 0 0 0

0 16 0 0 1 0 0 0 -32 8 0 0 -32 -104 4 8 -32 -104 4 8 80

1 0 0 -12 1 0 0 6 0 0 0 0 16 0 0 2 0 0 0 -16 8 0 0 -16

-104 4 8 -16 -104 4 8 8 1 0 0 8 1 0 0 6 0 0 0 4 0 0 0 4

0 0 0 72 1 0 0 72 -127 4 8 72 -127 4 8 68 0 0 0 68 0 0 0

4 0 0 0 4 0 0 0 80 -27 116 100 20 8 0 0 20 -120 4 8 20

-120 4 8 44 0 0 0 44 0 0 0 4 0 0 0 4 0 0 0 81 -27 116

100 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6 0 0 0 4 0

0 0 47 108 105 98 47 108 100 45 108 105 110 117 120 46

115 111

(17)

La commande

c++ prog1.cpp -o prog1

traduit toutes les fonctions d ´efinies dans prog1.cpp

en langage de machine.

(18)

#include <iostream>

#include <fstream>

#include <cmath>

fo

int fonction1(. . . )

// utilise sin(..) et log(..) de <cmath>

{ fo. . . } fo

void fonction2(. . .) // appelle fonction1 {

fo. . . } fo

double fonction3(. . . )

// appelle fonction1 et fonction2 {

fo. . . } fo main()

// appelle fonction2 et fonction3 // utilise cout/cin et ifstream/ofstream {

fo. . . } fo

c++ prog1.cpp -o prog1

−→ fonction1:

−→ 01101011

−→ 11010001

−→ ...

−→ fonction2:

−→ 11100100

−→ 01010011

−→ ...

−→ fonction3:

−→ 00011010

−→ 10000111

−→ ...

−→ main:

−→ 11011101

−→ 00110010

−→ ...

(19)

La commande

c++ prog1.cpp -o prog1

traduit toutes les fonctions d ´efinies dans prog1.cpp en langage de machine.

De plus, un fichier pr êt à ex écuter est cr é é avec le nom prog1

La commande ./prog1 commence avec l’ex ´ecution de la

fonction main()

(20)

Probl `eme:

Pour le fonctionnement d’un programme ordinaire

on a besoin de beaucoup de fonctions/routines standards:

−→ des fonctions math ´ematiques

−→ #include <cmath>

(21)

Probl `eme:

Pour le fonctionnement d’un programme ordinaire

on a besoin de beaucoup de fonctions/routines standards:

−→ des fonctions math ´ematiques

−→ des routines (et types) entr ´ee / sortie

−→ #include <iostream>

(22)

Probl `eme:

Pour le fonctionnement d’un programme ordinaire

on a besoin de beaucoup de fonctions/routines standards:

−→ des fonctions math ´ematiques

−→ des routines (et types) entr ´ee / sortie

−→ des routines (et types) pour le traitement des fichiers

−→ #include <fstream>

(23)

Probl `eme:

Pour le fonctionnement d’un programme ordinaire

on a besoin de beaucoup de fonctions/routines standards:

−→ des fonctions math ´ematiques

−→ des routines (et types) entr ´ee / sortie

−→ des routines (et types) pour le traitement des fichiers

−→ . . .

. . . et beaucoup d’autres fonctions ´el ´ementaires “invisibles”

que de telles fonctions (ou routines/types) utilisent dans leur d ´efinition interne

−→ c¸a ferait un lourd processus de compilation . . .

(24)

Solution:

De telles fonctions standards sont d éj à pr écompil ées en langage de machine.

Elles sont disponibles dans des biblioth `eques standards qui

sont automatiquement prises en compte lors de l’ex ´ecution du

programme.

(25)

#include <iostream>

#include <fstream>

#include <cmath>

fo

{ fo. . . } fo

fo. . . } fo

fo. . . } fo main()

fo. . . } fo

c++ prog1.cpp -o prog1 compile d’abord les fonctions fonction1, fonction2, fonction3, main

(processus de compilation)

et ajoute ensuite un lien avec

les biblioth `eques standards

(processus de linking)

avant de cr ´eer l’ex ´ecutable

prog1

(26)

#include <iostream>

#include <fstream>

#include <cmath>

fo

{ fo. . . } fo

fo. . . } fo

fo. . . } fo main()

fo. . . } fo

c++ -c prog1.cpp compilation de

fonction1, fonction2, fonction3, main

et cr ´eation d’un “fichier d’objet”

prog1.o qui contient

la traduction de ces fonctions

en langage de machine

c++ prog1.o -o prog1

processus de linking avec

les biblioth `eques standards et

cr ´eation de l’ex ´ecutable prog1

(27)

Solution:

De telles fonctions standards sont d éj à pr écompil ées en langage de machine.

Elles sont disponibles dans des biblioth `eques standards qui sont automatiquement prises en compte lors de l’ex ´ecution du programme.

Comment peut-on appeler des fonctions standards si leurs d ´efinitions ne sont pas inclues dans le code `a compiler ?

−→ on inclut leur d ´eclaration dans le programme

(28)

La d ´efinition de la fonction puissance:

double puissance( double k, int n ) {

fodouble kn = 1;

foif ( n < 0 )

fofofor ( int i = -1; i >= n; i-- ) fofofokn /= k;

foelse

fofofor ( int i = 1; i <= n; i++ ) fofofo kn *= k;

foreturn kn;

}

La d ´eclaration de la fonction puissance:

double puissance( double k, int n );

(29)

La d ´eclaration

htypei hnomi ( htype1i hnom1i , htype2i hnom2i , ... );

dans un fichier C/C++ informe le compilateur qu’une fonction nomm ´ee

hnomi ( htype1i , htype2i , ... ) qui rend une valeur du type htypei sera disponible dans le programme final Le compilateur compile ce fichier donc

comme si cette fonction était explicitement d éfinie l à-dedans

(30)

Le contenu du fichier prog1.cpp:

#include <iostream>

fo

double puissance( double k, int n );

// declaration de puissance fo

main() {

fodouble a;

foint n;

focin >> a >> n;

focout << puissance( a, n ) << endl;

}

c++ -c prog1.cpp

−→ cr ´eation du fichier objet prog1.o contenant

−→ la d ´efinition de la fonction main

−→ en langage de machine

(31)

Le contenu du fichier prog1.cpp:

#include <iostream>

fo

main() {

fodouble a;

foint n;

focin >> a >> n;

}

c++ prog1.cpp -o prog1

−→ erreur:

−→ undefined reference to 'puissance(double, int)'

(32)

Le contenu du fichier prog1.cpp:

#include <iostream>

fo

main() {

fodouble a;

foint n;

focin >> a >> n;

}

Le contenu du fichier puis.cpp:

double puissance( double k, int n ) // definition de puissance {

fodouble kn = 1;

foif ( n < 0 )

fofofor ( int i = -1; i >= n; i-- ) fofofokn /= k;

foelse

fofofor ( int i = 1; i <= n; i++ ) fofofokn *= k;

foreturn kn;

}

c++ -c puis.cpp

−→ cr ´eation du fichier objet puis.o contenant

−→ la d ´efinition de la fonction puissance

−→ en langage de machine

(33)

Le contenu du fichier prog1.cpp:

#include <iostream>

fo

main() {

fodouble a;

foint n;

focin >> a >> n;

}

Le contenu du fichier puis.cpp:

fodouble kn = 1;

foif ( n < 0 )

foelse

foreturn kn;

}

c++ puis.cpp -o puissance

−→ erreur:

−→ undefined reference to 'main'

(34)

Le contenu du fichier prog1.cpp:

#include <iostream>

fo

main() {

fodouble a;

foint n;

focin >> a >> n;

}

Le contenu du fichier puis.cpp:

fodouble kn = 1;

foif ( n < 0 )

foelse

foreturn kn;

}

c++ -c puis.cpp c++ -c prog1.cpp

c++ prog1.o puis.o -o prog1

−→ cr ´eation de l’ex ´ecutable prog1:

−→ linking des deux fonctions puissance et main

(35)

Le contenu du fichier prog1.cpp:

#include <iostream>

fo

main() {

fodouble a;

foint n;

focin >> a >> n;

}

Le contenu du fichier puis.cpp:

fodouble kn = 1;

foif ( n < 0 )

foelse

foreturn kn;

}

c++ -c puis.cpp

c++ prog1.cpp puis.o -o prog1

−→ cr ´eation de l’ex ´ecutable prog1:

−→ compilation de prog1.cpp et linking avec puis.o

(36)

Le contenu du fichier prog1.cpp:

#include <iostream>

fo

main() {

fodouble a;

foint n;

focin >> a >> n;

}

Le contenu du fichier puis.cpp:

fodouble kn = 1;

foif ( n < 0 )

foelse

foreturn kn;

}

c++ prog1.cpp puis.cpp -o prog1

−→ cr ´eation de l’ex ´ecutable prog1:

−→ compilation et linking de prog1.cpp et puis.cpp

(37)

Le contenu du fichier prog1.cpp:

#include <iostream>

fo

double puissance( double a, int b );

main() {

fodouble a;

foint n;

focin >> a >> n;

}

Le contenu du fichier puis.cpp:

fodouble kn = 1;

foif ( n < 0 )

foelse

foreturn kn;

}

c++ prog1.cpp puis.cpp -o prog1

−→ pas de probl `eme

(38)

Le contenu du fichier prog1.cpp:

#include <iostream>

fo

double puissance( double k, double n );

main() {

fodouble a;

foint n;

focin >> a >> n;

}

Le contenu du fichier puis.cpp:

fodouble kn = 1;

foif ( n < 0 )

foelse

foreturn kn;

}

c++ prog1.cpp puis.cpp -o prog1

−→ erreur:

−→ undefined reference to 'puissance(double, double)'

−→ pas de conversion implicite entre d ´eclarations et d ´efinitions

(39)

Le contenu du fichier prog1.cpp:

#include <iostream>

fo

double puissance( double &k, int &n );

main() {

fodouble a;

foint n;

focin >> a >> n;

}

Le contenu du fichier puis.cpp:

fodouble kn = 1;

foif ( n < 0 )

foelse

foreturn kn;

}

c++ prog1.cpp puis.cpp -o prog1

−→ erreur:

−→ undefined reference to 'puissance(double&, int&)'

(40)

Le contenu du fichier prog1.cpp:

#include <iostream>

fo

double puissance( double &k, int &n );

main() {

fodouble a;

foint n;

focin >> a >> n;

}

Le contenu du fichier puis.cpp:

double puissance( double &k, int &n ) // definition de puissance

{

fodouble kn = 1;

foif ( n < 0 )

foelse

foreturn kn;

}

c++ prog1.cpp puis.cpp -o prog1

−→ pas de probl `eme

(41)

Le contenu du fichier prog1.cpp:

#include <iostream>

fo

main() {

fodouble a;

foint n;

focin >> a >> n;

} fo

fodouble kn = 1;

foif ( n < 0 )

foelse

foreturn kn;

}

−→ c¸a peut rendre les programmes plus lisibles

(42)

Exemple: plusieurs m ´ethodes pour calculer la puissance fichier puis.cpp:

#include <cmath>

fo

double puissance( double k, int n, double puissance(int methode ) {

foif ( ( methode ) && ( k > 0 ) ) foforeturn ( exp( n * log( k ) ) );

fodouble kn = 1;

foif ( n < 0 )

foelse

foreturn kn;

}

fichier prog1.cpp:

#include <iostream>

fo

double puissance( double k, int n, double puissance( int methode );

fo main() {

fodouble a;

foint n;

focin >> a >> n;

focout << puissance( a, n, 0 ) << endl;

}

(43)

Exemple: plusieurs m ´ethodes pour calculer la puissance fichier puis.cpp:

#include <cmath>

fo

fodouble kn = 1;

foif ( n < 0 )

foelse

foreturn kn;

}

fichier prog1.cpp:

#include <iostream>

fo

double puissance( double k, int n, double puissance( int methode = 0 );

fo main() {

fodouble a;

foint n;

focin >> a >> n;

}

En g ´en ´eral, l’utilisateur d’une telle fonction n’aime pas

explicitement sp écifier la m éthode, sauf dans des cas sp éciaux

→ initialisation de methode dans la d ´eclaration de puissance

(44)

Exemple: plusieurs m ´ethodes pour calculer la puissance fichier puis.cpp:

#include <cmath>

fo

fodouble kn = 1;

foif ( n < 0 )

foelse

foreturn kn;

}

fichier prog1.cpp:

#include <iostream>

fo

fo main() {

fodouble a;

foint n;

focin >> a >> n;

}

−→ avec une telle initialisation, il n’est plus n ´ecessaire

−→ de sp ´ecifier methode dans l’appel de la fonction

(45)

Exemple: plusieurs m ´ethodes pour calculer la puissance fichier puis.cpp:

#include <cmath>

fo

fodouble kn = 1;

foif ( n < 0 )

foelse

foreturn kn;

}

fichier prog1.cpp:

#include <iostream>

fo

fo main() {

fodouble a;

foint n;

focin >> a >> n;

}

−→ utilisation de la m ´ethode k ⁿ = k × . . . × k

−→ (ou (k × . . . × k) ⁻¹ pour n < 0)

(46)

Exemple: plusieurs m ´ethodes pour calculer la puissance fichier puis.cpp:

#include <cmath>

fo

fodouble kn = 1;

foif ( n < 0 )

foelse

foreturn kn;

}

fichier prog1.cpp:

#include <iostream>

fo

fo main() {

fodouble a;

foint n;

focin >> a >> n;

}

−→ utilisation de la m ´ethode k ⁿ = k × . . . × k

−→ (ou (k × . . . × k) ⁻¹ pour n < 0)

(47)

Exemple: plusieurs m ´ethodes pour calculer la puissance fichier puis.cpp:

#include <cmath>

fo

fodouble kn = 1;

foif ( n < 0 )

foelse

foreturn kn;

}

fichier prog1.cpp:

#include <iostream>

fo

fo main() {

fodouble a;

foint n;

focin >> a >> n;

}

−→ utilisation de la m ´ethode k ⁿ = exp[n log(k)]

(48)

Exemple: plusieurs m ´ethodes pour calculer la puissance fichier puis.cpp:

#include <cmath>

fo

fodouble kn = 1;

foif ( n < 0 )

foelse

foreturn kn;

}

fichier prog1.cpp:

#include <iostream>

double puissance( double k = 2.0, int n, double puissance( int methode = 0 );

fo main() {

fodouble a;

foint n;

focin >> a >> n;

focout << puissance( a ) << endl;

}

−→ erreur: default argument missing for parameter 2 of

−→ 'double puissance(double, int, int)'

(52)

D éclaration d’une fonction avec des arguments pr é-initialis és:

htypei hnomi ( htype 1i hnom 1i , . . . , htype ni hnom ni , htypei hnomi ( htype i1i hnom i1i = hvaleur 1i , . . . , htypei hnomi ( htype iki hnom iki = hvaleur ki );

Possibilit ´es d’appel de cette fonction:

hnomi ( hexpr 1i , . . . , hexpr ni )

−→ la variable hnom i1i garde sa valeur hvaleur 1i

−→ la variable hnom i2i garde sa valeur hvaleur 2i

−→ . . .

−→ la variable hnom iki garde sa valeur hvaleur ki

(53)

D éclaration d’une fonction avec des arguments pr é-initialis és:

htypei hnomi ( htype 1i hnom 1i , . . . , htype ni hnom ni , htypei hnomi ( htype i1i hnom i1i = hvaleur 1i , . . . , htypei hnomi ( htype iki hnom iki = hvaleur ki );

Possibilit ´es d’appel de cette fonction:

hnomi ( hexpr 1i , . . . , hexpr ni , hexpr s1i )

−→ la variable hnom i1i prend la valeur de l’expression hexpr s1i

−→ la variable hnom i2i garde sa valeur hvaleur 2i

−→ . . .

−→ la variable hnom iki garde sa valeur hvaleur ki

(54)

D éclaration d’une fonction avec des arguments pr é-initialis és:

htypei hnomi ( htype 1i hnom 1i , . . . , htype ni hnom ni , htypei hnomi ( htype i1i hnom i1i = hvaleur 1i , . . . , htypei hnomi ( htype iki hnom iki = hvaleur ki );

Possibilit ´es d’appel de cette fonction:

hnomi ( hexpr 1i , . . . , hexpr ni , hexpr s1i , hexpr s2i )

−→ la variable hnom i1i prend la valeur de l’expression hexpr s1i

−→ la variable hnom i2i prend la valeur de l’expression hexpr s2i

−→ . . .

−→ la variable hnom iki garde sa valeur hvaleur ki

(55)

D éclaration d’une fonction avec des arguments pr é-initialis és:

htypei hnomi ( htype 1i hnom 1i , . . . , htype ni hnom ni , htypei hnomi ( htype i1i hnom i1i = hvaleur 1i , . . . , htypei hnomi ( htype iki hnom iki = hvaleur ki );

Possibilit ´es d’appel de cette fonction:

hnomi ( hexpr 1i , . . . , hexpr ni , hexpr s1i , . . . , hexpr ski )

−→ la variable hnom i1i prend la valeur de l’expression hexpr s1i

−→ la variable hnom i2i prend la valeur de l’expression hexpr s2i

−→ . . .

−→ la variable hnom iki prend la valeur de l’expression hexpr ski

(56)

le fichier prog1.cpp:

#include <iostream>

fo

fo main() {

fodouble a;

foint n;

focin >> a >> n;

}

le fichier puis.cpp:

double puissance( double k, int n ) {

fodouble kn = 1;

foif ( n < 0 )

foelse

foreturn kn;

}

c++ prog1.cpp puis.cpp -o prog1

cr ´ee l’ex ´ecutable prog1 contenant les fonctions

main et puissance(double, int)

(57)

le fichier prog1.cpp:

#include <iostream>

fo

int puissance( int k, unsigned int n );

fo main() {

fodouble a;

foint n;

focin >> a >> n;

focout << puissance( n, n ) << endl;

}

le fichier puis.cpp:

fodouble kn = 1;

foif ( n < 0 )

foelse

foreturn kn;

} fo

int puissance( int k, unsigned int n ) {

foint kn = 1;

foreturn kn;

}

(58)

le fichier prog2.cpp:

#include <iostream>

fo

void sort( int &a, int &b );

fo main() {

foint k, n;

focin >> k >> n;

fosort( k, n );

focout << puissance( k, n ) << endl;

}

le fichier sort.cpp:

void echange( int &a, int &b ) {

foint c = a;

foa = b;

fob = c;

} fo

void sort( int &a, int &b ) {

foif ( a < b ) fofoechange( a, b );

} fo

void sort( int &a, int &b, int &c ) {

fosort( a, b );

fosort( a, c );

fosort( b, c );

} fo

c++ prog2.cpp puis.cpp sort.cpp -o prog2

−→ output de k ⁿ si k > n, et de n ^k sinon

(59)

le fichier prog3.cpp:

#include <iostream>

fo

int factoriel( int n );

fo main() {

foint n, m;

focin >> n >> m;

fosort( n, m );

foint n m = factoriel( n ) foint n m/ factoriel( m ) foint n m/ factoriel( n - m );

focout << n m << endl;

}

le fichier fact.cpp:

int factoriel( int n ) {

foint nfac = 1;

fofor ( int i = 1; i <= n; i++ ) fofonfac *= i;

foreturn nfac;

}

c++ prog3.cpp sort.cpp fact.cpp -o prog3

−→ calcul de n

m

= n!

m!(n − m)!

(60)

le fichier prog3.cpp:

#include <iostream>

fo

int n sur m( int n, int m );

fo main() {

foint n, m;

focin >> n >> m;

fosort( n, m );

foint n m = n sur m( n, m );

}

le fichier fact.cpp:

foint nfac = 1;

foreturn nfac;

} fo

int n sur m( int n, int m ) {

foreturn ( factoriel( n ) / foreturn (factoriel ( m ) / foreturn (factoriel( n - m ) );

}

Comment éviter d’ écrire toujours les m êmes d éclarations dans des diff érents programmes ?

−→ utilisation des headers

(61)

le fichier prog3.cpp:

#include <iostream>

#include ''fact.h'' using namespace std;

fo

fo main() {

foint n, m;

focin >> n >> m;

fosort( n, m );

}

le fichier fact.cpp:

foint nfac = 1;

foreturn nfac;

} fo

}

le fichier fact.h:

−→ pour le compilateur, #include ''fact.h'' fait

−→ inclure le contenu de fact.h dans prog3.cpp

(62)

le fichier prog3.cpp:

#include <iostream>

#include ''fact.h'' using namespace std;

fo

fo main() {

foint n, m;

focin >> n >> m;

fosort( n, m );

}

le fichier fact.cpp:

foint nfac = 1;

foreturn nfac;

} fo

}

le fichier fact.h:

−→ fact.h contient l’interface des fonctions

−→ factoriel(int) et n sur m(int, int)

−→ fact.cpp contient leur impl ´ementation

(63)

le fichier prog3.cpp:

#include <iostream>

#include ''fact.h''

#include ''sort.h'' using namespace std;

fo fo main() {

foint n, m;

focin >> n >> m;

fosort( n, m );

}

le fichier sort.cpp:

foint c = a;

foa = b;

fob = c;

} fo

fosort( a, b );

fosort( a, c );

fosort( b, c );

} fo

le fichier sort.h:

void echange( int &a, int &b );

void sort( int &a, int &b, int &c );

(64)

le fichier prog2.cpp:

#include <iostream>

fo

fo main() {

foint k, n;

focin >> k >> n;

fosort( k, n );

}

le fichier sort.cpp:

foint c = a;

foa = b;

fob = c;

} fo

fosort( a, b );

fosort( a, c );

fosort( b, c );

} fo

le fichier sort.h:

(65)

le fichier prog2.cpp:

#include <iostream>

#include ''puis.h''

fo fo main() {

foint k, n;

focin >> k >> n;

fosort( k, n );

}

le fichier puis.cpp:

fodouble kn = 1;

foif ( n < 0 )

(67)

Des headers peuvent contenir

des d ´eclarations des fonctions

int factoriel( int n );

(68)

c++ -c hfichier.cppi -I hrepi

(74)

#include ...

repr ´esente une directive pour le compilateur qui lui demande `a inclure le fichier en question dans le programme actuel

Cette directive est trait ´ee par un pr ´eprocesseur

qui est (automatiquement) lanc ´e avant le “vrai” compilateur

(75)

le fichier prog3.cpp:

#include <iostream>

#include ''fact.h''

fo fo main() {

foint n, m;

focin >> n >> m;

fosort( n, m );

}

. . . “vu” par le compilateur apr `es le pr ´eprocesseur:

...

// le contenu de <iostream>

...

fo

fo main() {

foint n, m;

focin >> n >> m;

fosort( n, m );

}

(76)

#include ...

repr ´esente une directive pour le compilateur qui lui demande `a inclure le fichier en question dans le programme actuel

Cette directive est trait ´ee par un pr ´eprocesseur

qui est (automatiquement) lanc ´e avant le “vrai” compilateur D’autres directives du compilateur:

#define hnomi hexpressioni

permet de d ´efinir des constantes et des macros

#define pi 3.14159265359

−→ d ´efinition du macro pi qui sera remplac ´e par

−→ 3.14159265359 lors de la compilation

(77)

le fichier fermat2.cpp:

#include <iostream>

fo

#define carre(x) (x)*(x) fo

main() {

foint Nmax = 10;

fofor ( int k = 1; k <= Nmax; k++ ) fofor ( int l = 1; l <= Nmax; l++ ) fofor ( int m = 1; m <= Nmax; m++ ) fofoif ( carre( k ) + carre( l ) fofoif (== carre( m ) )

fofofocout << k << ''ˆ2+'' << l << ''ˆ2='' fofofocout<< m << ''ˆ2'' << endl;

}

. . . “vu” par le compilateur apr `es le pr ´eprocesseur:

#include <iostream>

fo fo main() {

foint Nmax = 10;

fofor ( int k = 1; k <= Nmax; k++ ) fofor ( int l = 1; l <= Nmax; l++ ) fofor ( int m = 1; m <= Nmax; m++ ) fofoif ( ( k ) * ( k ) + ( l ) * ( l ) fofoif (== ( m ) * ( m ) )

}

−→ n’utilisez pas de tels macros trop excessivement !

−→ en g én éral, il est pr éf érable de les remplacer

−→ par des “vraies” fonctions

(78)

le fichier fermat2.cpp:

#include <iostream>

fo

int carre( int x ) {

foreturn ( x * x );

} fo main() {

foint Nmax = 10;

fofor ( int k = 1; k <= Nmax; k++ ) fofor ( int l = 1; l <= Nmax; l++ ) fofor ( int m = 1; m <= Nmax; m++ ) fofoif ( carre( k ) + carre( l ) fofoif (== carre( m ) )

}

(79)

#include ...

repr ´esente une directive pour le compilateur qui lui demande `a inclure le fichier en question dans le programme actuel

Cette directive est trait ´ee par un pr ´eprocesseur

qui est (automatiquement) lanc ´e avant le “vrai” compilateur D’autres directives du compilateur:

#define hnomi hexpressioni

permet de d ´efinir des constantes et des macros

#if ..., #ifdef ..., #ifndef ..., #else, #endif:

−→ d ´efinition des branchements conditionnels

−→ pour le compilateur

(80)

Exemple:

calcul de la fonction Bessel J 0 (x) = 1 π

Z π

0 cos(ϕ − x sin ϕ)dϕ avec la fonction nag bessel j0(double)

de la biblioth `eque commerciale NAG (www.nag.co.uk)

. . . ou, si la derni `ere n’est pas disponible, avec la routine gsl sf bessel J0(double) de la biblioth `eque gratuite GSL

(GNU Scientific Library)

−→ interface (dans bessel.h):

double bessel( double x );

(81)

−→ impl ´ementation (dans bessel.cpp):

#ifdef NAG

#include <nag.h>

#else

#include <gsl sf bessel.h>

#endif fo

double bessel( double x ) {

#ifdef NAG

foreturn ( nag bessel j0( x ) );

#else

foreturn ( gsl sf bessel J0( x ) );

#endif }

(82)

−→ impl ´ementation (dans bessel.cpp):

#ifdef NAG

#include <nag.h>

#else

#endif fo

#ifdef NAG

#else

#endif }

code “vu” par le compilateur:

#include <nag.h>

fo

}

Compilation pour l’utilisation de la routine de NAG:

c++ -c bessel.cpp -D NAG

−→ l’option -D NAG d ´efinit l’expression NAG

−→ #ifdef NAG sera donc vrai

(83)

−→ impl ´ementation (dans bessel.cpp):

#ifdef NAG

#include <nag.h>

#else

#endif fo

#ifdef NAG

#else

#endif }

code “vu” par le compilateur:

fo

}

Compilation pour l’utilisation de la routine de GSL:

c++ -c bessel.cpp

−→ NAG n’est pas d ´efini

−→ #ifdef NAG sera donc faux

(84)

−→ impl ´ementation (dans bessel.cpp):

#ifdef NAG

#include <nag.h>

#else

#endif fo

#ifdef NAG

#else

#endif }

Compilation et linking avec la biblioth `eque de NAG:

c++ -c bessel.cpp -D NAG

c++ prog.cpp bessel.o -o prog -lnag

−→ l’option -lnag cr ´ee un lien avec le fichier libnag.a

−→ qui se trouve dans un des r ´epertoires standards

−→ (e.g. /usr/lib) pour des biblioth `eques

(85)

−→ impl ´ementation (dans bessel.cpp):

#ifdef NAG

#include <nag.h>

#else

#endif fo

#ifdef NAG

#else

#endif }