为什么模板化的 c++ 函数在 Visual Studio 2013 下无法编译

Why the templated c++ function does not compile under Visual Studio 2013

我正在尝试实现一个模板化函数,以便该函数只接受某些特定类型的输入。我尝试了 std::enable_if 和 std::is_base_of 来实现目标。简化代码如下所示。当启用 c++11 时,代码使用 clang++ 或 g++ 编译和运行。但是当我用 Visual Studio 2013 编译它时,它总是说 could not deduce template argument for 'is_base_class'。谁能告诉我为什么 Visual Studio 2013 无法编译以及如何解决这个问题?

#include <type_traits>
#include <map>
#include <unordered_map>
#include <iostream>

using namespace std;

template <class Type>
struct TypeWrapper {};

template <class T0, class T1>
struct CompoundType : public TypeWrapper<T0>, public TypeWrapper<T1> {};

template <class Type,
    typename std::enable_if<
        std::is_base_of<
             TypeWrapper<Type>,
             CompoundType<
                 std::map<typename Type::key_type, typename Type::mapped_type>,
                 std::unordered_map<typename Type::key_type, typename Type::mapped_type>
             >
        >::value
        , Type
    >::type* is_base_class = nullptr
>
void TemplatedFunction(Type map) {
    std::cout << "Hello, world!" << std::endl;
}

int main(int argc, char *argv[])
{
    std::unordered_map<int, double> a;
    TemplatedFunction(a);
}

解决方法:

template <typename T,
          typename K = typename T::key_type,
          typename V = typename T::mapped_type>
struct rebind_to_unordered_map
{
    using type = std::unordered_map<K, V>;
};

template <typename T,
          typename K = typename T::key_type,
          typename V = typename T::mapped_type>
struct rebind_to_map
{
    using type = std::map<K, V>;
};

template <class Type>
typename std::enable_if<
        std::is_base_of<
             TypeWrapper<Type>,
             CompoundType<
                 typename rebind_to_map<Type>::type,
                 typename rebind_to_unordered_map<Type>::type
             >
        >::value
        , void
    >::type
TemplatedFunction(const Type& ) {
    std::cout << "Hello, world!" << std::endl;
}

甚至

template <class Type,
          typename K = typename Type::key_type,
          typename V = typename Type::mapped_type,
          typename std::enable_if<
             std::is_base_of<
               TypeWrapper<Type>,
               CompoundType<std::map<K, V>, std::unordered_map<K, V>
             >
        >::value
        , Type
    >::type* is_base_class = nullptr
>
void TemplatedFunction(Type map) {
    std::cout << "Hello, world!" << std::endl;
}