Vorlagentyp Abzug für Membervariablen und Funktionsargumente

Question

Betrachten Sie die folgende Implementierung eines Template-Klasse:

template<class T> 
class MyClass 
{ 
public: 
    void setVar1(const T& v1) 
    { 
     var1 = v1; 
    } 
    void setVar2(const T1& v2) 
    { 
     var2 = v2; 
    } 

    T var1;   
    T1 var2; 
}; 

Wenn die Template-Parameter T ein Grundtyp ist (wie float, double oder long double) Ich möchte habe T1 = T.

Wenn der Vorlagenparameter Tstd::complex<float> ist, möchte ich T=std::complex<float> und T1 = float haben. Ähnlich für std::complex<double> und std::complex<long double>.

Ableiten der Typ der Variablen ist an Template type derivation diskutiert

jedoch die Zusatzelementfunktionen Nutzung ihrer Lösung in diesem Zusammenhang verhindert.

Answer 1

Eine benutzerdefinierte Traits-Klasse würde ausreichen. Sie können Teilspezialisierungen verwenden, um den gewünschten Typ auszuwählen. Beispielcode

template<typename T, bool F> class Base; 

template<typename T> 
class Base <T, true> { 
public: 
    T var2; 
}; 

template<typename T> 
class Base <std::complex<T>, false> { 
public: 
    typename std::complex<T>::value_type var2; 
}; 

template <typename T> 
class BaseHelper : public Base<T, std::is_fundamental<T>::value> {}; 

template<class T> 
class MyClass : public BaseHelper<T> { 
public: 

    using T1 = decltype(BaseHelper<T>::var2); 

    void setVar1(const T& v1) { 
    var1 = v1; 
    } 
    void setVar2(const T1& v2) { 
    this->var2 = v2; 
    } 

    T var1; 
}; 

Live Example

Es gibt jedoch viele andere Möglichkeiten.

Answer 2

Basierend auf Bo personns Kommentar und die vorgesehene Antwort auf https://stackoverflow.com/questions/47334675/template-type-derivation

ich das folgende Arbeitsbeispiel bekam.

Der Inhalt meiner .h-Datei ist wie folgt.

#include <iostream> 
#include <complex> 
#include <typeinfo> 


template <typename T> 
class MyClass 
{ 


template <typename T0> 
struct myTypeTraits 
{ using type = T0; }; 

template <typename T0> 
struct myTypeTraits<std::complex<T0>> 
{ using type = T0; }; 


public: 

    using T0 = typename myTypeTraits<T>::type; 

    void setVar1(const T0& v); 

    void setVar2(const T& v); 


T getVar2() const; 




    void print() const; 

    T0 var1; 
    T var2; 
}; 

Die CPP-Datei enthält die folgenden Codezeilen.

template <class T> 
void MyClass<T>::setVar1(const T0& v) 
{ 
    var1 = v; 
} 


template <class T> 
void MyClass<T>::setVar2(const T& v) 
{ 
    var2 = v; 
} 



template <class T> 
T MyClass<T>::getVar2() const 
{ 
    return var2; 
} 


template <typename T> 
void MyClass<T>::print() const 
{ 
    std::cout<<"var1: "<<var1<<std::endl; 
    std::cout<<"var2: "<<var2<<std::endl; 

} 



int main() 
{ 

    MyClass<float> tmp; 

    MyClass<std::complex<float> > tmp1; 

    tmp.print(); 
    tmp1.print(); 
    return 0; 
} 

Der obige Code funktioniert wie vorgesehen.

Allerdings habe ich eine andere damit zusammenhängende Frage an Template type deduction in function return type posted