标签: c++20

#include <iostream>
#include <numeric>
#include <ranges>
#include <vector>
#include <string>
#include <string_view>

int main() {
    auto str = (
        std::views::iota(1)
        | std::ranges::views::take(5)
        | std::ranges::views::transform([](int x) -> std::string_view {
            return std::to_string(x) + "|";
        })
        | std::ranges::views::join
    );

    for (const char ch : str) {
        std::cout << ch;
    }

    return 0;
}

我是 cpp 函数式编程的新手。我想生成前五个自然数并将它们转换为字符串，然后连接它们并打印它。

如果我使用std::stringlambda 的返回类型进行转换，它会在编译时引发许多错误。我想我应该把它改成std::string_view. 我这样改了，编译没有编译错误。但是，如果我std::string_view在那里使用，lambda 函数仅返回字符串的引用，并且当 lambda 结束时，堆栈内存上的翻译字符串将被从内存中删除。因此，该程序不会打印任何内容。

我该如何修复它？

我在大型代码库中定义了几个数学数字常量。其中几个（但不是全部）现在在新的 C++20<numbers>标头中重复。我想把它们都集中在一处；是否允许扩展std::numbers标头以包含尚未定义的标头？

我最近想用 C++ 制作一个快速模拟器，而不使用 C++（允许使用 C）标准库功能。因此，我使用原始指针数组来存储模拟器的内存。但是，我在将内存类移动到另一个内存类时遇到了读取访问冲突。欢迎所有建议。

内存等级：

#ifndef MEM_HPP
#define MEM_HPP

#include <cstdint>
#include <cstddef>

namespace handle {
    using num = std::uint8_t;
    using size = std::size_t;
    struct memory {
        enum { EIGHT_BIT_MAX_MEM = 256, SIXTEEN_BIT_MAX_MEM = 65536 };
        constexpr explicit memory(size max_mem) : mem_size(max_mem) {
            mem = new num[max_mem];
        }
        constexpr memory(memory&& other) noexcept {
            delete[] mem;
            mem = other.mem;
            mem_size = other.mem_size;
            other.mem = nullptr;
            other.mem_size = 0;
        }
        constexpr memory(const memory& other) = delete;
        constexpr ~memory() {
            delete[] mem; …

考虑以下示例，它尝试将 a 传递std::array给函数。当然不考虑“转换”，但是有没有不需要明确的解决方法？特别是如果该类已经提供了必要的属性（value_type 等）。

template <typename T, size_t N>
struct Array_t
{
    using value_type = T;
    using size_type = size_t;

    std::array<T, N> Internal{};

    constexpr operator auto() { return Internal; }
};

template <typename T, size_t N> constexpr bool Test(std::array<T, N> Input)
{
    return Input.size() == 32;
}

constexpr std::array<uint8_t, 32> OK1 = Array_t<uint8_t, 32>();
constexpr auto OK2 = Test((std::array<uint8_t, 32>)Array_t<uint8_t, 32>{});
constexpr auto OK3 = Test(Array_t<uint8_t, 32>().Internal);

// could not deduce template argument for 'std::array<_Ty,_Size>'
// from 'Array_t<uint8_t,32>' …

想象一下我有一个可调用的模板参数“Fn fn”。现在我想检查它的返回类型是否是有符号标量。我如何使用 C++20 概念做到这一点？

我需要要求某种类型 A 存在一个函数 f(A, A::B)。

我正在通过使用 A 和 A::B 的实例调用 f 来测试这一点。是否有一种不那么招摇的方法来测试依赖类型的实例而不需要默认可构造？

template <class Container>
concept CanPutData = requires (Container a)
{
  //put(typename Container::data_type{}, a);  // overconstrained
  put(*reinterpret_cast<typename Container::data_type*>(0), a); // oof
};

void test(CanPutData auto container) {}

template<class Container>
void put(typename Container::data_type const& data, Container& into) {}


template<class Data>
struct data_container { using data_type = Data; };
struct not_default_constructible_data { int& v; };

int main()
{
  test(data_container<not_default_constructible_data>{});

  return 0;
}