为什么 C 编译器可以将函数声明为 constexpr，而 constexpr 不能是 constexpr？

Question

为什么 C 编译器可以将函数声明为 constexpr，而 constexpr 不能是 constexpr？

例如:http://melpon.org/wandbox/permlink/AGwniRNRbfmXfj8r

#include <iostream>
#include <functional>
#include <numeric>
#include <initializer_list>

template<typename Functor, typename T, size_t N>
T constexpr reduce(Functor f, T(&arr)[N]) {
  return std::accumulate(std::next(std::begin(arr)), std::end(arr), *(std::begin(arr)), f);
}

template<typename Functor, typename T>
T constexpr reduce(Functor f, std::initializer_list<T> il) {
  return std::accumulate(std::next(il.begin()), il.end(), *(il.begin()), f);
}

template<typename Functor, typename T, typename... Ts>
T constexpr reduce(Functor f, T t1, Ts... ts) {
  return f(t1, reduce(f, std::initializer_list<T>({ts...})));
}

int constexpr constexpr_func() { return 2; }

template<int value>
void print_constexpr() { std::cout << value << std::endl; }

int main() {
  std::cout << reduce(std::plus<int>(), 1, 2, 3, 4, 5, 6, 7) << std::endl;  // 28
  std::cout << reduce(std::plus<int>(), {1, 2, 3, 4, 5, 6, 7}) << std::endl;// 28

  const int input[3] = {1, 2, 3};   // 6
  std::cout << reduce(std::plus<int>(), input) << std::endl;

  print_constexpr<5>(); // OK
  print_constexpr<constexpr_func()>();  // OK
  //print_constexpr<reduce(std::plus<int>(), {1, 2, 3, 4, 5, 6, 7})>(); // error 

  return 0;
}

输出:

28
28
6
5
2

为什么此行出错：//print_constexpr

• std：:p lus - constexpr T 运算符（）（ const T

为什么编译器允许将reduce（）标记为constexpr，但即使在编译时传递给reduce（）的所有参数都是已知的，也不能将reduce？

对于一些支持C 14-std=c 14的编译器具有相同的效果：

• x86 GCC 7.0.0-std=c 1z-O3：http://melpon.org/wandbox/permlink/AGwniRNRbfmXfj8r
• x86 gcc 4.9.2-std=c 14-O3：https://godbolt.org/g/wmAaDT
• x86 gcc 6.1-std=c 14-O3：https://godbolt.org/g/WjJQE5
• x86 clang 3.5-std=c 14-O3：https://godbolt.org/g/DSCpYv
• x86 clang 3.8-std=c 14-O3：https://godbolt.org/g/orSrgH
• x86 Visual C-您应该将代码复制粘贴到：http://webcompiler.cloudapp.net/
• ARM gcc 4.8.2、ARM64 gcc 4.8、PowerPC gcc 4.8、AVR gcc 4.5.3-不支持C 14-std=c 14

对于所有这些情况，编译OK，直到未使用的行:< code>//print_constexpr




Answer 1

如果您确实编写了此代码：

  constexpr int result = reduce(std::plus<int>(), {1, 2, 3, 4, 5, 6, 7});

您将看到reduce不会产生constexpr结果。

原因是因为“注意：非 constexpr 函数”累积

std::accumulate不是constexpr

编辑扩展以回答实际问题，谢谢@peterchen：它是在达到用法时编译的，在编译模板的特定版本之前，它不会也无法尝试解析函数。当它遇到用法并触发编译时，它会解决累积并看到它不是 constexpr，因此发出错误。

Answer 2

让我们直接从它的提案开始，www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf 在第 4.1 节第三段中：我引用：

可以使用非常量表达式调用常量表达式函数，在这种情况下，不需要在编译时计算结果值。

请参阅此问题：constexpr 函数何时在编译时被计算？

template<typename Functor, typename T>
T constexpr reduce(Functor f, std::initializer_list<T> il) {
  return std::accumulate(std::next(il.begin()), il.end(), *(il.begin()), f);
}

同样，如您所知，< code>std::accumulate不是一个< code>constexpr函数。

template<int value>
void print_constexpr() { std::cout << value << std::endl; }

同样，如您所知，非类型模板参数必须是常量表达式。

现在:

template<typename Functor, typename T>
T constexpr reduce(Functor f, std::initializer_list<T> il) {
  return std::accumulate(std::next(il.begin()), il.end(), *(il.begin()), f);
}

至于为什么会这样:C标准是这么说的:

[dcl.constexpr/6]（强调我的）：

如果 constexpr 函数模板的实例化模板专用化或类模板的成员函数无法满足 constexpr 函数或 constexpr 构造函数的要求，则该专用化仍然是 constexpr 函数或 constexpr 构造函数，即使对此类函数的调用不能出现在常量表达式中......

注意:那个

从函数模板实例化的函数称为函数模板专门化；

如果不是模板，它将失败：

int constexpr reduce(int(*f)(int, int), std::initializer_list<int> il) {
  return std::accumulate(std::next(il.begin()), il.end(), *(il.begin()), f);
}

编译器现在会抱怨，不能在定义为constexpr的函数中调用非constexprfunction

Answer 3

匿名用户

为什么 C 编译器可以将函数声明为 constexpr，而 constexpr 不能是 constexpr？

它没有。但您没有定义函数的。您正在定义一个模板。

让我们设置：

struct Is_constexpr {
  constexpr Is_constexpr() = default;
  constexpr auto bar() {
    return 24;
  }
};

struct Not_constexpr {
  auto bar() {
    return 24;
  }
};

现在，如果您尝试将一个函数（而不是模板）定义为使用Not_constexpr编译器不允许您：

constexpr auto foo_function(Not_constexpr v)
{
  return v.bar();
  // error: call to non-constexpr function 'auto Not_constexpr::bar()'
}

但是，您正在定义一个模板。让我们看看这是怎么回事：

template <class T>
constexpr auto foo(T v)
{
  return v.bar();
}

编译器允许您这样做。没有错误。为什么？因为是模板。有些实例化可能是< code>constexpr，有些不是，这取决于< code>T:

int main() {
  constexpr Is_constexpr is_c;
  constexpr Not_constexpr not_c;

  std::integral_constant<int, foo(is_c)> a; // OK
  //std::integral_constant<int, foo(not_c)> a; // ERROR

}