我有以下旨在创建数组的代码，但没有默认初始化其对象。我想完美地转发到 placement new，这似乎发生了，但我发现对象的析构函数在 emplace 函数中被调用。

#include <iostream>
#include <memory> // std::uninitialized_copy, std::allocator...
#include <utility> // std::move...
#include <bitset>


struct Int {

    int i;

    Int ( ) : i ( -1 ) { std::cout << "default constructed\n"; }
    Int ( const int i_ ) : i ( i_ ) { std::cout << i << " constructed\n"; }
    Int ( Int && int_ ) : i ( std::move ( int_.i ) ) { std::cout << i << " move constructed\n"; }
    Int ( const Int & int_ ) : i ( int_.i ) { std::cout << i << " copy constructed\n"; }
    ~Int ( ) { std::cout << i << " destructed\n"; i = -1; }
};


template <typename T, size_t S = 64>
class NoInitArray {

    std::bitset<S> m_used;

    T *m_array = reinterpret_cast < T* > ( ::operator new ( sizeof ( T ) * S ) );

public:

    T const &operator [ ] ( const size_t idx_ ) const {

        return m_array [ idx_ ];
    }

    NoInitArray ( ) { }

    ~NoInitArray ( ) {

        for ( size_t idx = 0; idx < S; ++idx ) {

            if ( m_used [ idx ] ) {

                reinterpret_cast< const T* > ( m_array + idx )->~T ( );
            }
        }
    }

    template<typename ...Args>
    void emplace ( const size_t idx_, Args &&... value_ ) {

        std::cout << "start emplace\n";

        m_used [ idx_ ] = 1;

        new ( m_array + idx_ ) T ( std::forward<T> ( value_ ) ... );

        std::cout << "end emplace\n";
    }
};


int main ( ) {

    NoInitArray<Int> nia;

    nia.emplace ( 0, 0 );
    nia.emplace ( 1, 1 );

    std::cout << nia [ 1 ].i << std::endl;

    nia.emplace ( 2, 2 );

    return 0;
}

运行该程序的结果如下:

start emplace
0 constructed
0 move constructed
0 destructed
end emplace
start emplace
1 constructed
1 move constructed
1 destructed
end emplace
1
start emplace
2 constructed
2 move constructed
2 destructed
end emplace
0 destructed
1 destructed
2 destructed

它表明对象被构造一次并被破坏两次(这显然是 UB)，一次是在 emplace 函数中，然后一次是在 NoInitArray 的破坏中。

问题是“为什么我的 Int 对象的析构函数在 emplace 函数内部被调用”？

编译器，Windhoze 上最新的 Clang/LLVM。

编辑 1:我已将移动和复制构造函数添加到 Int 结构，现在计数匹配，即 2 次构造和 2 次破坏。

EDIT2:从 new ( m_array + idx_ ) T ( std::forward<T> ( value_ ) ... ); 更改展示位置新行至 new ( m_array + idx_ ) T ( value_ ... );避免了多余的构造/破坏，不需要移动构造函数。

EDIT3:仅供 future 的读者使用。如上所述，~NoInitArray() 会泄漏内存。在 m_array 上调用 delete 是个坏消息，而且这个调用(在 Clang/LLVM 中)m_array [ 0 ] 的析构函数(但据我现在所知，这绝不能保证，即 UB)。 std::malloc/std::free 似乎是要走的路，但有人说如果你这样做，一切都会崩溃，而且可能会失去一条腿。

最佳答案

“它表明对象被构造一次并被破坏两次”是不正确的。输出 X move constructed应该作为一个结构包括在内，所以结构是两倍。

线

new ( m_array + idx_ ) T ( std::forward<T> ( value_ ) ... );

应该是

new ( m_array + idx_ ) T ( std::forward<Args&&> ( value_ )... );

std::forward<T>(value_) T=Int 时调用构造函数，并且这个临时对象被移动，所以有一个额外的移动构造函数调用。

编辑

在您的编辑 2 中，您替换了没有 std::forward 的行了。在这种情况下，好的，但是当您调用 emplace 时会出现差异。像这样

    nia.emplace ( 0, Int(0) );

没有std::forward , new T(value_...)会调用复制构造函数，而 new T(std::forward<Args&&>(value_)...)将调用移动构造函数。

编辑-2

应该是new T(std::forward<Args>(value_)...) .感谢@Constantin Baranov。

关于c++ - 放置新的和完美的转发，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/37771037/