视觉C++ Battle4锡安项目 引发未处理的异常:读取访问冲突.**这**是空的.发生

我已经开始了我的程序来测试我的头像在竞技场中的移动。 我试图向任何方向移动我的头像，我的程序停止工作。使用调试器，我在函数中发现了一条消息my Robot::move()上面写着

引发未经处理的异常：读取访问冲突。 这是无效的。发生

复制了以下代码，希望你们中的一个人可以解释我必须做什么：

// zion.cpp
// Portions you are to complete are marked with a TODO: comment.
// We've provided some incorrect return statements (so indicated) just
// to allow this skeleton program to compile and run, albeit incorrectly.
// The first thing you probably want to do is implement the trivial
// functions (marked TRIVIAL).  Then get Arena::display going.  That gives
// you more flexibility in the order you tackle the rest of the functionality.
// As you finish implementing each TODO: item, remove its TODO: comment.
#include <iostream>
#include <string>
#include <cstdlib>
#include <ctime>
using namespace std;
///////////////////////////////////////////////////////////////////////////
// Manifest constants
///////////////////////////////////////////////////////////////////////////
const int MAXROWS = 20;             // max number of rows in the arena
const int MAXCOLS = 40;             // max number of columns in the arena
const int MAXROBOTS = 130;          // max number of robots allowed
const int MAXSHOTLEN = 5;           // max number of steps you can shoot
const int UP = 0;
const int DOWN = 1;
const int LEFT = 2;
const int RIGHT = 3;
///////////////////////////////////////////////////////////////////////////
//  Auxiliary function declarations
///////////////////////////////////////////////////////////////////////////
int decodeDirection(char dir);
void clearScreen();
///////////////////////////////////////////////////////////////////////////
// Type definitions
///////////////////////////////////////////////////////////////////////////
class Arena;  // This is needed to let the compiler know that Arena is a
          // type name, since it's mentioned in the Robot declaration.
class Robot
{
public:
    // Constructor
    Robot(Arena* ap, int r, int c);
    // Accessors
    int  row() const;
    int  col() const;
    // Mutators
    void move();
    bool takeDamageAndLive();
private:
    Arena* m_arena;
    int    m_row;
    int    m_col;
    // TODO: You'll probably find that a robot object needs an additional
    // data member to support your implementation of the behavior affected
    // by being hit and taking damage.
};
class Player
{
public:
    // Constructor
    Player(Arena *ap, int r, int c);
    // Accessors
    int  row() const;
    int  col() const;
    int  age() const;
    bool isDead() const;
    // Mutators
    string takeComputerChosenTurn();
    void   stand();
    void   move(int dir);
    bool   shoot(int dir);
    void   setDead();
private:
    Arena* m_arena;
    int    m_row;
    int    m_col;
    int    m_age;
    bool   m_dead;
};
class Arena
{
public:
    // Constructor/destructor
    Arena(int nRows, int nCols);
    ~Arena();
    // Accessors
    int     rows() const;
    int     cols() const;
    Player* player() const;
    int     robotCount() const;
    int     nRobotsAt(int r, int c) const;
    void    display(string msg) const;
    // Mutators
    bool   addRobot(int r, int c);
    bool   addPlayer(int r, int c);
    void   damageRobotAt(int r, int c);
    bool   moveRobots();
private:
    int     m_rows;
    int     m_cols;
    Player* m_player;
    Robot*  m_robots[MAXROBOTS];
    int     m_nRobots;
};
class Game
{
public:
    // Constructor/destructor
    Game(int rows, int cols, int nRobots);
    ~Game();
    // Mutators
    void play();
private:
    Arena* m_arena;
};
///////////////////////////////////////////////////////////////////////////
//  Robot implementation
///////////////////////////////////////////////////////////////////////////
Robot::Robot(Arena* ap, int r, int c)
{
    if (ap == nullptr)
    {
        cout << "***** A robot must be in some Arena!" << endl;
        exit(1);
    }
    if (r < 1 || r > ap->rows() || c < 1 || c > ap->cols())
    {
        cout << "***** Robot created with invalid coordinates (" << r << ","
        << c << ")!" << endl;
        exit(1);
    }
    m_arena = ap;
    m_row = r;
    m_col = c;
}
int Robot::row() const
{
    return m_row;
}
int Robot::col() const
{
    return m_col; // returns what column the robot is at.
}
void Robot::move()
{
    // Attempt to move in a random direction; if we can't move, don't move
    switch (rand() % 4)
    {
    case UP:
        if (m_row > 1) 
            m_row--; /* Robot may move to the row above unless it is a
                 boundry. */
        break;
    case DOWN:
        if (m_row < m_arena->rows()) 
            m_row++; /* Robot may move to the row below unless it is a
                 boundry. */
        break;
    case LEFT:
        if (m_col > 1) 
            m_col--; /* Robot may move to the left column unless it is a
                 boundry. */
        break;
    case RIGHT:
        if (m_row < m_arena->cols()) 
            m_col++; /* Robot may move to the right column unless it is a
                 boundry. */
        break;
    }
}
bool Robot::takeDamageAndLive()
{
    // TODO:  If the robot has been hit once before, return false (since a
    // second hit kills a robot).  Otherwise, return true (since the robot
    // survived the damage).
    return false; //temp
}
///////////////////////////////////////////////////////////////////////////
//  Player implementations
///////////////////////////////////////////////////////////////////////////
Player::Player(Arena* ap, int r, int c)
{
    if (ap == nullptr)
    {
        cout << "***** The player must be in some Arena!" << endl;
        exit(1);
    }
    if (r < 1 || r > ap->rows() || c < 1 || c > ap->cols())
    {
        cout << "**** Player created with invalid coordinates (" << r
        << "," << c << ")!" << endl;
        exit(1);
    }
    m_arena = ap;
    m_row = r;
    m_col = c;
    m_age = 0;
    m_dead = false;
}
int Player::row() const
{
    return m_row;
}
int Player::col() const
{
    return m_col;
}
int Player::age() const
{
    return m_age;
}
string Player::takeComputerChosenTurn()
{
    // Your replacement implementation should do something intelligent
    // and return a string that describes what happened.  When you've
    // decided what action to take, take it by calling move, shoot, or stand.
    // This function must return one of the following four strings:
    //     "Moved."
    //     "Shot and hit!"
    //     "Shot and missed!"
    //     "Stood."
    // Here's one possible strategy:
    //   If moving in some direction would put me in less immediate danger
    //     than standing, then move in that direction.
    //   else shoot in the direction of the nearest robot I can hit.
    // A more aggressive strategy is possible, where you hunt down robots.
    int r = row(), c = col();
    int nRobotsLeft = 0, nRobotsRight = 0, nRobotsUp = 0, nRobotsDown = 0;
    if (c > 1) // checks the number of robots 1 space to the left of the player.
        nRobotsLeft = m_arena->nRobotsAt(r, c - 1);
    if (c < m_arena->cols()) /* checks the number of robots 1 space to the right
                         of the player. */
        nRobotsRight = m_arena->nRobotsAt(r, c + 1);
    if (r > 1) // checks the number of robots 1 space above the player
        nRobotsUp = m_arena->nRobotsAt(r - 1, c);
    if (r < m_arena->rows()) /* checks the number of robots 1 space under the
                         player. */
        nRobotsDown = m_arena->nRobotsAt(r + 1, c);
    int nRobotsLeftRow = 0, nRobotsRightRow = 0, nRobotsAboveCol = 0,
    nRobotsBelowCol = 0;
    for (int q = c - 2; q >= 1; q--) /* looking for robots on the same row to
                                 the left, but not adjacent to the player */
        nRobotsLeftRow += m_arena->nRobotsAt(r, q); /* increments the number of
                                                robots if any are found */
    for (int q = c + 2; q <= m_arena->cols(); q++) /* looking for robots on
                                               the same row, to the right, but not adjacent to the player */
        nRobotsRightRow += m_arena->nRobotsAt(r, q); /* increments the number of
                                                 robots if any are found */
    for (int k = r - 2; k >= 1; k--) /* looks for robots in the same column,
                                 above but not adjacent to the player */
        nRobotsAboveCol += m_arena->nRobotsAt(k, c);
    for (int k = r + 2; k <= m_arena->rows(); k++) /* looks for robots in the
                                               same column, below but not adjacent to the player */
        nRobotsBelowCol += m_arena->nRobotsAt(k, c);
    // # robots directly next to player
    int nRobotsAdjacent = nRobotsRight + nRobotsLeft + nRobotsUp + nRobotsDown;
    int nRobotsInRange = nRobotsRightRow + nRobotsLeftRow + nRobotsAboveCol +
    nRobotsBelowCol; //# robots not directly next to player but in shooting range
    if (nRobotsAdjacent == 0) /* if no robots are adjacent to the player, */     {
        if (nRobotsInRange > 0) /* and there are robots in shooting range, the player
                            should shoot towards a robot. */
        {
            if (nRobotsRightRow > 0) /*shoots right*/ {
                bool hit = shoot(RIGHT);
                if (hit)
                    return "Shot and hit!";
                else
                    return "Shot and missed!";
            }
            else if (nRobotsLeftRow > 0) /*shoots left*/ {
                bool hit = shoot(LEFT);
                if (hit)
                    return "Shot and hit!";
                else
                    return "Shot and missed!";
            }
            else if (nRobotsAboveCol > 0) /*shoots up*/ {
                bool hit = shoot(UP);
                if (hit)
                    return "Shot and hit!";
                else
                    return "Shot and missed!";
            }
            else if (nRobotsBelowCol > 0) /*shoots down*/ {
                bool hit = shoot(DOWN);
                if (hit)
                    return "Shot and hit!";
                else
                    return "Shot and missed!";
            }
            else /* this should never trigger. only goes off if an error occurs. */ {
                stand();
                return "Stood.";
            }
        }
        else /* player is safe, but has nothing to shoot at */ {
            stand();
            return "Stood.";
        }
    }
    if (nRobotsAdjacent > 0) {
        /* should calculate the safest of the 4 spots and choose a spot to move to based on relative safety */
        int safetyRatingR = m_arena->nRobotsAt(r + 1, c + 1) + m_arena->nRobotsAt(r - 1, c + 1) + m_arena->nRobotsAt(r, c + 2);
        // creates an integer value of the amount of robots directly adjacent to the space 1 spot to the right of the player
        int safetyRatingL = m_arena->nRobotsAt(r + 1, c - 1) + m_arena->nRobotsAt(r - 1, c - 1) + m_arena->nRobotsAt(r, c - 2);
        // safety value for the left space
        int safetyRatingU = m_arena->nRobotsAt(r - 1, c - 1) + m_arena->nRobotsAt(r - 1, c + 1) + m_arena->nRobotsAt(r - 2, c);
        //safety value for the above space
        int safetyRatingD = m_arena->nRobotsAt(r + 1, c + 1) + m_arena->nRobotsAt(r + 1, c - 1) + m_arena->nRobotsAt(r + 2, c);
        //safety value for the below space
        if (safetyRatingR <= safetyRatingL && safetyRatingR <= safetyRatingU && safetyRatingR <= safetyRatingD && c != m_arena->cols()) {
            // if R has the lowest safety rating, and moving right would not take you off the grid
            move(RIGHT);
            return "Moved.";
        }
        else if ((safetyRatingL <= safetyRatingU) && (safetyRatingL <= safetyRatingD) && (c != 1)) {
            // if L has the lowest safety rating of the remaining possible directions to move, and moving left would not go off the grid
            move(LEFT);
            return "Moved.";
        }
        else if ((safetyRatingU <= safetyRatingD) && (r != 1)) {
            // if U has the lowest safety rating of the 2 remaining poss directions, and moving up would not go off the grid
            move(UP);
            return "Moved.";
        }
        else if (r != m_arena->rows()) { // final option is to move down, only triggers if this would not take you off the grid
            move(DOWN);
            return "Moved.";
        }
        else { // something went wrong, and none of the 4 directions will work
            stand();
            return "Stood.";
        }
    }
}
void Player::stand()
{
    m_age++;
}
void Player::move(int dir)
{
    m_age++;
    switch (dir)
    {
    case UP:
        if (m_row > 1)
            m_row--;
        break;
    case DOWN:
        if (m_row < m_arena->rows())
            m_row++;
        break;
    case LEFT:
        if (m_col > 1)
            m_col--;
        break;
    case RIGHT:
        if (m_col < m_arena->cols())
            m_col++;
        break;
    }
}
bool Player::shoot(int dir)
{
    m_age++;
    if (rand() % 3 == 0)  // miss with 1/3 probability
        return false;
    // Damages the nearest robot in direction dir, returning
    // true if a robot is hit and damaged, false if not hit.
    switch (dir) {
    case UP:
        for (int r = m_row; r >= 1; r--) /* starts at the player's row position
                                     and steps down, stopping at the end of the arena */
        {
            if (m_arena->nRobotsAt(r, m_col) >= 1) /* if there is a robot at the
                                               current step, throw damage and return */
            {
                m_arena->damageRobotAt(r, m_col);
                return true;
            }
        }
        break;
    case DOWN:
        for (int r = m_row; r <= m_arena->rows(); r++) /* starts at player's row
                                                   and goes down */
        {
            if (m_arena->nRobotsAt(r, m_col) >= 1) /* if there is a robot at the
                                               current step, throw damage and return */
            {
                m_arena->damageRobotAt(r, m_col);
                return true;
            }
        }
        break;
    case LEFT:
        for (int c = m_col; c >= 1; c--) /* starts at player's column position
                                     and steps to the left one space at a time */
        {
            if (m_arena->nRobotsAt(m_row, c) >= 1) {
                m_arena->damageRobotAt(m_row, c); /* if there is a robot at the
                                              current step, throw damage and return */
                return true;
            }
        }
        break;
    case RIGHT:
        for (int c = m_col; c <= m_arena->cols(); c++) /* starts at player's column
                                                   position and steps to the right one space at a time */
        {
            if (m_arena->nRobotsAt(m_row, c) >= 1) {
                m_arena->damageRobotAt(m_row, c); /* if there is a robot at the
                                              current step, throw damage and return */
                return true;
            }
        }
        break;
    }
    return false; // didn't hit anything
}
bool Player::isDead() const
{
    // returns whether the player is dead.
    if (m_dead)
        return true;
    return false;
}
void Player::setDead()
{
    m_dead = true;
}
///////////////////////////////////////////////////////////////////////////
//  Arena implementations
///////////////////////////////////////////////////////////////////////////
Arena::Arena(int nRows, int nCols)
{
    if (nRows <= 0 || nCols <= 0 || nRows > MAXROWS || nCols > MAXCOLS)
    {
        cout << "***** Arena created with invalid size " << nRows << " by "
        << nCols << "!" << endl;
        exit(1);
    }
    m_rows = nRows;
    m_cols = nCols;
    m_player = nullptr;
    m_nRobots = 0;
}
Arena::~Arena()
{
    for (int i = 0; i < m_nRobots; i++) {
        delete m_robots[i]; /* deletes all remaining dynamically allocated
                        robots */
        m_nRobots--;
    }
    delete m_player; // deletes the player
}
int Arena::rows() const
{
    // TODO:  TRIVIAL:  Return the number of rows in the arena.
    // Delete the following line and replace it with the correct code.
    return m_rows;  // This implementation compiles, but is incorrect.
}
int Arena::cols() const
{
    // TODO:  TRIVIAL:  Return the number of columns in the arena.
    // Delete the following line and replace it with the correct code.
    return m_cols;  // This implementation compiles, but is incorrect.
}
Player* Arena::player() const
{
    return m_player;
}
int Arena::robotCount() const
{
    return m_nRobots;
}
int Arena::nRobotsAt(int r, int c) const
{
    // returns the number of robots at row r, column c.
    int tally = 0;
    for (int j = 0; j < m_nRobots; j++)
        if (m_robots[j]->row() == r && m_robots[j]->col() == c)
            tally++; /* adds a robot to the tally if it is positioned at
                 (r, c) */
    return tally;
}
void Arena::display(string msg) const
{
    // Position (row,col) in the arena coordinate system is represented in
    // the array element grid[row-1][col-1]
    char grid[MAXROWS][MAXCOLS];
    int r, c;
    // Fill the grid with dots
    for (r = 0; r < rows(); r++)
        for (c = 0; c < cols(); c++)
            grid[r][c] = '.';
    // Indicate each robot's position
    /*for (r = 1; r <= rows(); r++) {
        for (c = 1; c <= cols(); c++) {
            if (nRobotsAt(r, c) == 1)
                grid[r][c] = 'R'; /* If one robot is at some grid point,
                              char is set to 'R'. */
            /*else if (nRobotsAt(r, c) > 1 && nRobotsAt(r, c) < 9)
                grid[r][c] = nRobotsAt(r, c); /* If it's 2 though 8, char
                                          is set to '2' through '8'.
            else if (nRobotsAt(r, c) >= 9)
                grid[r][c] = '9'; // For 9 or more, char is set to '9'.
            else
                grid[r][c] = '.';
        }
    }*/
    // Indicate player's position
    if (m_player != nullptr)
    {
        // Set the char to '@', unless there's also a robot there,
        // in which case set it to '*'.
        char& gridChar = grid[m_player->row() - 1][m_player->col() - 1];
        if (gridChar == '.')
            gridChar = '@';
        else
            gridChar = '*';
    }
    // Draw the grid
    clearScreen();
    for (r = 0; r < rows(); r++)
    {
        for (c = 0; c < cols(); c++)
            cout << grid[r][c];
        cout << endl;
    }
    cout << endl;
    // Write message, robot, and player info
    cout << endl;
    if (msg != "")
        cout << msg << endl;
    cout << "There are " << robotCount() << " robots remaining." << endl;
    if (m_player == nullptr)
        cout << "There is no player." << endl;
    else
    {
        if (m_player->age() > 0)
            cout << "The player has lasted " << m_player->age() << " steps." << endl;
        if (m_player->isDead())
            cout << "The player is dead." << endl;
    }
}
bool Arena::addRobot(int r, int c)
{
    // If the maximum amount of robots exists, none shall be added.
    if (m_nRobots = MAXROBOTS)
        return false;
    // Dynamically allocates another robot and add it to arena
    m_robots[m_nRobots] = new Robot(this, r, c);
    m_nRobots++;
    return true;
}
bool Arena::addPlayer(int r, int c)
{
    // Don't add a player if one already exists
    if (m_player != nullptr)
        return false;
    // Dynamically allocate a new Player and add it to the arena
    m_player = new Player(this, r, c);
    return true;
}
void Arena::damageRobotAt(int r, int c)
{
    // TODO:  Damage one robot at row r, column c if at least one is there.
    // If the robot does not survive the damage, destroy it.
    if (nRobotsAt(r, c) > 0) {
        for (int l = 0; l < m_nRobots; l++) {
            /* the following statement looks through the robot array to
        find an element that has coordinates matching the robot taking
        damage */
            if (m_robots[l]->row() == r && m_robots[l]->col() == c) {
                // TODO: robot takes damage
                delete m_robots[l]; // removes this element
                while (l < m_nRobots) {
                    m_robots[l] = m_robots[l + 1]; /* copies all elements
                                               over one element */
                    l++;
                }
                m_nRobots--; // decrements the number of all robots
            }
        }
    }
}
bool Arena::moveRobots()
{
    for (int k = 0; k < m_nRobots; k++)
    {
        m_robots[k]->move(); // robot makes a move
                             /* If that move results in that robot being in the same
                         position as the player, the player dies. */
        if (m_robots[k]->row() == m_player->row() && m_robots[k]->col() == m_player->col())
            m_player->setDead();
    }
    // return true if the player is still alive, false otherwise
    return !m_player->isDead();
}
///////////////////////////////////////////////////////////////////////////
//  Game implementations
///////////////////////////////////////////////////////////////////////////
Game::Game(int rows, int cols, int nRobots)
{
    if (nRobots > MAXROBOTS)
    {
        cout << "***** Trying to create Game with " << nRobots
            << " robots; only " << MAXROBOTS << " are allowed!" << endl;
        exit(1);
    }
    // Create arena
    m_arena = new Arena(rows, cols);
    // Add player
    int rPlayer = 1 + rand() % rows;
    int cPlayer = 1 + rand() % cols;
    m_arena->addPlayer(rPlayer, cPlayer);
    // Populate with robots
    while (nRobots > 0)
    {
        int r = 1 + rand() % rows;
        int c = 1 + rand() % cols;
        // Don't put a robot where the player is
        if (r == rPlayer  &&  c == cPlayer)
            continue;
        m_arena->addRobot(r, c);
        nRobots--;
    }
}
Game::~Game()
{
    delete m_arena;
}
void Game::play()
{
    Player* p = m_arena->player();
    if (p == nullptr)
    {
        m_arena->display("");
        return;
    }
    string msg = "";
    do
    {
        m_arena->display(msg);
        msg = "";
        cout << endl;
        cout << "Move (u/d/l/r/su/sd/sl/sr/c//q): ";
        string action;
        getline(cin, action);
        if (action.size() == 0)
            p->stand();
        else
        {
            switch (action[0])
            {
            default:   // if bad move, nobody moves
                cout << 'a' << endl;  // beep
                continue;
            case 'q':
                return;
            case 'c':  // computer moves player
                msg = p->takeComputerChosenTurn();
                break;
            case 'u':
            case 'd':
            case 'l':
            case 'r':
                p->move(decodeDirection(action[0]));
                break;
            case 's':
                if (action.size() < 2)  // if no direction, nobody moves
                {
                    cout << 'a' << endl;  // beep
                    continue;
                }
                switch (action[1])
                {
                default:   // if bad direction, nobody moves
                    cout << 'a' << endl;  // beep
                    continue;
                case 'u':
                case 'd':
                case 'l':
                case 'r':
                    if (p->shoot(decodeDirection(action[1])))
                        msg = "Hit!";
                    else
                        msg = "Missed!";
                    break;
                }
                break;
            }
        }
        m_arena->moveRobots();
    } while (!m_arena->player()->isDead() && m_arena->robotCount() > 0);
    m_arena->display(msg);
}
///////////////////////////////////////////////////////////////////////////
//  Auxiliary function implementations
///////////////////////////////////////////////////////////////////////////
int decodeDirection(char dir)
{
    switch (dir)
    {
    case 'u':  return UP;
    case 'd':  return DOWN;
    case 'l':  return LEFT;
    case 'r':  return RIGHT;
    }
    return -1;  // bad argument passed in!
}
///////////////////////////////////////////////////////////////////////////
//  main()
///////////////////////////////////////////////////////////////////////////
int main()
{
    // Initialize the random number generator.  (You don't need to
    // understand how this works.)
    srand(static_cast<unsigned int>(time(0)));
    // Create a game
    // Use this instead to create a mini-game:   Game g(3, 3, 2);
    Game g(15, 18, 80);
    // Play the game
    g.play();
}
///////////////////////////////////////////////////////////////////////////
//  clearScreen implementations
///////////////////////////////////////////////////////////////////////////
// DO NOT MODIFY OR REMOVE ANY CODE BETWEEN HERE AND THE END OF THE FILE!!!
// THE CODE IS SUITABLE FOR VISUAL C++, XCODE, AND g++ UNDER LINUX.
// Note to Xcode users:  clearScreen() will just write a newline instead
// of clearing the window if you launch your program from within Xcode.
// That's acceptable.
#ifdef _MSC_VER  //  Microsoft Visual C++
#include <windows.h>
void clearScreen()
{
    HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
    CONSOLE_SCREEN_BUFFER_INFO csbi;
    GetConsoleScreenBufferInfo(hConsole, &csbi);
    DWORD dwConSize = csbi.dwSize.X * csbi.dwSize.Y;
    COORD upperLeft = { 0, 0 };
    DWORD dwCharsWritten;
    FillConsoleOutputCharacter(hConsole, TCHAR(' '), dwConSize, upperLeft,
        &dwCharsWritten);
    SetConsoleCursorPosition(hConsole, upperLeft);
}
#else  // not Microsoft Visual C++, so assume UNIX interface
#include <cstring>
void clearScreen()  // will just write a newline in an Xcode output window
{
    static const char* term = getenv("TERM");
    if (term == nullptr || strcmp(term, "dumb") == 0)
        cout << endl;
    else
    {
        static const char* ESC_SEQ = "x1B[";  // ANSI Terminal esc seq:  ESC [
        cout << ESC_SEQ << "2J" << ESC_SEQ << "H" << flush;
    }
}
#endif

/*main.cpp
Open with*/