C++ 通过一个函数传递一个2D数组，我得到一个错误

我正在做一个递归算法，作为课程额外学分项目的一部分，以通过0和1的2D int数组迷宫找到最短路径。0表示墙，1表示可以穿过的走廊。我想我的一切都很完美，但它就是无法编译。它说我正在尝试将一些东西从int转换为array或其他什么。这是我的密码，请帮忙

#include <iostream> 
using namespace std;    

#define 20 SIZEX;   
#define 5 SIZEY;
int value; //to compare paths to take
int starti = 1;
int startj = 0;
int newi;
int newj;
int counter = 0; //keeps track of how many steps taken

void pathfinder(int a[][SIZEX], int currenti, int currentj);

    int arr[SIZEY][SIZEX] =         {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,       
                                     1,1,1,1,1,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,   
                                     0,0,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,   
                                     0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,
                                     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};  
int main()
{    
    pathfinder(arr, starti, startj);
    system("PAUSE");
    return 0;
}

void pathfinder(int a[][SIZEX], int currenti, int currentj)
{
    //as soon as it walks somewhere, the value of that spot increments
    int temp;
    temp = a[currenti][currentj];
    temp++;
    a[currenti][currentj] = temp;
    if (counter == 0) //keeps track of starting point
    {
            starti = currenti;
        startj = currentj;
    }

    if (currenti-1 >= 0 && a[currenti-1][currentj] != 0) //checks up
     {
        value = a[currenti-1][currentj];
     }
    else if (currenti+1 < 5 && a[currenti+1][currentj] != 0) //checks down
    {
        value = a[currenti+1][currentj];
    }
    else if (currentj-1 >= 0 && a[currenti][currentj-1] != 0) //checks left
    {
        value = a[currenti][currentj-1];
    }
    else if (currentj+1 < 20 && a[currenti][currentj+1] != 0) //checks right
    {
        value = a[currenti][currentj+1];
    }

    //value has a value, now check it against all possible values for the least travelled path
    if ((currenti-1 >= 0 && a[currenti-1][currentj] !=0) && value > a[currenti-1][currentj])
    {
        value = a[currenti-1][currentj];
    }

     if ((currenti+1 < 5 && a[currenti+1][currentj] !=0) && value > a[currenti+1][currentj])
    {
        value = a[currenti+1][currentj];
    }

    if ((currentj-1 >= 0 && a[currenti][currentj-1] != 0) && value > a[currenti][currentj-1]) 
     {
         value = a[currenti][currentj-1];
     }

    if ((currentj+1 < 20 && a[currenti][currentj+1] != 0) && value > a[currenti][currentj+1])
    {
        value = a[currenti][currentj+1];
    }

//value now holds the smallest possible value among the four possible paths
if ((currenti-1 >= 0 && a[currenti-1][currentj] !=0) && value == a[currenti-1][currentj]) //move up
{
    newi = currenti-1;
    newj = currentj;
    counter++;
}
else if ((currenti+1 < 5 && a[currenti+1][currentj] !=0) && value == a[currenti+1][currentj]) //move down
{
    newi = currenti+1;
    newj = currentj;
    counter++;
}
else if ((currentj-1 >= 0 && a[currenti][currentj-1] != 0) && value == a[currenti][currentj-1]) //move left
{
    newi = currenti;
    newj = currentj-1;
    counter++;
}
else if ((currentj+1 < 20 && a[currenti][currentj+1] != 0) && value == a[currenti][currentj+1]) //move right
{
    newi = currenti;
    newj = currentj+1;
    counter++;
}

//upon reaching the exit, it will print out a new 2d maze, and the path with the smallest value of non-zero integers is the shortest path
if ((currenti == 0 || currentj == 0 || currenti == 4 || currentj == 19) && (currenti != starti || currentj !=startj))
{
    for (int i = 0; i < 5; i++)
    {
        for (int j = 0;j < 20;j++)
        {
            cout << a[i][j] << " ";
        }
        cout << endl;
    }
    return;
}

pathfinder(arr, newi, newj);
}

#包括
使用名称空间std；
#定义20个SIZEX；
#定义5个大小；
int值//比较要采取的路径
int-starti=1；
int startj=0；
int newi；
int newj；
int计数器=0//跟踪采取了多少步骤
无效路径查找器（int a[][SIZEX]，int currenti，int currentj）；
int arr[SIZEY][SIZEX]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0，
1,1,1,1,1,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,   
0,0,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,   
0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};  
int main（）
{    
探路者（arr、starti、startj）；
系统（“暂停”）；
返回0；
}
无效路径查找器（int a[][SIZEX]，int currenti，int currentj）
{
//一旦它移动到某个地方，该点的值就会增加
内部温度；
温度=a[currenti][currentj]；
temp++；
a[currenti][currentj]=温度；
if（counter==0）//跟踪起点
{
starti=电流i；
startj=currentj；
}
如果（currenti-1>=0&&a[currenti-1][currentj]！=0）//检查
{
值=a[currenti-1][currentj]；
}
如果（currenti+1<5&&a[currenti+1][currentj]！=0）//检查
{
值=a[currenti+1][currentj]；
}
如果（currentj-1>=0&&a[currenti][currentj-1]！=0）//则向左检查
{
值=a[currenti][currentj-1]；
}
如果（currentj+1<20&&a[currenti][currentj+1]！=0）//检查是否正确
{
值=a[currenti][currentj+1]；
}
//值有一个值，现在对照最小行程路径的所有可能值进行检查
如果（（currenti-1>=0&&a[currenti-1][currentj]！=0）&&value>a[currenti-1][currentj]）
{
值=a[currenti-1][currentj]；
}
如果（（currenti+1<5&&a[currenti+1][currentj]！=0）&&value>a[currenti+1][currentj]）
{
值=a[currenti+1][currentj]；
}
如果（（当前j-1>=0&&a[currenti][currentj-1]！=0）&&value>a[currenti][currentj-1]）
{
值=a[currenti][currentj-1]；
}
如果（（当前j+1<20&&a[currenti][currentj+1]！=0）&&value>a[currenti][currentj+1]）
{
值=a[currenti][currentj+1]；
}
//值现在保存四条可能路径中的最小可能值
如果（（currenti-1>=0&&a[currenti-1][currentj]！=0）和&value==a[currenti-1][currentj]）//向上移动
{
newi=当前i-1；
newj=currentj；
计数器++；
}
如果（（currenti+1<5&&a[currenti+1][currentj]！=0）和&value==a[currenti+1][currentj]）/向下移动
{
newi=当前i+1；
newj=currentj；
计数器++；
}
如果（（currentj-1>=0&&a[currenti][currentj-1]！=0）和&value==a[currenti][currentj-1]）//向左移动
{
newi=当前i；
newj=当前j-1；
计数器++；
}
如果（（currentj+1<20&&a[currenti][currentj+1]！=0）和&value==a[currenti][currentj+1]）/向右移动
{
newi=当前i；
newj=currentj+1；
计数器++；
}
//到达出口后，将打印出一个新的2d迷宫，非零整数值最小的路径为最短路径
如果（（currenti==0 | | currentj==0 | | currenti==4 | | currentj==19）和&（currenti！=starti | | currentj！=startj））
{
对于（int i=0；i<5；i++）
{
对于（int j=0；j<20；j++）
{
cout c:\users\justin\documents\visualstudio 2012\projects\project5\project5\source.cpp（22）：错误C2664：
“pathfinder”：无法将参数1从“int”转换为“int[][20]”
1> 从整数类型转换为指针类型需要
重新解释_类型转换、C类型转换或功能类型转换
1> c:\users\justin\documents\visual studio
2012\projects\project5\project5\source.cpp（114）：错误C2664：
“pathfinder”：无法将参数1从“int”转换为“int[][20]”
1> 从整数类型转换为指针类型需要
重新解释_类型转换、C类型转换或功能类型转换
======生成：0成功，1失败，0最新，0跳过==========

这些是不正确的：

#define 20 SIZEX;   
#define 5 SIZEY;

如果确实需要宏，定义宏的正确方法是：

#define SIZEX 20
#define SIZEY 5

但是，这是C++，你应该使用<代码> const int <代码>：
const int SIZEX = 20;
const int SIZEY = 5;

这将解决编译问题

另请注意：如果要将
arr
作为初始参数传递给
pathfinder（）
以启动
main
中的递归，则可以更改递归调用以传递传递传递的参数
pathfinder（）
。即：

pathfinder(a, newi, newj);

否则，即使
main
将一个不同的数组传递给
pathfinder
，它仍然会在
arr
上完成大部分工作，使参数变得无用。
感谢您的回答：-）嗯，我不太理解您的第二部分，但我的编译问题没有消失……可能是visual studio？您确定吗上面问题中的e代码是您试图编译的代码吗？当我修复了我在本地推荐的SIZEX/SIZEY时，它修复了编译器错误。第二部分：我是说当您递归时，您应该将
a
，而不是
arr
传递给
pathfinder
中的递归调用。仔细想想会发生什么如果您有两个不同的数组，
arr1
和
arr2
，并且您希望
main
在这两个数组上调用
pathfinder
，以解决这两个问题。当您运行I