J'ai un problème pour utiliser les fonctions inline. Dans mon .h, j'ai
la classe Truc dont une des méthodes est celle-ci:
int foo();
Et dans mon .cpp, j'ai ça:
inline int Truc::foo()
Et dans mon main, j'ai ça :
Truc *tr = new Truc();
tr->foo();
Le problème, c'est que g++ me sort ça un undefined reference sur foo().
Si j'enlève le inline, ça marche. J'ai loupé un truc?
J'ai un problème pour utiliser les fonctions inline. Dans mon .h, j'ai la classe Truc dont une des méthodes est celle-ci:
int foo();
Et dans mon .cpp, j'ai ça: inline int Truc::foo() je dirais :
inline int Truc::foo(){}
AG, débutant C++.
Falk Tannhäuser
Pascal wrote:
J'ai un problème pour utiliser les fonctions inline. Dans mon .h, j'a i la classe Truc dont une des méthodes est celle-ci:
int foo();
Si tu veux que la fonction soit inline, il faut mettre sa définition (c.a.d. avec le corps de la fonction entre {}) *** dans le .h *** - soit dans la classe :
class Truc { int foo() { return 6*7; } };
soit en dehors de la classe mais précédée du mot clé inline :
class Truc { int foo(); };
inline int Truc::foo() { return 6*7; }
Falk
Pascal wrote:
J'ai un problème pour utiliser les fonctions inline. Dans mon .h, j'a i
la classe Truc dont une des méthodes est celle-ci:
int foo();
Si tu veux que la fonction soit inline, il faut mettre sa définition
(c.a.d. avec le corps de la fonction entre {}) *** dans le .h *** -
soit dans la classe :
class Truc
{
int foo() { return 6*7; }
};
soit en dehors de la classe mais précédée du mot clé inline :
J'ai un problème pour utiliser les fonctions inline. Dans mon .h, j'a i la classe Truc dont une des méthodes est celle-ci:
int foo();
Si tu veux que la fonction soit inline, il faut mettre sa définition (c.a.d. avec le corps de la fonction entre {}) *** dans le .h *** - soit dans la classe :
class Truc { int foo() { return 6*7; } };
soit en dehors de la classe mais précédée du mot clé inline :
class Truc { int foo(); };
inline int Truc::foo() { return 6*7; }
Falk
Pascal
On Wed, 23 Feb 2005 11:43:12 +0100, AG wrote:
inline int Truc::foo(){}
AG, débutant C++.
Euh les accolades étaient implicites, évidement que j'ai redéfini la fonction complètement.
On Wed, 23 Feb 2005 11:43:12 +0100, AG wrote:
inline int Truc::foo(){}
AG, débutant C++.
Euh les accolades étaient implicites, évidement que j'ai redéfini la
fonction complètement.
Euh les accolades étaient implicites, évidement que j'ai redéfini la fonction complètement.
Pascal
On Wed, 23 Feb 2005 13:52:26 +0100, Falk Tannhäuser wrote:
Si tu veux que la fonction soit inline, il faut mettre sa définition (c.a.d. avec le corps de la fonction entre {}) *** dans le .h *** - soit dans la classe :
class Truc { int foo() { return 6*7; } };
Déclaration implicite. Mais je préfère éviter.
soit en dehors de la classe mais précédée du mot clé inline :
class Truc { int foo(); };
inline int Truc::foo() { return 6*7; }
Ca compile parfaitement si je n'appelle pas foo. Dès que je l'utilise, ça me met undefined reference.
On Wed, 23 Feb 2005 13:52:26 +0100, Falk Tannhäuser wrote:
Si tu veux que la fonction soit inline, il faut mettre sa définition
(c.a.d. avec le corps de la fonction entre {}) *** dans le .h *** -
soit dans la classe :
class Truc
{
int foo() { return 6*7; }
};
Déclaration implicite. Mais je préfère éviter.
soit en dehors de la classe mais précédée du mot clé inline :
class Truc
{
int foo();
};
inline int Truc::foo() { return 6*7; }
Ca compile parfaitement si je n'appelle pas foo. Dès que je l'utilise, ça
me met undefined reference.
On Wed, 23 Feb 2005 13:52:26 +0100, Falk Tannhäuser wrote:
Si tu veux que la fonction soit inline, il faut mettre sa définition (c.a.d. avec le corps de la fonction entre {}) *** dans le .h *** - soit dans la classe :
class Truc { int foo() { return 6*7; } };
Déclaration implicite. Mais je préfère éviter.
soit en dehors de la classe mais précédée du mot clé inline :
class Truc { int foo(); };
inline int Truc::foo() { return 6*7; }
Ca compile parfaitement si je n'appelle pas foo. Dès que je l'utilise, ça me met undefined reference.
Falk Tannhäuser
Pascal wrote:
On Wed, 23 Feb 2005 13:52:26 +0100, Falk Tannhäuser wrote:
class Truc { int foo() { return 6*7; } };
Déclaration implicite. Mais je préfère éviter.
C'est une *définition* (chaque définition est aussi une déclaration , mais pas l'inverse) qui est implicitement "inline".
soit en dehors de la classe mais précédée du mot clé inline :
class Truc { int foo(); };
inline int Truc::foo() { return 6*7; }
Ca compile parfaitement si je n'appelle pas foo. Dès que je l'utilise , ça me met undefined reference.
Même si la définition inline se trouve dans le fichier .h où est définie la classe Truc (et non pas dans un fichier .cpp, sinon il est normal que tu aies une "undefined reference" si tu appelles cette fonction depuis un autre fichier .cpp) ? Au fait, il faut que la définition (est non seulement la déclaration) soit visible pendant la compilation, pour que le compilateur puisse mettre la fonction en inline (sauf si le compilateur est assez sophistiqué pour faire de l'optimisation entre modules - mais les compilateurs capables de faire cela ne sont pas encore légion à ma connaissance).
Falk
Pascal wrote:
On Wed, 23 Feb 2005 13:52:26 +0100, Falk Tannhäuser wrote:
class Truc
{
int foo() { return 6*7; }
};
Déclaration implicite. Mais je préfère éviter.
C'est une *définition* (chaque définition est aussi une déclaration ,
mais pas l'inverse) qui est implicitement "inline".
soit en dehors de la classe mais précédée du mot clé inline :
class Truc
{
int foo();
};
inline int Truc::foo() { return 6*7; }
Ca compile parfaitement si je n'appelle pas foo. Dès que je l'utilise , ça
me met undefined reference.
Même si la définition inline se trouve dans le fichier .h où est
définie la classe Truc (et non pas dans un fichier .cpp, sinon il
est normal que tu aies une "undefined reference" si tu appelles
cette fonction depuis un autre fichier .cpp) ?
Au fait, il faut que la définition (est non seulement la déclaration)
soit visible pendant la compilation, pour que le compilateur puisse
mettre la fonction en inline (sauf si le compilateur est assez
sophistiqué pour faire de l'optimisation entre modules - mais
les compilateurs capables de faire cela ne sont pas encore légion
à ma connaissance).
On Wed, 23 Feb 2005 13:52:26 +0100, Falk Tannhäuser wrote:
class Truc { int foo() { return 6*7; } };
Déclaration implicite. Mais je préfère éviter.
C'est une *définition* (chaque définition est aussi une déclaration , mais pas l'inverse) qui est implicitement "inline".
soit en dehors de la classe mais précédée du mot clé inline :
class Truc { int foo(); };
inline int Truc::foo() { return 6*7; }
Ca compile parfaitement si je n'appelle pas foo. Dès que je l'utilise , ça me met undefined reference.
Même si la définition inline se trouve dans le fichier .h où est définie la classe Truc (et non pas dans un fichier .cpp, sinon il est normal que tu aies une "undefined reference" si tu appelles cette fonction depuis un autre fichier .cpp) ? Au fait, il faut que la définition (est non seulement la déclaration) soit visible pendant la compilation, pour que le compilateur puisse mettre la fonction en inline (sauf si le compilateur est assez sophistiqué pour faire de l'optimisation entre modules - mais les compilateurs capables de faire cela ne sont pas encore légion à ma connaissance).
Falk
AG
Pascal wrote:
On Wed, 23 Feb 2005 11:43:12 +0100, AG wrote:
inline int Truc::foo(){} inline int Truc::foo(){return 0;}
AG, débutant C++.
Euh les accolades étaient implicites, évidement que j'ai redéfini la fonction complètement.
RE-défini ? les fonctions inline n'ont pas besoin de déclaration (sous forme de prototype) puisqu'elles sont justement "inline". Elles sont définies une seule fois, à l'endroit du "inline", et comme le dit M.Tannhäuser, dans le .h . Il n'y a pas de re-définition je pense.
Pascal wrote:
On Wed, 23 Feb 2005 11:43:12 +0100, AG wrote:
inline int Truc::foo(){}
inline int Truc::foo(){return 0;}
AG, débutant C++.
Euh les accolades étaient implicites, évidement que j'ai redéfini la
fonction complètement.
RE-défini ? les fonctions inline n'ont pas besoin de déclaration (sous
forme de prototype) puisqu'elles sont justement "inline". Elles sont
définies une seule fois, à l'endroit du "inline", et comme le dit
M.Tannhäuser, dans le .h . Il n'y a pas de re-définition je pense.
inline int Truc::foo(){} inline int Truc::foo(){return 0;}
AG, débutant C++.
Euh les accolades étaient implicites, évidement que j'ai redéfini la fonction complètement.
RE-défini ? les fonctions inline n'ont pas besoin de déclaration (sous forme de prototype) puisqu'elles sont justement "inline". Elles sont définies une seule fois, à l'endroit du "inline", et comme le dit M.Tannhäuser, dans le .h . Il n'y a pas de re-définition je pense.
Pascal
AG wrote:
RE-défini ? les fonctions inline n'ont pas besoin de déclaration (sous forme de prototype) puisqu'elles sont justement "inline". Elles sont définies une seule fois, à l'endroit du "inline", et comme le dit M.Tannhäuser, dans le .h . Il n'y a pas de re-définition je pense.
Bon problème de vocabulaire. Oui je l'ai défini une fois, mais dans le .cpp. Apparament, faut le mettre en bas de la classe, dans le .h. Merci. -- Pascal
AG wrote:
RE-défini ? les fonctions inline n'ont pas besoin de déclaration (sous
forme de prototype) puisqu'elles sont justement "inline". Elles sont
définies une seule fois, à l'endroit du "inline", et comme le dit
M.Tannhäuser, dans le .h . Il n'y a pas de re-définition je pense.
Bon problème de vocabulaire. Oui je l'ai défini une fois, mais dans le
.cpp. Apparament, faut le mettre en bas de la classe, dans le .h. Merci.
--
Pascal
RE-défini ? les fonctions inline n'ont pas besoin de déclaration (sous forme de prototype) puisqu'elles sont justement "inline". Elles sont définies une seule fois, à l'endroit du "inline", et comme le dit M.Tannhäuser, dans le .h . Il n'y a pas de re-définition je pense.
Bon problème de vocabulaire. Oui je l'ai défini une fois, mais dans le .cpp. Apparament, faut le mettre en bas de la classe, dans le .h. Merci. -- Pascal
