Adrian McCarthy's questions

我更新了一些旧代码以使用std::format，并惊讶地发现它仍然有效，尽管我忘记std::formatter为该类型提供专业化。

我立即制作了一个小测试程序来尝试重现这个问题，但正如我所料，它们总是出现编译时错误。

经过数小时的调试，我发现，如果自定义类型具有公共begin方法end，则库将把序列格式化为用方括号括起来的逗号分隔的列表。

问：这是标准定义的功能std::format还是实现错误？（或者其他什么？）

这是一个独立的复制品：

#include <array>
#include <print>

class MyType {
    public:
        MyType() : m_values{1, 2, 3, 4} {}

        using internal_type = std::array<int, 4>;
        using const_iterator = typename internal_type::const_iterator;

        const_iterator cbegin() const { return m_values.cbegin(); }
        const_iterator cend()   const { return m_values.cend();   }
        const_iterator begin()  const { return cbegin(); }
        const_iterator end()    const { return cend();   }

    private:
        internal_type m_values;
};

int main() {
    MyType foo;
    // Since MyType is a user-defined type, I would not
    // expect this print statement to compile without a
    // specialization of std::formatter, but because
    // it's iterable, it prints: "foo = [1, 2, 3, 4]\n".
    std::print("foo = {}\n", foo);
    return 0;
}

我正在使用 Visual Studio 17.12.15 中的 MS VC++ 并使用 进行编译/std:c++latest。

假设我有一个返回的函数std::vector，并且我想异步调用它。

std::vector<int> foo(int n);

int main() {
    auto future_vector = std::async(foo, 999);
    // ... other stuff

    // Questions are all about this:
    auto actual_vector = future_vector.get();

    // ... do stuff with actual_vector ...
}

Q1：是actual_vector从共享状态复制构造还是移动构造？我需要std::move(future_vector.get())明确写出来吗？

Q2：假设函数已完成并且不再履行承诺：共享状态的生存期是否在get未来被调用时结束，还是会持续到未来到达其生存期的结束？

我有一个返回 lambda 的函数。

auto make_scanner(std::vector<int> const &v) {
    auto begin = v.cbegin();
    auto end = v.cend();
    return [begin, end] () mutable -> int {
        return (begin != end) ? *begin++ : 0;
    };
}

请注意，lambda 将迭代器捕获到向量中，但不会捕获向量本身。在常见用例中，这是可以的：

// Common Use Case
std::vector<int> data = {1, 2, 3};
auto scanner = make_scanner(data);
for (int x = scanner(); x != 0; x = scanner()) {
    // compute something
}

但是如果调用者从未命名的临时向量中创建一个扫描器，那么 lambda 表达式就会留下悬垂迭代器：

// Incorrect Use Case
auto scanner = make_scanner(std::vector<int>{1, 2, 3});
// Invoking scanner() is UB because the iterators reference
// the vector after its lifetime.

在非优化版本（即调试版本）中，即使代码有误，这通常也会按预期工作。在优化版本中，如果幸运的话，它会崩溃或至少导致测试失败。

当使用未命名的临时向量调用 make_scanner 时，是否有办法导致编译失败，同时仍允许常见用例？

我一直在尝试使用 r 值引用进行各种重载，但答案却让我困惑。

（是的，我意识到可以使用非临时向量，但最终在 lambda 中仍然会出现悬垂迭代器。我现在不关心这些情况。）

tl;dr：给定一个数字类型 T，是否有一种简洁的方法将变量声明为std::uniform_int_distribution<T>或std::uniform_real_distribution<T>取决于 T 是整数还是浮点数？

我需要生成std::chrono::duration在调用者定义的范围内均匀分布的随机数，因此我创建了一个uniform_duration_distribution以标准库的分布类模板为模型的类模板。

首先，我写了一个概念来将我的分布限制在一个时间持续时间内（或适当相似的类型）。

// Is T similar enough to std::chrono::duration for our purposes?
template <typename T>
concept chrono_duration = requires (T d) {
    { d.count() } -> std::same_as<typename T::rep>;
    { d.zero()  } -> std::same_as<T>;
    { d.max()   } -> std::same_as<T>;
};

持续时间有一个称为计数的数字表示。我的类包含标准库中的数字均匀分布，使用它来生成计数，并根据该计数构造持续时间。

template<chrono_duration DurationT>
class uniform_duration_distribution {
  // ...
  private:
    using rep = typename DurationT::rep;
    std::uniform_distribution<rep> m_distribution;  // Whoops!
};

问题就在这里。持续时间计数的类型可以是整数类型，也可以是浮点类型，因此的类型m_distribution并不像 这么简单，std::uniform_distribution<T>因为没有这样的模板。

我不想对我的类进行多次特化，也不想将调用者限制在持续时间的一个特定实例上。我只想根据持续时间的表示类型选择包含分布的类型。

我的第一次尝试是使用受概念限制的类型别名模板。

template <std::integral IntT>
using dist_selector = std::uniform_int_distribution<IntT>;

template <std::floating_point FloatT>
using dist_selector = std::uniform_real_distribution<FloatT>;

这似乎不允许。我可以（显然）用一个概念来约束单个使用别名模板，但我不能使用概念在不同的别名之间进行选择。至少，我试过不行。有办法吗？

我还了解到我无法使用别名模板进行专门化。

最后我制作了一个针对数字类型的专门结构模板。

// Select the appropriate distribution type based on the value type.
template <typename T> struct dist_selector {};
template <> struct dist_selector<long double>        { using t = std::uniform_real_distribution<long double>; };
template <> struct dist_selector<double>             { using t = std::uniform_real_distribution<double>; };
template <> struct dist_selector<float>              { using t = std::uniform_real_distribution<float>; };
template <> struct dist_selector<long long>          { using t = std::uniform_int_distribution<long long>; };
template <> struct dist_selector<long>               { using t = std::uniform_int_distribution<long>; };
template <> struct dist_selector<int>                { using t = std::uniform_int_distribution<int>; };
template <> struct dist_selector<short>              { using t = std::uniform_int_distribution<short>; };
template <> struct dist_selector<unsigned long long> { using t = std::uniform_int_distribution<unsigned long long>; };
template <> struct dist_selector<unsigned long>      { using t = std::uniform_int_distribution<unsigned long>; };
// ...

那么成员变量定义为：

using rep = typename DurationT::rep;
using dist_type = typename dist_selector<rep>::t;
dist_type m_distribution;

这可行，但感觉像回到了旧方法。我是否错过了一种更现代的方法来实现这一点？

我想我知道这个问题的答案，但我希望能进行一次理智检查。

迭代器无效是否适用于 std::back_insert_iterators？

#include <cassert>
#include <iterator>
#include <vector>

int main() {
    auto v = std::vector<int>{ 0, 1, 2 };
    auto iter = std::back_inserter(v);
    *iter++ = 3;
    v.clear();    // invalidates iterators, but
    *iter++ = 4;  //  back_insert_iterator is special?
    assert(v.size() == 1 && v[0] == 4);
    return 0;
}

这段代码对我来说是可行的，因为我的供应商提供的 std::back_insert_iterator 实现不包含迭代器（或指针或引用）。它只是调用容器的 push_back 方法。

但是标准是否要求实现该功能？其他供应商的 back_insert_iterator 是否可以保存并维护一个尾端迭代器，以便与容器的 insert 方法调用一起使用？这似乎可以满足要求。当然，这种差异在于它容易失效。

我知道 cppreference.com 不是权威的，但是它比标准更容易访问。

[向量的 clear 方法] [i] 使引用所含元素的任何 ... 迭代器无效。任何超出末尾的迭代器也将失效。 [ cppreference.com，重点补充]

std::back_insert_iterator 可能是末尾迭代器的典型代表。