Quando devo scrivere la parola chiave "inline" per una funzione / metodo?

Quando devo scrivere la parola chiave inlineper una funzione / metodo in C ++?

Dopo aver visto alcune risposte, alcune domande correlate:

• Quando non dovrei scrivere la parola chiave "inline" per una funzione / metodo in C ++?

• Quando il compilatore non saprà quando rendere "inline" una funzione / metodo?

• Importa se un'applicazione è multithread quando si scrive "inline" per una funzione / metodo?

Oh amico, uno dei miei animali domestici.

inlineè più simile statico externdi una direttiva che dice al compilatore di incorporare le tue funzioni. extern, static, inlineSono direttive linkage, utilizzati quasi esclusivamente dal linker, non il compilatore.

Si dice che inlinesuggerisce al compilatore che si ritiene che la funzione debba essere integrata. Questo potrebbe essere vero nel 1998, ma un decennio dopo il compilatore non ha bisogno di tali suggerimenti. Per non parlare degli umani di solito hanno torto quando si tratta di ottimizzare il codice, quindi la maggior parte dei compilatori ignora il "suggerimento".

• static- il nome della variabile / funzione non può essere utilizzato in altre unità di traduzione. Linker deve assicurarsi che non usi accidentalmente una variabile / funzione definita staticamente da un'altra unità di traduzione.

• extern- usa questo nome variabile / funzione in questa unità di traduzione ma non lamentarti se non è definito. Il linker lo risolverà e si assicurerà che tutto il codice che ha tentato di usare un simbolo esterno abbia il suo indirizzo.

• inline- questa funzione sarà definita in più unità di traduzione, non ti preoccupare. Il linker deve assicurarsi che tutte le unità di traduzione utilizzino una singola istanza della variabile / funzione.

Nota: in generale, dichiarare i modelli inlineè inutile, poiché hanno già la semantica del collegamento inline. Tuttavia, è necessarioinline utilizzare la specializzazione esplicita e la creazione di istanze di modelli .

Risposte specifiche alle tue domande:

• Quando devo scrivere la parola chiave "inline" per una funzione / metodo in C ++?

  Solo quando si desidera che la funzione sia definita in un'intestazione. Più esattamente solo quando la definizione della funzione può essere visualizzata in più unità di traduzione. È una buona idea definire piccole funzioni (come in una riga) nel file di intestazione in quanto fornisce al compilatore ulteriori informazioni su cui lavorare mentre ottimizza il codice. Aumenta anche il tempo di compilazione.

• Quando non dovrei scrivere la parola chiave "inline" per una funzione / metodo in C ++?

  Non aggiungere in linea solo perché pensi che il tuo codice verrà eseguito più velocemente se il compilatore lo incorpora.

• Quando il compilatore non saprà quando rendere "inline" una funzione / metodo?

  Generalmente, il compilatore sarà in grado di farlo meglio di te. Tuttavia, il compilatore non ha l'opzione per incorporare il codice se non ha la definizione della funzione. Nel codice ottimizzato al massimo di solito tutti i privatemetodi sono indicati se lo chiedi o meno.

  A parte questo, per evitare di entrare in GCC, usa __attribute__(( noinline )), e in Visual Studio, usa __declspec(noinline).

• Importa se un'applicazione è multithread quando si scrive "inline" per una funzione / metodo?

  Il multithreading non influisce in alcun modo sull'inline.

Vorrei contribuire a tutte le grandi risposte in questa discussione con un esempio convincente per dissipare eventuali equivoci rimanenti.

Dati due file di origine, come ad esempio:

• inline111.cpp:

  #include <iostream>
  
  void bar();
  
  inline int fun() {
    return 111;
  }
  
  int main() {
    std::cout << "inline111: fun() = " << fun() << ", &fun = " << (void*) &fun;
    bar();
  }

• inline222.cpp:

  #include <iostream>
  
  inline int fun() {
    return 222;
  }
  
  void bar() {
    std::cout << "inline222: fun() = " << fun() << ", &fun = " << (void*) &fun;
  }

• Caso A:

  Compilare :

  g++ -std=c++11 inline111.cpp inline222.cpp

  Uscita :

  inline111: fun() = 111, &fun = 0x4029a0
  inline222: fun() = 111, &fun = 0x4029a0

  Discussione :

  1. Anche se dovresti avere definizioni identiche delle tue funzioni inline, il compilatore C ++ non lo contrassegna in caso contrario (in realtà, a causa della compilazione separata non ha modo di controllarlo). È tuo dovere assicurarti questo!

  2. Linker non si lamenta di One Definition Rule , come fun()dichiarato inline. Tuttavia, poiché inline111.cpp è la prima unità di traduzione (che in realtà chiama fun()) elaborata dal compilatore, il compilatore crea un'istanza fun()al suo primo incontro di chiamata in inline111.cpp . Se il compilatore decide di non espandere fun()la propria chiamata da qualsiasi altra parte del programma ( ad es. Da inline222.cpp ), la chiamata a fun()sarà sempre collegata alla sua istanza prodotta da inline111.cpp (la chiamata fun()all'interno di inline222.cpppuò anche produrre un'istanza in quell'unità di traduzione, ma rimarrà non collegata). In effetti, ciò è evidente dalle &fun = 0x4029a0stampe identiche .

  3. Infine, nonostante il inlinesuggerimento al compilatore di espandere effettivamente il one-liner fun(), ignora completamente il tuo suggerimento, il che è chiaro perché fun() = 111in entrambe le righe.

• Caso B:

  Compila (nota ordine inverso) :

  g++ -std=c++11 inline222.cpp inline111.cpp

  Uscita :

  inline111: fun() = 222, &fun = 0x402980
  inline222: fun() = 222, &fun = 0x402980

  Discussione :

  1. Questo caso afferma ciò che è stato discusso in caso A .

  2. Si noti un punto importante, che se si commenta la chiamata effettiva fun()in inline222.cpp ( ad es. Commento di coutoutstatement in inline222.cpp completamente), quindi, nonostante l'ordine di compilazione delle unità di traduzione, fun()verrà istanziato al primo incontro di chiamata in inline111.cpp , con conseguente stampa per il caso B come inline111: fun() = 111, &fun = 0x402980.

• Caso C:

  Compila (avviso -O2) :

  g++ -std=c++11 -O2 inline222.cpp inline111.cpp

  o

  g++ -std=c++11 -O2 inline111.cpp inline222.cpp

  Uscita :

  inline111: fun() = 111, &fun = 0x402900
  inline222: fun() = 222, &fun = 0x402900

  Discussione :

  1. Come descritto qui , l' -O2ottimizzazione incoraggia il compilatore ad espandere effettivamente le funzioni che possono essere integrate (si noti anche che -fno-inlineè predefinito senza opzioni di ottimizzazione). Come è evidente dalla stampa qui, il file fun()è stato effettivamente ampliato in linea (secondo la sua definizione in quella particolare unità di traduzione), risultando in due stampe diverse fun() . Ciononostante, esiste ancora solo un'istanza collegata a livello globale di fun()(come richiesto dallo standard), come risulta dalla stampa identica &fun .

Devi ancora incorporare esplicitamente la tua funzione quando esegui la specializzazione del modello (se la specializzazione è nel file .h)

1) Al giorno d'oggi, praticamente mai. Se è una buona idea incorporare una funzione, il compilatore lo farà senza il tuo aiuto.

2) Sempre. Vedi # 1.

(Modificato per riflettere che hai diviso la tua domanda in due domande ...)

Quando non dovrei scrivere la parola chiave "inline" per una funzione / metodo in C ++?

Se la funzione è dichiarata nell'intestazione e definito nel .cppfile, è necessario non scrivere la parola chiave.

Quando il compilatore non saprà quando rendere "inline" una funzione / metodo?

Non esiste una situazione del genere. Il compilatore non può rendere inline una funzione. Tutto ciò che può fare è incorporare alcune o tutte le chiamate alla funzione. Non può farlo se non ha il codice della funzione (in tal caso il linker deve farlo se è in grado di farlo).

Importa se un'applicazione è multithread quando si scrive "inline" per una funzione / metodo?

No, non importa affatto.

• Quando il compilatore non saprà quando rendere "inline" una funzione / metodo?

Questo dipende dal compilatore utilizzato. Non fidarti ciecamente che al giorno d'oggi i compilatori conoscano meglio gli umani come inline e non dovresti mai usarlo per motivi di prestazioni, perché è la direttiva sul collegamento piuttosto che un suggerimento per l'ottimizzazione. Mentre sono d'accordo sul fatto che ideologicamente sono questi argomenti, l'incontro corretto con la realtà potrebbe essere una cosa diversa.

Dopo aver letto più thread in giro, ho provato per curiosità gli effetti dell'inline sul codice che sto solo lavorando e i risultati sono stati che ho ottenuto una velocità misurabile per GCC e nessuna velocità per il compilatore Intel.

(Maggiori dettagli: simulazioni matematiche con poche funzioni critiche definite al di fuori della classe, GCC 4.6.3 (g ++ -O3), ICC 13.1.0 (icpc -O3); l'aggiunta in linea ai punti critici ha causato uno speedup del 6% con il codice GCC).

Quindi, se qualifichi GCC 4.6 come un moderno compilatore, il risultato è che la direttiva in linea è ancora importante se scrivi attività ad alta intensità di CPU e sai dove si trova esattamente il collo di bottiglia.

In realtà, praticamente mai. Tutto quello che stai facendo è suggerire che il compilatore renda in linea una determinata funzione (ad esempio, sostituisci tutte le chiamate a questa funzione / con il suo corpo). Non ci sono garanzie, ovviamente: il compilatore può ignorare la direttiva.

Il compilatore farà generalmente un buon lavoro nel rilevare + ottimizzare cose come questa.

gcc di default non incorpora alcuna funzione durante la compilazione senza l'ottimizzazione abilitata. Non so di Visual Studio - deft_code

Ho verificato questo per Visual Studio 9 (15.00.30729.01) compilando con / FAcs e osservando il codice assembly: Il compilatore ha prodotto chiamate alle funzioni membro senza ottimizzazione abilitata in modalità debug . Anche se la funzione è contrassegnata con __forceinline , non viene prodotto alcun codice di runtime inline.

Vuoi metterlo all'inizio, prima di restituire il tipo. Ma la maggior parte dei compilatori lo ignora. Se è definito e ha un blocco di codice più piccolo, la maggior parte dei compilatori lo considera comunque in linea.

A meno che tu non stia scrivendo una libreria o abbia motivi particolari, puoi invece dimenticarti inlinee usare invece l' ottimizzazione del tempo di collegamento . Rimuove il requisito secondo cui una definizione di funzione deve essere presente in un'intestazione affinché possa essere considerata come inline tra le unità di compilazione, che è esattamente ciò che inlineconsente.

(Ma vedi C'è qualche motivo per non usare l'ottimizzazione del tempo di collegamento? )

La parola chiave inline richiede al compilatore di sostituire la chiamata di funzione con il corpo della funzione, prima valuta l'espressione e quindi passa.Riduce il sovraccarico della chiamata di funzione in quanto non è necessario memorizzare l'indirizzo di ritorno e la memoria dello stack non è necessaria per la funzione argomenti.

Quando usare:

• Per migliorare le prestazioni
• Per ridurre l'overhead delle chiamate.
• Dato che è solo una richiesta al compilatore, alcune funzioni non verranno incorporate * funzioni di grandi dimensioni
  • funzioni che hanno troppi argomenti condizionali
  • codice ricorsivo e codice con loop ecc.

C ++ inline è totalmente diverso da C inline .

#include <iostream>
extern inline int i[];
int i [5];
struct c {
  int function (){return 1;} //implicitly inline
  static inline int j = 3; //explicitly inline
};
int main() {
  c j;
  std::cout << i;
}

inlineda solo influenza il compilatore, l'assemblatore e il linker. È una direttiva per il compilatore che dice di emettere un simbolo per questa funzione / dati solo se utilizzato nell'unità di traduzione, e se lo è, quindi come i metodi di classe, dire all'assemblatore di memorizzarli nella sezione .section .text.c::function(),"axG",@progbits,c::function(),comdato .section .bss.i,"awG",@nobits,i,comdatper i dati. Le istanze dei modelli vanno anche nei loro gruppi di comdat.

Questo segue .section name, "flags"MG, @type, entsize, GroupName[, linkage]. Ad esempio, il nome della sezione è .text.c::function(). axGsignifica che la sezione è allocabile, eseguibile e in un gruppo, cioè verrà specificato un nome di gruppo (e non c'è un flag M quindi non verrà specificato alcun entsize); @progbitsindica che la sezione contiene dati e non è vuota; c::function()è il nome del gruppo e il gruppo hacomdatcollegamento che significa che in tutti i file oggetto, tutte le sezioni incontrate con questo nome di gruppo taggato con comdat verranno rimosse dall'eseguibile finale ad eccezione di 1 ovvero il compilatore si assicura che ci sia una sola definizione nell'unità di traduzione e quindi dice all'assemblatore di mettere nel suo gruppo nel file oggetto (1 sezione in 1 gruppo) e quindi il linker farà in modo che se qualsiasi file oggetto ha un gruppo con lo stesso nome, includerne solo uno nel file .exe finale. La differenza tra inlinee non utilizzo inlineè ora visibile all'assemblatore e di conseguenza al linker, perché non è memorizzato nel normale .datao .textecc dall'assemblatore a causa delle loro direttive.

static inlinein una classe significa che si tratta di una definizione di tipo e non di una dichiarazione (consente di definire un membro statico nella classe) e di renderlo in linea; ora si comporta come sopra.

static inlinenell'ambito del file riguarda solo il compilatore. Significa per il compilatore: emettere un simbolo per questa funzione / dati solo se viene utilizzato nell'unità di traduzione e farlo come un normale simbolo statico (memorizzare in.text /.data senza la direttiva .globl). Per l'assemblatore non esiste ora alcuna differenza tra staticestatic inline

extern inlineè una dichiarazione che significa che è necessario definire questo simbolo nell'unità di traduzione o generare un errore del compilatore; se è definito, trattalo come un normale inlinee per l'assemblatore e il linker non ci sarà alcuna differenza tra extern inlinee inline, quindi questa è solo una protezione del compilatore.

extern inline int i[];
extern int i[]; //allowed repetition of declaration with incomplete type, inherits inline property
extern int i[5]; //declaration now has complete type
extern int i[5]; //allowed redeclaration if it is the same complete type or has not yet been completed
extern int i[6]; //error, redeclaration with different complete type
int i[5]; //definition, must have complete type and same complete type as the declaration if there is a declaration with a complete type

Tutto quanto sopra senza la riga di errore collassa a inline int i[5]. Ovviamente se avete fatto extern inline int i[] = {5};allora externsarebbe ignorato a causa della definizione esplicita attraverso l'assegnazione.

inlinesu uno spazio dei nomi, vedi questo e questo

Quando si sviluppa e si inlineesegue il debug del codice, lasciarlo fuori. Complica il debug.

Il motivo principale per aggiungerli è aiutare a ottimizzare il codice generato. In genere questo inlineconsente di scambiare lo spazio di codice aumentato per la velocità, ma a volte consente di risparmiare spazio di codice e tempo di esecuzione.

Spendere questo tipo di pensiero sull'ottimizzazione delle prestazioni prima del completamento dell'algoritmo è l'ottimizzazione prematura .

Quando uno dovrebbe essere in linea:

1.Quando si vuole evitare il sovraccarico di cose che accadono quando si chiama funzione come passaggio di parametri, trasferimento di controllo, ritorno di controllo ecc

2.La funzione dovrebbe essere piccola, chiamata frequentemente e rendere in linea è davvero vantaggioso poiché secondo la regola 80-20, cerca di rendere in linea quella funzione che ha un impatto notevole sulle prestazioni del programma.

Come sappiamo che inline è solo una richiesta per compilatore simile alla registrazione e ti costerà alla dimensione del codice oggetto.

La funzione inline C ++ è un concetto potente che viene comunemente usato con le classi. Se una funzione è in linea, il compilatore inserisce una copia del codice di quella funzione in ciascun punto in cui la funzione viene chiamata al momento della compilazione.

Qualsiasi modifica a una funzione inline potrebbe richiedere la ricompilazione di tutti i client della funzione poiché il compilatore dovrebbe sostituire nuovamente tutto il codice, altrimenti continuerà con le funzionalità precedenti.

Per incorporare una funzione, posizionare la parola chiave in linea prima del nome della funzione e definire la funzione prima di effettuare qualsiasi chiamata alla funzione. Il compilatore può ignorare il qualificatore inline nel caso in cui la funzione definita sia più di una riga.

Una definizione di funzione in una definizione di classe è una definizione di funzione inline, anche senza l'uso dell'identificatore inline.

Di seguito è riportato un esempio, che utilizza la funzione incorporata per restituire un massimo di due numeri

#include <iostream>

using namespace std;

inline int Max(int x, int y) { return (x > y)? x : y; }

// Main function for the program
int main() {
   cout << "Max (100,1010): " << Max(100,1010) << endl;

   return 0;
}

per maggiori informazioni vedi qui .