Figura 1: modelli di funzioni

TemplHeader.h

template<typename T>
void f();

TemplCpp.cpp

template<typename T>
void f(){
   //...
}    
//explicit instantation
template void f<T>();

main.cpp

#include "TemplHeader.h"
extern template void f<T>(); //is this correct?
int main() {
    f<char>();
    return 0;
}

È questo il modo corretto di utilizzare extern templateo devo usare questa parola chiave solo per i modelli di classe come nella Figura 2?

Figura 2: modelli di classe

TemplHeader.h

template<typename T>
class foo {
    T f();
};

TemplCpp.cpp

template<typename T>
void foo<T>::f() {
    //...
}
//explicit instantation
template class foo<int>;

main.cpp

#include "TemplHeader.h"
extern template class foo<int>();
int main() {
    foo<int> test;
    return 0;
}

So che è bene mettere tutto questo in un file di intestazione, ma se istanziamo modelli con gli stessi parametri in più file, avremo più definizioni uguali e il compilatore le rimuoverà tutte (tranne una) per evitare errori. Come si usa extern template? Possiamo usarlo solo per le classi o possiamo usarlo anche per le funzioni?

Inoltre, la Figura 1 e la Figura 2 possono essere espanse in una soluzione in cui i modelli sono in un unico file di intestazione. In tal caso, dobbiamo utilizzare la extern templateparola chiave per evitare più istanze stesse. È solo per classi o funzioni?

Dovresti usare solo extern templateper forzare il compilatore a non istanziare un modello quando sai che verrà istanziato da qualche altra parte. Viene utilizzato per ridurre il tempo di compilazione e la dimensione del file oggetto.

Per esempio:

// header.h

template<typename T>
void ReallyBigFunction()
{
    // Body
}

// source1.cpp

#include "header.h"
void something1()
{
    ReallyBigFunction<int>();
}

// source2.cpp

#include "header.h"
void something2()
{
    ReallyBigFunction<int>();
}

Ciò si tradurrà nei seguenti file oggetto:

source1.o
    void something1()
    void ReallyBigFunction<int>()    // Compiled first time

source2.o
    void something2()
    void ReallyBigFunction<int>()    // Compiled second time

Se entrambi i file sono collegati insieme, uno void ReallyBigFunction<int>()verrà scartato, con conseguente perdita di tempo di compilazione e dimensione del file oggetto.

Per non sprecare tempo di compilazione e dimensioni del file oggetto, esiste una externparola chiave che impedisce al compilatore di compilare una funzione modello. Dovresti usarlo se e solo se sai che è usato nello stesso binario da qualche altra parte.

Passaggio source2.cppa:

// source2.cpp

#include "header.h"
extern template void ReallyBigFunction<int>();
void something2()
{
    ReallyBigFunction<int>();
}

Risulterà nei seguenti file oggetto:

source1.o
    void something1()
    void ReallyBigFunction<int>() // compiled just one time

source2.o
    void something2()
    // No ReallyBigFunction<int> here because of the extern

Quando entrambi saranno collegati insieme, il secondo file oggetto utilizzerà semplicemente il simbolo del primo file oggetto. Nessuna necessità di eliminazione e nessuna perdita di tempo di compilazione e dimensione del file oggetto.

Questo dovrebbe essere usato solo all'interno di un progetto, come quando usi un modello vector<int>più volte, dovresti usarlo externin tutti i file sorgente tranne uno.

Ciò si applica anche alle classi e alla funzione come una sola, e anche alle funzioni membro del modello.

Wikipedia ha la migliore descrizione

In C ++ 03, il compilatore deve creare un'istanza di un modello ogni volta che viene incontrato un modello completamente specificato in un'unità di traduzione. Se il modello viene istanziato con gli stessi tipi in molte unità di traduzione, ciò può aumentare notevolmente i tempi di compilazione. Non c'è modo di impedirlo in C ++ 03, quindi C ++ 11 ha introdotto dichiarazioni di modelli esterni, analoghe alle dichiarazioni di dati esterni.

C ++ 03 ha questa sintassi per obbligare il compilatore a creare un'istanza di un modello:

  template class std::vector<MyClass>;

C ++ 11 ora fornisce questa sintassi:

  extern template class std::vector<MyClass>;

che dice al compilatore di non istanziare il modello in questa unità di traduzione.

_{^{L'avviso: nonstandard extension used...}}

Microsoft VC ++ aveva una versione non standard di questa funzionalità già da alcuni anni (in C ++ 03). Il compilatore avverte di ciò per evitare problemi di portabilità con il codice che doveva essere compilato anche su diversi compilatori.

Guarda l'esempio nella pagina collegata per vedere che funziona più o meno allo stesso modo. Puoi aspettarti che il messaggio scompaia con le versioni future di MSVC, tranne ovviamente quando si utilizzano contemporaneamente altre estensioni del compilatore non standard.

extern template è necessario solo se la dichiarazione del modello è completa

Questo è stato accennato in altre risposte, ma non credo che sia stata data abbastanza enfasi.

Ciò significa che negli esempi OP, extern templatenon ha alcun effetto perché le definizioni del modello sulle intestazioni erano incomplete:

• void f();: solo dichiarazione, nessun corpo
• class foo: dichiara il metodo f()ma non ha una definizione

Quindi consiglierei semplicemente di rimuovere la extern templatedefinizione in quel caso particolare: è necessario aggiungerle solo se le classi sono completamente definite.

Per esempio:

TemplHeader.h

template<typename T>
void f();

TemplCpp.cpp

template<typename T>
void f(){}

// Explicit instantiation for char.
template void f<char>();

main.cpp

#include "TemplHeader.h"

// Commented out from OP code, has no effect.
// extern template void f<T>(); //is this correct?

int main() {
    f<char>();
    return 0;
}

compila e visualizza i simboli con nm:

g++ -std=c++11 -Wall -Wextra -pedantic -c -o TemplCpp.o TemplCpp.cpp
g++ -std=c++11 -Wall -Wextra -pedantic -c -o Main.o Main.cpp
g++ -std=c++11 -Wall -Wextra -pedantic -o Main.out Main.o TemplCpp.o
echo TemplCpp.o
nm -C TemplCpp.o | grep f
echo Main.o
nm -C Main.o | grep f

produzione:

TemplCpp.o
0000000000000000 W void f<char>()
Main.o
                 U void f<char>()

e poi da man nmvediamo che Usignifica indefinito, quindi la definizione è rimasta solo TemplCppcome desiderato.

Tutto questo si riduce al compromesso delle dichiarazioni di intestazione complete:

• aspetti positivi:
  • consente al codice esterno di utilizzare il nostro modello con nuovi tipi
  • abbiamo la possibilità di non aggiungere istanze esplicite se stiamo bene con il rigonfiamento degli oggetti
• aspetti negativi:
  • quando si sviluppa quella classe, le modifiche all'implementazione dell'intestazione porteranno i sistemi di build intelligenti a ricostruire tutti gli includer, che potrebbero essere molti molti file
  • se vogliamo evitare il blocco del file oggetto, dobbiamo non solo fare istanze esplicite (come con le dichiarazioni di intestazione incomplete) ma anche aggiungere extern templatesu ogni includer, che i programmatori probabilmente dimenticheranno di fare

Ulteriori esempi di questi sono mostrati in: Istanziazione esplicita del modello: quando viene utilizzata?

Poiché il tempo di compilazione è così critico nei progetti di grandi dimensioni, consiglio vivamente dichiarazioni di modelli incomplete, a meno che parti esterne non abbiano assolutamente bisogno di riutilizzare il codice con le proprie complesse classi personalizzate.

E in tal caso, proverei prima a utilizzare il polimorfismo per evitare il problema del tempo di compilazione e utilizzare i modelli solo se è possibile ottenere notevoli miglioramenti delle prestazioni.

Testato in Ubuntu 18.04.

Il problema noto con i modelli è il rigonfiamento del codice, che è conseguenza della generazione della definizione di classe in ogni modulo che richiama la specializzazione del modello di classe. Per evitare ciò, a partire da C ++ 0x, si potrebbe utilizzare la parola chiave extern davanti alla specializzazione del modello di classe

#include <MyClass>
extern template class CMyClass<int>;

L'istanziazione esplicita della classe template dovrebbe avvenire solo in una singola unità di traduzione, preferibile quella con definizione template (MyClass.cpp)

template class CMyClass<int>;
template class CMyClass<float>;

Se hai già utilizzato extern per le funzioni, per i modelli viene seguita esattamente la stessa filosofia. in caso contrario, potrebbe essere d'aiuto andare dall'esterno per funzioni semplici. Inoltre, potresti voler mettere gli extern nel file di intestazione e includere l'intestazione quando ne hai bisogno.