c++ - 在这种情况下，可以避免在c++中手动管理内存吗？

Question

我有一个Storage类，其中包含Things的列表:

#include <iostream>
#include <list>
#include <functional>

class Thing {
    private:
        int id;
        int value = 0;
        static int nextId;
    public:
        Thing() { this->id = Thing::nextId++; };
        int getId() const { return this->id; };
        int getValue() const { return this->value; };
        void add(int n) { this->value += n; };
};
int Thing::nextId = 1;

class Storage {
    private:
        std::list<std::reference_wrapper<Thing>> list;
    public:
        void add(Thing& thing) {
            this->list.push_back(thing);
        }
        Thing& findById(int id) const {
            for (std::list<std::reference_wrapper<Thing>>::const_iterator it = this->list.begin(); it != this->list.end(); ++it) {
                if (it->get().getId() == id) return *it;
            }
            std::cout << "Not found!!\n";
            exit(1);
        }
};

我从一个简单的 std::list<Thing>开始，但是随后在插入和检索时复制了所有内容，因此我不希望这样做，因为如果得到一个副本，对其进行更改将不再反射(reflect)原始对象。在寻找解决方案时，我发现了 std::reference_wrapper on this SO question，但是现在我遇到了另一个问题。

现在到使用它们的代码:

void temp(Storage& storage) {
    storage.findById(2).add(1);
    Thing t4; t4.add(50);
    storage.add(t4);
    std::cout << storage.findById(4).getValue() << "\n";
}

void run() {
    Thing t1; t1.add(10);
    Thing t2; t2.add(100);
    Thing t3; t3.add(1000);

    Storage storage;
    storage.add(t3);
    storage.add(t1);
    storage.add(t2);

    temp(storage);

    t2.add(10000);

    std::cout << storage.findById(2).getValue() << "\n";
    std::cout << storage.findById(4).getValue() << "\n";
}

我的 main()只是调用 run()。我得到的输出是:

50
10101
Not found!!

尽管我一直在寻找:

50
10101
50

题

看起来当函数返回时，本地声明的对象 t4不存在了，这很有意义。我可以使用 new通过动态分配它来防止这种情况，但是后来我不想手动管理内存...

如何在不删除temp()函数且无需手动管理内存的情况下修复代码？

如果我只是按照建议的方式使用 std::list<Thing>，那么 t4和 temp的问题肯定会不复存在，但是还会出现另一个问题:例如，该代码将不再打印 10101。如果我一直在复制内容，则将无法更改存储对象的状态。

Answer 1

仓库中事物的所有者是谁？

您的实际问题是所有权。当前，您的Storage并不真正包含Things，而是由Storage的用户来管理放置在其中的对象的生命周期。这与标准容器的理念背道而驰。所有standard C++ containers都拥有您放置在其中的对象，并且容器管理着它们的生命周期(例如，您仅对 vector 调用 v.resize(v.size()-2) 并破坏了最后两个元素)。

为什么引用？

您已经找到了一种使容器不拥有实际对象的方法(通过使用reference_wrapper)，但是没有理由这样做。在一个名为Storage的类中，我希望它包含对象而不仅仅是引用。此外，这为许多令人讨厌的问题打开了大门，其中包括不确定的行为。例如这里:

void temp(Storage& storage) {
    storage.findById(2).add(1);
    Thing t4; t4.add(50);
    storage.add(t4);
    std::cout << storage.findById(4).getValue() << "\n";
}

您将对 t4的引用存储在 storage中。问题是: t4的生存期仅到该函数结束时，您最终会得到悬挂的引用。您可以存储这样的引用，但是它并不是有用的，因为基本上不允许您对其进行任何操作。

不引用很酷的东西吗？

当前，您可以推送 t1，对其进行修改，然后观察 Storage中内容的变化，如果您想模仿Java，这可能会很好，但是在c++中，我们习惯于在推送内容时使用容器进行复制(还有创建适当元素的方法，以防您担心一些无用的临时对象)。是的，当然，如果您真的想要，您可以使一个标准容器也包含引用，但让我们绕个小弯路...

谁收集所有这些垃圾？

也许有助于考虑Java是垃圾回收而C++具有析构函数。在Java中，您经常使用 float 引用直到垃圾收集器启动。在C++中，您必须 super 了解对象的生命周期。这听起来可能很糟糕，但是从根本上说，完全控制对象的生存期非常有用。

垃圾？什么垃圾

在现代C++中，您不必担心忘记 delete，而应该了解拥有 RAII的优点。在初始化时获取资源并知道何时调用析构函数可以对基本上任何类型的资源进行自动资源管理，这是垃圾收集器只能梦dream以求的(例如文件，数据库连接等)。

“如何在不删除temp()函数且无需手动管理内存的情况下修复代码？”

一个对我有很大帮助的技巧是:每当我发现自己以为需要手动管理资源时，我就会停下来问“别人可以做脏事吗？”。我很难找到一个开箱即用的标准容器，这真的非常罕见。在您的情况下，只需让 std::list完成“肮脏”的工作即可。

如果没有模板，就不能成为C++，对吗？

我实际上建议您按照以下方式将 Storage用作模板:

template <typename T>
class Storage {
private:
    std::list<T> list;
//....

然后

Storage<Thing> thing_storage;
Storage<int> int_storage;

是分别包含 Storage和 Thing的 int。这样，如果您想使用引用或指针进行实​​验，则仍可以实例化 Storage<reference_wrapper<int>>。

我错过了什么吗？...也许是引用？

I won't be able to alter the state of a stored object

假定容器拥有该对象，您宁愿让用户引用该容器中的对象。例如，将 vector 设为

auto t = std::vector<int>(10,0);  // 10 element initialized to 0
auto& first_element = t[0];       // reference to first element
first_element = 5;                // first_element is an alias for t[0]
std::cout << t[0];                // i dont want to spoil the fun part

要使它与 Storage一起使用，您只需要使 findById返回一个引用即可。作为演示:

struct foo {
    private: 
        int data;
    public:
        int& get_ref() { return data;}
        const int& get_ref() const { return data;}
};

auto x = foo();
x.get_ref = 12;

TL； DR

如何避免人工资源管理？让别人为您做这件事，并将其称为自动资源管理:P