分割故障错误

我在测试我的getstartnode（）和getendNode（）函数时不断遇到分割故障错误。当我使用search（）函数将字符串文字作为参数分配启动节点/endnode时，它可以正常工作，但是当我出于某种原因使用名称分配的字符串时，它却不能，这给了我一个分割错误。问题行发生在GenerateGraph（String File）函数中。

我的问题是，为什么它可以与字符串文字合作，而不能与具有与文字本身相同的值分配的字符串？

编译：g -std = c 11 main.cpp node.h node.cpp graph.h graph.cpp

运行：./a.out Samplegraph.txt

main.cpp

#include <iostream>
#include <fstream>
#include <string>
//#include "Banner.h"
//#include "Player.h"
#include "Graph.h"
#include "Node.h"
using namespace std;

int main(int argc, char *argv[])
{
    string file = argv[1];
    cout << file << endl;
    Graph maze;
    maze.generateGraph(file);
    // Welcome banner for start of game
    //Banner welcome("Welcome to the Snakes and Ladders Maze Game");
    //cout << welcome.getBanner() << endl;
    // Testing
    cout << maze.getNumberOfNodes() << endl;
    cout << maze.getNodeList()[47].getNodeName() << endl;
    cout << maze.getNodeList()[4].getAttachedNode(0)->getNodeName() << endl;
    cout << maze.getStartNode()->getNodeName() << endl;
    cout << maze.getEndNode()->getNodeName() << endl;
    return 0;
}

node.h

#ifndef NODE_H
#define NODE_H
#include <string>
class Node 
{
    public:
        Node();
        Node(std::string newname);
        void setNodeName(std::string newname);
        std::string getNodeName();
        void attachNewNode(Node *newNode, int direction);
        Node *getAttachedNode(int direction);
        void attachSnakeLadderNode(Node *newNode);
        Node *getSnakeLadderNode();
    private:
        std::string name; // Name of Node
        Node *attachedNodes[4];
        Node *snakeOrLadderNodes;
};
#endif // NODE_H

node.cpp

#include "Node.h"
using namespace std;
//enum Direction {N, E, S, W};
// Constructors
Node::Node()
{
}
Node::Node(string newname)
{
    name = newname;
}
// Function:    setNodeName
// Inputs:  string newname
// Outputs: void
// Description: Assigns name of Node to newname
void Node::setNodeName(string newname)
{
    name = newname;
}
// Function:    getNodeName
// Inputs:  None
// Outputs: string
// Description: Returns the Nodes name.
string Node::getNodeName()
{
    return name;
}
// Function:    attachNewNode
// Inputs:  Node *newNode, int direction
// Outputs: void
// Description: Attaches a new node with a specific direction.
void Node::attachNewNode(Node *newNode, int direction)
{
    attachedNodes[direction] = newNode;
}
// Function:    *getAttachedNode
// Inputs:  int direction
// Outputs: Node
// Description: Returns the Node located at specified direction.
Node *Node::getAttachedNode(int direction)
{
    return attachedNodes[direction];
}
// Function:    attachSnakeLadderNode
// Inputs:  Node *newNode
// Outputs: void
// Description: Attaches snake/ladder Node
void Node::attachSnakeLadderNode(Node *newNode)
{
    snakeOrLadderNodes = newNode;
}
// Function:    *getSnakeLadderNode
// Inputs:  None
// Outputs: Node
// Description: Returns snake/ladder Node.
Node *Node::getSnakeLadderNode()
{
    return snakeOrLadderNodes;
}

Graph.h

#ifndef GRAPH_H
#define GRAPH_H
#include <fstream>
#include <sstream>
#include <vector>
#include "Node.h"
class Graph
{
    public:
        Graph();
        void setNumberOfNodes(int num);
        int getNumberOfNodes();
        void setNodeList(int num);
        Node *getNodeList();
        Node *search(std::string target);
        void setStartNode(Node *newNode);
        Node *getStartNode();
        void setEndNode(Node *newNode);
        Node *getEndNode();
        void generateGraph(std::string file);
    private:
        int numOfNodes;
        Node *nodeList;
        Node *startNode;
        Node *endNode;
};
#endif // GRAPH_H

graph.cpp

#include "Graph.h"
#include <iostream>
#include <cstdlib>
using namespace std;
// Constructor
Graph::Graph()
{
}
// Function:    setNumberofNodes
// Inputs:  int num
// Outputs: void
// Description: Sets the number of Nodes
void Graph::setNumberOfNodes(int num)
{
    numOfNodes = num;
}
// Function:    getNumberOfNodes
// Inputs:  None
// Outputs: int
// Description: Return number of Nodes.
int Graph::getNumberOfNodes()
{
    return numOfNodes;
}
// Function: setNodeList
// Inputs:  int numOfNodes
// Outputs: void
// Description: Sets the Node list with size of numOfNodes.
void Graph::setNodeList(int num)
{
    nodeList = new Node[num];
}
// Function: getNodeList
// Inputs:  None
// Outputs: nodeList
// Description: Returns pointer to array of nodes
Node *Graph::getNodeList()
{
    return nodeList;
}
// Function:    search
// Inputs:  string name of node target
// Outputs: Pointer to found node
// Description: Returns pointer of the targeted node.
Node *Graph::search(string target)
{
    for (int i = 0; i < numOfNodes; i++)
    {
            if (nodeList[i].getNodeName() == target)
            {
                return &nodeList[i];
            }
    }
}
void Graph::setStartNode(Node *newNode)
{
    startNode = newNode;
}
// Function:    getStartNode
// Inputs:  None
// Outputs: Node *startNode
// Description: Returns pointer to starting node.
Node *Graph::getStartNode()
{
    return startNode;
}
void Graph::setEndNode(Node *newNode)
{
    endNode = newNode;
}
// Function:    getEndNode
// Inputs:  None
// Outputs: Node *endNode
// Description: Returns pointer to destination node.
Node *Graph::getEndNode()
{
    return endNode;
}
// Function: generateGraph
// Inputs:
// Outputs:
// Description:
void Graph::generateGraph(string inFile)
{
    ifstream fin;
    fin.open(inFile);
    if (!fin.fail())
    {
        vector<string> rows;
        string row;
        // First Line (Number of Nodes)
        string numberOfNodes;
        getline(fin, numberOfNodes);
        setNumberOfNodes(stoi(numberOfNodes));
        setNodeList(numOfNodes);
        // Second Line (Start Node)
        string startNodeName;
        getline(fin, startNodeName);
        // Third Line (Destination Node)
        string endNodeName;
        getline(fin, endNodeName);
        // Fourth-Last Lines (Graph)
        while (!fin.eof()) // Scans remaining rows of file and adds each line to a vector<string>
        {
            getline(fin, row);
            rows.push_back(row);
        }
        fin.close();
        // Reads the first column, creates Node objects with names and adds it to the node list
        for (int i = 0; i < numOfNodes; i++)
        {
            string nodeName;
            istringstream iss(rows[i]);
            iss >> nodeName;
            nodeList[i] = Node(nodeName);
        } // end loop
        // Assign start/end nodes
        cout << "Start node: " << startNodeName << endl; 
        setStartNode(search(startNodeName)); // Problem, should be A1
        // setStartNode(search("A1")); // Works, but start node can change.
        setEndNode(search(endNodeName)); // Problem, should be H6
        // setEndNode(search("H6")); //Works, but end node can change.
        // Reads lines stored in vector<string> and links each node
        string info;
        string north, east, south, west, snake_ladder;
        for (int i = 0; i < numOfNodes; i++)
        {
            info = rows[i].substr(rows[i].find(" ") + 1, string::npos);
            istringstream iss(info);
            iss >> north >> east >> south >> west >> snake_ladder;
            // Link North Node
            if (north == "*")
            {
                nodeList[i].attachNewNode(NULL, 0);
            }
            else
            {
                nodeList[i].attachNewNode(search(north), 0);
            }
            // Link East Node
            if (east == "*")
            {
                nodeList[i].attachNewNode(NULL, 1);
            }
            else
            {
                nodeList[i].attachNewNode(search(east), 1);
            }
            // Link South Node
            if (south == "*")
            {
                nodeList[i].attachNewNode(NULL, 2);
            }
            else
            {
                nodeList[i].attachNewNode(search(south), 2);
            }
            // Link West Node
            if (west == "*")
            {
                nodeList[i].attachNewNode(NULL, 3);
            }
            else
            {
                nodeList[i].attachNewNode(search(west), 3);
            }
            // Link Snake/Ladder Node
            if (snake_ladder == "*")
            {
                nodeList[i].attachSnakeLadderNode(NULL);
            }
            else
            {
                nodeList[i].attachSnakeLadderNode(search(snake_ladder));
            }
        } // end loop
    }
    else
    {
        cerr << "nt*** ERROR: File failed to open, program terminating! ***n" << endl;
        exit(0);
    }
}

samplegraph.txt

48
A1
H6
A1 * B1 * * *
B1 B2 * * * *
C1 C2 D1 * * *
D1 * * * * G3
E1 E2 F1 * * B1
F1 * * * E1 *
G1 G2 H1 * * *
H1 * * * G1 G5
A2 A3 B2 * * *
B2 * C2 B1 A2 *
C2 C3 * C1 B2 *
D2 D3 E2 * * *
E2 * * E1 D2 *
F2 F3 G2 * * *
G2 * H2 G1 F2 *
H2 * * * G2 E4
A3 * * A2 * D3
B3 B4 C3 * * *
C3 * D3 C2 B3 *
D3 D4 * D2 C3 *
E3 * F3 * * *
F3 F4 * F2 E3 *
G3 G4 H3 * * *
H3 H4 * * G3 *
A4 * B4 * * *
B4 B5 * B3 A4 *
C4 * D4 * * F2
D4 D5 E4 D3 C4 *
E4 * F4 * D4 *
F4 * G4 F3 E4 *
G4 G5 * G3 F4 *
H4 * * H3 * *
A5 A6 B5 * * *
B5 * C5 B4 A5 *
C5 * * * B5 B2
D5 D6 E5 D4 * *
E5 * F5 * D5 *
F5 F6 * * E5 *
G5 * H5 G4 * *
H5 H6 * * G5 *
A6 * B6 A5 * *
B6 * C6 * A6 E5
C6 * * * B6 *
D6 * * D5 * C3
E6 * F6 * * *
F6 * G6 F5 E6 *
G6 * * * F6 F4
H6 * * H5 * *