如何使用C++线程模拟pthread_kill()函数？我之前问了一个关于这个的问题,但没有回应.线程:: native_handle()函数会帮助吗？
我已经阅读了几篇有关堆栈溢出的文章，并了解了有关在线动态链接的信息。这就是我从所有这些读物中学到的东西-
动态链接是一种优化技术，用于充分利用系统的虚拟内存。一个进程可以与其他进程共享其页面。例如，libc++需要与所有C ++程序链接，而不是将可执行文件复制到每个进程，而可以通过共享的虚拟页面将其动态链接到许多进程。
但是，这导致我以下问题
*.cpp file?lib/ directory with *.a files and *.dylib (on mac-OSX) files. How do I know which ones to link to statically as I would with a regular *.o file and …可升级和共享锁的 boost 文档说，当共享锁被持有时，只有一个其他线程可以获得可升级锁。因此，如果其他线程在共享锁与可升级锁一起持有时尝试获取可升级锁，它们将被阻塞。
当多个线程获取可升级锁以及一个（或多个共享锁）时，是否存在某种死锁可能性？或者这只是一个合乎逻辑的要求（所以“不应该这样做”之类的事情）？
请注意，我不是在谈论专门的锁定状态。只有可升级的锁定状态。如果一个可升级锁与其他共享锁一起持有，它本质上就是一个 READ 锁。那为什么不能将两个可升级的锁放在一起呢？
我偶然发现了这个http://llvm.org/docs/doxygen/html/classllvm_1_1ArrayRef.html，我试图了解它的用途。
我看不到ArrayRef解决了什么问题，有人可以解释一下背后的动机吗？
为什么std::shared_ptr接受删除器作为构造函数参数而不是模板参数？存储类型擦除删除器似乎违背了 C++ 哲学，即不向标准库组件添加任何不必要的开销。
我在这背后看到的唯一逻辑是，由于引用计数的原子增量成本如此之高，因此忽略了通过类型擦除进行的间接成本。但这似乎仍然是不必要的开销。
当为此在rvalue限定符上重载时，大多数C ++标准库实用程序都通过rvalue引用返回。例如std :: optional具有以下value()函数重载
constexpr T& value() &;
constexpr const T & value() const &;
constexpr T&& value() &&;
constexpr const T&& value() const &&;
这样就可以将返回值从需要的时候移走，很好。这是一个可靠的优化。
但是，与右值返回相关的不确定性又如何呢？例如（此处为实时示例https://wandbox.org/permlink/kUqjfOWWRP6N57eS）
auto get_vector() {
auto vector = std::vector<int>{1, 2, 3};
return std::optional{std::move(vector)};
}
int main() {
for (auto ele : *get_vector()) {
cout << ele << endl;
}
}
上面的代码由于无法扩展基于循环的范围而导致未定义的行为
{
auto && __range = range_expression ;
auto __begin = begin_expr ;
auto __end = end_expr ;
for ( ; …std::optional截至此日期有8个构造函数,如下所示(另请参见http://en.cppreference.com/w/cpp/utility/optional/optional)
/* (1) */ constexpr optional() noexcept;
/* (1) */ constexpr optional( std::nullopt_t ) noexcept;
/* (2) */ constexpr optional( const optional& other );
/* (3) */ constexpr optional( optional&& other ) noexcept(/* see below */);
template < class U >
/* (4) */ /* EXPLICIT */ optional( const optional<U>& other );
template < class U >
/* (5) */ /* EXPLICIT */ optional( optional<U>&& other );
template< class... Args >
/* (6) */ constexpr explicit optional( …关于内存命令的cppreference文档说
放宽内存排序的典型用法是递增计数器,例如std :: shared_ptr的引用计数器,因为这只需要原子性,但不需要排序或同步(请注意,递减shared_ptr计数器需要与析构函数进行获取 - 释放同步)
这是否意味着宽松的内存排序实际上不会导致相同变量的原子性？但更确切地说,结果是与其他放松的内存负载和/或compare_exchanges相关的最终一致性？使用std::memory_order_seq_cst是与配对时看到一致结果的唯一方法std::memory_order_relaxed吗？
我假设std::memory_order_relaxed对于相同的变量仍然是原子的,但是没有提供关于其他数据的加载和存储的任何其他约束.
结构化绑定功能表示,如果tuple_size模板是完整类型,它会像分解一样使用元组.如果std::tuple_size在程序中的某一点是给定类型的完整类型并且在另一点未完成,会发生什么？
#include <iostream>
#include <tuple>
using std::cout;
using std::endl;
class Something {
public:
template <std::size_t Index>
auto get() {
cout << "Using member get" << endl;
return std::get<Index>(this->a);
}
std::tuple<int> a{1};
};
namespace {
auto something = Something{};
}
void foo() {
auto& [one] = something;
std::get<0>(one)++;
cout << std::get<0>(one) << endl;
}
namespace std {
template <>
class tuple_size<Something> : public std::integral_constant<std::size_t, 1> {};
template <>
class tuple_element<0, Something> {
public:
using type = int; …c++ one-definition-rule undefined-behavior c++17 structured-bindings
确保在足够小以适合缓存行的结构中真正共享的正确且可移植的方法是什么？仅仅确保结构足够小就足够了吗？或者它也必须在缓存边界上对齐？
例如，假设缓存行的大小为 64 字节，以下是否足够？
struct A {
std::uint32_t one;
std::uint32_t two;
};
还是我必须这样做？
struct alignas(std::hardware_constructive_interference_size) A {
std::uint32_t one;
std::uint32_t two;
};
注意：这将始终在堆栈上，因此不需要过度对齐的内存分配。
另一个后续，这足以确保没有虚假共享吗？
struct A {
public:
alignas(hardware_destructive_interference_size) std::uint32_t one;
alignas(hardware_constructive_interference_size) std::uint32_t two;
};
还是必须这样做（在说hardware_constructive_interference_size<的情况下hardware_destructive_interference_size？）
struct A {
public:
alignas(hardware_destructive_interference_size) std::uint32_t one;
alignas(hardware_destructive_interference_size) std::uint32_t two;
};