使用存储在向量中的对象的正确方法是什么？

Question

来自 Java，我对如何正确访问存储在向量中的对象感到困惑。

在这个测试用例中，我希望两个输出都显示相同的数字 (2)：

#include <iostream>
#include <vector>

using namespace std;

class Item {
public:
  int id = 0;
  Item(int id)
  {
    this->id = id;
  }
};

int main()
{
  vector<Item> items;
  Item item = Item(1);
  items.push_back(item);

  Item itemFromVector = items.at(0);
  itemFromVector.id = 2;

  cout << "item: " << item.id << endl;
  cout << "itemFromVector: " <<  itemFromVector.id << endl;
}
// output:
// item: 1
// itemFromVector: 2

Answer 1

在这种情况下，item.id 等于 1。

这背后的原因是push_back 调用将执行向量中对象的副本（向量中的Item 和item 是两个不同的对象）。

观察你想要达到的目标的一种方法是使用指针：

int main()
{
  vector<Item*> items; //items contains addresses of Item object
  Item item = Item(1);
  items.push_back(&item); // push address of your item

  Item* itemFromVector = items.at(0); // Pointer to item
  itemFromVector->id = 2; // Modify item id attribute

  cout << "item: " << item.id << endl; // Access item id attribute
  cout << "itemFromVector: " <<  itemFromVector->id << endl; // Access item id attribute
}

Answer 2

当你执行时：

items.push_back(item);

item 的副本存储在向量中。 item 和向量中的副本这两个对象是完全独立的对象。对一个的更改不会影响另一个。

如果您希望能够更改其中一个并期望更改反映在另一个中，您需要创建一个指针向量或std::reference_wrappers 的向量。

#include <iostream>
#include <vector>
#include <functional>

class Item {
   public:
      int id = 0;
      Item(int id)
      {
         this->id = id;
      }
};

void test1()
{
   std::cout << "Output from test1() ...\n";
   std::vector<Item*> items;
   Item item(1);
   items.push_back(&item);

   Item* itemFromVector = items.at(0);
   itemFromVector->id = 2;

   std::cout << "item: " << item.id << std::endl;
   std::cout << "itemFromVector: " <<  itemFromVector->id << std::endl;
}

void test2()
{
   std::cout << "Output from test1() ...\n";
   std::vector<std::reference_wrapper<Item>> items;
   Item item(1);
   items.push_back(item);

   Item& itemFromVector = items.at(0);
   itemFromVector.id = 20;

   std::cout << "item: " << item.id << std::endl;
   std::cout << "itemFromVector: " <<  itemFromVector.id << std::endl;
}

int main()
{
   test1();
   test2();
}

输出：

Output from test1() ...
item: 2
itemFromVector: 2
Output from test1() ...
item: 20
itemFromVector: 20

Answer 3

vector<Item> items;

在此代码中，您有一个 Item 类的列表。
当您调用items.push_back(item); 时，您会将item 的副本推送到items 数组中。因此，当您调用 itemFromVector.id = 2; 时，您会更改刚刚放入数组中的副本的 id。

如果要将原始 item 对象复制到数组中并在之后进行编辑，则必须进行以下更改：

vector<Item*> items;
items.push_back(&item);
Item* itemFromVector = items.at(0);
itemFromVector->id = 2;

在第一行中，您告诉向量我们要存储 Item 类的指针，而不是它的副本。
在第二行中，我们通过在变量名前添加& 将item 的地址推送到我们的数组中。
在第三行中，我们通过在变量名前添加 * 来告诉编译器我们的变量类型是 Item 类的指针。
在第四行中，我们将. 更改为->，因为我们正在使用指针对象。

Answer 4

由于您来自 Java，因此在 C++ 中使用 references 来获得预期的行为对您来说并不难。

项目项目 = 项目（1）；

与 Java 不同，这里的 item 不是一个引用，而是一个实际的实例。你可以在没有赋值的情况下立即构造它：

Item item(1);

items.push_back(item);

在这里，您需要知道您在向量中推送的内容不是对项目的引用，而是它的副本，一个从项目复制的真实新实例。

Item itemFromVector = items.at(0);

在这里，您将 itemFromVector 执行为向量中第一个项目的 reference。但实际上它是从它复制的一个实例。如果要引用，就声明为引用，就这么简单：

Item& itemFromVector = items.at(0);

总之，在使用 Java 时，一切都是参考。这在 C++ 中是不正确的。只有明确声明为引用时，引用才是引用。

Answer 5

  Item(int id)
  {
    this->id = id;
  }

这是典型的 Java 主义。惯用的 C++ 方式是：

Item(int id) : id(id) {}

Item item = Item(1);

这个也是。惯用的 C++ 方式是：

Item item(1);

items.push_back(item);

这会创建item 的副本，并将副本存储在向量中。

Item itemFromVector = items.at(0);

同样，这会创建第一项的副本并将其存储在itemFromVector 变量中。

您可能会想到 Java 代码，例如：

List<Item> list = new ArrayList<Item>();
list.add(item);
Item item = list.get(0);

但这是错误的类比。 Java 只是将指针存储在列表中。更合适的 Java 类比是：

List<Item> list = new ArrayList<Item>();
list.add(item.clone());
Item item = list.get(0).clone();

如果您希望 C++ 表现出 Java list.add(item); Item item = list.get(0); 的行为，那么您必须创建一个指针向量：

  vector<Item*> items;
  Item item(1);
  items.push_back(&item);

  Item* itemFromVector = items.at(0);
  itemFromVector->id = 2;

但是 C++ 不是 Java，所以这不是一件常见的事情，并且会导致与 C++ 没有任何内置垃圾收集这一事实相关的各种问题。作为一般准则，请尽可能避免使用指针，并特别注意指向本地对象的指针。