小编Pet*_*her的帖子

在此代码示例中，使用放置 new 在另一个对象的存储中创建一个对象，并且永远不会访问释放的内存。

以下是事件的顺序：

1. 新的 Object1 在分配的内存中创建。Object2 是一个联合体，因此不会被触及。
2. 使用placement new 在Object1 内部创建Object2
3. 对象 1 被破坏。对象 2 未受影响。
4. 打印object2的内容
5. 调用 Object2 析构函数
6. Object1 的内存已删除

这安全吗？

#include <stdio.h>
#include <new>

struct Object2
{
    char a{1};
    char b{2};
    char c{3};
};

struct Object1
{
    //
    // disconnect Object2 lifetime from Object1
    //
    
    union
    {
        Object2 o;
    };

    char d{3};

    Object1()
    {
    }
};

int main(int argc, char* argv[])
{
    //
    // Create object1, internal object2 is not yet constructed
    //
    
    Object1* object1 = …

我多次发现，当在类中将 std::map 声明为静态内联（C++ 17）时，

struct MyStruct
{
    static inline std::map <A, B> mymap;

    MyStruct(A& a, B& b)
    {
        mymap[a] = b;
    }
};

如果较早调用 MyStruct 构造函数，即在 main 之前、在第一次使用映射成员时调用，它将会崩溃。

如果 std::map 以不同的方式声明，即

struct MyStruct
{
    static std::map <A, B>& mymap()
    {
        static std::map <A, B> map;
        return map;
    }
    
    MyStruct(A& a, B& b)
    {
        mymap()[a] = b;
    }
};

那么就不会发生崩溃。

我本以为在这两种情况下，都会在允许继续调用 MyStruct 构造函数之前初始化映射。

谁能解释这里发生了什么？

这是一个关于理解设计决策的问题，而不是对错误或缺陷的抱怨。

在C++标准库中，创建共享指针及其对象的函数是直函数，

template< class T, class... Args> std::shared_ptr<T> make_shared( Args&&... args );

为什么这个函数不是static的函数shared_ptr<T>，如下所示：

template <class... Args> std::shared_ptr<T>::make(Args&&... args);

这将使std::命名空间更加整洁，并且还允许这样的事情：

using shared_vector = std::shared_ptr<std::vector<int>>;

shared_vector a = shared_vector::make(7);