标签: c++23

一些范围适配器，例如filter_\xc2\xadview,take_\xc2\xadwhile_\xc2\xadview和transform_view使用std::optional\ 的同类copyable-box来存储可调用对象：

template<input_\xc2\xadrange V, copy_\xc2\xadconstructible F>\nclass transform_view : public view_interface<transform_view<V, F>> {\n private:\n  V base_ = V();\n  copyable-box<F> fun_;\n};\n

这要求可调用对象F为copy_\xc2\xadconstructible，这也阻止我们将捕获仅移动对象的可调用对象传递给transform_view（Godbolt）：

#include <ranges>\n#include <memory>\n\nstruct MoveOnlyFun {\n  std::unique_ptr<int> x;\n  MoveOnlyFun(int x) : x(std::make_unique<int>(x)) { } \n  int operator()(int y) const { return *x + y; }\n};\n\nint main() {\n  auto r = std::views::iota(0, 5)\n         | std::views::transform(MoveOnlyFun(1));\n}\n

既然view不是必需的copy_constructible，为什么我们要求可调用的呢 …

Cppreference文档包含 5个stdfloat新类型：float16_t、float32_t、float64_t和float128_t。bfloat16_t虽然前 4 种类型是不言自明的（分别是 16、32、64 和 128 位的浮点数），但最后一种类型bfloat16_t对我来说根本不清楚。这个类型代表什么？它的名字中的是什么b意思？

方便的initializer_list语法似乎是以无法移动列表成员、创建不必要的副本为代价的。

struct  A
{
    // some members which are dynamic resources...
    A() { cout << "Default Constructor\n"; }
    A(const A& original) { cout << "Copy constructor\n"; }
    A(A&& original) { cout << "Move constructor\n";  }
};
    
int main() {
    vector<A> v1{ A() , A() }; // calls copy
    vector<A> v2;
    v2.push_back(A()); v2.push_back(A()); // calls move
    return 0;
}

如果我理解正确，这是因为取消引用初始化器迭代器会给出const T，即使尝试移动时也会复制它。

有解决方法吗？

阅读/sf/answers/3101541901/，提出了一种使用可变参数模板的解决方案，如下所示：

template<class Array> struct maker;

// a maker which makes a std::vector
template<class …

我知道 iota 可能很复杂（例如无限），因此在一般情况下这不容易完成，但在某些情况下应该可以在 O(1) 中进行查找/包含操作。

例如

int main() {
    auto vals = views::iota(10'000'000'000, 100'000'000'000);
    return ranges::find(vals, 74'656'000'000) != vals.end();
}

“无限”运行（进行线性搜索）

显然检查可以在 O(1) 内完成。

有没有办法用 C++ 来实现这种通用方式（即在其他视图上查找/包含需要线性时间，并且当它检测到 iota 时需要 O(1)），或者我需要手动检测传递给我的函数的视图是什么时候有限iota视图并进行>=front <=back检查？

class stacktrace_entry {
public:
  string description() const;
  string source_file() const;
  uint_least32_t source_line() const;
  /* ... */
};

struct source_location {
  // source location field access
  constexpr uint_least32_t line() const noexcept;
  constexpr uint_least32_t column() const noexcept;
  constexpr const char* file_name() const noexcept;
  constexpr const char* function_name() const noexcept;
  /* ... */
};

它们的目的基本相同，为什么它们有差异，特别是 中没有列stacktrace_entry，或者甚至不共享同一类？

我正在使用 C++23std::optional添加，但我不知道如何优雅地访问对象的值（如果optional处于活动状态）。

我知道我可以使用if，但这就是C ++20 。

我真的很喜欢 C++23 API 的变化，但我不知道如何跳过实现身份的样板。例如：

#include <functional>
#include <iostream>
#include <optional>

void print(std::optional<std::string>& name) {
    name.transform([](std::string& x) {
        std::cout << x << std::endl;
        // I just want to print, without modifying optional, but next line is required
        return x;
    });
}

int main() {
    std::optional<std::string> name{{"Bjarne"}};
    print(name);
}

感觉就像std::optional缺少invoke会员功能一样。

注意：在我的示例中，我在转换后不会链接任何其他内容，但为了简洁起见，我关心可选内容是否被修改。

关键字constexpr在引入 C++11 标准时对其函数实施了相当严格的限制。C++14 和 C++20 放宽了这些限制（最值得注意）：

• C++14 允许多个return语句static_assert等。
• C++20 允许try并且asm

C++23 进一步软化了这些限制。从我在cppreference中看到的，constexprfor函数似乎只剩下以下含义：

• 它不能是协程
• 对于构造函数和析构函数，该类必须没有虚拟基类
• 对于 constexpr 函数模板和类模板的 constexpr 成员函数，至少一种特化必须满足上述要求。

C++23 甚至删除了 constexpr 函数必须在编译时对于p2448r2中的任何类型“可计算”的限制。根据我的理解，这完全消除了constexpr在编译时评估函数的想法。

是这样吗？如果是这样，constexpr函数还有什么用处呢？