C++ 模板参数推断和默认模板参数

下面的代码在使用clang和gcc时按照我的要求进行编译和工作，但在使用Visual Studio 2015 RTM时出现错误。我认为clang和gcc允许这样做是正确的，但我不确定。这段代码应该编译吗

#include <iostream>
#include <type_traits>
#include <utility>

template <typename T, size_t N, typename IS = decltype(std::make_index_sequence<N>{})>
struct Vector {
    T e_[N];
};

template <typename T, typename U, size_t N, size_t... Is>
constexpr auto operator+(const Vector<T, N, std::index_sequence<Is...>>& x,
                         const Vector<U, N>& y) {
    using V = std::common_type_t<T, U>;
    return Vector<V, N>{x.e_[Is] + y.e_[Is]...};
}

int main() {
    const auto v0 = Vector<float, 4>{1, 2, 3, 4};
    const auto v1 = Vector<float, 4>{5, 6, 7, 8};
    const auto v2 = v0 + v1;
    for (auto x : v2.e_) std::cout << x << ", ";
    std::cout << std::endl;
}

#包括
#包括
#包括
模板
结构向量{
T_[N]；
};
模板
常量表达式自动运算符+（常量向量和x，
常数向量（y）{
使用V=std:：common_type_t；
返回向量{x.e_[Is]+y.e_[Is]…}；
}
int main（）{
const auto v0=向量{1,2,3,4}；
const auto v1=向量{5,6,7,8}；
常数自动v2=v0+v1；
对于（auto x:v2.e_u2;）std:：cout
IS
不应是
向量类型的一部分。相反，请使用辅助函数：

template <typename T, std::size_t N>
struct Vector {
    T e_[N];
};

template <typename T, typename U, std::size_t N, std::size_t... Is>
inline constexpr auto add_impl(const Vector<T, N>& x, const Vector<U, N>& y,
                               std::index_sequence<Is...>) {
    using V = std::common_type_t<T, U>;
    return Vector<V, N>{x.e_[Is] + y.e_[Is]...};
}

template <typename T, typename U, std::size_t N,
          typename Is = std::make_index_sequence<N>>
constexpr auto operator+(const Vector<T, N>& x, const Vector<U, N>& y) {
    return add_impl(x, y, Is());
}

模板
结构向量{
T_[N]；
};
模板
内联常量表达式自动添加\u impl（常量向量&x，常量向量&y，
std:：索引（U序列）{
使用V=std:：common_type_t；
返回向量{x.e_[Is]+y.e_[Is]…}；
}
模板
常量表达式自动运算符+（常量向量与x、常量向量与y）{
返回add_impl（x，y，Is（））；
}

我没有访问VS2015的权限来测试这个，但它应该可以工作。
除非我遗漏了什么，
decltype（std:：make_index_sequence{}）
完全是无稽之谈，应该是
std:：make_index_sequence
@orlp好的观点。我不确定我怎么会错过这一点-我正在重构从中提取的真实代码，这就是最终的结果。有趣的是，更改它会让问题在VS2015中消失。然后这是一个编译器错误，因为N从本质上讲，它们应该是等价的。@orlp同意，你已经解决了我的问题，尽管如此，谢谢：-）这就是我最初做事情的方式。尽管如此，以这种方式重构它还是有一些好处。不仅如此，它让我可以用
constexpr
：-）解决另一个Visual Studio 2015 bug。主要的动机是减少inli在调试构建中定义深度。
template <typename T, std::size_t N>
struct Vector {
    T e_[N];
};

template <typename T, typename U, std::size_t N, std::size_t... Is>
inline constexpr auto add_impl(const Vector<T, N>& x, const Vector<U, N>& y,
                               std::index_sequence<Is...>) {
    using V = std::common_type_t<T, U>;
    return Vector<V, N>{x.e_[Is] + y.e_[Is]...};
}

template <typename T, typename U, std::size_t N,
          typename Is = std::make_index_sequence<N>>
constexpr auto operator+(const Vector<T, N>& x, const Vector<U, N>& y) {
    return add_impl(x, y, Is());
}