Question

我正在使用函子以以下方式生成编译时计算的代码（我为长代码道歉，但这是我发现的再现行为的唯一方法）：

#include <QtWidgets>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    QMainWindow w;
    QLabel *central_widget = new QLabel("Central Widget");
    central_widget->setAlignment(Qt::AlignCenter);
    w.setCentralWidget(central_widget);
    QDockWidget *dock = new QDockWidget("left");
    w.addDockWidget(Qt::LeftDockWidgetArea, dock);
    dock->setWidget(new QTextEdit);
    w.show();
    return a.exec();
}

我使用带有以下标志的GCC 8.2.0进行编译：

#include <array>
#include <tuple>

template <int order>
constexpr auto compute (const double h)
{
  std::tuple<std::array<double,order>,
         std::array<double,order> > paw{};

  auto xtab = std::get<0>(paw).data();
  auto weight = std::get<1>(paw).data();

  if constexpr ( order == 3 )
              {
            xtab[0] =  - 1.0E+00;
            xtab[1] =    0.0E+00;
            xtab[2] =    1.0E+00;

            weight[0] =  1.0 / 3.0E+00;
            weight[1] =  4.0 / 3.0E+00;
            weight[2] =  1.0 / 3.0E+00;
              }
  else if constexpr ( order == 4 )
              {
            xtab[0] =  - 1.0E+00;
            xtab[1] =  - 0.447213595499957939281834733746E+00;
            xtab[2] =    0.447213595499957939281834733746E+00;
            xtab[3] =    1.0E+00;

            weight[0] =  1.0E+00 / 6.0E+00;
            weight[1] =  5.0E+00 / 6.0E+00;
            weight[2] =  5.0E+00 / 6.0E+00;
            weight[3] =  1.0E+00 / 6.0E+00;
              }

  for (auto & el : std::get<0>(paw))
      el = (el + 1.)/2. * h ;

  for (auto & el : std::get<1>(paw))
    el = el/2. * h ;

  return paw;
}


template <std::size_t n>
class Basis
{
public:

  constexpr Basis(const double h_) :
    h(h_),
    paw(compute<n>(h)),
    coeffs(std::array<double,n>())
  {}

  const double h ;
  const std::tuple<std::array<double,n>,
           std::array<double,n> > paw ;
  const std::array<double,n> coeffs ;

  constexpr double operator () (int i, double x) const
  {
    return 1. ;
  }

}; 

template <std::size_t n,std::size_t p,typename Ltype,typename number=double>
class Functor
{
 public:
  constexpr Functor(const Ltype L_):
    L(L_)
  {}

  const Ltype L ;

  constexpr auto operator()(const auto v) const 
  {
    const auto l = L;
    // const auto l = L();
    std::array<std::array<number,p+1>,p+1> CM{},CM0{},FM{};
    const auto basis = Basis<p+1>(l);
    typename std::remove_const<typename std::remove_reference<decltype(v)>::type>::type w{};

    for (auto i = 0u; i < p + 1; ++i)
      CM0[i][0] += l;
    for (auto i = 0u ; i < p+1 ; ++i)
      for (auto j = 0u ; j < p+1 ; ++j)
        {
          w[i] += CM0[i][j]*v[j];
        }
    for (auto b = 1u ; b < n-1 ; ++b)
      for (auto i = 0u ; i < p+1 ; ++i)
        for (auto j = 0u ; j < p+1 ; ++j)
          {
            w[b*(p+1)+i] += CM[i][j]*v[b*(p+1)+j];
            w[b*(p+1)+i] += FM[i][j]*v[(b+1)*(p+1)+j];
          }
    return w ;
  }
};

int main(int argc,char *argv[])
{
  const auto nel = 4u;
  const auto p = 2u;
  std::array<double,nel*(p+1)> x{} ;
  constexpr auto L = 1.;
  // constexpr auto L = [](){return 1.;};
  const auto A = Functor<nel,p,decltype(L)>(L);
  const volatile auto y = A(x);
  return 0;
}

当查看生成的程序集时，正在运行时执行计算。

如果我更改下面两行注释的两行，则会发现代码确实在编译时正在执行，并且只将volatile变量的值放在了程序集中。

我试图生成一个较小的示例来重现此行为，但是在编译时确实会计算出代码中的微小变化。

我以某种方式理解为什么提供-march=native -std=c++1z -fconcepts -Ofast -Wa,-adhln lambda会有所帮助，但是我想理解为什么在这种情况下提供double不能工作。理想情况下，我不想提供lambda，因为它会使前端变得更混乱。

此代码是非常庞大的代码库的一部分，因此请忽略该代码实际在计算什么，我创建了此示例以演示行为，仅此而已。

在不更改编译时行为的情况下，向函子提供双精度并将其存储为constexpr成员变量的正确方法是什么？

为什么在const函数中进行小的修改（例如，其他小的修改也是如此）确实会产生编译时间代码？

我想了解GCC提供这些编译时计算的实际条件是什么，因为我正在工作的实际应用程序需要它。

谢谢！

Answer 1

不确定是否要理解何时在运行时执行代码以及何时在编译时执行代码，无论如何，C ++语言的规则（不仅是g ++，而且忽略了as-if规则）是constexpr功能

可以在运行时执行，并且在计算值知道运行时（例如：来自标准输入的值）时必须在运行时执行。
可以在编译时执行，并且在结果到达严格要求编译时知道值的地方时必须在编译时执行（例如：constexpr变量的初始化，非类型模板参数，C样式的数组尺寸，static_assert()个测试）
有一个灰色区域-当编译器知道计算编译时所涉及的值，但计算值没有到达严格要求编译时值的地方时-编译器可以选择是否计算编译时或运行时。

如果您对此感兴趣

const volatile auto y = A(x);

在我看来，我们处在灰色区域，编译器可以选择是否计算y编译时或运行时的初始值。

如果您想要一个y初始化的编译时，我想您可以获得定义它（以及前面的变量）的constexpr

  constexpr auto nel = 4u;
  constexpr auto p = 2u;
  constexpr std::array<double,nel*(p+1)> x{} ;
  constexpr auto L = 1.;
  // constexpr auto L = [](){return 1.;};
  constexpr auto A = Functor<nel,p,decltype(L)>(L);
  constexpr volatile auto y = A(x);

Answer 2

for (auto i = 0u; i < p + 1; ++i)
  CM0[i][0] += l;

当l是无状态lambda类型时，它将l转换为函数类型，然后转换为bool（整数类型）。允许进行两步转换，因为只有一个是“用户定义的”。

此转换始终产生1，并且不取决于l的状态。

constexpr函子中的成员导致运行时执行

2 个答案: