C++ fournit des fonctions en ligne pour réduire la surcharge des appels de fonction. Une fonction en ligne est une fonction qui est développée en ligne lorsqu'elle est appelée. Lorsque la fonction en ligne est appelée, le code entier de la fonction en ligne est inséré ou remplacé au moment de l'appel de la fonction en ligne. Cette substitution est effectuée par le compilateur C++ au moment de la compilation. Une fonction en ligne peut augmenter l'efficacité si elle est petite.
Syntaxe:
inline return-type function-name(parameters) { // function code }> 
N'oubliez pas que l'inline n'est qu'une requête adressée au compilateur, pas une commande. Le compilateur peut ignorer la demande d'inline.
Le compilateur ne peut pas effectuer d'inline dans des circonstances telles que :
- Si une fonction contient une boucle. ( pendant, pendant et pendant ce temps )
- Si une fonction contient des variables statiques.
- Si une fonction est récursive.
- Si le type de retour d’une fonction est autre que void et que l’instruction return n’existe pas dans le corps d’une fonction.
- Si une fonction contient une instruction switch ou goto.
Pourquoi les fonctions en ligne sont-elles utilisées ?
Lorsque le programme exécute l'instruction d'appel de fonction, le CPU stocke l'adresse mémoire de l'instruction suivant l'appel de fonction, copie les arguments de la fonction sur la pile et transfère enfin le contrôle à la fonction spécifiée. Le CPU exécute ensuite le code de fonction, stocke la valeur de retour de la fonction dans un emplacement/registre mémoire prédéfini et rend le contrôle à la fonction appelante. Cela peut devenir une surcharge si le temps d'exécution de la fonction est inférieur au temps de commutation de la fonction appelante à la fonction appelée (appelé).
Pour les fonctions volumineuses et/ou exécutant des tâches complexes, la surcharge de l’appel de fonction est généralement insignifiante par rapport au temps nécessaire à l’exécution de la fonction. Cependant, pour les petites fonctions couramment utilisées, le temps nécessaire pour effectuer l’appel de fonction est souvent bien supérieur au temps nécessaire pour exécuter réellement le code de la fonction. Cette surcharge se produit pour les petites fonctions car le temps d'exécution d'une petite fonction est inférieur au temps de commutation.
Fonctions en ligne Avantages :
- La surcharge des appels de fonction ne se produit pas.
- Cela permet également d'économiser la surcharge des variables push/pop sur la pile lorsqu'une fonction est appelée.
- Cela permet également d'économiser la surcharge d'un appel de retour d'une fonction.
- Lorsque vous intégrez une fonction, vous pouvez permettre au compilateur d'effectuer une optimisation spécifique au contexte sur le corps de la fonction. De telles optimisations ne sont pas possibles pour les appels de fonction normaux. D'autres optimisations peuvent être obtenues en considérant les flux du contexte appelant et du contexte appelé.
- Une fonction en ligne peut être utile (si elle est petite) pour les systèmes embarqués car elle peut produire moins de code que la fonction appelée préambule et retour.
Inconvénients de la fonction en ligne :
- Les variables ajoutées à partir de la fonction en ligne consomment des registres supplémentaires. Après la fonction en ligne, si le nombre de variables qui va utiliser le registre augmente, elles peuvent créer une surcharge sur l'utilisation des ressources variables du registre. Cela signifie que lorsque le corps de la fonction en ligne est remplacé au moment de l'appel de la fonction, le nombre total de variables utilisées par la fonction est également inséré. Ainsi, le nombre de registres qui seront utilisés pour les variables sera également augmenté. Donc, si après la fonction inline, les nombres de variables augmentent considérablement, cela entraînerait sûrement une surcharge sur l'utilisation des registres.
- Si vous utilisez trop de fonctions en ligne, la taille du fichier exécutable binaire sera importante, en raison de la duplication du même code.
- Trop d'inline peut également réduire le taux de réussite de votre cache d'instructions, réduisant ainsi la vitesse de récupération des instructions de celle de la mémoire cache à celle de la mémoire primaire.
- La fonction en ligne peut augmenter le temps de compilation si quelqu'un modifie le code à l'intérieur de la fonction en ligne, alors tout l'emplacement appelant doit être recompilé car le compilateur serait obligé de remplacer à nouveau tout le code pour refléter les modifications, sinon il continuera avec l'ancien. Fonctionnalité.
- Les fonctions en ligne peuvent ne pas être utiles pour de nombreux systèmes embarqués. Parce que dans les systèmes embarqués, la taille du code est plus importante que la vitesse.
- Les fonctions en ligne peuvent provoquer des problèmes car l'intégration peut augmenter la taille du fichier exécutable binaire. L'écrasement de la mémoire entraîne une dégradation des performances de l'ordinateur. Le programme suivant montre l'utilisation de la fonction inline.
Exemple:
C++
#include> using> namespace> std;> inline> int> cube(>int> s) {>return> s * s * s; }> int> main()> {> >cout <<>'The cube of 3 is: '> << cube(3) <<>'
'>;> >return> 0;> }> |
>
>Sortir
The cube of 3 is: 27>
Fonction et classes en ligne
Il est également possible de définir la fonction inline à l'intérieur de la classe. En fait, toutes les fonctions définies à l'intérieur de la classe sont implicitement en ligne. Ainsi, toutes les restrictions des fonctions en ligne sont également appliquées ici. Si vous devez déclarer explicitement une fonction en ligne dans la classe, déclarez simplement la fonction à l'intérieur de la classe et définissez-la en dehors de la classe à l'aide du mot-clé inline.
Syntaxe:
class S { public: inline int square(int s) // redundant use of inline { // this function is automatically inline // function body } };> Le style ci-dessus est considéré comme un mauvais style de programmation. Le meilleur style de programmation consiste simplement à écrire le prototype de la fonction dans la classe et à le spécifier en ligne dans la définition de la fonction.
Par exemple:
class S { public: int square(int s); // declare the function }; inline int S::square(int s) // use inline prefix { }> Exemple:
C++
// C++ Program to demonstrate inline functions and classes> #include> using> namespace> std;> class> operation {> >int> a, b, add, sub, mul;> >float> div>;> public>:> >void> get();> >void> sum();> >void> difference();> >void> product();> >void> division();> };> inline> void> operation ::get()> {> >cout <<>'Enter first value:'>;> >cin>> un;> >cout <<>'Enter second value:'>;> >cin>>b;> }> inline> void> operation ::sum()> {> >add = a + b;> >cout <<>'Addition of two numbers: '> << a + b <<>'
'>;> }> inline> void> operation ::difference()> {> >sub = a - b;> >cout <<>'Difference of two numbers: '> << a - b <<>'
'>;> }> inline> void> operation ::product()> {> >mul = a * b;> >cout <<>'Product of two numbers: '> << a * b <<>'
'>;> }> inline> void> operation ::division()> {> >div> = a / b;> >cout <<>'Division of two numbers: '> << a / b <<>'
'>;> }> int> main()> {> >cout <<>'Program using inline function
'>;> >operation s;> >s.get();> >s.sum();> >s.difference();> >s.product();> >s.division();> >return> 0;> }> |
>
qu'est-ce qu'une pile en Java
>
Sortir:
Enter first value: 45 Enter second value: 15 Addition of two numbers: 60 Difference of two numbers: 30 Product of two numbers: 675 Division of two numbers: 3>
Quel est le problème avec la macro ?
Les lecteurs familiers avec le langage C savent que le langage C utilise des macros. Le préprocesseur remplace tous les appels de macro directement dans le code de la macro. Il est recommandé de toujours utiliser la fonction en ligne au lieu de la macro. Selon le Dr Bjarne Stroustrup, les créateurs de macros C++ ne sont presque jamais nécessaires en C++ et sont sujets aux erreurs. Il existe quelques problèmes avec l’utilisation des macros en C++. La macro ne peut pas accéder aux membres privés de la classe. Les macros ressemblent à des appels de fonction, mais ce n’est pas le cas.
Exemple:
C++
// C++ Program to demonstrate working of macro> #include> using> namespace> std;> class> S {> >int> m;> public>:> >// error> #define MAC(S::m)> };> |
>
>
Sortir:
Error: '::' may not appear in macro parameter list #define MAC(S::m)>
Le compilateur C++ vérifie les types d'arguments des fonctions en ligne et les conversions nécessaires sont effectuées correctement. La macro du préprocesseur n'est pas capable de faire cela. Une autre chose est que les macros sont gérées par le préprocesseur et les fonctions en ligne sont gérées par le compilateur C++. N'oubliez pas : il est vrai que toutes les fonctions définies à l'intérieur de la classe sont implicitement en ligne et que le compilateur C++ effectuera des appels en ligne de ces fonctions, mais le compilateur C++ ne peut pas fonctionner en ligne si la fonction est virtuelle. La raison pour laquelle une fonction virtuelle est appelée est résolue au moment de l'exécution plutôt qu'au moment de la compilation. Virtuel signifie attendre l'exécution et inline signifie pendant la compilation, si le compilateur ne sait pas quelle fonction sera appelée, comment peut-il effectuer l'inline ? Une autre chose à retenir est qu'il n'est utile de rendre la fonction en ligne que si le temps passé lors d'un appel de fonction est supérieur au temps d'exécution du corps de la fonction.
Un exemple où la fonction inline n'a aucun effet :
inline void show() { cout << 'value of S = ' << S << endl; }> La fonction ci-dessus prend relativement beaucoup de temps à s'exécuter. En général, une fonction qui effectue une opération d’entrée-sortie (E/S) ne doit pas être définie comme en ligne car elle prend un temps considérable. Techniquement, l'intégration de la fonction show() a une valeur limitée car le temps que prendra l'instruction d'E/S dépasse de loin la surcharge d'un appel de fonction. Selon le compilateur que vous utilisez, le compilateur peut vous afficher un avertissement si la fonction n'est pas développée en ligne.
Les langages de programmation comme Java et C# ne prennent pas en charge les fonctions en ligne. Mais en Java, le compilateur peut effectuer une inline lorsque la petite méthode finale est appelée car les méthodes finales ne peuvent pas être remplacées par des sous-classes et l'appel à une méthode finale est résolu au moment de la compilation.
En C#, le compilateur JIT peut également optimiser le code en insérant de petits appels de fonction (comme remplacer le corps d'une petite fonction lorsqu'elle est appelée dans une boucle). La dernière chose à garder à l’esprit est que les fonctions en ligne sont une fonctionnalité précieuse du C++. Une utilisation appropriée des fonctions en ligne peut améliorer les performances, mais si les fonctions en ligne sont utilisées arbitrairement, elles ne peuvent pas fournir de meilleurs résultats. En d’autres termes, ne vous attendez pas à de meilleures performances du programme. Ne mettez pas toutes les fonctions en ligne. Il est préférable de garder les fonctions en ligne aussi petites que possible.