今天写程序的时候要用到二维数组作参数传给一个函数，我发现将二维数组作参数进行传递还不是想象得那么简单，但是最后我也解决了遇到的问题，所以这篇文章主要介绍如何处理二维数组当作参数传递的情况，希望大家不至于再在这上面浪费时间。

      下文是我从互联网上download的一篇文章，讲的很好，但是我后面将指出问题所在，并加以改进，希望对你有所帮助：

  首先，我引用了谭浩强先生编著的《C程序设计》上面的一节原文，它简要介绍了如何将二维数组作为参数传递，原文如下(略有改变，请原谅)：

  [原文开始]

    可以用二维数组名作为实参或者形参，在被调用函数中对形参数组定义时可以指定所有维数的大小，也可以省略第一维的大小说明，如：

    void Func(int array[3][10]);

    void Func(int array[][10]);

    二者都是合法而且等价，但是不能把第二维或者更高维的大小省略，如下面的定义是不合法的：

    void Func(int array[][]);

    因为从实参传递来的是数组的起始地址，在内存中按数组排列规则存放(按行存放)，而并不区分行和列，如果在形参中不说明列数，则系统无法决定应为多少行多少列，不能只指定一维而不指定第二维，下面写法是错误的：

    void Func(int array[3][]);实参数组维数可以大于形参数组，例如实参数组定义为：

    void Func(int array[3][10]);

    而形参数组定义为：

    int array[5][10];

    这时形参数组只取实参数组的一部分，其余部分不起作用。

  [原文结束]

  大家可以看到，将二维数组当作参数的时候，必须指明所有维数大小或者省略第一维的，但是不能省略第二维或者更高维的大小，这是由编译器原理限制的。大家在学编译原理这么课程的时候知道编译器是这样处理数组的：

  对于数组 int p[m][n];

  如果要取p[i][j]的值(i>=0 && i<m && 0<=j && j < n)，编译器是这样寻址的，它的地址为：

  p + i*n + j;

  从以上可以看出，如果我们省略了第二维或者更高维的大小，编译器将不知道如何正确的寻址。但是我们在编写程序的时候却需要用到各个维数都不固定的二维数组作为参数，这就难办了，编译器不能识别阿，怎么办呢？不要着急，编译器虽然不能识别，但是我们完全可以不把它当作一个二维数组，而是把它当作一个普通的指针，再另外加上两个参数指明各个维数，然后我们为二维数组手工寻址，这样就达到了将二维数组作为函数的参数传递的目的，根据这个思想，我们可以把维数固定的参数变为维数随即的参数，例如：

    void Func(int array[3][10]);

    void Func(int array[][10]);

  变为：

    void Func(int **array, int m, int n);

  在转变后的函数中，array[i][j]这样的式子是不对的(不信，大家可以试一下)，因为编译器不能正确的为它寻址，所以我们需要模仿编译器的行为把array[i][j]这样的式子手工转变为：

    *((int*)array + n*i + j);

    在调用这样的函数的时候，需要注意一下，如下面的例子：

    int a[3][3] =

    {

      {1, 1, 1},

      {2, 2, 2},

      {3, 3, 3}

    };

    Func(a, 3, 3);

  根据不同编译器不同的设置，可能出现warning 或者error,可以进行强制转换如下调用： 

    Func((int**)a, 3, 3);

  其实多维数组和二维数组原理是一样的，大家可以自己扩充的多维数组，这里不再赘述。写到这里，我先向看了这篇文章后悔的人道歉，浪费你的时间了。下面是一个完整的例子程序，这个例子程序的主要功能是求一个图中某个顶点到其他顶点的最短路经，图是以邻接矩阵的形式存放的(也就是一个二维数组)，其实这个函数也是挺有用的，但是我们这篇文章的重点在于将二维数组作为函数的参数传递。

    上文结束，上文最后指出了实现二位数组作为函数参数的方法，但是它实现的是将静态的二位数组作为参数，但是如何将动态而为数组作为参数呢？上面的方法显然是不合适的，下面是我琢磨出来的方法。

    先将静态数组作为参数的代码贴出来:

#include <iostream>
using namespace std;

void Calc(int **A, int m, int n);

int _tmain(int argc, _TCHAR* argv[])
{
    int row = 0;
    int col = 0;
    int i = 0;
    int A[3][3];
    
    for (row = 0; row < 3; row++)
    {
        for (col = 0; col < 3; col++)
        {
            A[row][col] = row + col;
        }
    }
    Calc((int **)A, 3, 3);
    return 0;
}

void Calc(int **A, int m, int n)
{
    if (NULL == A || m <1 || n < 1)
    {
        return;
    }

    int row = 0;
    int col = 0;
    int i = 0;
    int j = 0;
    int **matrix = NULL;
    matrix = new int*[m];
    if (NULL == matrix)
    {
        return;
    }
    for (row = 0; row < m; row++)
    {
        matrix[row] = new int[n];
        if (NULL == matrix[row])
        {
            for (i = 0; i < row; i++)
            {
                delete []matrix[i];
                matrix[i] = NULL;
            }
            delete []matrix;
            matrix = NULL;
            return;
        }
    }
    for (row = 0; row < m; row++)
    {
        for (col = 0; col < n; col++)
        {
            matrix[row][col] = *((int *)A + row * n + col);
            //matrix[row][col] = A[row][col];
        }
    }
    
    
    for (row = 0; row < m; row++)
    {
        for (col = 0; col < n; col++)
        {
            cout<<matrix[row][col]<<"  ";
        }
        cout<<"\n";
    }
}

下面是动态二位数组作为函数参数时的代码：

#include <iostream>
using namespace std;

void Calc(int **A, int m, int n);

int main(int argc, char* argv[])
{
    int row = 0;
    int col = 0;
    int i = 0;
    int **A = NULL;
    A = new int*[3];
    if (NULL == A)
    {
        return 0;
    }
    for (row = 0; row < 3; row++)
    {
        A[row] = new int[3];
        if (NULL == A[row])
        {
            for (i = 0; i < row; i++)
            {
                delete []A[i];
                A[i] = NULL;
            }
            delete []A;
            A = NULL;
            return 0;
        }
    }
    
    for (row = 0; row < 3; row++)
    {
        for (col = 0; col < 3; col++)
        {
            A[row][col] = row + col;
        }
    }
    Calc((int **)A, 3, 3);
    return 0;
}

void Calc(int **A, int m, int n)
{
    if (NULL == A || m <1 || n < 1)
    {
        return;
    }

    int row = 0;
    int col = 0;
    int i = 0;
    int j = 0;
    int **matrix = NULL;
    matrix = new int*[m];
    if (NULL == matrix)
    {
        return;
    }
    for (row = 0; row < m; row++)
    {
        matrix[row] = new int[n];
        if (NULL == matrix[row])
        {
            for (i = 0; i < row; i++)
            {
                delete []matrix[i];
                matrix[i] = NULL;
            }
            delete []matrix;
            matrix = NULL;
            return;
        }
    }
    for (row = 0; row < m; row++)
    {
        for (col = 0; col < n; col++)
        {
            //matrix[row][col] = *((int *)A + row * n + col);
            matrix[row][col] = A[row][col];
        }
    }
    
    
    for (row = 0; row < m; row++)
    {
        for (col = 0; col < n; col++)
        {
            cout<<matrix[row][col]<<"  ";
        }
        cout<<"\n";
    }
}
    注意上面的代码的不同之处，即将动态二维数组作为函数参数时，在函数里面应用时候要将其伪装成静态二维数组！

    这样，以上的两段代码不仅实现了堆和栈之间数据的传递，而且实现了堆和堆之间数据的传递！