Question

为了便于处理，我想创建一个自定义元素的向量，之后我可以通过A[0]轻松访问这些元素，依此类推。问题是每个元素都有一个非空的构造函数，即我不能写

elem A;

相反，我必须写

elem A(int a, int b, int c);

在创建期间使用a，b，c固定值。但这对我来说是不可能的，因为我在运行时得到了这些元素的值那么，有没有办法做这样的事情：

Vector<elem> A;
elem B(int a, int b, int c);
A.push_back(B);

如果是，怎么样？作为解释：Vector可以是std::vector或QVector，但它们都会导致问题，无论是在编译期间还是在运行时期间崩溃。编辑：完整代码：

#ifndef DPC_H
#define DPC_H
#include "../BlackLib/v2_0/BlackGPIO.h"
#include <QVector>


class DPC
{
private:
    QVector<BlackLib::BlackGPIO> A;
public:
    DPC();
    ~DPC();
};

#endif // DPC_H


#include "dpc.h"


    DPC::DPC()
    {
        BlackLib::BlackGPIO Pin(BlackLib::BlackGPIO(BlackLib::GPIO_32, BlackLib::input));
        /*DPC::A[0] = new */A.push_back(Pin);
        A.push_back(Pin);
        /*DPC::A[1] = new B*/A.push_back(BlackLib::BlackGPIO(BlackLib::GPIO_33, BlackLib::input));

    }

BlackLib是来自https://github.com/yigityuce/BlackLib

的BBB引脚扩展的数据类型

解：
使用std::vector<std::unique_ptr<BlackLib::BlackGPIO> > A;

Answer 1

事实上，你的写作方式非常接近。你可以做到

#include <vector>

...

std::vector<B> A;
B foo(a, b, c);
A.push_back(foo);

或者，如果你有一个知道C ++ 11的足够新的编译器，

#include <vector>

...

std::vector<B> A;
A.emplace_back(a, b, c);

后者保存副本（对象直接在向量中构建），因此它更好。尽管如@JonathanWakely在评论中指出的那样，必须注意保持emplace_back的异常安全，其中

std::vector<std::unique_ptr<B> > vec;

vec.emplace_back(new B); // is not exception-safe if the vector has to 
                         // relocate and might throw bad_alloc, in which case
                         // the newly allocated foo object is leaked because
                         // no one is responsible for cleaning it up.

vec.push_back(new B);    // does not compile

在std::vector<std::unique_ptr<...>>：

的情况下，这很容易解决

vec.emplace_back(std::make_unique<B>());     // C++14
vec.emplace_back(std::unique_ptr<B>(new B)); // C++11

// these also work and do the same thing with push_back

......但你必须记得这样做。

Answer 2

那么，有没有办法做这样的事情：
 vector<elem> A;
 elem B(int a, int b, int c);
 A.push_back(B);
如果是，怎么样？

是。有几种可能性。首先，查看emplace_back。它类似于推回，但参数直接传递给被保持对象的构造函数（完美转发）：

vector<elem> A;
A.emplace_back(a, b, c); // for an existing elem::elem(int a, int b, int c)

您还可以依赖elem的复制构造函数，在模型之后构造n个元素：

elem model{ a, b, c };
vector<elem> A{ 10, model }; // create 10 elements equal to model

Answer 3

您可以创建指向某个结构的指针向量：

std::vector<elem*> v;

现在你可以将指针推回到新创建的对象，如下所示：

v.push_back(new elem(a, b ,c));

或

elem* A = new elem (a, b, c);
v.push_back(A);

但如果可以，那就使用默认构造函数。

如果您不喜欢语法，也可以创建简单的功能：

void addToVector (int _a, int _b, int _c)
{
    elem* A = new elem (_a, _b, _c);
    v.push_back(A);
}

addToVector(1, 2, 3); // calling

如何创建结构的向量并在以后初始化它们

3 个答案: