重写的比较运算符和表达式模板答案

【问题标题】：Rewritten comparison operators and expression templates重写的比较运算符和表达式模板
【发布时间】：2021-02-13 14:07:30
【问题描述】：

我有一个有限体积库，受openfoam 的强烈影响，它使连续介质力学问题的解决方案可以用 C++ 编写，就像一个会在纸上。例如，为了求解不可压缩层流的 Navier-Stokes 方程，我只需编写：

solve(div(U * U) - nu * lap(U) == -grad(p));

当然，这个表达式涉及表达式模板，因此系统系数是单程计算的，系统以无矩阵方式求解。

这些表达式模板基于 CRTP，因此所有必要的运算符都在基类中定义。特别是，相等运算符的定义如下：

template <typename T>
class BaseExpr {};

template <std::size_t dim, std::size_t rank, typename... TRest, 
          template <std::size_t, std::size_t, typename...> typename T>
class BaseExpr<T<dim, rank, TRest...>>
{
// ...

public:
  template <typename... URest, template <std::size_t, std::size_t, typename...> typename U>
  SystemExpr<dim, rank, T<dim, rank, TRest...>, U<dim, rank, URest...>>
  operator ==(BaseExpr<U<dim, rank, URest...>> const &rhs) const
    { return {*this, rhs}; }

  SystemExpr<dim, rank, T<dim, rank, TRest...>, Tensor<dim, rank>>
  operator ==(Tensor<dim, rank> const &rhs) const
    { return {*this, rhs}; }
};

其中SystemExpr<dim, rank, T<dim, rank, TRest...>, U<dim, rank, URest...>> 具有延迟评估系数和计算解的功能。

与 OpenFOAM 相比，您必须通过 fvm::lap、fvc::grad 等来表示该术语将被明确评估或隐含地，我采用了我在论文中一直使用的约定：左侧的所有内容都被隐式评估，而右侧的被明确评估。因此，BaseExpr::operator == 不可交换。随着方程变长，这变得越来越有用。例如，可压缩流的ε输运方程为：

solve(div(φ * ε) - div(µt * grad(ε)) / σε + ρ * Sp((C2 * ω + 2.0 / 3.0 * C1 * div(U)) * ε) == C1 * ω * G);

我担心在 C++20 下这种设计可能会因为 operator == 的新“重写候选”而被破坏。 G++-10 编译库没有任何警告 -std=c++20 -Wall -Wextra -pedantic 但我想再次检查一下：上面的代码在 C++20 下格式正确吗？

我知道有些人可能认为上面的设计很糟糕，但我喜欢它以至于我宁愿留在-std=c++17模式而不是使用一个不同的运算符（例如，operator >> 或其他）来表示相等（是的，这是一种相等形式）。

使用 GCC-10.2，我得到了我想要的行为。考虑非定常传热方程：

solve(d(T) / dt - α * lap(T) == 0); // OK: implicit scheme
  
solve(d(T) / dt == α * lap(T)); // OK: explicit scheme

solve(d(T) / dt - 0.5 * α * lap(T) == 0.5 * α * lap(T)); // OK: Crank-Nicholson scheme
  
solve(0 == d(T) / dt - α * lap(T)); // OK: doesn't compile

最后一个示例无法编译完全没问题，因为它没有意义。我得到的错误是：

prova.cpp:51:11: error: return type of ‘VF::TExprSistema<d, r1, T<d, r1, TRest ...>, VF::TTensor<d, r> > VF::TExprBase<T<d, r1, TRest ...> >::operator==(const VF::TTensor<d, r>&) const [with long unsigned int d = 3; long unsigned int r1 = 0; TRest = {VF::TExprBinaria<3, 0, VF::TExprd<3, 0>, double, std::divides<void> >, VF::TExprBinaria<3, 0, double, VF::TExprLap<3, 0, void>, std::multiplies<void> >, std::minus<void>}; T = VF::TExprBinaria]’ is not ‘bool’
   51 |   solve(0 == d(T) / dt - α * lap(T));
      |         ~~^~~~~~~~~~~~~~~~~~~~~~~~~
prova.cpp:51:11: note: used as rewritten candidate for comparison of ‘int’ and ‘VF::TExprBinaria<3, 0, VF::TExprBinaria<3, 0, VF::TExprd<3, 0>, double, std::divides<void> >, VF::TExprBinaria<3, 0, double, VF::TExprLap<3, 0, void>, std::multiplies<void> >, std::minus<void> >’

因此，即使在 C++20 模式下，GCC 的行为似乎也完全符合我的要求。

这是一个“最小”的例子：

#include <cstddef>
#include <utility>
#include <functional>

template<typename>
class TExprBase;

template<std::size_t, std::size_t, typename, typename>
class TExprSistema;

template<std::size_t, std::size_t, typename, typename>
class TExprUnaria;

template<std::size_t, std::size_t, typename, typename, typename>
class TExprBinaria;

template<std::size_t, std::size_t>
class TCampo;

template<typename T>
class TExprBase {};

template<std::size_t d, std::size_t r1, typename... TRest,
         template<std::size_t, std::size_t, typename...> typename T>
class TExprBase<T<d, r1, TRest...>>
{
public:
  template<typename... URest, template<std::size_t, std::size_t, typename...> typename U>
  TExprBinaria<d, r1, T<d, r1, TRest...>, U<d, r1, URest...>, std::plus<>>
  operator +(TExprBase<U<d, r1, URest...>> const &rhs) const
    { return {*this, rhs}; }

  template<typename... URest, template<std::size_t, std::size_t, typename...> typename U>
  TExprBinaria<d, r1, T<d, r1, TRest...>, U<d, r1, URest...>, std::minus<>>
  operator -(TExprBase<U<d, r1, URest...>> const &rhs) const
    { return {*this, rhs}; }

  TExprUnaria<d, r1, T<d, r1, TRest...>, std::negate<>>
  operator -() const
    { return {*this}; }

  template<std::size_t r2, typename... URest,
           template<std::size_t, std::size_t, typename...> typename U>
  TExprBinaria<d, r1 + r2, T<d, r1, TRest...>, U<d, r2, URest...>, std::multiplies<>>
  operator *(TExprBase<U<d, r2, URest...>> const &rhs) const
    { return {*this, rhs}; }

  TExprBinaria<d, r1, T<d, r1, TRest...>, double, std::multiplies<>>
  operator *(double const rhs) const
    { return {*this, rhs}; }

  template<typename... URest, template<std::size_t, std::size_t, typename...> typename U>
  TExprBinaria<d, r1, T<d, r1, TRest...>, U<d, 0u, URest...>, std::divides<>>
  operator /(TExprBase<U<d, 0u, URest...>> const &rhs) const
    { return {*this, rhs}; }

  TExprBinaria<d, r1, T<d, r1, TRest...>, double, std::divides<>>
  operator /(double const rhs) const
    { return {*this, rhs}; }

  template<typename... URest, template<std::size_t, std::size_t, typename...> typename U>
  TExprSistema<d, r1, T<d, r1, TRest...>, U<d, r1, URest...>>
  operator ==(TExprBase<U<d, r1, URest...>> const &rhs) const
    { return {*this, rhs}; }

  operator T<d, r1, TRest...> const &() const
    { return *static_cast<T<d, r1, TRest...> const *>(this); }
};

template<std::size_t d, std::size_t r, typename T, typename U>
class TExprSistema : public TExprBase<TExprSistema<d, r, T, U>>
{
private:
  TExprBase<T> const &lhs;
  TExprBase<U> const &rhs;

public:
  TExprSistema() = delete;

  TExprSistema(TExprBase<T> const &lhs_, TExprBase<U> const &rhs_) :
    lhs(lhs_), rhs(rhs_) {}

  TExprSistema(TExprBase<T> const &lhs_, U const &rhs_) :
    lhs(lhs_), rhs(rhs_) {}
};

template<std::size_t d, std::size_t r, typename T, typename TOp>
class TExprUnaria : public TExprBase<TExprUnaria<d, r, T, TOp>>
{
private:
  T const &rhs;
  [[no_unique_address]] TOp const Op = {};

public:
  TExprUnaria(T const &rhs_) :
    rhs(rhs_) {}
};

template<std::size_t d, std::size_t r, typename T, typename U, typename TOp>
class TExprBinaria : public TExprBase<TExprBinaria<d, r, T, U, TOp>>
{
private:
  T const &lhs;
  U const &rhs;
  [[no_unique_address]] TOp const Op = {};

public:
  TExprBinaria(T const &lhs_, U const &rhs_) :
    lhs(lhs_), rhs(rhs_) {}
};

template<std::size_t d, std::size_t r>
class TCampo : public TExprBase<TCampo<d, r>> {};

template<std::size_t d, std::size_t r, typename T>
class TExprDiv : public TExprBase<TExprDiv<d, r, T>> {};

template<std::size_t d, std::size_t r>
class TExprGrad : public TExprBase<TExprGrad<d, r>> {};

template<std::size_t d, std::size_t r, typename T>
class TExprLap : public TExprBase<TExprLap<d, r, T>> {};

template<std::size_t d, std::size_t r, typename... TRest,
         template<std::size_t, std::size_t, typename...> typename T>
TExprDiv<d, r - 1u, T<d, 1u, TRest...>>
inline div(TExprBinaria<d, r, T<d, 1u, TRest...>, TCampo<d, r - 1u>, std::multiplies<>> const &)
  { return {}; }

template<std::size_t d, std::size_t r>
TExprGrad<d, r + 1u>
inline grad(TCampo<d, r> const &)
  { return {}; }

template<std::size_t d, std::size_t r>
TExprLap<d, r, void>
inline lap(TCampo<d, r> const &)
  { return {}; }

template<std::size_t d, std::size_t r>
class TSistema
{
public:
  template<typename T, typename U>
  TSistema(TExprSistema<d, r, T, U> const &);

  void
  Solve() const;

  void
  friend solve(TSistema const &Sistema)
    { Sistema.Solve(); }
};

template<std::size_t d, std::size_t r, typename T, typename U>
void
inline solve(TExprSistema<d, r, T, U> const &Expr)
  { solve(TSistema(Expr)); }

int main()
{
  TCampo<3u, 1u> U;
  TCampo<3u, 0u> nu, p;

  solve(div(U * U) - nu * lap(U) == -grad(p));

  return 0;
}

【问题讨论】：

你有没有 a == b 在 C++17 中格式错误的情况（而 b == a 很好）？如果没有，你很好。
@Jarod42 评论太长了。我正在编辑问题。
在不知道任何类型是什么的情况下很难回答。你能提供一个minimal reproducible example吗？
@Barry 添加了示例。我认为在这种情况下，口头解释我的情况会更清楚。
看来只有运算符==返回bool才被认为是重写候选，所以这个库可能不会受到影响。

标签： openfoam c++ c++20 comparison-operators spaceship-operator

【解决方案1】：

我将严重简化您的示例，如下所示：

template <typename T>
struct Other { };

template <typename T>
struct Base {
    template <typename U>
    void operator==(Base<U> const&) const;

    template <typename U>
    void operator==(Other<U> const&) const;
};

struct A : Base<A> { };
template <typename T> struct B : Base<B<T>> { };

基本上，您所拥有的是一些 CRTP 基类模板，它可以与任何其他类似的东西相媲美，也可以与任何Other<U> 相媲美。我为这些选择了最简单的非bool 返回类型，也就是说...void。

所以问题就变成了：上述方法有效吗？比较A、B<T> 和Other<U> 的每种组合都有效吗？

答案是：它可能做你想做的事。

比较 A{} 与 B<int>{} 或 B<double>{} 与 B<char>{} 是可以的。在这种情况下，我们既有真正的候选者（来自左侧）和重写的候选者（来自右侧），并且两个候选者都涉及 both 上的派生到基础的转换em> 参数，因此首选未重写的候选者。

即使我们在任一方向上直接比较 Base<K> 和 A 也是如此。这是一个对称比较。

其他类型更有趣。

在那个方向上比较 A{} 和 Other<T>{} 很好。我们像在 C++17 中那样调用成员 operator==，这是唯一的候选对象，它会执行您所期望的操作。

在 C++17 中比较 Other<T>{} 和 A{}（即在另一个方向）是错误的，因为没有任何候选人。但出于不同的原因，它在 C++20 中的格式不正确。现在我们确实有一个候选人：反转的A{} == Other<T>{} 候选人。但是我们后来因为[over.match.oper]/9而拒绝了候选人：

如果通过重载决议为operator @ 选择重写的operator== 候选者，则其返回类型应为cv bool，并且[...]

请注意，bool 要求的返回类型在重载决议的结束开始发挥作用（如果非bool-returning 重写的候选者获胜，则它的格式不正确）而不是比开始（正如你在评论中提到的那样，暗示非bool-returning 函数甚至不被视为重写候选者）。

所以我们确实考虑了这个候选者（这是我们唯一的候选者），但我们拒绝了，因为它是一个无效的重写候选者。结果，它在 C++20 中仍然像在 C++17 中那样格式不正确。由于不同的原因，它现在格式不正确，因此您将收到不同的错误消息。例如，Clang 给了我：

error: return type 'void' of selected 'operator==' function for rewritten '==' comparison is not 'bool'
    b == a;
    ~ ^  ~

而在 C++17 中它会给出：

error: invalid operands to binary expression ('Other<int>' and 'A')
    b == a;
    ~ ^  ~

【讨论】：

是的。它正是我想要的。我基本上不希望重写的候选人获胜。非常感谢。
如果非bool-returning 重写的候选人最终被拒绝，为什么他们会被包含在重载集中？用于诊断？
@metalfox 为什么私有函数包含在重载集中的一般原则相同，即使它们最终会被拒绝。