La specializzazione del modello non riesce al collegamento

Question

Ho un problema con la specializzazione dei modelli che vorrei capire. Sto lavorando con Visual C++ 10.0 (2010). Ho una classe come questa:

class VariableManager 
{ 
public: 

    template<typename VarT> 
     VarT get(std::string const& name) const 
     { 
        // Some code... 
     } 

    // This method supposed to be fully evaluated, linkable method. 
    template<> 
     std::string get<std::string>(std::string const& name) const; 

private: 
    std::map<std::string, boost::any> mVariables; 
}; 

In teoria, perché mi sono specializzato il metodo "get", il linker dovrebbe essere in grado di raccogliere da un file oggetto. Invece, ottengo un errore riferimento non risolto con il linker se ho posto il metodo nel file di origine:

template<> 
    std::string VariableManager::get<std::string>(std::string const& name) const 
      { 
       // Doing something... 
      } 

Se metto questo metodo nel file di intestazione come linea, la build va più che bene. Capisco che funzioni modello come questo:

 template<typename VarT> 
      VarT get(std::string const& name) const; 

deve essere posto nell'intestazione perché il compilatore non sarà in grado di specializzarsi il modello in base al codice chiamante, ma nel caso della piena specializzazione è il l'implementazione di classe che lo fa, quindi il metodo template specializzato dovrebbe già esistere come simbolo pubblico. Qualcuno potrebbe far luce su questo problema?

Answer 1

La tua analisi è corretta - un modello di funzione esplicitamente specializzato che dispone di tutti i parametri di modello specificate con valori espliciti fornisce una definizione completa di una funzione.

Se è stato incluso correttamente il file .cpp corrispondente che contiene la definizione della specializzazione esplicita nel progetto, VC++ non deve generare un errore del linker. Per quanto riguarda la conformità agli standard, tuttavia, tieni presente che devi dichiarare la tua specializzazione al di fuori dello della classe che li ospita. Lo Standard proibisce di dichiarare le specializzazioni esplicite all'interno della classe che le include (e altri compilatori rifiuteranno il tuo codice). Quindi modificare il file di intestazione per dichiarare la specializzazione in questo modo, invece

class VariableManager 
{ 
public: 

    template<typename VarT> 
     VarT get(std::string const& name) const 
     { 
        // Some code... 
     } 

private: 
    std::map<std::string, boost::any> mVariables; 
}; 

// This method supposed to be fully evaluated, linkable method. 
template<> 
std::string VariableManager::get<std::string>(std::string const& name) const; 

Lasciatemi nota anche che non si può chiamare get<std::string> all'interno del vostro corpo di classe. Questo perché qualsiasi chiamata di questo tipo non vedrebbe ancora la dichiarazione di specializzazione esplicita e quindi proverebbe a creare un'istanza della funzione dalla definizione del modello. Lo standard rende malformato tale codice, senza che sia necessaria una diagnostica.

Answer 2

La specializzazione di un modello non costringe il compilatore a istanziarlo (penso che GCC lo faccia comunque); devi ancora dire esplicitamente al compilatore di istanziare realmente il modello. Puoi farlo con l'istanziazione del template esplicita. In pratica, basta aggiungere questo nel file di origine:

template std::string VariableManager::get(const std::string& name) const; 

Answer 3

Metodo partendo template<> è ancora considerato un templatespecializzazione metodo. Quindi devi essere messo in un file di intestazione.

Se si desidera inserirlo in un file di implementazione, è necessario sovraccaricare .

class VariableManager 
{ 
//... 
    VarT get(std::string const& name) const 
    {} 

    std::string get(std::string const& name) const; //overloading not specialization 
};