C++ 取消对指针向量的迭代器的引用时出现SEGFULT

我有一个对象指针向量

    std::vector<Element*> elements;

要素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_;
};

---

将悬空指针推入向量：

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

---

这里冰和火是局部变量。将地址推送到向量，当到达final}时，两个地址都会被销毁。稍后，当您重新引用时，此无效指针行为未定义。

您正在将指向局部变量的指针传递到此处的向量：

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

当您退出该功能时，

ice

和

fire

不再存在，因此剩下的指针将悬空

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

这个问题的解决方案取决于您是否真的需要指针向量。使用

std:：vector可能更简单：

初始化函数已损坏。创建本地对象，然后将其地址推送到向量上。但是当函数返回时，这些对象被销毁，指针不再有效。除非您需要多态性，否则最简单的修复方法是只生成元素对象的向量，而不是指针

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

std:：向量元素；
...
元素。推回（元素（“冰”，1））；
元素。推回（元素（“火”，2））；

如果需要多态性，那么使用智能指针

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

std:：向量元素；
...
元素。推回（std:：unique_ptr（新元素（“ice”，1））；
元素。推回（std:：unique_ptr（新元素（“fire”，2））；

如果您要继续使用原始指针，那么您需要某种方法来确保对象的持久性，也许可以通过使用
new
来分配它们。然后，您需要确保对每个指针调用
delete
。我不推荐这种方法。
您的向量正在存储指向在堆栈上创建的局部变量的指针。函数完成后，这些变量占用的内存将被回收。如果您试图访问内存，将出现SEG故障

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

typedef std:：vector:：iterator EIter；
对于（EIter it=elements.begin（）；it！=elements.end（）；+it）{
删除*它；
}
所有答案都很好，但我需要一个指针向量，所以我将接受这个回答。谢谢你提供的额外信息。
typedef std::vector<Element *>::iterator EIter;
for (EIter it = elements.begin(); it != elements.end(); ++it) {
    delete *it;
}