Je me souviens que quelqu´un avais posé une question quand à l´efficacité du mot cle register.
Moi je me pose la question sur inline.
Dans tout ce que j´ai lu, les auteurs restent toujours dans le vague, explicant que le compilateur ne met en ligne que les petites fonctions.
Mais, c´est quoi une petite fonction ? ??

. ..

Je profite du post pour annoncer à ceux qui le savent pas la sortie de ZDaemon qui permet de jouer à Doom ( 1, 2 ) sur le net facilement puisqu´il trouve automatiquement les serveurs en cours et permet de s´y connecter ( comme return to castle wolf, pour ceux qui connaissent ) .
Si vous avez envie de vous faire une petite partie sur une de ces antiquité ( en coopération, ultra violence ) ce soir ou plus tard, faite moi signe

inline, disons que je V te le faire version chanson :
Imagine que tu veilles afficher les paroles d´une chanson, ou le refrain revient souvent :
Tu vas faire une fonction Refrain et tu vas faire ceci :

void Refrain()
{
printf("refrain 1er phrase\n");
printf("refrain 2e phrase\n");
printf("refrain 3e phrase\n");
. ..
}

void main()
{
printf("blablabla\n");
Refrain();
printf("blablabla\n");
Refrain();
printf("blablabla\n");
Refrain();
printf("blablabla\n");
}

tu vois déja l´intéret de la fonction Refrain ici, non ?

Bon, quand le prog va éxécuter, il va écrire les blabla, puis appeler la fonction refrain : appeler une fonction est un truc qui prend un peu de temps ( tres tres peu, mais un chouia : le temps de la trouver, d´empiler certains trucs, mais ça oublie, dis toi juste que ça prend un chouia de temps)

maintenant considère le meme programme avec :

inline void Refrain()

au lieu de

void Refrain()

Ce qui va se passer, c´est que AVANT la compilation, le compilateur va transformer ton programme en :

void main()
{
printf("blablabla\n");
printf("refrain 1er phrase\n");
printf("refrain 2e phrase\n");
printf("refrain 3e phrase\n");
. ..
printf("blablabla\n");
printf("refrain 1er phrase\n");
printf("refrain 2e phrase\n");
printf("refrain 3e phrase\n");
. ..
printf("blablabla\n");
printf("refrain 1er phrase\n");
printf("refrain 2e phrase\n");
printf("refrain 3e phrase\n");
. ..
printf("blablabla\n");
}

Résultat : PAS d´appel de fonction, c´est un chouia plus rapide donc ! !
par contre, le programme est beaucoup plus gros ! !

A toi de choisir...

Dis toi que inline est necessaire que dans des cas EXTREMES, tu ne devrais pas t´en servir, sauf si tu as une fonction dans une boucle avec plusieurs milliers, voir millions d´appels par seconde, sinon, ça ne vaut pas le coup.

Perso, je n´ai encore jamais eu le réel besoin d´utiliser inline...

Arf je suis sur que tu t´en es déjà servi sans t´en rendre compte

class machin
{
int bidule;

machin()
{
bidule=0;
}

void chouette()
{
bidule++;
}

};

etc..

ca t´es jamais arrivé d´écrire le corps d´une méthode directement dans la décl. d´une classe? ( bah ces méthodes là sont par défaut inline)

ah oui, en effet j´avais oublié ce cas la !

je parlais que je ne m´étais pas trop servi explicitement du mot inline

Je pense qu´il sait ce qu´est inline, déjà...

Ensuite, pour ce qui est de la taille des fonctions automatiquement inlinés, ça dépend de ton compilateur. Mais il est vrai que c´est écrit dans la norme, le compilateur a le droit d´inliner certaines petites fonctions. Quand à savoir lequelles...

Ah, et au niveau vitesse:
-on évite les mécanismes de passages de paramètres sur la pile.

Et j´imagine que un compilateur intelligent remplacerait un paramètre par une constante dans un registre. Ex:

void inline mafonction(int a)
{
machin = a;
truc = a+2;
bidule = a+7;
}

mafonction(1);

En inlinant:

; Code normal
; appel de mafonction(1) *inline*
mov eax, 1
mov machin, eax
add eax, 2
mov truc, eax
add eax, 3
mov bidule, eax

Ce qui est, bien sur, bien plus rapide que de constament déréférencer de la pile avec des [ebp+8] . ..

Et bien, c´est tout ce que j´ai à dire là dessus je pense...

Kelios
---------

Woops, c´est bien sur add eax+4, pas add eax+3! Toutes mes excuses...

Kelios
---------

Merci mais j´ai déjà parfaitement compris le fonctionnement de inline ( y compris le fait que les fonctions définies dans la classes sont automatiquement mises en ligne ) .

Ce que je demande c´est : quand est ce que le compilateur choisis de mettre la fonction inline ( quand celle ci est déclarée telle quelle ) ?
Dans les cours que j´ai lu, il est écrit que le compilateur ne mettra en ligne que les petites fonctions et qu´il ignorera inline pour les grosses fonctions.
Mais alors qu´appellent ils une " petite fonction" ? ??

Oups, je t´ai pas lu Kelios

Fonctions qui, pour le compilo, semblent intéressante d´un point de vue optimisation en les remplacant par le code plutôt qu´un appel . ..
soit en clair des " petites" fonctions de quelques lignes en général, sans boucles etc...

En gros si le temps perdu par un appel de fonction et le passage des paramètres est plus important que le contenu de cette fonction je pense qu´elle sera remplacée par son contenu avec une certaine marge qui là dépend du compilo . ..