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