指针向量解引用迭代器时出现段错误

Segfault when dereferencing iterator for vector of pointers

本文关键字：段错误 错误 向量 引用 迭代器 指针      更新时间：2023-10-16

我有一个对象指针向量

    std::vector<Element*> elements;

当遍历vector时，我想对迭代器进行双引用，以便调用对象的方法。

    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;
}

Element.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_;
};

Element.cpp: 

#include "Element.h"
Element::Element(std::string name, int id) {
    name_ = name;
    id_ = id;
}

初始化函数被破坏了。您创建本地对象，然后将它们的地址压入向量。但是当函数返回时，这些对象将被销毁，指针也不再有效。除非您需要多态，否则最简单的修复方法就是创建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。我不推荐你走这条路。

将指向局部变量的指针传递给vector:

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));

将悬空指针压入vector:

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

这里冰和火是局部变量。将地址压入vector，然后当到达final}时，它们都被销毁。当你稍后引用这个无效指针的行为是未定义的。

vector存储的是指向堆栈上创建的局部变量的指针。当函数结束时，这些变量所占用的内存将被回收。如果你试图访问内存，你会得到一个段错误。

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;
}
相关文章：