C ++：如何“存储”节点

Question

So I am trying to read data in the following format from a text file for a simple maze game:

A * B * *
B * C * A
C G D * B
D * * * C
E I F * *
F J G * E
G * H C F
H * * * G
I * * E *
J * K F *
K * L * J
L * * * K

The first column is the current node. The second column, the node to its immediate north. Third, to its immediate east, Fourth, to the immediate south, and fifth, to the immediate west. Any * represents no node, and the pointer should be set to null.

Keeping in mind that I am a rookie at OOP, I am curious how to go about "saving" this information into a class called Node.

I've got the following class definition:

public:
    int BuildGraph();
    char name;
    char north;
    char east;
    char south;
    char west;
};  
    std::vector<Node> nodes;

With the code build >> node.name >> node.north >> node.east >> node.south >> node.west; the correct characters are read in.

This correctly gets the characters that I want. However, once I get to the end of the line, how do I store this node and then move on to the next line and store THAT node? Right now, I've got a do/while loop that loops through this until it reaches the end of file but of course it overwrites everything each time it goes through so the only code it is effectively reading in is the last line of L * * * K. How do I get the first line to save as node A, the second as node B, etc? How do I reference this elsewhere in the program? Right now, I'm just creating an object node of type Node. When I get to the end of the line, I need everything in node to be copied to a new Node, called A.

EDIT: Sorry about the formatting; Stack Overflow is not recognizing my 4 spaces as indention of code.

Answer 1

I'm not sure if I'm getting what is what you want to get, but if you want to save each element of type Node with a different identifier you may try the next:

pair<char, Node> node_with_name;

And then you can assign the name to the first element doing build >> node_with_name.first; , then put the rest of the elements in the node and assign it in the same way to the second position of the pair .

And the vector should also be changed in order to use this solution:

std::vector<pair<char, Node> > nodes;

And finally you would do:

nodes.push_back(node_with_name);

in every iteration of the loop.

---

Edit: I think that a map would possibly fit better to your needs. I will show you an example:

std::map<char,Node> mymap;

do {
  char name;                          // to store temporarily each node's name
  build >> name;            
  build >> mymap[name].north;      // we start getting the data for the node with this name
  build >> mymap[name].east;
  build >> mymap[name].south;
  build >> mymap[name].west;
}while(! build.eof());

And then you can output each node's data with:

std::cout << "mymap['A'].north is " << mymap['A'].north << '\n';

Map reference: http://www.cplusplus.com/reference/map/map/operator%5B%5D/

Pair Reference: http://www.cplusplus.com/reference/utility/pair/

Answer 2

在文件上使用getline（）函数，逐行读取文件，然后将节点信息解析为节点结构。

Answer 3

One thing that's rough for you is that you can't create nodes directly, because early on you'll need to get pointers to nodes you haven't created yet. One way to render this problem moot is what you seem to be doing: storing the node letters instead of pointers:

#include <iostream>
class Maze; // Holds all the nodes; defined later.

class Node
{public:
    static const char kNoLink = '*';
    Node(): north(kNoLink), east(kNoLink), south(kNoLink), west(kNoLink) {}
private:
    char name;
    char north;
    char east;
    char south;
    char west;
    friend std::istream& operator>>(std::istream&, Node&);
    friend std::ostream& operator<<(std::ostream&, const Node&);
    friend class Maze;
};

std::istream& operator>>(std::istream& is, Node& node)
{
    return is >> node.name >> node.north >> node.east >> node.south >> node.west; 
}

std::ostream& operator<<(std::ostream& os, const Node& node)
{
    return os << node.name << ' ' << node.north << ' ' << node.east << ' ' 
        << node.south << ' ' << node.west << '\n'; 
}

Then the Maze class holds them all:

#include <map>

class Maze
{public:
    Maze() {}
    ~Maze();
    Node* GetNode(char name)
    {
        NodeMap::iterator ni = nodeMap.find(name);
        return ni == nodeMap.end()? 0: *ni;
    }
    Node* GoNorth(Node* start) { return GetNode(start->north); }
    Node* GoEast(Node* start) { return GetNode(start->east); }
    Node* GoSouth(Node* start) { return GetNode(start->south); }
    Node* GoWest(Node* start) { return GetNode(start->west); }
private:
    typedef std::map<char, Node*> NodeMap;
    NodeMap nodeMap;
    friend std::istream& operator>>(std::istream&, Maze&);
    friend std::ostream& operator<<(std::ostream&, const Maze&);
};

Maze::~Maze()
{
    // While the map itself will get properly destroyed, its contents won't.
    // So we have to delete the nodes in the map ourselves.
    // For std::map, i->first is the key and i->second is the value.
    for(NodeMap::iterator i = nodeMap.begin(); i != nodeMap.end(); ++i)
        delete i->second;
}

std::istream& operator>>(std::istream& is, Maze& maze)
{
    while(is)
    {
        Node* newNode = new Node;
        is >> newNode;
        maze.nodeMap[newNode.name] = newNode;
    }
    return is;
}

std::ostream& operator<<(std::ostream& os, const Maze& maze)
{
    for(NodeMap::const_iterator i = nodeMap.begin(); i != nodeMap.end(); ++i)
        os << *(i->second);
    return os;
}

Now reading the maze is simply:

Maze maze;
build >> maze;

And printing it is something like:

cout << maze;

There are lots of improvements that can be made here, such as storing pointers directly in the nodes (this requires a two-pass reader: you still have to store the letters, then link all the nodes after reading the whole maze) and removing the names on the nodes and the node map and putting all the code into the Node class (allows you to manage the whole maze from any node; node names are discarded after reading the maze and regenerated when printing it out).

Also, I'm assuming you aren't using C++11. If you are, then you can simplify the code even further. For example, this:

    for(NodeMap::const_iterator i = nodeMap.begin(); i != nodeMap.end(); ++i)
        os << *(i->second);

becomes:

    for(auto i: nodeMap)
        os << *(i->second);

That all said, there are far more robust parsing options than istreams. Check out Boost::Spirit if you think writing Backus-Naur Form (BNF) is no big deal and want to see the crazy things you can do with operator overloading in C++.

Answer 4

#include <iostream>
#include <iterator>
#include <vector>
#include <algorithm>

struct node
{
    char name;
    char north;
    char east;
    char south;
    char west;
}; 

std::istream& operator >> (std::istream& is, node& n)
{
    is >> n.name >> n.north >> n.east >> n.south >> n.west;
    return is;
}

std::ostream& operator << (std::ostream& os, const node& n)
{
    os << n.name << ' ' << n.north << ' ' << n.east << ' ' << n.south << ' ' << n.west;
    return os;
}

int main(int argc, char* argv[])
{
    std::vector<node> nodes;

    node n;

    while(std::cin >> n)
      nodes.push_back(n);

    std::copy(nodes.begin(), nodes.end(), std::ostream_iterator<node>(std::cout,"\n"));
    return 0;
}

$ cat nodes.txt | ./a.out 
A * B * *
B * C * A
C G D * B
D * * * C
E I F * *
F J G * E
G * H C F
H * * * G
I * * E *
J * K F *
K * L * J
L * * * K

Answer 5

As I understand the question, you'd want to be able to read in a description of nodes from a file and store them in a data structure in memory. Looks like a text adventure map.

I've copied your maze game map into a text file called "maze.dat"

Here's a simple program that parses the maze.dat file, line by line, storing each line into a user defined data structure called Node. Each node is then placed in another data structure called a vector.

At the end of the program I've printed out each node in the vector so that you can see it matches the original input file. Here is my example:

#include <iostream>
#include <fstream>
#include <vector>

// storing each node in a data structure
class Node
{
public:
    Node(char name, char north, char east, char south, char west)
    {
        this->name = name;
        this->north = north;
        this->east = east;
        this->south = south;
        this->west = west;
    };

    char name;
    char north;
    char east;
    char south;
    char west;
};

// function to print out a node
void print_node(Node n)
{
    std::cout << n.name << " " << n.north << " " << n.east << " " << n.south << " " << n.west << " " << std::endl;
}

int main(int argc, const char * argv[])
{
    // first off let's read in our maze data file
    std::ifstream maze_file("maze.dat");

    // create somewhere to store our nodes
    std::vector<Node> nodes;

    // check that we opened the file, then parse each line
    if( maze_file.is_open() )
    {
        while( maze_file.good() )
        {
            // temporary node_data for each line in the file
            std::string node_data;

            // read the current line
            getline( maze_file, node_data );

            // parse the line into tokens (e.g. A, ,*, ,B, ,*, ,* )
            std::vector<char> tokens(node_data.begin(), node_data.end());

            // strip out the blanks ' ' (e.g. A,*,B,*,*)
            tokens.erase( std::remove(tokens.begin(), tokens.end(), ' '), tokens.end() );

            // there should be 5 tokens for a node description
            if( tokens.size() == 5 )
            {
                Node node( tokens[0], tokens[1], tokens[2], tokens[3], tokens[4] );
                nodes.push_back(node);
            }
            else
                std::cout << "There weren't 5 tokens in the node description, there were: " << tokens.size() << std::endl;
        }

        // clean-up the open file handle
        maze_file.close();
    }
    else
        std::cout << "Unable to open file maze.dat";

    // now we can prove that we've stored the nodes in the same way as they were in the file
    // let's print them out from the vector of nodes
    std::for_each(nodes.begin(), nodes.end(), print_node);

    return 0;
}

This is a pretty simple method to translate the file into a data structure. This is useful for loading files, you could then create a way to save maps, hence build a map creator program.

This probably does not help much when it comes to actually using the maze map in the actual game. It's more likely that you will want to retrieve the relevant room depending on whether you want to travel north, east, south, west. For this you're going to need to build a graph data structure using std::map as previously described by Str1101