函数是否有可能只接受给定参数的有限类型集？

Question

我知道如何使用模板处理任何数据类型：

template<typename T>
T myFunc(T data) { ... }

但是有没有办法将允许的类型集缩小到例如int 和char 或std::string 和std::wstring，所以编译器在遇到不允许的参数类型时会抛出错误，我会在编译时而不是运行时出错？

编辑：非常感谢 ecatmur，现在我理解了整个概念。

template<typename itemA_type, typename itemB_type>
typename std::enable_if<
  (
    std::is_same<itemA_type, int>::value ||
    std::is_same<itemA_type, char>::value) &&
  (
    std::is_same<itemB_type, std::string>::value ||
    std::is_same<itemB_type, std::wstring>::value ||
    std::is_same<itemB_type, const char*>::value ||
    std::is_same<itemB_type, const wchar_t*>::value
  ) ,
  void
>::type
myFunction(itemA_type itemA, itemB_type itemB) {
  using namespace std;
  cout << itemA << itemB << endl;
}

Answer 1

采用这个实用程序特征类：

template<typename T, typename U, typename... Us>
struct is_any_of
    : std::integral_constant<
        bool,
        std::conditional<
            std::is_same<T,U>::value,
            std::true_type,
            is_any_of<T,Us...>
        >::type::value
      >
{ };

template<typename T, typename U>
struct is_any_of<T,U> : std::is_same<T,U>::type { };

然后你可以在静态断言中使用它：

template<typename T>
T myFunc(T data)
{
    static_assert( is_any_of<T, int, char, std::string>{}, "T not allowed");
}

如果您觉得更合适，可以使用std::is_convertible 或std::is_constructible 代替std::is_same。

Live example.

Answer 2

使用enable_if 和is_same 的简单解决方案：

template<typename T>
typename std::enable_if<
    std::is_same<T, int>::value ||
    std::is_same<T, char>::value,
    T>::type
myFunc(T data) { ... }

随着T 上的谓词变得更加复杂（例如，您是否只允许string 和wstring，或basic_string 的其他特化？）您可能开始想要编写更复杂的谓词元函数；但现在，一个简单的表达式可能就足够了。

Answer 3

您可以使用 SFINAE 做到这一点：

#include <type_traits>

template<class T> struct AllowedType : std::false_type {};
template<> struct AllowedType<int> : std::true_type {}; // Add more specializations.
template<> struct AllowedType<char> : std::true_type {}; // Add more specializations.

template<typename T>
typename std::enable_if<AllowedType<T>::value, T>::type
myFunc(T data);

int main() {
    myFunc(1);   // int, okay
    myFunc('c'); // char, okay
    myFunc(1.);  // double, fail
}

或者你可以指定允许的类型集合为boost::mpl::vector<>序列（效果同上）：

#include <boost/mpl/vector.hpp>
#include <boost/mpl/contains.hpp>
#include <boost/utility/enable_if.hpp>

typedef boost::mpl::vector<int, char> allowed_type_set;

template<typename T>
typename boost::enable_if<boost::mpl::contains<allowed_type_set, T>, T>::type
myFunc(T data);

int main() {
    myFunc(1);   // int, okay
    myFunc('c'); // char, okay
    myFunc(1.);  // double, fail
}

Answer 4

Trait 类需要大量输入，而 boost 是一个重度依赖项，只是为了获得一个简单的类型列表。我会为此实现一个简单的可变参数类型列表模板：

template <typename...>
struct typelist {
    template <typename U>
    static constexpr bool contains() {
        return false;
    }
};

template <typename Head, typename...Tail>
struct typelist<Head, Tail...> {
    template <typename U>
    static constexpr bool contains() {
        return std::is_same<Head, U>::value || typelist<Tail...>::template contains<U>();
    }
};

所以myFunc 变成：

template<typename T>
typename std::enable_if<typelist<int,char,std::string>::contains<T>(), T>::type
myFunc(T data);

See it live at Coliru.

---

拥有 Concepts Lite 会很好，这样我们就可以编写：

template <typename T, typename...Types>
concept bool InList() {
    return typelist<Types...>::template contains<T>();
}

template<InList<int,char,std::string> T>
T myFunc(T data);

使用语法要简单得多。

Answer 5

template<class...>struct types{typedef types type;};
template<class T, class types>struct contains:std::false_type {};
template<class T, class T0, class... Ts>struct contains<T, types<T0, Ts...>>:
  std::integral_constant<bool,
    std::is_same<T, T0>::value || contains<T, types<Ts...>>::value
  >
{};

使用上述，我们可以使用 SFINAE 或标签调度。您可能还想考虑std::is_convertible 而不是is_same。

typedef types<int,double, std::string> allowed_types;

template<typename T, typename=typename std::enable_if< contains<T, allowed_types>::value >::type>
T myFunc(T data) {
  // code
}

或标签调度：

namespace details {
  template<typename T>
  T myFunc(T data, std::true_type) {
    // code
  }
}
template<typename T>
T myFunc(T data) {
  return details::myFunc(std::forward<T>(data), contains<T, allowed_types>{});
}

它会产生很好的错误并允许您轻松编写后备版本，或者通过static_assert 来编写：

template<typename T>
T myFunc(T data) {
  static_assert(contains<T, allowed_types>{}, "type not allowed");
  // code
}

所有这些都有不同的优点。虽然 SFINAE 看起来很诱人，但我建议不要这样做：它很脆弱，会产生疯狂的错误消息。

Answer 6

您可以使用重载、SFINAE、标签分派或特化来实现此目的。都可以产生你想要的结果。