小编Ami*_*mit的帖子

关于std::filesystem::is_regular_file(path)，cppreference.com说：

\n

检查给定的文件状态或路径是否对应于常规文件 [\xe2\x80\xa6] 相当于s.type() == file_type::regular.

\n

例如，在Linux内核中，文件类型是在头文件中声明的sys/stat.h。下面列出了每种 Linux 文件类型的类型名称和符号名称：

\n
• 套接字（S_IFSOCK）
\n
• 符号链接 (S_IFLNK)
\n
• 常规文件(S_IFREG)
\n
• 块特殊文件（S_IFBLK）
\n
• 目录 (S_IFDIR)
\n
• 字符设备（S_IFCHR）
\n
• FIFO（命名管道）(S_IFIFO)
\n

这个函数在 Windows 上检查什么？

当我看到这个 CPP Con 2017 网络研讨会时，Fedor Pikus 说：“它必须是直接初始化”

这是网络研讨会的链接。

这些初始化方法有什么区别？（随后，为什么它必须是“直接”初始化？为什么“间接”初始化是“不是”？）

// C++17 Compiler

#include <atomic>

class Example
{
    std::atomic<bool> m_b1 = false; // 1-h
    std::atomic<bool> m_b2{ false }; // 2-h

    static void doSomethng()
    {
        std::atomic<bool> b1 = false; // 1-f
        std::atomic<bool> b2{ false }; // 2-f
        std::atomic<bool> b3(false); // 3-f

        // Do something
    }
};

（假设：int x{ 6 }并且2个评价x = 6同时写入）

--

CPP 参考资料中提到内存模型：线程和数据竞争：

当一个表达式的计算写入一个内存位置而 另一个计算读取或修改同一内存位置时，这些表达式被称为冲突。具有两个相互冲突的评估的程序会发生数据竞争，除非：

• 两个评估在同一线程或同一信号处理程序中执行，或者

• 两个相互冲突的求值都是原子操作（参见 std::atomic），或者

• 一个相互冲突的评估发生在另一个评估之前（请参阅 std::memory_order）。

如果发生数据竞争，则程序的行为是不确定的。

参考文献说：“另一评价修改”；它没有说“另一篇评论写道”。

--

C++ 标准关于6.9.2.2 数据竞争的规定：

2. 如果两个表达式求值之一修改内存位置 ([intro.memory])，而另一个表达式求值读取或 修改同一内存位置，则两个表达式求值会发生冲突。

--

将相同的值重新写入内存位置是否算作修改内存？

cppreference.com说：

线程和数据竞争

当一个表达式的求值修改到一个内存位置而另一个求值读取或修改相同的内存位置时，这些表达式被称为冲突。具有两个相互冲突的评估的程序会发生数据竞争，除非......

这谈到了“thread1-modify thread2-read”(MR) 的场景以及“thread1-modify thread2-modify”(MM) 的场景。

“线程 1 读取线程 2 读取”(RR) 怎么样？

（编辑：只是为了澄清：“缓存一致性”的问题是在不使用原子变量的情况下。）

是否有可能（单CPU情况：Windows可以在Intel / AMD / Arm CPU上运行），线程1运行在core-1上存储一个bool变量（例如）并且它保留在L1缓存中，而线程2在 core-n 上运行使用该变量，并且它会查找内存中该变量的另一个副本？

代码示例（为了演示该问题，我们假设这std::atomic_bool只是一个普通的bool）：

#include <thread>
#include <atomic>
#include <chrono>

std::atomic_bool g_exit{ false }, g_exited{ false };

using namespace std::chrono_literals;

void fn()
{
    while (!g_exit.load(std::memory_order_acquire))
    {
        // do something (lets say it takes 1-4s, repeatedly)
        std::this_thread::sleep_for(1s);
    }

    g_exited.store(true, std::memory_order_release);
}

int main()
{
    std::thread wt(fn);
    wt.detach();

    // do something (lets say it took 2s)
    std::this_thread::sleep_for(2s);

    // Exit

    g_exit.store(true, std::memory_order_release);

    for (int i = 0; i < 5; …

（我承认这个问题是基于意见的，但可能是需要考虑的方法和指南。）

[[nodiscard]]作为对编译器以及随后对开发人员的警告，表明该函数的返回值很重要并且应该使用或捕获。

什么是更好的做法（在早期阶段检测可能的错误）：将[[nodiscard]]属性应用于返回值的任何成员函数（特殊情况除外）？...或者仅将其应用于必要的成员函数（例如：返回内存分配的成员函数）？

假设这是一个为多个线程提供服务的函数。他们读kHKeys不受保护，因为从同一内存地址读取-读取不是数据争用。

但是，在读一读时，kHKeys就被构建了。有可能在构造过程中，另一个线程进入了reentrantFunction函数。

是否有必要构建kHKeys在释放同时调用 reentrantFunction 的线程之前

例子：

int reentrantFunction(const std::wstring& key_parent_c)\n{\n    // const 'static' means that kHKeys is constructed only once \xe2\x80\x94\n    // The 1st the function is run \xe2\x80\x94 and put into a shared memory space.\n    // Otherwise, kHKeys is local and it must be constructed each time the function is called.\n    const static std::map<std::wstring, HKEY> kHKeys{ { L"HKEY_CURRENT_USER", HKEY_CURRENT_USER } ,\n        { L"HKEY_LOCAL_MACHINE", HKEY_LOCAL_MACHINE } , { L"HKEY_CLASSES_ROOT", HKEY_CLASSES_ROOT …

我有Node课。成员是int id, 和指向下一个节点的指针：Node* next。我按如下方式实现了构造函数和析构函数：

#include <iostream>

class Node
{
public:
  int id;
  Node *next;
  Node() : id(0), next(nullptr) {}
  explicit Node(int id) : id(id), next(nullptr) {}

  ~Node() {
    std::cout << (*this) << " destructed \n";
    delete next;
    next = nullptr;
  }

  friend std::ostream &operator<<(std::ostream &os, const Node &node) {
    os << "Node(" << node.id << ")";
    return os;
  }
};

int main()
{
  Node *node0;
  Node *node1;
  node0 = new Node(0);
  node1 = new …

断言失败并且具有未定义的行为

#include<bits/stdc++.h>

const int MaxN = 1e5 + 10;

struct Node{
    long long sum;
    int left,right;
    Node() :sum(0),left(0),right(0){

    }
    Node(long long sum,int left,int right) :sum(sum),left(left),right(right){

    }
};
struct PersistentSegmentTree{
    std::vector<Node> st;
    std::vector<int> ver;
    int n;
    PersistentSegmentTree(int n) :n(n){
        ver.push_back(0);
        st.push_back(Node());
    }
    int update(int l,int r,int pos,int val,int oldId){
        std::cerr << l << " " << r << "\n";
        st.push_back(Node());
        if(l == r){
            st.back() = Node(val,0,0);
            assert((int)st.size() - 1 != 0);
            return (int)st.size() - 1;
        }
        int cur = (int)st.size() - …