Réponse.

En C++, une fonction membre de classe peut être déclarée :

À l'intérieur de la classe (définition inline) :
```
class A {
    void foo() { /* ... */ } // directement dans la classe
};
```
Ces fonctions sont considérées comme inline implicitement.

À l'intérieur de la classe (seulement déclaration) :

class A {
    void foo(); // seulement déclaration
};
void A::foo() { /* ... */ } // définition à l'extérieur de la classe

Différence :

La définition à l'intérieur de la classe (« sur place ») suppose automatiquement inline, le compilateur peut intégrer cette fonction directement dans le code de son appel.
La définition à l'extérieur de la classe n'est pas automatiquement inline sans une indication explicite (inline), bien que le mot clé puisse être ajouté :
```
inline void A::foo() { /* ... */ }
```
La déclaration à l'extérieur de la classe est nécessaire lorsque la définition est séparée, par exemple, dans un fichier .cpp pour accélérer la compilation et pour séparer l'interface de l'implémentation.

Avantages et inconvénients des approches :

La définition à l'intérieur de la classe est pratique pour les petites fonctions souvent appelées.
Pour les méthodes volumineuses ou les méthodes qui changent indépendamment, il est plus efficace de ne donner que la déclaration dans la classe, et la définition dans le .cpp.

Question piège.

Est-ce qu'une fonction définie à l'intérieur d'une classe sera toujours réellement intégrée par le compilateur ?

Réponse : Non. Le mot clé inline (y compris la déclaration implicite lors de la définition à l'intérieur de la classe) est seulement une suggestion pour le compilateur. Le compilateur peut ignorer ce conseil s'il considère que la fonction est trop complexe ou peu judicieuse à intégrer.

Exemples d'erreurs réelles dues à l'ignorance des subtilités du sujet.

Histoire 1

Dans un grand projet, les fonctions membres ont été définies comme inline dans des fichiers d'en-tête et incluses dans des milliers d'unités de traduction, ce qui a entraîné une augmentation du temps de compilation et une augmentation de la taille du binaire en raison de la duplication de code — le compilateur ne fusionne pas toujours l'implémentation-machine identique.

Histoire 2

Dans une tentative d'accélérer l'exécution, le développeur a déplacé toute la logique de la classe dans la déclaration (dans le fichier .h). Cela a conduit à ce que, lors de la modification de la fonction, l'ensemble du projet soit recompilé, et non seulement les fichiers individuels (auxquels l'intégration a réellement été touchée).

Histoire 3

Un nouveau membre de l'équipe a placé de longues méthodes de sérialisation et de manipulation de fichiers directement dans la déclaration de la classe template, provoquant une propagation accidentelle d'erreurs dans tous les TU, et une augmentation excessive de la taille du fichier exécutable sans gain de performance.