将地址存储到向量中的堆栈分配对象

Question

我在为向量中的堆栈分配对象存储指向地址的指针时遇到问题。不知何故，指针似乎以我不理解的方式相互覆盖。

在我的主文件中，我想从文件中读取，创建节点（分配堆栈）并将它们放入向量中。后来我继续从文件中读取以在节点之间创建连接（边缘），从而堆栈分配边缘对象并尝试将地址存储到相应的节点中（节点包含一个向量）。输入文件的格式为 index_1 a, index_2, b, capacity c，这意味着要创建从 a 到 b 的 Edge，反之亦然，容量为 c。

每次我将 Edge 添加到节点 (vector::push_back()) 时，节点中的整个向量都会设置为相同的指针（而不是像预期的那样只是附加另一个指针）。将 3 条边添加到同一节点后的示例输出：

#0 named: ORIGINS connected to: 
#1 named: 2, capacity: -1, flow: 0

#0 named: ORIGINS connected to: 
#17 named: 3W, capacity: -1, flow: 0
#17 named: 3W, capacity: -1, flow: 0

#0 named: ORIGINS connected to: 
#16 named: 3E, capacity: -1, flow: 0
#16 named: 3E, capacity: -1, flow: 0
#16 named: 3E, capacity: -1, flow: 0

如果我的代码中有任何测试或打印，请原谅：

主要：

#include <iostream>
#include <vector>
#include <stdlib.h>
#include <string>
#include <fstream>
#include <algorithm>
#include <map>
#include <sstream>
#include "Edge.h"
#include "Node.h"
#include <memory>

using namespace std;

ostream& operator<<(ostream& os, const Node& obj) {
    os << "#" << obj.index << " named: " << obj.name << " connected to: " << endl;
    for (size_t i = 0; i < obj.edges.size(); ++i) {
        Edge* e = obj.edges[i];
        os << "#" << e->getEndNode()->getIndex() << " named: " << e->getEndNode()->getName() << ", capacity: " << e->getCapacity() << ", flow: " << e->getFlow() << endl;
    }
    return os;
}

int main() {
    string fileName = "rail.txt";

    //open file
    ifstream infile(fileName.c_str());

    //initialize variables
    string line;
    vector<Node> graph;

    int n;
    getline(infile, line);
    n = atoi(line.c_str());
    //read n nodes
    for (int i = 0; i < n; ++i) {
        if (getline(infile, line)) {
            Node node(line, i);
            graph.push_back(node);
        } else {
            cout << "Error in parsing nodes" << endl;
            return 1;
        }
    }

    int m;
    getline(infile, line);
    m = atoi(line.c_str());
    //read m edges
    for (int i = 0; i < m; ++i) {
        if (getline(infile, line)) {
            istringstream iss(line);
            int a, b, c;

            iss >> a >> b >> c;
            Edge e1(&graph[b], c, 0);
            Edge e2(&graph[a], c, 0);
            graph[a].addEdge(&e1);
            graph[b].addEdge(&e2);
            cout << graph[a] << endl;
        } else {
            cout << "Error in parsing edges" << endl;
            return 1;
        }
    }

    /*for (auto e : graph[0].getEdges()) {
        cout << e->getEndNode()->getName() << endl;
    }*/


    return 0;
}

Edge.cpp：

#include "Edge.h"

Edge::Edge() : endNode(nullptr), capacity(0), flow(0) {};
Edge::Edge(Node* n, int c, int f) : endNode(n), capacity(c), flow(f) {};
Edge::Edge(const Edge& other) {
    endNode = other.endNode;
    capacity = other.capacity;
    flow = other.flow;
};

bool Edge::pushFlow(int f) {
    if (flow + f <= capacity) {
        flow += f;
        return true;
    } else {
        return false;
    }
}

bool Edge::popFlow(int f) {
    if (flow - f >= 0) {
        flow -= f;
        return true;
    } else {
        return false;
    }
}

Node* Edge::getEndNode() {
    return endNode;
}

int Edge::getCapacity() {
    return capacity;
}

int Edge::getFlow() {
    return flow;
}

Node.cpp：

#include "Node.h"
#include <iostream>
Node::Node() : name(""), index(-1) {};
Node::Node(std::string n, int i) : name(n), index(i) {};
Node::Node(const Node& other) : name(other.name), index(other.index), edges(other.edges) {};

void Node::addEdge(Edge* e) {
    edges.push_back(e);
}

std::vector<Edge*> Node::getEdges() {
    return edges;
}

Node& Node::operator=(const Node& rhs) {
    if (this == &rhs) return *this;
    name = rhs.name;
    index = rhs.index;
    edges = rhs.edges;
    return *this;
}

std::string Node::getName() {
    return name;
}

int Node::getIndex() {
    return index;
}

感谢您的任何帮助或指点（呵呵）！

Answer 1

一旦执行离开作用域，就会在其中声明一个非static 变量，该变量将不复存在，指向它的指针变为悬空指针。

悬空指针无效。即使只是检查该值也可能导致硬件陷阱。因此，任何使用它都是未定义的行为。

这就是你所拥有的，因为你会做这样的事情

graph[a].addEdge(&e1);

在循环中，e1 是在循环体中声明的变量。