Fonctions inline
Remonter à Classes - Index
Vous pouvez déclarer des fonctions membres dans leur classe et les définir ailleurs. Vous pouvez aussi les déclarer et les définir dans leur classe : ces fonctions sont dites fonctions inline.
Le compilateur peut parfois réduire le temps d'appel d'une fonction en remplaçant l'appel directement par le code compilé du corps de la fonction. Ce processus, dit de développement inline d'un corps de fonction, n'affecte pas la portée du nom ni les arguments de la fonction. Les développements inline ne sont pas toujours réalisables. Le spécificateur inline indique au compilateur que vous souhaitez un développement inline.
Les demandes explicites et implicites inline sont plutôt réservées à des petites fonctions, fréquemment utilisées, comme, par exemple, les fonctions opérateur qui implémentent des opérateurs de surcharge. La déclaration de classe de func :
int i; // int global
class X {
public:
char* func(void) { return i; } // inline par défaut
char* i;
};
est l'équivalent de :
inline char* X::func(void) { return i; }
func est définie "hors" de la classe avec un spécificateur inline explicite. La valeur i renvoyée par func est le char* i
de la classe X (voir Portée des membres).
Fonctions inline et exceptions
Une fonction inline avec spécification d'exception ne sera jamais développée en ligne par le compilateur. Par exemple,
inline void f1() throw(int)
{
// Avertissement : Les fonctions avec spécification d'exception ne sont pas développées
}
Les restrictions restantes ne s'appliquent que lorsque l'élimination des destructeurs est activée.
Une fonction inline qui accepte au moins un paramètre du type "classe avec un destructeur" ne sera pas développée inline. Remarquez que cette restriction ne s'applique qu'aux classes transmises par référence.
Exemple :
struct foo {
foo();
~foo();
};
inline void f2(foo& x)
{
// pas d'avertissement, f2() peut être développé inline
}
inline void f3(foo x)
{
// Avertissement : Les fonctions acceptant le ou les arguments classe-par-valeur
// ne sont pas développées inline dans la fonction f3(foo)
}
Une fonction inline qui renvoie par valeur une classe contenant un destructeur ne sera pas développée inline chaque fois que des variables ou des objets temporaires devront être détruits dans l'expression renvoyée :
struct foo {
foo();
~foo();
};
inline foo f4()
{
return foo();
// pas d'avertissement, f4() peut être développée inline
}
inline foo f5()
{
foo X;
return foo(); // L'object X doit être détruit
// Avertissement : Les fonctions contenant les instructions
// renvoyées ne sont pas développées inline dans la fonction f5()
}
inline foo f6()
{
return ( foo(), foo() ); // provisoire dans la valeur renvoyée
// Avertissement : les fonctions contenant les instructions
// renvoyées ne sont pas développées inline dans la fonction f6()
}
Voir aussi
- inline
- #pragma inline
- Classes C++
- Types de classes
- Portée de classe
- Objets de classes
- Liste des membres de classe
- Fonctions membres
- Mot clé This
- Membres statiques (C++)
- Portée des membres
- Déclarations de types imbriqués
- Contrôle d'accès aux membres
- Accès aux classes de base et dérivées
- Classes de base virtuelles
- Amies de classes