小编康桓瑋*_*康桓瑋的帖子

考虑以下简单concept：

template <typename T>
concept C = requires(T a) { a.f(); };

如果我们将抽象类类型作为requires 表达式的参数会发生什么？

struct B { virtual void f() = 0; };

static_assert(C<B>);

gcc-trunk 和 msvc-trunk通过断言，但是，clang-trunk、gcc-10.2 和 msvc v19.24拒绝该断言。

标准怎么说？

C++23 引入了std::function的表兄弟std::move_only_function，就像它的名字一样，它是仅移动可调用对象的仅移动包装器（演示）：

#include <functional>
#include <memory>

int main() {
  auto l = [p = std::make_unique<int>(0)] { };
  std::function<void(void)>           f1{std::move(l)}; // ill-formed
  std::move_only_function<void(void)> f2{std::move(l)}; // well-formed
}

但与 不同的是std::function，该标准没有为其定义推导指南（演示）：

#include <functional>

int func(double) { return 0; }
int main() {
  std::function f1{func};           // guide deduces function<int(double)>
  std::move_only_function f2{func}; // deduction failed
}

禁止 CTAD 有理由吗？

考虑struct S具有operator==相同&&限定符和不同const限定符的两个重载：

struct S {
  bool operator==(const S&) && { 
    return true;
  }
  bool operator==(const S&) const && { 
    return true;
  }
};

如果我将两者S与operator==：

S{} == S{};

gcc 和 msvc 接受此代码，clang拒绝它：

<source>:14:7: error: use of overloaded operator '==' is ambiguous (with operand types 'S' and 'S')
  S{} == S{};
  ~~~ ^  ~~~

为什么 clang 认为这里有一个不明确的重载决议？在这种情况下，非常量不应该是最好的候选人吗？

同样，如果我将两个S与合成的进行比较operator!=：

S{} != S{};

gcc 仍然接受此代码，但 msvc …

在 C++20 或 range-TS 中是否有一个已经定义的概念来指定特定类型的范围？

就像是：

template < class T, class InnerType >
concept RangeOf =
  requires(T&& t) {
    requires std::same_as<
           std::remove_cvref_t<decltype(*std::ranges::begin(t))>,
           InnerType
         >;
    std::ranges::end(t);
  };

允许，例如：

void print(const RangeOf<char> auto& char_seq) { /* ... */ }

有没有一种方法可以使用 C++ 概念来要求类派生自模板化类，而模板化类的模板参数又是另一个模板化类的派生类。

例子：

template <class T>
class A{};

template <class T>
class B{};

class X{};
class Y : public A<X> {};

class Z : public B<Y> {};

我如何办理登机手续B，这是某些人的T表格而不指定是什么？我不想添加到 的模板参数列表中，因为我不想在派生自的每个实例上更改代码（例如最后一行）。std::is_base_of<A<X>,T>XXXBBclass Z

我注意到 C++23zip_view有以下限制：

template<input_range... Views>
  requires (view<Views> && ...) && (sizeof...(Views) > 0)
class zip_view;

这意味着只能zip_view压缩输入范围。

/* zipped input_range */
auto zip_in = views::zip(views::iota(0, 3),
                         views::iota(3, 6),
                         views::iota(6, 9));

std::vector<int> v1, v2, v3;
auto make_insert_range = [](auto inserter) {
  return ranges::subrange(inserter, std::unreachable_sentinel);
};
/* zipped output_range */
auto zip_out = views::zip(make_insert_range(std::back_inserter(v1)),
                          make_insert_range(std::back_inserter(v2)),
                          make_insert_range(std::back_inserter(v3)));

/* copy */
ranges::copy(zip_in, zip_out.begin());
std::println("v1: {}", v1); // v1: [0, 1, 2]
std::println("v2: {}", …