C++如何從1模板類投射到另一個模板類？

Question

我有一個課程，我打算使用與類型float或double。據我所知，沒有辦法限制模板選項，所以也許我可能會在這裏做一些危險的事情？

template<class T> 
class A 
{ 
    A(T arg) { _data = arg; } 

    T _data; 
} 

typedef A<float> A_f; 
typedef A<double> A_d; 

我該怎麼做？

int main() 
{ 
    A_f f(3.1415); 
    A_d d(3.1415); 
    f = (A_f)d; 
} 

IE：將包含double類型數據的類轉換爲包含float類型數據的類。

編輯：這似乎並沒有在任何地方去，所以我想這個玩弄，但很明顯，我不知道在這裏做什麼，因此不會編譯...

template<class T> 
class A 
{ 
    friend     // Intention is for T to be double here 
    A<float> operator A<float>(const A<T> input); 
} 

A<float> operator A<float>(const A<double> input) 
{ 
    return A<float>(input._data); 
} 

也許這有助於解釋我想實現的目標？

亞當

第二個編輯：

return A<float>((float)input._data); 

這是更好？

Answer 1

有一個選項可以根據您提供的類型自定義一個類。該技術被稱爲「模板專業化」

#include <iostream> 
using namespace std; 

template <typename T> 
class A { 
public: 
    void print_my_type() { 
     cout << "Generic template instance" << endl; 
    } 

    explicit operator A<int>() const { 
     cout << "Casting to int" << endl; 
     return A<int>(); 
    } 
}; 

template <> 
class A<int> { 
public: 
    void print_my_type() { 
     cout << "Class templated with an int" << endl; 
    } 

    explicit operator A<double>() const { 
     cout << "Casting to double" << endl; 
     return A<double>(); 
    } 
}; 

int main() { 
    A<double> a; 
    A<int> b; 

    a.print_my_type(); 
    b.print_my_type(); 

    a = static_cast<A<double>>(b); 

    return 0; 
} 

您不應該投射那樣的對象。如果你打算有一個對象，你想投向另一個。您應該提供一個operator A()方法，以便它可以正常處理轉換

Answer 2

不要投射，但提供一個（且只有一個）隱式轉換構造函數或轉換運算符。你的情況可能是微不足道的operator T() const { return _data; }

Answer 3

你可以使用std::enable_if只允許某些類型：

#include <type_traits> 
using namespace std; 

// Our catch-all is not defined, so will not compile 
// Could also be made to print a nice error message 
template<typename T, typename Sfinae = void> class A; 

// Ok if T is float or double 
template<typename T> 
class A<T, typename std::enable_if<std::is_same<T, float>::value 
           || std::is_same<T, double>::value>::type> 
{ 
    // Your class here 
}; 

int main() 
{ 
    A<int> a; // FAILS 
    A<float> b; // Ok 
    A<double> c; // Ok 

    return 0; 
} 

然後你只需要在你的類定義轉換運營商投工作。

Answer 4

我將第二，你不應該投這樣的，但如果你堅持，添加一個模板拷貝構造函數的參數：

template<class T> 
class A 
{ 
public:         // add this 
    A(T arg) { _data = arg; } 

    template <class U>     // add this 
    A(A<U> arg) { _data = arg._data; } // add this 

    T _data; 
} 

這將然後允許從A<U>轉換到A<T>只要U是可以隱式轉換爲T。

Answer 5

實例與模板轉換操作符+ static_assert類型驗證：

http://coliru.stacked-crooked.com/a/6b01010ea5f02aee

#include <vector> 
#include <iostream> 

template < typename T > class TD; // type visualiser 

template<class T> 
class A 
{ 
    public: 
    A(T arg) { _data = arg; } 

    template<typename D> 
    operator A<D>() { 
     static_assert(std::is_same<D, float>::value || std::is_same<D, double>::value, "double/floats allowed only"); 
     //TD<D>(); // D is float here 
     return static_cast<D>(_data); 
    } 

    T _data; 
}; 

typedef A<float> A_f; 
typedef A<double> A_d; 
typedef A<int> A_i; 

int main() { 
    A_f f(3.14151); 
    A_d d(3.14152); 

    std::cout << f._data << std::endl; 
    std::cout << d._data << std::endl;  

    f = (A_f)d; 
    //f = (A_i)d; // static assertion here 

    std::cout << f._data << std::endl; 
    return 0; 
} 

[編輯]

template<class T> 
class A 
{ 
public: 
    A(T arg) { _data = arg; } 

    template<typename D> 
    operator A<D>() { 
    static_assert(std::is_same<D, float>::value || std::is_same<D, double>::value, "double/floats allowed only"); 
    //TD<D>(); // D is float here 
    return A<D>(static_cast<D>(_data)); 
    } 

    T _data; 
};