Fonctions inline

De Appmethod Topics
Aller à : navigation, rechercher

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.

Remarque :  Le compilateur peut ignorer les demandes de 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.

Remarque :  Les destructeurs sont appelés par défaut. Voir Initialisation des options de gestion des exceptions pour de plus amples informations sur les options de gestion des exceptions.

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