C++ 03：相互排斥的方法，由於enable_if

Question

在一個類中，我有兩種不同的方法，根據調用者模板參數應該是相互排斥的。

class Foo 
{ 
    // For collections 
    template<class T> 
    typename boost::enable_if<boost::is_same<typename std::vector<typename T::value_type>, T>::value, const T&>::type 
    doSomething() 
    { } 


    // For single types 
    template<class T> 
    typename boost::enable_if<!boost::is_same<typename std::vector<typename T::value_type>, T>::value, const T&>::type 
    doSomething() 
    { } 
} 

這不會編譯。

error: type/value mismatch at argument 1 in template parameter list for 'template struct boost::enable_if' error: expected a type, got '! boost::is_same::value'

Answer 1

如果你想要的是超載基礎上的功能是否給你一個載體或不

#include <type_traits> 
#include <iostream> 
#include <vector> 

using std::cout; 
using std::endl; 

class Foo { 
public: 
    // For collections 
    template <class T> 
    const vector<T>& do_something(const std::vector<T>& input) { 
     cout << __PRETTY_FUNCTION__ << endl; 
     return input; 
    } 


    // For single types 
    template <class T> 
    const T& do_something(const T& input) { 
     cout << __PRETTY_FUNCTION__ << endl; 
     return input; 
    } 
}; 

int main() { 
    auto foo = Foo{}; 
    auto v = std::vector<int>{}; 
    auto i = int{}; 
    foo.do_something(v); 
    foo.do_something(i); 
} 

如果你想更加普遍和檢查任何實例化的類型

#include <type_traits> 
#include <iostream> 
#include <vector> 

using std::cout; 
using std::endl; 

namespace { 

    template <typename T, template <typename...> class TT> 
    struct IsInstantiationOf 
      : public std::integral_constant<bool, false> {}; 
    template <template <typename...> class TT, typename... Args> 
    struct IsInstantiationOf<TT<Args...>, TT> 
      : public std::integral_constant<bool, true> {}; 
} // namespace anonymous 

class Foo { 
public: 
    // For collections 
    template <typename VectorType, typename std::enable_if_t<IsInstantiationOf< 
      std::decay_t<VectorType>, std::vector>::value>* = nullptr> 
    void do_something(VectorType&&) { 
     cout << "Vector overload" << endl; 
    } 

    // For single types 
    template <class T, typename std::enable_if_t<!IsInstantiationOf< 
      std::decay_t<T>, std::vector>::value>* = nullptr> 
    void do_something(T&&) { 
     cout << "Non vector overload" << endl; 
    } 
}; 

int main() { 
    auto foo = Foo{}; 
    auto v = std::vector<int>{}; 
    auto i = int{}; 
    foo.do_something(v); 
    foo.do_something(i); 
} 

---

另請注意，您應該避免將std::enable_if放在函數簽名中，可能由於這些原因https://stackoverflow.com/a/14623831/5501675

Answer 2

如何：

template <typename T> struct is_std_vector : std::false_type {}; 
template <typename T, typename A> 
struct is_std_vector<std::vector<T, A>> : std::true_type {}; 

然後

class Foo 
{ 
    // For collections 
    template<class T> 
    typename std::enable_if<is_std_vector<T>::value, const T&>::type 
    doSomething(); 

    // For single types 
    template<class T> 
    typename std::enable_if<!is_std_vector<T>::value, const T&>::type 
    doSomething(); 
}; 

Answer 3

不像std的版本，boost::enable_if接受型（下布爾值還挺包裝器），所以你應該喜歡寫東西

class Foo 
{ 
    // For collections 
    template<class T> 
    typename boost::enable_if< 
     typename boost::is_same<typename std::vector<typename T::value_type>, T>, 
    const T&>::type doSomething() 
    { } 


    // For single types 
    template<class T> 
    typename boost::enable_if_с< 
     !boost::is_same<typename std::vector<typename T::value_type>, T>::value, 
    const T&>::type doSomething() 
    { } 
} 

請注意這裏，我已經使用typename之前boost::is_same，並沒有在第一個規範中使用::value。相反，我不得不在第二次過載中使用enable_if_с，因爲!運算符不適用於某個類型。

Answer 4

怎麼樣的一種標籤調度？

#include <vector> 
#include <iostream> 

template <typename, typename> 
struct isSame 
{ typedef int type; }; 

template <typename T> 
struct isSame<T, T> 
{ typedef long type; }; 

struct foo 
{ 
    template <typename T> 
    T const & doSomething (T const & t, int) 
    { std::cout << "int version" << std::endl; return t; } 

    template <typename T> 
    T const & doSomething (T const & t, long) 
    { std::cout << "long version" << std::endl; return t; } 

    template <typename T> 
    T const & doSomething (T const & t) 
    { return doSomething(t, typename isSame< 
     typename std::vector<typename T::value_type>, T>::type()); } 
}; 

int main() 
{ 
    foo f; 
    std::vector<int> v; 
    f.doSomething(v); // print "long version" 
}