Perché le funzioni inline C ++ sono nell'intestazione?

_{NB Questa non è una domanda su come usare le funzioni inline o su come funzionano, ma piuttosto sul motivo per cui sono fatte come sono.}

La dichiarazione di una funzione membro di una classe non ha bisogno di definire una funzione in inlinequanto è solo l'effettiva implementazione della funzione. Ad esempio, nel file di intestazione:

struct foo{
    void bar(); // no need to define this as inline
}

Allora perché l'implementazione inline di una funzione di classi deve essere nel file di intestazione? Perché non posso inserire la funzione inline nel .cppfile? Se dovessi provare a inserire la definizione inline nel .cppfile, riceverei un errore sulla falsariga di:

error LNK2019: unresolved external symbol 
"public: void __thiscall foo::bar(void)"
(?bar@foo@@QAEXXZ) referenced in function _main 
1>C:\Users\Me\Documents\Visual Studio 2012\Projects\inline\Debug\inline.exe 
: fatal error LNK1120: 1 unresolved externals

La definizione di una inlinefunzione non deve essere necessariamente in un file di intestazione ma, a causa della regola dell'una definizione ( ODR ) per le funzioni inline, deve esistere una definizione identica per la funzione in ogni unità di traduzione che la utilizza.

Il modo più semplice per ottenere ciò è inserire la definizione in un file di intestazione.

Se vuoi mettere la definizione di una funzione in un unico file sorgente, non dovresti dichiararla inline. Una funzione non dichiaratainline non significa che il compilatore non possa incorporare la funzione.

Il fatto che tu debba dichiarare inlineo meno una funzione di solito è una scelta che dovresti fare in base alla versione delle regole di definizione che ha più senso per te seguire; aggiungere inlinee poi essere limitati dai vincoli successivi ha poco senso.

Ci sono due modi per vederlo:

1. Le funzioni inline sono definite nell'intestazione perché, per inline una chiamata di funzione, il compilatore deve essere in grado di vedere il corpo della funzione. Affinché un compilatore ingenuo possa farlo, il corpo della funzione deve essere nella stessa unità di traduzione della chiamata. (Un compilatore moderno può ottimizzare tra unità di traduzione, quindi una chiamata di funzione può essere inline anche se la definizione della funzione è in un'unità di traduzione separata, ma queste ottimizzazioni sono costose, non sono sempre abilitate e non sono sempre state supportate dal compilatore)

2. le funzioni definite nell'intestazione devono essere contrassegnate inlineperché altrimenti, ogni unità di traduzione che include l'intestazione conterrà una definizione della funzione e il linker si lamenterà di più definizioni (una violazione della regola dell'una definizione). La inlineparola chiave lo sopprime, consentendo a più unità di traduzione di contenere definizioni (identiche).

Le due spiegazioni si riducono davvero al fatto che la inlineparola chiave non fa esattamente quello che ti aspetteresti.

Un compilatore C ++ è libero di applicare l' ottimizzazione inlining (sostituire una chiamata di funzione con il corpo della funzione chiamata, risparmiando l'overhead della chiamata) ogni volta che vuole, purché non alteri il comportamento osservabile del programma.

La inlineparola chiave rende più facile per il compilatore applicare questa ottimizzazione, consentendo alla definizione della funzione di essere visibile in più unità di traduzione, ma l'uso della parola chiave non significa che il compilatore debba inline la funzione, e non usare la parola chiave non lo fa proibire al compilatore di integrare la funzione.

Questo è un limite del compilatore C ++. Se metti la funzione nell'intestazione, tutti i file cpp in cui può essere inline possono vedere il "sorgente" della tua funzione e l'inlining può essere fatto dal compilatore. Altrimenti l'inlining dovrebbe essere fatto dal linker (ogni file cpp è compilato in un file obj separatamente). Il problema è che sarebbe molto più difficile farlo nel linker. Un problema simile esiste con le classi / funzioni "modello". Devono essere istanziate dal compilatore, perché il linker avrebbe problemi a crearne un'istanza (creando una versione specializzata). Alcuni compilatori / linker più recenti possono eseguire una compilazione / collegamento "in due passaggi" in cui il compilatore esegue un primo passaggio, quindi il linker fa il suo lavoro e chiama il compilatore per risolvere le cose non risolte (inline / templates ...)

Il motivo è che il compilatore deve effettivamente vedere la definizione per poterla rilasciare al posto della chiamata.

Ricorda che C e C ++ utilizzano un modello di compilazione molto semplicistico, in cui il compilatore vede sempre solo un'unità di traduzione alla volta. (Questo non riesce per l'esportazione, che è il motivo principale per cui solo un fornitore lo ha effettivamente implementato.)

La inlineparola chiave c ++ è fuorviante, non significa "inline this function". Se una funzione è definita come inline, significa semplicemente che può essere definita più volte purché tutte le definizioni siano uguali. È perfettamente legale per una funzione contrassegnata inlinecome una funzione reale che viene chiamata invece di ottenere il codice inline nel punto in cui viene chiamata.

La definizione di una funzione in un file di intestazione è necessaria per i modelli, poiché ad esempio una classe basata su modelli non è realmente una classe, è un modello per una classe di cui è possibile apportare più varianti. Affinché il compilatore sia in grado, ad esempio, di creare una Foo<int>::bar()funzione quando si utilizza il modello Foo per creare una classe Foo , la definizione effettiva di Foo<T>::bar()deve essere visibile.

So che questo è un vecchio thread ma ho pensato di doverlo menzionare la externparola chiave. Di recente ho riscontrato questo problema e l'ho risolto come segue

helper.h

namespace DX
{
    extern inline void ThrowIfFailed(HRESULT hr);
}

Helper.cpp

namespace DX
{
    inline void ThrowIfFailed(HRESULT hr)
    {
        if (FAILED(hr))
        {
            std::stringstream ss;
            ss << "#" << hr;
            throw std::exception(ss.str().c_str());
        }
    }
}

Perché il compilatore ha bisogno di vederli per inserirli in linea . E i file di intestazione sono i "componenti" che sono comunemente inclusi in altre unità di traduzione.

#include "file.h"
// Ok, now me (the compiler) can see the definition of that inline function. 
// So I'm able to replace calls for the actual implementation.

Funzioni inline

In C ++ una macro non è altro che una funzione inline. Così ora le macro sono sotto il controllo del compilatore.

• Importante : se definiamo una funzione all'interno di una classe, questa diventerà automaticamente Inline

Il codice della funzione Inline viene sostituito nel punto in cui viene chiamato, quindi riduce il sovraccarico della funzione di chiamata.

In alcuni casi l'inlining della funzione non può funzionare, come

• Se la variabile statica viene utilizzata all'interno della funzione inline.

• Se la funzione è complicata.

• Se la chiamata ricorsiva di funzione

• Se l'indirizzo della funzione è preso implicitamente o esplicitamente

La funzione definita al di fuori della classe come di seguito può diventare inline

inline int AddTwoVar(int x,int y); //This may not become inline 

inline int AddTwoVar(int x,int y) { return x + y; } // This becomes inline

Anche la funzione definita all'interno della classe diventa inline

// Inline SpeedMeter functions
class SpeedMeter
{
    int speed;
    public:
    int getSpeed() const { return speed; }
    void setSpeed(int varSpeed) { speed = varSpeed; }
};
int main()
{
    SpeedMeter objSM;
    objSM.setSpeed(80);
    int speedValue = A.getSpeed();
} 

Qui entrambe le funzioni getSpeed ​​e setSpeed ​​diventeranno inline