Speichern der Adresse zu Stack zugeordneten Objekt in Vektor

Question

Ich habe Probleme mit dem Speichern von Zeigern zu Adressen für Stack zugeordneten Objekten in Vektoren. Irgendwie scheinen die Zeiger einander auf eine Weise zu überschreiben, die ich nicht verstehe.

In meiner Hauptsache möchte ich aus einer Datei lesen, Knoten (Stapel zugeordnet) erstellen und sie in einen Vektor einfügen. Später lese ich weiter aus der Datei, um Verbindungen (Edges) zwischen den Knoten zu erstellen und staple somit Edge-Objekte zu und versuche, die Adressen zu diesen im jeweiligen Knoten zu speichern (Knoten enthalten einen Vektor). Die Eingabedatei hat das Format index_1 a, index_2, b, Kapazität c, was bedeutet, dass eine Kante von a nach b und umgekehrt mit der Kapazität c erstellt werden soll.

Jedes Mal, wenn ich einem Knoten eine Kante (vector :: push_back()) hinzufüge, wird der gesamte Vektor im Knoten auf den gleichen Zeiger gesetzt (anstatt nur einen anderen Zeiger wie vorgesehen anzuhängen). Beispiel Ausgabe nach der Zugabe von 3 Kanten zum gleichen Knoten:

#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 

Excuse meines Code, wenn es irgendwelche Tests oder Druck in ihm links:

Main:

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

Vielen Dank für jede Hilfe oder Zeiger (er he)!

Answer 1

Sobald die Ausführung den Bereich verlässt, in dem eine nicht static Variable deklariert ist, ist diese Variable nicht mehr vorhanden und die Zeiger darauf werden dangling pointer.

Ein Dangling-Zeiger ist ungültig. Auch wenn Sie nur den Wert prüfen, kann dies zu einem Hardware-Trap führen. Daher ist jede Verwendung von Undefined Behavior.

Und so ist das, was du hast, weil du Dinge wie

graph[a].addEdge(&e1); 

in einer Schleife zu tun, wo e1 eine Variable in der Schleife deklariert ist.