标签: c++23

如何在 C++23 中迭代 2 个容器的“枚举 zip”？
在Python中，我会写这样的东西：

A = [10, 20, 30]
B = [40, 50, 60]
for (i, (a, b)) in enumerate(zip(A, B)):
  print(i, a, b)

它依次输出和中的索引i和相应元素。AB

在 C++23 中enumerate，zip存在等效项 ( <ranges>)，但我不知道如何正确组合它们。

  using namespace std;
  
  auto A = vector {10, 20, 30};
  auto B = vector {40, 50, 60};
  
  // zip
  for (auto [a, b]: views::zip(A, B))
    cout << a << " " << b << "\n";
  
  // enumerate
  for …

我遇到了这种奇怪的行为，如果您创建一个列表的分块视图（由 2 个元素组成），然后尝试在范围 for 循环中打印正面和背面，则前面的方法将起作用，但后面的方法将不起作用t。它将产生一个编译器错误，指出实例化 .back() 方法需要双向迭代器。我错过了什么吗？

重现错误的代码

#include <iostream>
#include <list>
#include <ranges>
#include <vector>

int main() {
  std::list<int> nums_list = {0, 1, 2, 3, 4, 5};

  auto rng = nums_list | std::views::chunk(2);
  for (auto pair : rng) {
    std::cout << pair.front(); // Front will work normally
    std::cout << pair.back();  // No matching member function for 'back'.
  }
}

我也用矢量尝试过，它按预期工作。

cppreference 说std::string::contains出来了， https ://en.cppreference.com/w/cpp/string/basic_string/contains

但没有运行时要求。是否保证在线性时间内运行？（比如，在实现中使用 KMP 算法）还是二次时间？

我试图在当前的 C++ 标准草案（http://open-std.org/jtc1/sc22/wg21/docs/papers/2020/n4849.pdf）中找到它，但我找不到参考。

<spanstream>将在 C++23 中首次亮相（请参阅cppreference）。根据提案，它们是std::span基于缓冲区的字符串流。

我的问题是：

• 是否std::spanstream与旧的std::strstream（或strstream在 C++ 98 中已弃用）有些等效？
• 在 C++ 23 完全发布后使用它们有什么好处？

反射 TS - 此处描述的 C++ 功能：https : //en.cppreference.com/w/cpp/keyword/reflexpr

我正在寻找有关此功能的任何信息。

我有这个描述编译器支持的表：https : //en.cppreference.com/w/cpp/compiler_support

但我没有看到此功能是计划中的，或者此功能的名称可能不同？

哪个 C++ 版本将支持此功能？

我在哪里可以找到有关此主题的任何教程/信息？

来自提案的 \xc2\xa74.2.7 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p0847r7.html#pathological-cases

它说：

\n

这些更不可能是真正有用的代码。在此示例中，B既不能转换为A也int，因此这两个函数甚至都不能使用普通成员语法调用。但是，您可以获取指向此类函数的指针并通过该指针调用它们。(&B::bar)(42)有效，如果奇怪，请致电。

\n

但是，它没有指定标准是否不允许将 type-of-self 的显式对象参数隐式转换为特定的另一种类型。

struct A { };\nstruct B {\n    void foo(this A&);\n    void bar(this int);\n};\n

这是否意味着：

struct A { };\nstruct B {\n  operator A() const noexcept;\n  void foo(this A);\n};\n\n// ...\n// \'&B::foo\' is of type function pointer not pointer to member function\n// because it uses explicit object parameter.\n(&B::foo)(A{}); \n(&B::foo)(B{});\nB{}.foo(); // will work?\n

将工作？

在另一种情况下，这是一个 lambda。由于 lambda 的类型是不可言说的并且始终是相关的。那上面的案例呢？（这个无捕获 lambda …

我想混合 co_yielding 字符串文字和std::strings

Generator<std::string_view> range(int first, const int last) {
    while (first < last) {
        char ch = first++;
        co_yield " | ";
        co_yield std::string{ch, ch, ch};
    }
}

但是，我想知道 std::string 的生命周期？

如果您知道要string_view立即食用，也许是安全的？

for(auto sv : range(65, 91))
   std::cout << sv;

https://godbolt.org/z/d5eoP9aTE

你可以像这样保证安全

Generator<std::string_view> range(int first, const int last) {
    std::string result;
    while (first < last) {
        char ch = first++;
        co_yield " | ";
        result = std::string{ch, ch, ch};
        co_yield result;
    }
}

我正在阅读 cpp 23 标准，我偶然发现了std::unexpected.

Expected.un.cons部分定义

template<class Err = E>
constexpr explicit unexpected(Err&& e);

具有以下约束（除其他外）

is_same_v<remove_cvref_t<Err>, unexpected> is false; 

考虑到unexpected是一个类模板，这个表达式什么时候为真？

考虑以下十六进制表示的字节序列（ASCII 解释，如果有，在第二列中作为阅读辅助）：

0x73 s\n0x74 t\n0x61 a\n0x74 t\n0x69 i\n0x63 c\n0x5f _\n0x61 a\n0x73 s\n0x73 s\n0x65 e\n0x72 r\n0x74 t\n0x28 (\n0x55 U\n0x27 \'\n0xe2\n0x84\n0xab\n0x27 \'\n0x3d =\n0x3d =\n0x55 U\n0x27 \'\n0xc3\n0x85\n0x27 \'\n0x29 )\n0x3b ;\n

此字节序列解码为 UTF-8 读取

static_assert(U\'\xe2\x84\xab\'==U\'\xc3\x85\');\n

请注意，左侧\xe2\x84\xab是 Unicode 标量值

0x212B ANGSTROM SIGN\n

右侧\xc3\x85是 Unicode 标量值

0x00C5 LATIN CAPITAL LETTER A WITH RING ABOVE\n

当字节序列被解释为强制支持的 UTF-8 编码中的源时，断言在 C++23 中是否应该失败？

在翻译阶段1，将UTF-8序列解码为Unicode标量值序列后，这些标量值应该映射到翻译字符集的元素以形成翻译字符集元素的序列，请参阅[ lex.phases] /1.1 . 根据[lex.charset]/1.1，除了未分配的标量值之外，翻译字符集的元素是具有分配的 Unicode 代码点的抽象字符。

我能找到的最接近抽象字符的 …

auto()在 C++23 中，由于or ，完美转发纯右值变得更加容易auto{}。有了这个新工具，现在是否可以为具有以下要求的FORWARD(e)表达式构建表达式？e

1. FORWARD(e)与 具有相同的类型e，忽略引用限定符
2. ifdecltype(e)是左值/右值引用，则FORWARD(e)分别是左值/x值
3. 否则，FORWARD(e)具有相同的值类别e
4. 不得进行额外的复制或移动

我们已经可以进行不完美转发了std::forward：

#define FORWARD(...) ::std::forward<decltype(__VA_ARGS__)>(__VA_ARGS__)

这会保留类型并适当地转换引用。但是，纯右值将转换为 xvalue，因为std::forward返回右值引用（即FORWARD(e)转换后是 xvalue）。

作为结果：

T x = T();          // copy elision because x is initialized to prvalue
T x = FORWARD(T()); // calls move constructor

是否有可能在 C++ 中进行真正的完美转发，包括保留纯右值？