Risposta.

In C++, una funzione membro di una classe può essere dichiarata:

All'interno della classe (definizione inline):
```
class A {
    void foo() { /* ... */ } // direttamente all'interno della classe
};
```
Queste funzioni sono considerate implicitamente inline.

All'interno della classe (solo dichiarazione):

class A {
    void foo(); // solo dichiarazione
};
void A::foo() { /* ... */ } // definizione al di fuori della classe

Differenza:

La definizione all'interno della classe («in loco») implica automaticamente inline, il compilatore può incorporare tale funzione direttamente nel codice della sua chiamata.
La definizione al di fuori della classe non è automaticamente inline senza un'indicazione esplicita (inline), sebbene la parola chiave possa essere aggiunta:
```
inline void A::foo() { /* ... */ }
```
La dichiarazione al di fuori della classe è necessaria quando la definizione è separata, ad esempio, in un file .cpp per accelerare la compilazione e per separare l'interfaccia dall'implementazione.

Vantaggi e svantaggi degli approcci:

La definizione all'interno della classe è comoda per funzioni piccole e frequentemente chiamate.
Per metodi grandi o metodi che cambiano separatamente, è più efficace fornire solo la dichiarazione nella classe, e la definizione nel .cpp.

Domanda insidiosa.

La funzione definita all'interno della classe sarà sempre realmente incorporata dal compilatore?

Risposta: No. La parola chiave inline (compresa l'assegnazione implicita alla definizione all'interno della classe) è solo un suggerimento per il compilatore. Il compilatore può ignorare questo consiglio se ritiene che la funzione sia troppo complessa o poco praticabile per l'incorporamento.

Esempi di errori reali a causa della mancanza di conoscenza delle sottigliezze del tema.

Storia 1

In un grande progetto, le funzioni membro erano definite come inline all'interno dei file header e incluse in migliaia di unità di traduzione, il che ha causato un aumento dei tempi di compilazione e un aumento delle dimensioni del binario a causa della duplicazione del codice: il compilatore non sempre unisce l'implementazione macchina identica.

Storia 2

Nel tentativo di accelerare l'esecuzione, lo sviluppatore ha spostato tutta la logica della classe nella dichiarazione (nel file .h). Questo ha comportato che, a seguito di una modifica della funzione, si ricompilasse l'intero progetto, e non solo i singoli file (quelli effettivamente coinvolti nell'integrazione).

Storia 3

Un nuovo membro del team ha inserito metodi lunghi per la serializzazione e la gestione dei file direttamente nella dichiarazione della classe template, causando la diffusione casuale di errori in tutte le TU e una crescita eccessiva delle dimensioni del file eseguibile senza un aumento delle prestazioni.