如何在C++中通过网格来操作/移动对象

Question

我在尝试将障碍物移向2x2阵列上的目标时遇到了一些问题。我有一个函数，它将两个整数作为参数。该函数然后创建一个大小为10的2x2数组，填充空闲空间，创建一个障碍物（障碍物每次保持不变）。然后它创建目标点（每次将它分配到同一个点）和球点（它位于数组位置[x] [y]中）。

目标是让球向目标移动，直到撞到障碍物，然后绕过障碍物，同时跟踪障碍物周围每个空间离目标多远，然后返回到最近点并继续朝着目标前进。

我试图开发一个moveToGoal函数，该方法将球移向目标，因为没有障碍，但我在访问printGrid函数之外的网格时遇到了很多麻烦。如果我在打印网格功能之外创建网格，我无法访问它，因为它超出了范围。我知道这可能看起来很混乱，但我会尽力回答任何有关它的问题。这是我到目前为止：

#include <stdio.h> 
#include <vector> 
#include <cstdlib> 
#include <ctime> 
#include <iostream> 
#include <fstream> 
#include <string> 
#include <unistd.h> 

using namespace std; 

void printGrid(int x, int y)  //Used to clear old grids, and print a 
{         //new grid with input location for ball 
    system("CLS"); 
    string grid [10][10];   //Initialize grid array 
    for (int i=0; i<10; i++) 
    { 
     for (int j=0; j<10; j++) 
     { 
      grid[i][j] = ' ';  //Constructs grid with freespace 
     } 
    } 
    for (int i=2; i<8; i++)   //Constructs obstacle(s) 
    { 
     grid[5][i]='O'; 
    } 
    grid[2][5] = 'G';    //Sets Goal location 
    grid[x][y] = 'B';    //Sets current ball location(starts 8,5) 
    for (int i=0; i<10; i++)  //Prints finished grid 
    { 
     for (int j=0; j<10; j++) 
     { 
      cout<<grid[i][j]; 
     } 
     cout<<endl; 
    } 
} 

void moveToGoal(int x, int y) 
{ 
    printGrid(x-1, y); 
} 

int main() 
{ 
    moveToGoal(8,5); 
    sleep(1); 
    moveToGoal(7,5); 
    sleep(1); 
    moveToGoal(6,5); 
    sleep(1); 
    moveToGoal(5,5); 
    sleep(1); 
    moveToGoal(4,5); 
    sleep(1); 
    moveToGoal(3,5); 
} 

任何帮助，将不胜感激！

Answer 1

尝试这种情况：

string grid [10][10];   // the grid array is now global 

void printGrid(int x, int y)  //Used to clear old grids, and print a 
{         //new grid with input location for ball 
    system("CLS"); 
    for (int i=0; i<10; i++) // clean the old grid 
    { 
     for (int j=0; j<10; j++) 
     { 
      grid[i][j] = ' ';  //Constructs grid with freespace 
     } 
    } 
    for (int i=2; i<8; i++)   //Constructs obstacle(s) 
    { 
     grid[5][i]='O'; 
    } 
    grid[2][5] = 'G';    //Sets Goal location 
    grid[x][y] = 'B';    //Sets current ball location(starts 8,5) 
    for (int i=0; i<10; i++)  //Prints finished grid 
    { 
     for (int j=0; j<10; j++) 
     { 
      cout<<grid[i][j]; 
     } 
     cout<<endl; 
    } 
} 

Answer 2

在下面的代码

int f() { 
    int i = 1; 
    i++; 
    std::cout << i << "\n"; 
} 

int main() { 
    f(); 
    f(); 
} 

在功能f可变i是一个局部变量。这意味着每次调用f()时都会创建一个新实例。所以上面代码的输出是2，两次，不是2，然后是3。

在您的代码中，网格位于printGrid的本地，因此每次调用printGrid时都会创建网格。

解决方案是使网格成为传递给它的参数或全局变量。将网格作为参数传递是首选，您可能会考虑将其放置在结构或类中，以使其更易于执行。

#include <array> 
#include <utility> 
#include <iostream> 

class Grid 
{ 
    // type alias for a grid of 10x10 chars 
    using grid_t = std::array<std::array<char, 10>, 10>; 

    grid_t grid_; // our actual grid data: note grid_[y][x]. 
    int ballX_ = -1, ballY_ = -1; 

public: 
    // Constructor 
    Grid(int goalX, int goalY) 
    { 
     // populate the grid with free space 
     for (auto&& row: grid_) { 
      std::fill(row.begin(), row.end(), ' '); 
     } 
     // add obstacles 
     for (size_t i = 2; i < 8; ++i) 
      grid_[i][5] = 'O'; 
     // place the goal 
     grid_[goalY][goalX] = 'G'; 
    } 

    // place, move or remove the ball on the grid 
    void placeBall(int x, int y) 
    { 
     // Remove the ball from any previous location 
     if (ballX_ != -1 && ballY != -1) 
      grid_[ballY_][ballX_] = ' '; 

     // update location 
     ballX_ = x, ballY = y; 

     // Place ball on board if location is not -1,-1 
     if (ballX_ != -1 && ballY != -1) 
      grid_[ballY_][ballX_] = 'B'; 
    } 

    // Return the character at a given location 
    char at(int x, int y) const 
    { 
     return grid_[y][x]; 
    } 

    // Query ball position 
    int ballX() const { return ballX_; } 
    int ballY() const { return ballY_; } 

    // print the grid 
    friend ostream& operator << (ostream&, const Grid&); 
}; 

ostream& operator<<(ostream& stream, const Grid& grid) 
{ 
    for (auto&& row: grid.grid_) { 
     for (auto&& col: row) { 
      stream << col << ' '; 
     } 
     stream << '\n'; 
    } 
    return stream; 
} 

// helper for your cls/sleep thing around printing the grid. 
void printGrid(const Grid& grid) 
{ 
    system("CLS"); 
    std::cout << grid; 
    sleep(1); 
} 

void manipulateGrid(Grid& grid) // reference to the caller's grid 
{ 
    printGrid(grid); 
    grid.placeBall(8, 5); 
    printGrid(grid); 
    grid.placeBall(7, 5); 
    // ... 
} 

int main() 
{ 
    Grid g(2, 5); // create grid with [2,5] as the goal 
    manipulateGrid(g); // to demonstrate passing as parameter 
}