C++ Battle4Zion 项目抛出未处理的异常:读取访问冲突。 **this** 是 nullptr。发生了

Posted

技术标签:

【中文标题】C++ Battle4Zion 项目抛出未处理的异常:读取访问冲突。 **this** 是 nullptr。发生了【英文标题】:C++ Battle4Zion project Unhandled exception thrown: read access violation. **this** was nullptr. occurred 【发布时间】:2017-11-08 03:54:37 【问题描述】:

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

抛出未处理的异常:读取访问冲突。 this 为 nullptr。发生了

我复制了以下代码,希望你们能解释我必须做什么:

// 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*/

【问题讨论】:

请提供Minimal, Complete, and Verifiable example 请edit您的代码将其减少为您的问题的minimal reproducible example。您当前的代码包含许多与您的问题无关的内容 - 一个最小样本通常看起来类似于一个好的单元测试:只执行一项任务,并为可重复性指定输入值。 请edit你的问题告诉我们你做了什么样的调试。我希望您已经在 Valgrind 或类似的检查器中运行了您的minimal reproducible example,并使用诸如 GDB 之类的调试器进行了调查。确保您也启用了全套编译器警告。这些工具告诉了你什么,它们缺少什么信息?并阅读 Eric Lippert 的 How to debug small programs。 【参考方案1】:

您的代码假定数组的索引从 1 到 N(例如,r &lt; 1 || r &gt; ap-&gt;rows()),但在 C 和 C++ 中,数组从 0 到 N-1。访问位置 N 的数组是访问冲突。

【讨论】:

【参考方案2】:

addRobot 中,您的if 语句中有一个赋值,而不是比较。这导致不添加任何机器人,并最终取消引用 NULL 指针。

此外,您在Arena::~Arena 中泄漏了内存,因为您在循环中更改了m_nRobots 的值,导致一些机器人未被删除。

【讨论】:

以上是关于C++ Battle4Zion 项目抛出未处理的异常:读取访问冲突。 **this** 是 nullptr。发生了的主要内容,如果未能解决你的问题,请参考以下文章

ExpressJS - 抛出未处理的错误事件

PeekMessage() 抛出未处理的异常(访问冲突)

从 Parallel.ForEach 抛出未处理的 OperationCanceledException

在 TPL 中快速抛出未处理的异常

Visual C ++ - 从设置表单图标中抛出未处理的异常?

NestJS + Angular 项目抛出未找到模块:错误:无法解析“缓存管理器”