考虑这个例子:

template <typename T> inline constexpr bool C1 = true;    
template <typename T> inline constexpr bool C2 = true;

template <typename T> requires C1<T> && C2<T> 
constexpr int foo() { return 0; }

template <typename T> requires C1<T> 
constexpr int foo() { return 1; }

constexpr int bar() {
    return foo<int>();
}

是调用foo<int>()不明确，或者约束 C1<T> && C2<T>包含 C1<T> ？

最佳答案

是的。 只有 概念可以被包含。调用foo<int>是模棱两可的，因为这两个声明都不是“至少与”另一个声明一样受约束。

但是，如果 C1和 C2都是concept s 而不是 inline constexpr bool s，然后是 foo() 的声明返回 0至少与 foo() 的声明一样受到限制返回 1 , 以及对 foo<int> 的调用将有效并返回 0 .这是更喜欢使用概念作为对任意 bool 常量表达式的约束的原因之一。

背景

这种差异的原因(概念包含，任意表达式不包含)在 Semantic constraint matching for concepts 中得到了最好的表达。 ，值得全文阅读(我不会在这里重述所有论点)。但以论文为例:

namespace X {
  template<C1 T> void foo(T);
  template<typename T> concept Fooable = requires (T t) { foo(t); };
}
namespace Y {
  template<C2 T> void foo(T);
  template<typename T> concept Fooable = requires (T t) { foo(t); };
}

X::Fooable is equivalent to Y::Fooable despite them meaning completely different things (by virtue of being defined in different namespace). This kind of incidental equivalence is problematic: an overload set with functions constrained by these two concepts would be ambiguous.

That problem is exacerbated when one concept incidentally refines the others.

namespace Z {
  template<C3 T> void foo(T);
  template<C3 T> void bar(T);
  template<typename T> concept Fooable = requires (T t) {
    foo(t);
    bar(t);
  };
}

An overload set containing distinct viable candidates constrained by X::Fooable, Y::Fooable, and Z::Fooable respectively will always select the candidate constrained by Z::Fooable. This is almost certainly not what a programmer wants.

标准引用

包含规则在[temp.constr.order]/1.2中:

an atomic constraint A subsumes another atomic constraint B if and only if the A and B are identical using the rules described in [temp.constr.atomic].

原子约束在 [temp.constr.atomic] 中定义:

An atomic constraint is formed from an expression E and a mapping from the template parameters that appear within E to template arguments involving the template parameters of the constrained entity, called the parameter mapping ([temp.constr.decl]). [ Note: Atomic constraints are formed by constraint normalization. E is never a logical AND expression nor a logical OR expression. — end note ]

Two atomic constraints are identical if they are formed from the same expression and the targets of the parameter mappings are equivalent according to the rules for expressions described in [temp.over.link].

这里的关键是原子约束是形成的。这是这里的关键点。在 [temp.constr.normal] :

The normal form of an expression E is a constraint that is defined as follows:

• The normal form of an expression ( E ) is the normal form of E.
• The normal form of an expression E1 || E2 is the disjunction of the normal forms of E1 and E2.
• The normal form of an expression E1 && E2 is the conjunction of the normal forms of E1 and E2.
• The normal form of an id-expression of the form C<A₁, A₂, ..., A_n>, where C names a concept, is the normal form of the constraint-expression of C, after substituting A₁, A₂, ..., A_n for C's respective template parameters in the parameter mappings in each atomic constraint. If any such substitution results in an invalid type or expression, the program is ill-formed; no diagnostic is required. [ ... ]
• The normal form of any other expression E is the atomic constraint whose expression is E and whose parameter mapping is the identity mapping.

对于 foo 的第一次重载, 约束是 C1<T> && C2<T> , 所以为了规范化它，我们得到 C1<T> 的范式的合取₁ 和 C2<T> ₁ 然后我们就完成了。同样，对于 foo 的第二次重载, 约束是 C1<T> ₂ 是它自己的范式。

使原子约束相同的规则是它们必须由相同的表达式(源代码级构造)形成。虽然这两个函数都具有使用标记序列 C1<T> 的原子约束，它们与源代码中的文字表达式 不同。

因此下标表明这些实际上不是同一个原子约束。 C1<T> ₁ 不等于 C1<T> <子>2。规则不是 token 等价!所以第一个foo的 C1<T>不包含第二个 foo的 C1<T> ，反之亦然。

因此，模棱两可。

另一方面，如果我们有:

template <typename T> concept D1 = true;    
template <typename T> concept D2 = true;

template <typename T> requires D1<T> && D2<T> 
constexpr int quux() { return 0; }

template <typename T> requires D1<T> 
constexpr int quux() { return 1; }

第一个函数的约束是D1<T> && D2<T> .第三个项目符号给了我们 D1<T> 的结合和 D2<T> .第 4 个项目符号然后引导我们代入概念本身，因此第一个项目符号归一化为 true。 ₁ 和第二个变成true <子>2。同样，下标表示哪个 true正在被提及。

第二个函数的约束是D1<T> ，将(第 4 个项目符号)标准化为 true ₁.

现在，true ₁ 确实是与 true 相同的表达式₁，因此这些约束被认为是相同的。结果，D1<T> && D2<T>包含 D1<T> , 和 quux<int>()是返回 0 的明确调用.

关于c++ - 约束包含是否仅适用于概念？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/53941789/