enable_ifと複数の条件の問題

Question

ジェネリック型を文字列に変換する関数を実装しようとしました。積分型は、std::string()を使用してstd::to_string()、文字列と文字を使用して、要素ごとにベクトルを、他の方法の1つ（内容に応じて）を使用して文字列に変換する必要があります。

これは私が持っているものです。

//Arithmetic types  

template<class T> 
typename std::enable_if<std::is_arithmetic<T>::value, std::string>::type convertToString(const T& t){ 
    return std::to_string(t); 
} 

//Other types using string ctor 

template<class T> 
typename std::enable_if<std::__and_<std::__not_<std::is_arithmetic<T>>::type, 
     std::__not_<std::is_same<T, <T, 
     std::vector<typename T::value_type, typename T::allocator_type>>::value 
     >>>::value, std::string>::type convertToString(const T& t){ 
    return std::string(t); 
} 

//Vectors 

template<class T> 
typename std::enable_if<std::is_same<T, std::vector<typename T::value_type, 
    typename T::allocator_type>>::value, std::string>::type convertToString(const T& t){ 
    std::string str; 
    for(std::size_t i = 0; i < t.size(); i++){ 
     str += convertToString(t[i]); 
    } 
    return str; 
} 

問題は、第二の機能がコンパイルされないということです。 2番目の関数をコンパイル（および動作）し、あいまいさの問題を起こさないように、どのようにして2番目の関数を設計できますか？

Answer 1

Oktalist's答えは説明しています。また、__and_と__not_を使用しないでください。それらは予約されており、次のコンパイラバージョンでは簡単に変更できます。独自のバージョンの特徴を実装するのは簡単です（たとえば、conjunctionの実装をご覧ください）。

私は全く異なるアプローチを提案します。私たちは、はるかに簡単これらのケースの過負荷を作るためにchoice<>を使用することができます。

template <int I> struct choice : choice<I+1> { }; 
template <> struct choice<10> { }; 

経由：

// arithmetic version 
template <class T> 
auto convertToStringHelper(T const& t, choice<0>) 
    -> decltype(std::to_string(t)) 
{ 
    return std::to_string(t); 
} 

// non-arithmetic version 
template <class T> 
auto convertToStringHelper(T const& t, choice<1>) 
    -> decltype(std::string(t)) 
{ 
    return std::string(t); 
} 

// vector version 
template <class T, class A> 
std::string convertToStringHelper(std::vector<T,A> const& v, choice<2>) 
{ 
    // implementation here 
} 

template <class T> 
std::string convertToString(T const& t) { 
    return convertToStringHelper(t, choice<0>{}); 
} 

あなたがenable_if嫌なもののいずれかなしにすべてSFINAEを取得するので、これはいいです。

Answer 2

1つの可能な方法はis_vectorトレイト（詳細はhereを見て）追加することです：

template<typename T> struct is_vector : public std::false_type {}; 

template<typename T, typename A> 
struct is_vector<std::vector<T, A>> : public std::true_type {}; 

をそして次のように関数テンプレートをconvertToStringあなたを変更します。

// Arithmetic types 

template<class T> 
typename std::enable_if<std::is_arithmetic<T>::value, std::string>::type convertToString(const T& t) { 
    return std::to_string(t); 
} 

// Other types using string ctor 

template<class T> 
typename std::enable_if<!std::is_arithmetic<T>::value && !is_vector<T>::value, std::string>::type convertToString(const T& t) { 
    return std::string(t); 
} 

// Vectors 

template<class T> 
typename std::enable_if<!std::is_arithmetic<T>::value && is_vector<T>::value, std::string>::type convertToString(const T& t) { 
    std::string str; 
    for(std::size_t i = 0; i < t.size(); i++){ 
     str += convertToString(t[i]); 
    } 
    return str; 
} 

wandbox example

Answer 3

温度後半にマークされエラーが発生した：

template<class T> 
typename std::enable_if<std::__and_<std::__not_<std::is_arithmetic<T>>::type, 
//                 ^^^^^^[1] 
     std::__not_<std::is_same<T, <T, 
//         ^^^[2] 
     std::vector<typename T::value_type, typename T::allocator_type>>::value 
//                  ^^^^^^^[3] 
     >>>::value, std::string>::type convertToString(const T& t){ 
//  ^[4] 
    return std::string(t); 
} 
// [1] nested ::type not needed and ill-formed without typename keyword 
// [2] <T, is garbage 
// [3] nested ::value ill-formed because std::__not_ argument must be a type 
// [4] too many closing angle brackets 

を固定エラーのテンプレート：あなたのタイプの形質がコンパイルできない理由

template<class T> 
typename std::enable_if<std::__and_<std::__not_<std::is_arithmetic<T>>, 
     std::__not_<std::is_same<T, 
     std::vector<typename T::value_type, typename T::allocator_type>> 
     >>::value, std::string>::type convertToString(const T& t){ 
    return std::string(t); 
}