无临时实例的参数转发

Question

我有一个模板类，它包装了一个名为mObject的std::向量。

类有一个insert函数，它转发MyArray实例中实际存储的类型的参数（我认为它称为可变模板参数）。在本例中，我存储MyMesh类型，但它可以是任何类型。

正如您在main（）函数中看到的，mObject向量不会增长，它的元素会被一次又一次地覆盖。

考虑对象池类型的数据结构。

一切正常。

template <class T>
class MyArray
{
    public:

        MyArray(const int capacity) :
            mObjects(capacity)
        {
            mNextIndex = 0;
        }

        template <typename... Args>
        void insert(Args&&... args)
        {

            mObjects[mNextIndex] = T{ std::forward<Args>(args)... };    //PROBLEMATIC ASSIGNMENT

            //... not relevant code
        }

    private:

        int             mNextIndex;
        std::vector<T>  mObjects;

};



int main()
{
    MyArray<Mesh> sa(2);

    sa.insert("foo",1111);  //goes to mObjects[0]
    sa.insert("bar",2222);  //goes to mObjects[1], and tada, the vector is full

    sa.remove(1111);    //not implemented above, but not relevant. Remove func basically adjusts mNextIndex, so mObjects[0] will be overwritten upon next insert.

    sa.insert("xxx",3333);  //mObjects[0] gets overwritten from "foo" to "xxx" and 1111 to 3333
}

我的问题是上面的一行被注释为//有问题的作业。

mObjects[mNextIndex] = T{ std::forward<Args>(args)... };

当该命令执行时，会发生3种情况：

>

调用MyMesh（const string s，int x）构造函数，这意味着在这里的堆栈上分配整个MyMesh。为什么？我只想将转发的参数传递给现有的mObjects[mNextIndex]元素。

运算符=（MyMesh

~cVMesh（）的调用意味着临时变量释放并消亡。

我想摆脱#1和#3。所以不想要“昂贵”的临时对象创建。我只想将传入的MyMesh参数转发/分配给mObject[mNextIndex]。类似于std::vector.emplace_back（）所做的，但指向mNextIndex指向的任何位置。

如何只将参数转发给C中的现有变量，而不实例化临时变量？

为了实现完整性，这里是存储在MyArray类中的MyMesh类。调用构造函数/析构函数/赋值运算符时，只打印一些消息，没有什么特别之处：

class Mesh
{
public:
    Mesh()
    {
        cout << "Mesh()" << std::endl;
        mStr = "";
        mId = 99999999;
    }
    Mesh(const string s, int x)
    {
        cout << "Mesh(const string s, int x)" << std::endl;
        mStr = s;
        mId = x;
    }
    ~Mesh()
    {
        cout << "~Mesh()" << std::endl;
    }
    Mesh& operator=(const Mesh& other)
    {
        cout << "operator=(const Mesh& other)" << std::endl;
        cout << mStr << " becomes " << other.mStr << endl;
        cout << mId << " becomes " << other.mId << endl;
        mStr = other.mStr;
        mId = other.mId;
        return *this;
    }
    Mesh& operator=(Mesh&& other) noexcept
    {
        cout << "operator=(Mesh&& other)" << std::endl;
        cout << mStr << " becomes " << other.mStr << endl;
        cout << mId << " becomes " << other.mId << endl;
        mStr = other.mStr;
        mId = other.mId;
        return *this;
    }
    Mesh(const Mesh& other)
    {
        cout << "Mesh(const Mesh& other)" << std::endl;
        mStr = other.mStr;
        mId= other.mId;
    }
    Mesh(Mesh&& other) noexcept
    {
        cout << "Mesh(Mesh&& other)" << std::endl;
        mStr = other.mStr;
        mId = other.mId;
        other.mStr = "";
        other.mId = 99999999;
    }

    string mStr;
    int mId;

};

Answer 1

您可以添加：

void assign(const string& s, int x)
{
    cout << "assign(const string s, int x)" << std::endl;
    mStr = s;
    mId = x;
}

并使用它：

mObjects[mNextIndex].assign(std::forward<Args>(args)...);

Answer 2

mObject[mNextIndex]=T{std::forward

整个MyArray类非常无用，因为vector已经具有类似的功能。

vector<Mesh> sa;
sa.reserve(2);
sa.emplace_back("foo",1111); // Mesh constructor called once
sa.emplace_back("bar",2222); // Mesh constructor called once again

Answer 3

我想你想要的是用新的值重建向量中的任意元素

#include<vector>

template<class T, class... Args>
void create_at_nth_place(std::vector<T>& v, int n, Args&&...args){
    auto& elem = v[n];
    elem.~T();
    new(&elem) T(std::forward<Args>(args)...);
}

struct S {
    S();
    S(int, bool);
    template<class... Args>
    S(Args&&...);
    S(S&&) noexcept;
    ~S();
};

void f() {
    std::vector<S> v(3);
    create_at_nth_place(v, 2, 4323, false);
    char a = 'a';
    create_at_nth_place(v, 2, 'a', 123, 1232, 32.f, a);
}

链接：https://godbolt.org/g/3K9akZ