petite question sur des contraintes de compilation

[invite397ab838]

Bonjour,
J'ai une question dans un exerice ou je seche totalement j'espère que vous pourrez m'aider:

On a un programme composé de 3 modules X.c Y.c et Z.c
X.c contient la fonction main mais aussi, utilise des fonctions des 2 autres modules(Y.c et Z.c) .
Z.c utilise elle aussi des fonctions du module Y.c

Quelles sont les contraintes de compiltation des modules ? Quelles sont les fichiers qui sont utile à l'édition(en GCC)

En espérant que vous pourriez m'apporter une lumière car la je ne voit vraiment vraimant pas, je vous remercie
-----

[invite397ab838]

Je parle de langage C au fait je précise

[invite1c6b0acc]

Bonjour,
en fait, il n'y a pas vraiment de contrainte de compilation, sauf qu'il est très fortement conseillé, même si ce n'est pas obligatoire, que les modules appelants connaissent les prototypes des fonctions qu'ils appellent.

Pour cela, le plus simple est de créer des fichiers Y.h et Z.h qui contiennent respectivement les prototypes des fonctions de Y.c et Z.c
Il faut alors inclure ces fichiers (avec #include) au début des sources qui utilisent les fonctions correspondantes : inclure Y.h dans X.c et dans Y.c ; inclure Z.h dans X.c, Y.c et Z.c

Tu remarqueras que je conseille d'inclure Y.h dans Y.c et Z.h dans Z.c : c'est pour que le compilateur puisse vérifier que les prototypes des fonctions sont bien conforme à leur déclaration.

A+

[invite895675d5]

Bonjour,
en fait, il n'y a pas vraiment de contrainte de compilation, sauf qu'il est très fortement conseillé, même si ce n'est pas obligatoire, que les modules appelants connaissent les prototypes des fonctions qu'ils appellent.
A+

Cela devient obligatoire si la fonction est utilisée avant d'être définie. Il y a donc bien une contrainte (en fait 2 mais elles sont exclusives) :
- soit tu définis les prototypes de tes fonctions dans un fichier d'entête (.h)
- soit tu compiles dans le bon ordre (quand c'est possible).

[A voir en vidéo sur Futura]

[invite1c6b0acc]

Non, je maintiens, ce n'est pas obligatoire (et l'ordre de compilation n'y change rien). Par contre ça peut générer des erreurs : en l'absence de prototype, le compilateur considère que toute fonction retourne un int, ce qui peut être faux, et il ne peut pas vérifier le nombre et le type des arguments. Si on donne de mauvais arguments, on obtient n'importe quoi, évidemment.


J'ai construit un petit exemple : ce sera plus clair.


D'abord sans prototype :
Y.c :

int division_arrondie (double a, double b)
    {
    return (int) (a/b + 0.5);
    }
double division_exacte (double a, double b)
    {
    return a/b;
    }

X.c :

#include <stdio.h>
int main ()
    {
    double a = 5;
    double b = 3;
    double resultat_exact;
    int resultat_arrondi;


    resultat_exact = division_exacte (a, b);
    resultat_arrondi = division_arrondie (a, b);


    printf ("resultat exact = %lf\n", resultat_exact);
    printf ("resultat arrondi = %d\n", resultat_arrondi);


    return 0;
    }

Compilation :

> gcc -Wall -o essai X.c Y.c
X.c: In function ‘main’:
X.c:9:2: attention : implicit declaration of function ‘division_exacte’ [-Wimplicit-function-declaration]
X.c:10:2: attention : implicit declaration of function ‘division_arrondie’ [-Wimplicit-function-declaration]

Exécution :

> essai
resultat exact = 2.000000
resultat arrondi = 2

Le résultat "exact" est faux !




La même chose en ajoutant les prototypes :
Y.h:

int division_arrondie (double a, double b);
double division_exacte (double a, double b);

Y.c :

#include "Y.h"
int division_arrondie (double a, double b)
    {
    return (int) (a/b + 0.5);
    }
double division_exacte (double a, double b)
    {
    return a/b;
    }

X.c :

#include <stdio.h>
#include "Y.h"
int main ()
    {
    double a = 5;
    double b = 3;
    double resultat_exact;
    int resultat_arrondi;


    resultat_exact = division_exacte (a, b);
    resultat_arrondi = division_arrondie (a, b);


    printf ("resultat exact = %lf\n", resultat_exact);
    printf ("resultat arrondi = %d\n", resultat_arrondi);


    return 0;
    }

Compilation :

> gcc -Wall -o essai X.c Y.c

Pas de warning

Exécution :

> essai
resultat exact = 1.666667
resultat arrondi = 2

Resultat correct


Explication : dans le premier exemple, en compilant X.c, le compilateur considère que la fonction "resultat_exact" retourne un int et ne prévoit que 4 octets pour stocker son résultat, alors qu'il en faut 8 pour stocker le vrai résultat de la fonction.


A noter que si je n'avais pas mis -Wall en option de compilation, il n'y aurais même pas eu de warning.