C ++ 20概念:GCC和Clang中带有指针类型成员的复合需求表达式的行为差异 [英] C++20 Concepts: Difference in the behavior of the compound requirement expression with a pointer-type member in GCC and Clang

问题描述

考虑以下代码( Godbolt ):

#include <iostream>
//#include <concepts>
#include <type_traits>

// Since the latest clang doesn't have <concepts>,
// took this here: https://en.cppreference.com/w/cpp/concepts/same_as
// Using of std::same_as still gives an error in GCC.
namespace detail {
    template< class T, class U >
    concept SameHelper = std::is_same_v<T, U>;
}

template< class T, class U >
concept same_as = detail::SameHelper<T, U> && detail::SameHelper<U, T>;

template<typename T>
concept HasStr = requires(T a) { { a.str } -> same_as<const char*>; };

struct A {
    const char* str = "A";
};

const char* f(HasStr auto has_str) {
    return has_str.str;
}

int main() {
    A a;
    std::cout << f(a) << "\n";
    return 0;
}

Clang 10.0.1成功编译了该程序.但是GCC 10.2失败了:

Clang 10.0.1 successfully compiles this program. But GCC 10.2 fails:

<source>: In function 'int main()':
<source>:28:21: error: use of function 'const char* f(auto:11) [with auto:11 = A]' with unsatisfied constraints
   28 |     std::cout << f(a) << "\n";
      |                     ^
<source>:22:13: note: declared here
   22 | const char* f(HasStr auto has_str) {
      |             ^
<source>:22:13: note: constraints not satisfied
<source>: In instantiation of 'const char* f(auto:11) [with auto:11 = A]':
<source>:28:21:   required from here
<source>:16:9:   required for the satisfaction of 'HasStr<auto:11>' [with auto:11 = A]
<source>:16:18:   in requirements with 'T a' [with T = A]
<source>:16:38: note: 'a.str' does not satisfy return-type-requirement, because
   16 | concept HasStr = requires(T a) { { a.str } -> same_as<const char*>; };
      |                                    ~~^~~
<source>:16:36: error: deduced expression type does not satisfy placeholder constraints
   16 | concept HasStr = requires(T a) { { a.str } -> same_as<const char*>; };
      |                                  ~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<source>:16:36: note: constraints not satisfied
<source>:9:13:   required for the satisfaction of 'SameHelper<T, U>' [with T = const char*&; U = const char*]
<source>:13:9:   required for the satisfaction of 'same_as<const char*&, const char*>'
<source>:9:31: note: the expression 'is_same_v<T, U> [with T = const char*&; U = const char*]' evaluated to 'false'
    9 |     concept SameHelper = std::is_same_v<T, U>;
      |                          ~~~~~^~~~~~~~~~~~~~~
Compiler returned: 1

最有趣的部分是:

<source>:9:31: note: the expression 'is_same_v<T, U> [with T = const char*&; U = const char*]' evaluated to 'false'

据我了解，在复合要求中， {a.str} 表达式的类型为 const char *& 而不是 const char * .那么，为什么会这样呢?哪个编译器是正确的?

As I understand it, in the compound requirement { a.str } expression has type const char*& instead of const char*. So, why is this happening? Which compiler is correct?

推荐答案

通过阅读

By my reading of [expr.prim.req.compound]/1, GCC is correct to emit an error:

必须满足decltype((E))的类型约束的立即声明约束([temp.param]).

The immediately-declared constraint ([temp.param]) of the type-constraint for decltype((E)) shall be satisfied.

附带示例:

requires {
  { E1 } -> C;
  { E2 } -> D<A₁, ⋯, An>;
};

等同于

requires {
  E1; requires C<decltype((E1))>;
  E2; requires D<decltype((E2)), A₁, ⋯, An>;
};

decltype((a.str))确实是 const char *& ，所以我希望这就是传递给 same_as .

decltype((a.str)) is indeed const char*&, so I would expect that this is what's passed to same_as.

这篇关于C ++ 20概念:GCC和Clang中带有指针类型成员的复合需求表达式的行为差异的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！