如何在 C++11 中编写这个 C++17 静态 constexpr 方法？

Question

在 C++11 中编写下面的static constexpr size_t Foo<>::sum() 方法最简洁的方法是什么？这适用于 C++17 编译器，但我正在寻找一种在 C++11 模式下适用于 g++、clang 和 Visual Studio 2015 的方法。

#include <iostream>
#include <type_traits>

template<typename T,size_t N>
class Foo
{
  public:
    static constexpr size_t sum();
};

template<typename>
struct is_foo : std::false_type { };
template<typename T,size_t N>
struct is_foo<Foo<T,N>> : std::true_type { };

template<typename T,size_t N>
constexpr size_t Foo<T,N>::sum()
{
    if constexpr (is_foo<T>::value)
        return N + T::sum();
    else
        return N;
}

int main()
{
    constexpr size_t sum = Foo<Foo<Foo<double,3>,4>,5>::sum(); // 12 = 3+4+5
    std::cout << "sum = " << sum << std::endl;
    return 0;
}

编译运行：

$ g++ --version
g++ (GCC) 7.3.1 20180303 (Red Hat 7.3.1-5)
...
$ g++ -std=c++17 sum.cpp
$ ./a.out 
sum = 12

我可以为sum() 编写一个外部函子来完成此任务，但我真的希望它是上面的static constexpr 成员函数。这在 C++11 中是否可行？

Answer 1

我会这样写：

template <typename>
struct foo_sum : std::integral_constant<size_t, 0> {};

template <typename T, size_t N>
struct foo_sum<Foo<T, N>> : std::integral_constant<size_t, foo_sum<T>::value + N> {};

它可以很容易地包装成static constexpr 函数：

template <typename T, size_t N>
constexpr size_t Foo<T, N>::sum()
{
    return foo_sum<Foo<T, N>>::value;
}

Answer 2

HolyBlackCat's answer 的另一种方法是使用函数重载：

template <typename> struct tag {};

template <typename T>
constexpr size_t sum(tag<T>) {
    return 0;
}

template <typename T, size_t N>
constexpr size_t sum(tag<Foo<T,N>>) {
    return sum(tag<T>{}) + N;
}

眼睛可能会轻松一些。还可以让函数返回integral_constants 而不是size_t，这有一些好处。

Answer 3

使用标签调度：

template<typename T,size_t N>
class Foo
{
    static constexpr size_t sum_impl(std::true_type) { return N + T::sum(); }
    static constexpr size_t sum_impl(std::false_type) { return N; };
  public:
    static constexpr size_t sum();
};

sum的实现：

template<typename T,size_t N>
constexpr size_t Foo<T,N>::sum()
{
    return sum_impl( is_foo<T>{} );
}

Answer 4

专攻完整的Foo 课程怎么样？

你也可以避开is_foo。

#include <iostream>
#include <type_traits>

template <typename, std::size_t N>
struct Foo
 { static constexpr std::size_t sum () { return N; } };

template <typename T, std::size_t N1, std::size_t N2>
struct Foo<Foo<T, N1>, N2>
 { static constexpr std::size_t sum () { return Foo<T, N1>::sum() + N2; } };

int main()
{
    constexpr size_t sum = Foo<Foo<Foo<double,3>,4>,5>::sum(); // 12 = 3+4+5
    std::cout << "sum = " << sum << std::endl;
    return 0;
}

-- 编辑--

OP 问：

实际上，Foo 是一个包含许多成员函数的大类。这需要重新声明所有这些吗？

不一定：您可以使用Foo（Bar，在以下示例中）的基类/结构来实现这一点

#include <iostream>
#include <type_traits>

template <typename T, std::size_t N>
struct Foo;

template <typename, std::size_t N>
struct Bar
 { static constexpr std::size_t sum () { return N; } };

template <typename T, std::size_t N1, std::size_t N2>
struct Bar<Foo<T, N1>, N2>
 { static constexpr std::size_t sum () { return Foo<T, N1>::sum() + N2; } };

template <typename T, std::size_t N>
struct Foo : public Bar<T, N>
 { /* many common member and methods */};

int main()
{
    constexpr size_t sum = Foo<Foo<Foo<double,3>,4>,5>::sum(); // 12 = 3+4+5
    std::cout << "sum = " << sum << std::endl;
    return 0;
}