Aufruf explizit instanziiert Template-Funktion durch Umwandlung Operator

Question

Nehmen wir an, wir eine Funktion Vorlage haben, die in der CPP-Datei mit Hilfe von expliziten Instanziierung wie dies umgesetzt wird:

function.h

template<typename T> void function(T val); 

function.cpp

#include "function.h" 

template<typename T> void function(T val) { /* do something */ } 

template void function<double>(double val); 

Wir sind nun in der Lage die Funktion in einer Hauptdatei aufzurufen, die function.h wie folgt enthält:

double val = 1.0; 

function(val); 

Nehmen wir weiter an haben wir eine Klasse, die wie folgt durchgeführt wird:

data.h

class Data 
    { 
    private: 
     double mVal; 

    public: 
     Data(double val) { mVal = val; } 

     operator double() { return mVal; } 
    }; 

der folgende Code führt zum Linkerfehler LNK2019: nicht aufgelöstes externes (Visual Studio 2010):

Data a(1.0); 

function(a); 

Wir sind einer der folgenden Ausdrücke verwenden könnte eine-Funktion()

function<double>(a); 
function(double(a)); 
... 

aber warum ist es nicht möglich, einfach anrufen Funktion (a) zu liefern? Gibt es eine andere Lösung, um dies zu erreichen, ohne die Funktion function() mit dem Typ Data explizit zu instanziieren?

Answer 1

Warum ist es nicht möglich, einfach function(a) anzurufen?

Es ist. Du rufst es an. Aber denken Sie daran, dass function als deklariert ist:

template<typename T> void function(T val); 

so Vorlage Abzug function<Data> ableiten wird. Der Vorlagenabzug weiß nicht, dass Sie an anderer Stelle im Code nur eine Definition für function<double> haben - es macht nur einen Abzug. Und function<Data> hat keine Definition, daher kann es nicht verlinkt werden.

Die explizite Besetzung selbst (entweder function<double>(a) oder function(static_cast<double>(a))) wäre meiner Meinung nach die beste Lösung. Explizit ist nett. Sie könnten zusätzlich eine separate Funktion mit allen Überlastungen schreiben Sie tatsächlich unterstützen und nur uns auf die Funktionsvorlage:

void fwd_function(double v) { function(v); } 
void fwd_function(foo v) { function(v); } 
void fwd_function(bar v) { function(v); } 

fwd_function(a); // now we call function<double> because fwd_function(double) 
       // is the what we're actually calling 

Answer 2

Es ist nicht möglich function(a) zu nennen, weil dann T vom Typ sein Data und nicht double, obwohl es diesen Konvertierungsoperator hat. Und weil Sie es nicht explizit in der Datei cpp definieren, erhalten Sie einen Linker-Fehler.

Hier sind einige Lösungen könnten Sie verwenden:

//Call operator double() explicitly 
function(a.operator double()); 

//Specify T 
function<double>(a); 

//Casting 
function(static_cast<double>(a));