小编Gio*_*ani的帖子

<iosfwd>标题用于什么(在此文件中提到)？

为什么有必要？

任何例子？

I've written this implementation of a double buffer:

// ping_pong_buffer.hpp

#include <vector>
#include <mutex>
#include <condition_variable>

template <typename T>
class ping_pong_buffer {
public:

    using single_buffer_type = std::vector<T>;
    using pointer = typename single_buffer_type::pointer;
    using const_pointer = typename single_buffer_type::const_pointer;

    ping_pong_buffer(std::size_t size)
        : _read_buffer{ size }
        , _read_valid{ false }
        , _write_buffer{ size }
        , _write_valid{ false } {}

    const_pointer get_buffer_read() {
        {
            std::unique_lock<std::mutex> lk(_mtx);
            _cv.wait(lk, [this] { return _read_valid; });
        }
        return _read_buffer.data();
    }

    void end_reading() {
        {
            std::lock_guard<std::mutex> lk(_mtx);
            _read_valid = …

尝试编译此代码时

#include <stdarg.h>

void bar_ptr(int n, va_list *pvl) {
    // do va_arg stuff here
}

void bar(int n, va_list vl) {
    va_list *pvl = &vl; // error here
    bar_ptr(n, pvl);
}

void foo(int n, ...) {
    va_list vl;
    va_list *pvl = &vl; // fine here
    va_start(vl, n);
    bar(n, vl);
    va_end(vl);
}

int main() {
    foo(3, 1, 2, 3);
    return 0;
}

GCC 编译器会initialization from incompatible pointer type在bar函数中打印一条警告。相同的语句在foo.

似乎 type 的 agument 的类型va_list不是 …

我有这个 C++14 代码：

#include <type_traits>

struct f1 {
    enum struct e { a };
};

struct f2 {
    enum struct e {};
};

template <typename T>
struct my_struct {
    using e = typename T::e;
    my_struct()
    : _e{e::a} {} // e::a used here
    e _e;
};

int main() {
    my_struct<f1> a;
    my_struct<f2> b; // compilation fails
}

显然，编译失败，类似于'a' is not a member of 'my_struct<f2>::e'. 我真的很想向 中添加一些静态断言my_struct，以添加自定义错误消息。首先，我可以检查是否e实际上是一个枚举：

static_assert(std::is_enum<e>::value, "my message");

那么，我应该添加什么来静态断言e::a定义的？

受这个答案的启发，我生成了这段代码，其输出取决于编译器：

template <typename... Args>
constexpr auto foo(Args&& ...args, ...) noexcept {
    return sizeof...(args);
}

constexpr auto bar() noexcept {
    return (&foo<int>)(1, 2);
}

如果使用 GCC 11 编译，bar则调用foo<int>并返回 1，而 clang 13 和 MSVC 2019 都会推导foo<int, int>并bar返回 2。

这是我在 godbolt 上的沙箱：https ://godbolt.org/z/MedvvbzqG 。

哪个输出是正确的？

编辑：

如果我return foo<int>(1, 2);直接使用，即与

constexpr auto bar() noexcept {
    return foo<int>(1, 2);
}

沙箱更新：https://godbolt.org/z/Wj757sc7b。

根据文档， std::string_view 有一个带有 aconst char *和 a的构造函数std::size_t，但未声明noexcept：

constexpr basic_string_view(const CharT* s, size_type count);

另一方面，文档还声明了用户定义的文字operator""sv，在我见过的所有实现中都是该构造函数的简单包装器，已声明noexcept：

constexpr std::string_view operator "" sv(const char* str, std::size_t len) noexcept;

你知道这种差异的原因吗？构造函数什么时候可以抛出？

根据cppreference.com 上的模板参数和模板参数：

类型模板参数的模板参数必须是类型 ID，它可能会命名不完整的类型

这意味着这个示例（从该页面复制）是合法的：

// Example 0

template <typename T>
struct X {};

struct A;

int main() {
    X<A> x1;
}

而且，我想，这也是合法的：

// Example 1

template <typename T>
struct X {};

struct A {
    X<A> x1;
};

int main() {
    A a1;
}

现在，让我们使代码复杂一些：

// Example 2

template <typename T>
struct X {
    using type = typename T::type;
};

struct A {
    using type = int;
    X<A>::type x1;
};

int main() {
    A a1;
}

在这种情况下，A …

我有这个模板功能

template <typename T, typename It, std::enable_if_t<std::is_integral<T>::value, int> = 0>
inline T decode(It &it) {
    static_assert(std::is_same<typename std::iterator_traits<It>::value_type, std::uint8_t>::value, "invalid");
    T* v_p = reinterpret_cast<T*>(&*it);
    it += sizeof(T);
    return *v_p;
}

用于从原始指针解码整数。该函数可以与任何具有迭代器特征的类型一起使用，即指向具有满足LegacyContiguousIterator要求的迭代std::uint8_t器的std::uint8_tSTL 容器的指针或迭代器。