取消引用指针向量的迭代器时的段错误答案

【问题标题】：Segfault when dereferencing iterator for vector of pointers取消引用指针向量的迭代器时的段错误
【发布时间】：2013-06-05 07:44:34
【问题描述】：

我有一个对象指针向量

    std::vector<Element*> elements;

在遍历向量时，我想对迭代器进行双重取消引用，以便调用对象的方法。

    std::cout << (*it)->getName() << std::endl;

这会导致段错误。相关代码如下。

我认为问题在于我如何初始化向量，因为我可以将 for 循环移动到方法 initialize() 中并且它工作正常。在takeTurn() 中，向量具有适当的大小，并且指针包含正确的地址。这是否意味着被指向的对象被过早地销毁了？

main.cpp:

#include <vector>
#include <iostream>
#include "Element.h"

    std::vector<Element*> elements;

void initialize() {
    Element ice = Element("ice",1);
    Element fire = Element("fire",2);
    elements.push_back(&ice); 
    elements.push_back(&fire);
}

void takeTurn() {
    std::vector<Element*>::iterator it;
    for(it = elements.begin(); it != elements.end(); ++it) {
        std::cout << (*it)->getName() << std::endl;
    }
}

int main() {
    initialize();
    takeTurn();
    return 0;
}

元素.h：

#include <string>

class Element {
    public:
        Element(std::string name, int id);
        int getID() { return id_; }
        std::string getName() { return name_; }

    private:
        int id_;
        std::string name_;
};

元素.cpp：

#include "Element.h"

Element::Element(std::string name, int id) {
    name_ = name;
    id_ = id;
}

【问题讨论】：

标签： c++ pointers vector dereference

【解决方案1】：

您的初始化功能已损坏。您创建本地对象，然后将它们的地址推送到向量上。但是当函数返回时，这些对象被销毁，指针不再有效。除非您需要多态性，否则最简单的解决方法是只创建一个 Element 对象的向量，而不是指针。

std::vector<Element> elements;
...
elements.push_back(Element("ice",1));
elements.push_back(Element("fire",2));

如果您需要多态性，请使用智能指针。

std::vector<std::unique_ptr<Element>> elements;
...
elements.push_back(std::unique_ptr<Element>(new Element("ice",1)));
elements.push_back(std::unique_ptr<Element>(new Element("fire",2)));

如果您要继续使用原始指针，那么您将需要一些方法来确保对象的持久性，也许通过使用new 分配它们。然后，您需要确保在您使用它们的每个指针上调用delete。我不推荐这条路线。

【讨论】：

所有答案都很好，但我需要一个指针向量，所以我将接受这个回复。感谢您提供额外的信息。

【解决方案2】：

您在这里将指向局部变量的指针传递给向量：

Element ice = Element("ice",1);
Element fire = Element("fire",2);
elements.push_back(&ice); 
elements.push_back(&fire);

当您退出函数时，ice 和 fire 将不复存在，因此您会留下悬空指针。

这个问题的解决方案取决于你是否真的需要一个指针向量。 std::vector<Element> 可能更简单：

std::vector<Element> elements;

然后

elements.push_back(Element("ice",1));
elements.push_back(Element("fire",2));

【讨论】：

【解决方案3】：

将悬空指针推入向量：

void initialize() {
    Element ice = Element("ice",1);
    Element fire = Element("fire",2);
    elements.push_back(&ice); 
    elements.push_back(&fire);
}

这里的冰与火是局部变量。您将地址推送到向量，然后在达到最终 } 时都被销毁。稍后当您重新引用此无效指针时，行为未定义。

【讨论】：

【解决方案4】：

您的向量存储指向在堆栈上创建的局部变量的指针。函数执行完毕后，这些变量占用的内存将被回收。如果你尝试访问内存，你会得到一个段错误。

void initialize() {
    Element ice = Element("ice",1); // Local variable.
    Element fire = Element("fire",2); // Local variable.
    elements.push_back(&ice); 
    elements.push_back(&fire);
} // Ice and fire disappear.

为堆上的元素分配内存：

void initialize() {
    Element *ice = new Element("ice",1);
    Element *fire = new Element("fire",2); 
    elements.push_back(ice); 
    elements.push_back(fire);
}

完成后记得释放内存！

typedef std::vector<Element *>::iterator EIter;
for (EIter it = elements.begin(); it != elements.end(); ++it) {
    delete *it;
}

【讨论】：