訪問函數的限制

Question

我有一個泛型類，帶有一個函數，我只想在編譯時限制爲浮點類型的實例。如下例所示：

template <typename T> 
class ClassName 
{ 
    // instance variables, etc.. 

    void some_method() 
    { 
     // do stuff, but only for floating point types 
    } 
} 

如何使編譯器拒絕some_method用於非浮點類型的ClassName？

我一直在尋找SFINAE，但我根本無法得到它的工作，所以經過幾個小時的失敗，我要求你的幫助。

謝謝:)

Answer 1

您可以使用std::is_floating_point和std::enable_if組合，僅能夠用於浮點類型的功能：

#include <type_traits> 

template <typename T> 
class ClassName 
{ 
    // instance variables, etc.. 
public: 
    template<typename T2 = T, 
      typename = typename std::enable_if< std::is_floating_point<T2>::value >::type> 
    void some_method() 
    { 
    // do stuff, but only for floating point types 
    } 
}; 

int main() 
{ 
    ClassName<double> d; // OK 
    d.some_method();  // OK 
    ClassName<int> i; // OK 
    i.some_method();  // ERROR 
} 

Answer 2

使用static_assert，如果你的編譯器支持C++ 11

void some_method() 
{ 
    static_assert(std::is_floating_point<T>::value, "Only for floating points"); 
    // do stuff, but only for floating point types 
} 

然後會有編譯錯誤，如果你嘗試調用非浮點參數此方法。

而對於沒有浮點：

static_assert(!std::is_floating_point<T>::value, "and only for non-floating point"); 

Answer 3

void some_method(){ 

    if (std::is_floating_point<T>::value) 
    { 
     // do stuff, but only for floating point types 
    } 
    else 
    { 
     return; 
    } 
} 

我boost::is_floating_point嘗試過： -

#include <boost/utility/enable_if.hpp> 
#include <boost/type_traits/is_floating_point.hpp> 

template <typename T> 
class ClassName { 
typename boost::enable_if<boost::is_floating_point<T> >::type 
some_method(const T & t) 
{ 

} 
}; 

int main() 
{ 
ClassName<float> p; //Compiles 

/* Following throws error, 
error: no type named 'type' in 
    'struct boost::enable_if<boost::is_floating_point<int>, void>' 
ClassName<int> q; 
*/ 
} 

Answer 4

事情是這樣的：

template< typename Tdummy = T, typename = typename std::enable_if< std::is_floating_point<Tdummy>::value >::type > 
void some_method() 
{ 
} 

編輯來闡述。這將導致以下結果。編譯器將僅爲具有浮點模板參數的ClassName生成some_method()。它不會爲非浮點類型生成，並會導致編譯時錯誤。

#include <type_traits> 

template <typename T> 
class ClassName 
{ 
    // instance variables, etc.. 
    template< typename Tdummy = T, typename = typename std::enable_if< std::is_floating_point<Tdummy>::value >::type > 
    void some_method() 
    { 
     // do stuff, but only for floating point types 
    } 

void some_general_method 
    { 
    // general stuff for all types 
    } 
}; 

int main() 
{ 
ClassName<float> bar; 
ClassName<int> foo; 

bar.some_general_method(); // OK 
foo.some_general_method(); // OK 

bar.some_method(); // OK 
foo.some_method(); // Compile-time ERROR 

return(0); 
} 

Answer 5

As detailed in this answer，你需要的成員函數是SFINAE工作模板（Live example at Coliru ）：

template <typename T> 
class ClassName 
{ 
    // instance variables, etc.. 

public: 
    template <typename = typename std::enable_if<std::is_floating_point<T>::value>::type> 
    void some_method() 
    { 
     // do stuff, but only for floating point types 
    } 
}; 

Answer 6

更新每R. Martinho費爾南德斯評論

#include <type_traits> 

template <typename T> 
struct ClassName 
{ 
    // instance variables, etc.. 

    template<typename R = T> 
    void some_method() 
    { 
     static_assert(std::is_floating_point<R>::value, 
      "ClassName<T>::some_method is implemented only for floating " 
       "point T"); 
     // do stuff, but only for floating point types 
    } 
}; 

int main() 
{ 
    ClassName<float> f; 
    f.some_method(); 
    ClassName<int> i; 
    i.some_method(); // <-- static_asserts here 
    return 0; 
}