pourquoi mettre en inline une fonction get.. ?

Est ce utile ?

Si ton accesseur ne fait que renvoyer une variable membre, c'est un peu bête de payer un appel de fonction si la performance est importante. Donc il est fréquent qu'on inline les accesseurs, oui.
Mais peut-être aussi que tu n'en as pas besoin, dans ce cas mieux vaut éviter de polluer la définition de ta classe avec des corps de fonction.

Salut,

Pour notre malheur à tous, la réponse que tu attends va prendre une forme de "réponse de normand" :P

En effet, toute l'utilité de déclarer une fonction inline dépendra... exclusivement du contexte.

Il faut, en effet, pour pouvoir comprendre la réponse, déjà savoir ce qui se passe quand tu décide de créer une fonction inline... et, pour bien faire, ce qui se passe quand tu crées une fonction dont tu ne demandes pas qu'elle soit inline.

Tu le sais sans doute, quand tu crées une fonction qui n'est pas inlinée, le processeur va mettre un certain nombre d'information "sur sa pile" avant d'appeler la fonction que tu as demandée, exécuteras les instructions demandées par la fonction, puis, une fois que la fonction est finie, retournera à l'adresse mémoire qui suit l'appel de la fonction, récupérera les données qu'il avait mis en pile, et continuera son exécution (l'explication n'est pas complete, mais au moins elle donne une bonne idée de ce qui se passe ;))

Evidemment, le fait de "sauvegarder" les données pour un usage ultérieur, de sauter à l'adresse mémoire à laquellle se trouve la fonction, puis de re-sauter à l'adresse mémoire qui suit l'appel de la fonction et de récupérer les informations qu'on a "mis de coté", tout cela, ca prend un temp bête ( on se comprend bien: je parle en nombre de fréquence d'horloge nécessaires pour y arriver... avec les processeurs actuels, ca fait quelques micro secondes à peine ;))

L'idée est donc de dire au compilateur "je sais que c'est une fonction, mais je voudrais que tu remplaces, dans l'exécutable, tous les appels de cette fonction par les instructions qu'elle contient"...

L'avantage théorique de déclarer une fonciton inline est donc relativement simple: quand elle est réellement inlinée, il est probable qu'elle soit plus rapide à l'exécution que sa version non inlinée...

Le hic, parce qu'il y a un hic, c'est que le compilateur peut parfaitement choisir de ne pas remplacer l'appel d'une fonction par ses instructions...

Le cas "peau de banane" par excellence est celui des fonctions récursives: même si tu le lui demande gentillement, il sera dans l'incapacité totale d'inliner ce genre de fonctions :P

Pour les autres, il n'est pas du tout impossible qu'il décide de l'ininer "parfois" mais de la gérer comme une fonction classique, avec tout ce que cela implique, à d'autres moments :P

Evidemment, tu ne pourras le remarquer qu'en observant le code assembleur ou le code binaire généré :P

Tout cela pour dire que, *théoriquement* tu devrais avoir un leger avantage à déclarer les accesseurs en tant que fonctions inline... mais, cet avantage peut très bien ne rester que théorique...

Inliner une fonction est une bonne chose d'un point de vue de la performance, modulo l'utilisation du cache.
Cela permet non seulement d'éviter le code d'appel de la fonction mais en plus cela permet d'adapter la fonction au contexte dans lequel elle est appelée, la rendant plus performante que dans le cas générique.
Aussi, si par exemple pour appeler une fonction qui prend en paramètre des références il faut poser des pointeurs vers les objets sur la pile, aucune opération n'est nécessaire lors de l'inlining.

Néanmoins, cela alourdit évidemment la taille de l'exécutable, puisque le code est dupliqué.
C'est cependant relativement peu souvent un problème.

Quoi qu'il en soit, pour une fonction qui se résume à très peu d'instructions, inliner est forcément bénéfique puisqu'on gagne en performance, sans gaspiller de taille de code, et sans contre-optimisation éventuelle à cause du cache.

Il est important de savoir tout de même qu'à cause du modèle de compilation de C++ en unités de traduction indépendantes qui sont ensuite liées, les compilateurs ne sont capables d'inliner qu'à l'intérieur d'une même unité de traduction. (il y a aussi de nombreuses autres optimisations impossibles et de fonctionnalités limitées à cause de ce modèle de compilation)
Du moins, je ne crois pas qu'un seul compilateur existant soit capable d'inliner à l'édition de liens. (Edit: apparemment le compilateur d'Intel le fait -- Re-Edit: apparemment, MSVC8 aussi peut le faire...)
Par conséquent, si tu veux qu'une fonction soit inlinée, il faut la mettre dans un fichier d'entête.

Après, le mot-clé inline n'a pas une grande utilité. Les compilateurs n'en ont pas vraiment besoin pour inliner les fonctions, ils peuvent le faire d'eux-mêmes avec les bonnes options.
C'est plus à utiliser dans de la méta-programmation complexe où la génération des fonctions serait vraiment problématique d'un point de vue performance.

ok ben merci pour vos réponses, c'était instructif !