如何在概念中使用 C++ requires 子句来要求成员变量满足概念约束？

Question

我正在观看 C++ 20 Concepts Presentation ，在尝试重现代码时，我似乎被卡住了。

我试图要求树的根应该满足 MyObjConcept0_，为简单起见，它只是一个 int。当我在 Tree_ 概念的 requires 子句中使用这个概念时，为什么结果是错误的？

我尝试直接从演示文稿中复制代码，但仍然没有成功。为什么 { t.root } 子句的返回类型是 int& - 我的意思是它是有道理的，因为当您以这种方式访问​​成员时，您会获得引用。

那么为什么在 39:00 的演示文稿中 this（与 MyObjConcept0_ 相同）需要通过子句？

从本次演示开始，标准是否发生了变化，还是我盲目地遗漏了什么？

#include <concepts>
#include <functional>

// Type is an int
template<typename T>
concept MyObjConcept0_ = std::same_as<T,int>;

// Type is any type that decays to int
template<typename T>
concept MyObjConcept1_ = std::same_as<std::decay_t<T>,int>;

// Type is an int&
template<typename T>
concept MyObjConcept2_ = std::same_as<T,int&>;



template<typename T>
concept Tree_ = requires (T t) {
    { t.root } -> MyObjConcept0_;          // does not work : This is the concept I want to use  
    { t.root } -> MyObjConcept1_;          // works but will pass for int and int& : unsafe
    { t.root } -> MyObjConcept2_;          // works but checks that t.root is an int&
    std::same_as<decltype(t.root),int>; // works: verbose and not a concept
};

template<MyObjConcept0_ MyObjConcept0T>
struct tree {
    MyObjConcept0T root;
};

static_assert(Tree_<tree<int>>);

Answer 1

复合要求

{ e } -> Concept;

意味着e 必须是一个有效的表达式并且Concept<decltype((e))> 必须成立。注意双括号，这很重要。让我们来一个更简单的树，我不知道为什么需要一个模板：

struct X {
    int root;
};

X t;

虽然decltype(t.root) 是int（该成员变量的声明类型是int），但decltype((r.root)) 是int&（因为它是int 类型的左值，因此是int&）。结果：

template <typename T>
concept Tree = requires(T t) {
    { t.root } -> std::same_as<int&>;
};

Tree<X> 成立 - 因为t.root 是int 类型的左值。

---

clang 只是弄错了。它没有实现P1084，这是#45088。

Answer 2

表达式的需求检查类型。为了评估一个变量的类型，你必须检查一个对你的变量的decltype进行编码的表达式。

template <typename T>
struct wrap{};

// member declared as `int`
{ wrap<decltype(t.intv)>() } -> std::same_as<wrap<int>>;

// member declared as `int&`
{ wrap<decltype(t.intlrefv)>() } -> std::same_as<wrap<int&>>;

// member declared as `int&&`
{ wrap<decltype(t.intrrefv)>() } -> std::same_as<wrap<int&&>>;

Answer 3

谢谢大家或您的回答，他们为我指明了正确的方向，但它们对我的问题还不够通用。因为关键问题是将概念类型传递给另一个概念的 requires 子句。我应该--of-指定。

在编译器资源管理器上几个小时后，我找到了一个解决方案。 在 clang 10.0.0 及更高版本中使用 -std=c++20 ：

#include <type_traits>
#include <functional>


template<typename T>
concept Node_ = std::is_object_v<T>; 

template<typename T>
concept Tree_ = requires (T t) {
    { t.root } -> Node_;
    /* implement child tuple constraints here */
};

// Generic tree object 
template<Node_ NodeT /*, Tree_ ... ChildrenT*/>
struct tree {
    NodeT root;
    /* implement child tuple here */
};

struct test_tree_int { int root; }; // Should satisfy tree concept
struct test_tree_intref { int& root; }; // Shouldnt satisfy tree concept


static_assert(Tree_<tree<int>>);
static_assert(Tree_<test_tree_int>);
//static_assert(Tree_<test_tree_intref>); /// Compilation fails

这对我之前不起作用的原因是因为我使用的是 GCC 10.2，它实际上确实存在 Barry 提到的编译器问题：Concept 中的双括号会产生参考。

似乎所有解决方案都会增加代码膨胀，这将使使用这些概念比帮助更麻烦。