Prototype de fonction inline

Bonjour,

Voilà, je me posais une petite question sur l'utilité d'un prototype d'une fonction inline.

J'ai lu dans la FAQ que la fonction inline doit etre définie dans le .h. Elle est ensuite appelée dans les fichiers .cpp dans lesquels on en a besoin.
Mais le prototype, est-il utile?

Pour une fonction "classique", je voyais l'utilité de mettre le prototype de la fonction dans le .h: On indiquait au compilateur que quelque part dans le code, on va peut etre rencontré une fonction "toto", mais pas de panique, elle sera définie quelque part.

Mais là, on a directement la définition de la fonction inline dans le .h. Quel interet de mettre alors un prototype...?

PS: J'ai fait le test: sans prototype, j'obtiens une erreur à l'édition de lien...

Bonjour,

Sans code, cela est difficile de voir ce qu'il ne va pas.

Lorsque tu définis une fonction, tu (re)déclare aussi son prototype.
Pour une fonction inline, on mettra dans le .h :

Code:

---

1 2 3 4

inline void foo(void) { //fait ce que tu veux }

---

Salut,

En fait, il faut surtout voir de quoi l'on parle car il est possible d'avoir des fonctions libres et des foncions membres.

Et comme il est tout aussi possible d'appeler des fonctions membre depuis une fonction libre et d'appeler une fonction libre depuis une fonction membre, et que, de plus, il est possible de déporter la définition de fonctions membre en dehors de la classe ou de la structure à laquelle elles appartiennent, ca fait pas mal de possibilités (que je vais essayer de parcourir avec toi ;))

Pour une fonction libre inline, tu peux en effet fournir directement son implémentation, sauf si tu as une autre définition de fonction qui apparait AVANT ta fonction et qui l'utilise.

A ce moment là, il y a lieu de réfléchir un tout petit peu :P

En effet, le compilateur parcoure le code source exactement de la manière dont tu lis un livre et, tout comme tu ne sais pas dire ce qui se passe à la page 11 quand tu es à la page 10, le compilateur ne connait à la ligne 10 que... ce qu'il a déjà rencontré.

Mettons que tu aies deux fonctions inline : foo et bar, et que bar doive faire appel à foo.

Le compilateur sera content s'il a rencontré foo avant de rencontrer son appel dans bar, et donc avec un code proche de

Code:

---

1 2 3 4 5 6

/* inline */ void foo(){ /*...*/ } /* inline */ void bar(){ foo(); }

---

alors qu'il t'enverra sur les roses avec le code suivant (si tu n'as pas déclaré le prototype de foo)

Code:

---

1 2 3 4 5 6 7

/* inline */ void bar(){ foo(); } /* inline */ void foo(){ /*...*/ }

---

Le fait que la fonction soit inlinée ou non ne change strictement rien ;)

Et si foo fait appel à bar et que bar fait appel à foo (c'est alors un certain type de récursivité :D), il est clair que tu n'auras pas le choix : il faudra fatalement fournir le prototype de la deuxième fonction avant d'essayer de donner l'implémentation de la première, et ce, que ta (tes) fonctions soi(ent) déclarée(s) inline ou non.

Dans le cas où tu as une fonction membre, il faut savoir que:

1. toute fonction définie directement dans le corps de la classe ou de la structure est implicitement déclarée inline
2. le compilateur analyse l'ensemble de la composition de la classe ou de la structure avant de regarder à l'implémentation des fonctions, ce qui facilite un peu les chose

Ainsi, les fonctions foo et bar sont implicitement déclarées inline dans la classe suivante

Code:

---

1 2 3 4 5

class MaClasse{ public: void foo(){/* ... */} void bar(){/* ... */} };

---

Mais, comme elles sont membres de la même classe ne se plaindra pas si foo appelle bar et / ou si bar appelle foo.

Par contre, si tu veux déporter les fonctions foo et bar sous une forme proche de

Code:

---

1 2 3 4 5 6 7 8 9 10 11

class MaClasse{ public: void foo(); void bar(); }; void MaClasse::foo(){ /* ... */ } void MaClasse::bar(){ /* ... */ }

---

et que tu veux qu'elles soient inlinées, il faudra

1. fournir leur prototype dans MaClasse
2. les déclarer explicitement inline

Encore une fois, le fait que l'une fasse éventuellement appel à l'autre n'aura pas d'incidence ;)

Enfin, il reste le problème (par chance fort similaire) d'une fonction libre qui fait appel à une fonction membre et vice versa.

Et là, on en revient toujours au même point : le compilateur ne connait que ce qu'il a déjà rencontré dans les lignes précédentes :aie:

Si tu veux qu'une fonction libre fasse appel à une fonction membre, il faut... que le compilateur ait déjà rencontré la définition complete de la classe ou de la structure dont la fonction membre est issue.

Le simple fait d'avoir une déclaration anticipée ne suffit alors plus.

De même, si tu veux appeler une fonction libre depuis une fonction membre, il faudra que le compilateur ait, au minimum, déjà rencontré le prototype de la fonction libre lorsqu'elle sera appelée dans la fonction membre.

Ainsi, le compilateur t'enverra sur les roses s'il rencontre un code proche de

Code:

---

1 2 3 4 5 6 7

class MaClasse{ public: void foo(){bar();} // implicitement inline }; inline void bar(){ /*...*/ }

---

tout comme il t'enverra sur les roses s'il rencontre un code proche de

Code:

---

1 2 3 4 5 6 7 8 9

class MaClasse; // seul moyen pour que le prototype de foo passe, et encore, // sous conditions inline void bar(MaClasse /* const */ & obj){ obj.foo(); } class MaClasse{ public: void foo(){/*...*/} // implicitement inline };

---

Et bien sur, si foo appelle bar et que bar appelle foo, tu n'es pas sorti de l'auberge :D

Enfin, si tu déportes l'implémentation de foo, il faudra encore réfléchir à l'ordre dans lequel tu définis foo et bar, car le compilateur refusera un code proche de

Code:

---

1 2 3 4 5 6 7 8 9 10

class MaClasse{ public: inline foo(); // explicitement inline } void MaClasse::foo(){ bar(); // KO : le compilateur ne connait pas encore bar } void bar(MaClasse /* const &*/ obj){ obj.foo(); //OK le compilateur connait MaClasse::foo() }

---

alors qu'il acceptera un code proche de

Code:

---

1 2 3 4 5 6 7 8 9 10

class MaClasse{ public: inline foo(); // explicitement inline } void bar(MaClasse /* const &*/ obj){ obj.foo(); //OK le compilateur connait MaClasse::foo() } void MaClasse::foo(){ bar(); // OK : le compilateur connait bar() }

---

Bref...

Tout cela pour dire que tu peux, effectivement, envisager de ne pas fournir de prototype seul sur les fonctions inline, mais qu'il faudra alors être particulièrement attentif à l'ordre dans lequel tu les écrit, surtout si l'une d'elle doit faire appel à une autre ;)

Bonjour à vous deux et merci de vous attarder sur mon problème.

Je pense que j'avais relativement bien compris ce que tu expliques Koala. Mais je n'arrive pas à comprendre ce qui se passe dans mon cas...

Tu as raison Neckara, je vais mettre un peu de code pour expliquer mon problème. Je pensais que ma question était relativement générale pour ne pas avoir besoin de s'attarder sur mon cas, mais visiblement non ;)

Je vous propose donc deux fichiers: toto.cpp et toto.h

toto.h contient plusieurs choses, dont la définition de la fonction inline qui m'intéresse:

Code:

---

1 2 3 4 5 6 7 8 9

// patati patata   inline double carre(double a, double b) { return a*a+b*b; // J'ai écris n'importe quoi ici }   // patati patata

---

toto.cpp contient lui plusieurs définition de fonction dont une en particulier

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

// patati patata   void Truc(...) { double carre(double a, double b); //qui ressemble à un prototype (mais sans "inline") double h,f,g; // patati patata h=carre(f,g); // patati patata   }   // patati patata

---

Avec ce code, ça ne fonctionne pas (ni même lorsque je rajoute "inline" dans le prototype de la fonction): "undefined reference to carre".

Pour tester, j'ai simplement déplacé le prototype de ma fonction (en ajoutant le mot clé inline cette fois) juste au dessus de la définition de ma fonction inline dans le .h et non plus dans le .cpp comme c'était le cas avant.

toto.h devient alors:

Code:

---

1 2 3 4 5 6 7 8 9 10

// patati patata   inline double carre(double a, double b); inline double carre(double a, double b) { return a*a+b*b; // J'ai écris n'importe quoi ici }   // patati patata

---

Et là suprise, ça fonctionne...
Je ne comprend pas pourquoi. Autant je comprend l'utilité d'un prototype quand il est possible que le compilateur rencontre l'appel à une fonction avant la déclaration de cette fonction.
Mais avec les fonction inline, la déclaration est dans le .h. Quoiqu'il arrive, il va donc rencontrer la déclaration avant l'appel (dans mon cas en tout cas) et je ne vois donc pas l'utilité de lui rajouter le prototype...

Citation:

---

Envoyé par Josiane22

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

// patati patata   void Truc(...) { double carre(double a, double b); //qui ressemble à un prototype (mais sans "inline") double h,f,g; // patati patata h=carre(f,g); // patati patata   }   // patati patata

---

---

Attention, ce code là ne fait absolument pas ce que tu crois!!!

Il déclare une fonction nommée carre qui prend deux double comme paramètres et renvoyant un double...

Si tu veux appeler ta fonction, il faut... déclarer une variable qui sera initialisée avec le retour de la fonction sous la forme de

Code:

---

1 2 3 4 5 6

// patati patata   void Truc(...) { double x/* ou truc, ou meme carre */ =carre(double a, double b); //qui ressemble à un prototype (mais sans "inline")

---

Désolé mais je ne comprends pas ce que tu veux me dire...

Code:

---

h=carre(f,g);

---

est bien remplacé par ce qu'il y a dans ma fonction inline non? Donc h vaut bien ensuite f*f+g*g?

Pour ce qui est de la ligne

Code:

---

double carre(double a, double b);

---

, on est d'accord que ce n'est que le prototype de la fonction inline non?

PS: Je précise que le problème que j'ai c'est lorsque je compile en mode DEBUG. Avec une compilation "normale", tout se passe bien...
De plus, le problème survient à l'édition de lien.

dans le main, le carré est une déclaration de fonction, pas un appel de variable.

h=carre(f,g) est l'appel de cette fonction déclarée… avec tous les écueils possibles et imaginables

Petite coquille: il ne faut pas lire :

Code:

---

double carre(double a, double b);

---

dans le .cpp mais:

Code:

---

double carre(double, double);

---

Je ne sais pas si ca change quelque chose...

Quoiqu'il en soit, quel rapport avec la définition de ma fonction inline dans le .h?

Vous etes en train de me dire que le double carre(double, double); de mon .cpp, c'est la déclaration d'une autre fonction que ma fonction carré du .h??? C'est pas tout bêtement le prototype? (en supprimant cette ligne et en mettant le prototype dans le .h, ca fonctionne!!..?)

Je double post pour redonner le bon programme et poser une seule question à la fois. Ca sera plus simple comme ça (j'avoue que je commence à me perdre...)

toto.h contient plusieurs choses, dont la définition de la fonction inline qui m'intéresse:

Code:

---

1 2 3 4 5 6 7

// patati patata   inline double carre(double a, double b) { return a*a+b*b; // J'ai écris n'importe quoi ici }

---

toto.cpp contient lui plusieurs définition de fonction dont une en particulier

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

#include'toto.h' // patati patata   void Truc(...) { double carre(double , double); double h,f,g; // patati patata h=carre(f,g); //LigneXXX // patati patata   }

---

Pourquoi lorsque je compile en mode DEBUG, j'obtiens à l'édition de lien l'erreur suivante:
Ligne XXX: undefined reference to carre?

Ce qu'il faut comprendre, c'est que le compilateur fonctionne "par niveaux":
chaque fois qu'il rencontre une accolade ouvrante, il ouvre un "niveau supérieur".

La définition de ta fonction carre qui se trouve dans le fichier d'en-tête est "hors de toutes portée" (elle n'est pas comprise entre une paire d'accolades), elle est donc de "niveau 0"

Par contre, dans toto.cpp, tu fournis ce qui sera considéré comme une déclaration de fonction (ca en suit la syntaxe, et le compilateur est un brave petit soldat qui ne peut faire que ce qu'on lui dit!!!)

Seulement, comme cette déclaration de fonction se trouve dans la définition d'une autre fonction, elle se fait dans "le niveau 1", et elle n'a rien à voir avec la définition qui se trouve au niveau 0

Pour lui, ce sont purement et simplement deux fonctions différentes la première est déclarée et définie, la seconde est uniquement déclarée.

Lorsque l'éditeur de liens arrive, il trouve une fonction inline dont le code a éventuellement été copié lors des différents appels, mais il trouve aussi une fonction non inline (la deuxième, celle qui est déclarée dans ta fonction) pour laquelle il ne trouve pas de code binaire correspondant, et c'est normal: elle n'est pas définie.

Et comme l'éditeur de liens est lui aussi un brave petit soldat qui ne sait faire que ce qu'on lui dit de faire, s'il se trouve dans une situation dans laquelle il ne sait pas faire ce qu'on lui a dit de faire, il "perd les pédales" et arrête de travailler (ce qui, en soi, est encore la meilleure de solutions à prendre).

La notion de prototype n'a strictement rien à voir dans l'histoire, c'est plutôt la notion de "mangling" (la manière qu'ont le compilateur et l'éditeur de liens de s'assurer que deux identifiants se trouvant dans des niveau différents seront identifiés de manière unique).

En cela, ils suivent exactement le même principe que celui qui fait que dans le code suivant

Code:

---

1 2 3 4 5 6 7 8 9 10 11

void foo(){ int a; if(test){ int a; /* ... */ for(/*...*/){ int a; /* ... */ } } }

---

la variable a qui se trouve en ligne 2 est totalement différente de celle qui se trouve en ligne 4 ET de celle qui se trouve en ligne 7...

La seule différence entre les deux situations, c'est que le compilateur est capable de constater qu'une variable est "cachée" par une autre de niveau supérieur, alors qu'il est dans l'impossibilité de remarquer q'une fonction n'est pas définie dans un niveau donné (car c'est le role de l'éditeur de liens que de s'amuser avec le code binaire).

Ca te parait un peu plus clair, maintenant :question:

C'est effectivement un peu plus clair (notamment grâce au parallèle que tu donne avec les boucles for ;) )

Comment puis-je donc faire pour que, lorsque je parcours ma fonction Truc, et donc que je fais des appels à ma fonction carre, il reconnaisse qu'il s'agit de la fonction inline définie dans le .h?

Déjà, est-ce possible? J'imagine que oui. Typiquement, lorsque je fais:

Code:

---

1 2 3 4 5 6 7

void titi(){....} void trucmuche() { int a h=titi(); }

---

titi est déclarer au niveau 0 comme tu dis et pourtant utilisée au niveau 1 sans que celà ne pose de problème...

Ben, tu n'as qu'à l'appeler, et non la déclarer...

Mais cela se fait sous la forme de

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

int toto(){ double x = 5.0; double y = 3.14;   carre(x,y); / ca, ca ne sert pas à grand chose, car tu ne récupère pas le résultat ;)   /*OU OU OU */ double z = carre(x,y);     /*OU OU OU */ double w; /*...*/ w = carre(x, y); }

---

Chaque fois que tu vois le terme carre dans le code ici, c'est l'appel de la fonction ;)

Tu veux dire qu'au lieu de mettre:

Code:

---

1 2 3 4 5 6 7 8 9 10

#include'toto.h'   void Truc(...) { double carre(double , double); double h,f,g;   h=carre(f,g); //LigneXXX   }

---

Je dois faire:

Code:

---

1 2 3 4 5 6 7 8 9

#include'toto.h'   void Truc(...) { double h,f,g;   h=carre(f,g); //LigneXXX   }

---

Tout simplement?

Mais oui, c'est ce que l'on essaye de t'expliquer depuis le début...

A partir du moment où le préprocesseur est passé par là pour remplacer la ligne 1 de toto.cpp par le contenu de toto.h, et où le compilateur se trouve à ce qui était avant à la ligne 2 de toto.cpp, il connait la fonction carré, et il n'y a plus aucune raison de lui rappeler qu'elle existe, et surtout pas à l'intérieur d'une fonction ;)

[EDIT]C'est au niveau de l'appel (donc au niveau de la ligne h=carre(f,g);que le compilateur se dira

Citation:

---

Envoyé par le compilateur

tiens, mais on m'a demander de remplacer l'appel de cette fonction par le code qu'elle contient, et, justement, les conditions pour accepter de le faire sont réunies, je vais donc faire ce qu'il m'a demandé ;)

---

je pêche peut etre par anthropomorphisme, mais ca te permet de comprendre l'idée ;)[/EDIT]

Effectivement, ça fonctionne...

En fait, ma fonction Truc appelle la fonction carre (niveau 1 donc) et regarde si quelque part au niveau 1 cette fonction est déclarée. Si c'est le cas (comme j'avais fais au début), elle prend cette fonction (qui chez moi était déclarée et non définie, d'où le soucis...). Si ce n'est pas le cas (comme avec ma correction), elle regarde au niveau 0 si jamais cette fonction est définie, ce qui est le cas (c'est ma fonction inline) et donc ça fonctionne.

C'est bien ça?

Citation:

---

Envoyé par Josiane22

Effectivement, ça fonctionne...

En fait, ma fonction Truc appelle la fonction carre (niveau 1 donc) et regarde si quelque part au niveau 1 cette fonction est déclarée. Si c'est le cas (comme j'avais fais au début), elle prend cette fonction (qui chez moi était déclarée et non définie, d'où le soucis...). Si ce n'est pas le cas (comme avec ma correction), elle regarde au niveau 0 si jamais cette fonction est définie, ce qui est le cas (c'est ma fonction inline) et donc ça fonctionne.

C'est bien ça?

---

Pour ce qui est du principe, on peut dire que ce sont les grandes lignes ;)

Et bien je te remercie beaucoup de ta patience Koala...
Grâce à toi, mon week-end ne sera pas gaché (et tu n'imagines pas l'épine que tu m'enlève du pied en me permettant de résoudre mon soucis dès ce soir ;) )

Encore merci et peut-être à bientôt sur le forum.

Sujet Résolu