C++中将一维数组和二维数组（动态的和静态的）作为函数的参数进行传递

在C++编程中，我们经常要将数组作为一个参数传递给另一个函数，数组的维数不同，传递的方式也不同。此处做一个总结，介绍一维静态，一维动态，二维静态，二维动态数组的传递方式。

一、一维数组（静态、动态一维数组）

1. 一位数组寻址形式：num[i]的地址：num+i，因此一维数组作为参数传递时候，只需要用数组名作为参数即可。

output(num)
void output(int num[])

2. 一维数组实例

#include <iostream>
using namespace std;

void ces1(int *num)
{
    for (int i = 0; i < 5; i++){
        cout << num[i] << endl;
    }
}


void ces2(int *num, int m)
{
    for (int i = 0; i < m; i++){
        cout << num[i] << endl;
    }
}


int main()
{
    int num1[5];
    for (int i = 0; i < 5; i++){
        num1[i] = i;
    }
    ces1(num1);


    int k = 5;
    int *num2 = new int[k];
    for (int i = 0; i < k; i++){
        num2[i] = i + 1;
    }
    ces2(num2, k);
    delete[] num2;


    return 0;
}

二、二维数组

1. 静态二维数组利用数组名和第二维大小作为参数

（1）二维数组如下 int num[rows][cols]，二维数组寻址形式：num[i][j]的地址：num + i*cols + j。由此可知二维数组作为参数传递的时候，除了需要数组名作为参数，还需要数组第二维度的大小，第一维随意。

二维数组实参：

output(num);

二维数组形参三种形式均可：

void output(int num[3][4]);
void output(int num[][4]);
void output(int (*num)[4]);

这里都不能忽略第二维的大小。主要原因是二维数组在栈内分配的内存是连续的。从实参传递来的是数组的起始地址，在内存中按数组排列规则存放（按行存放），而并不区分行和列，如果在形参中不说明列数，则系统无法决定应为多少行，多少列，因此必须指定第二维大小（即有多少列）。

（2）二维数组实例

#include <iostream>
using namespace std;

void ces(int num[5][5])      //这样可以
//void ces(int num[][5])     //这样可以
//void ces(int num[5][])     //这样不可以
{
    for (int i = 0; i < 5; i++){
        for (int j = 0; j < 5; j++){
            cout<<num[i][j]<<" ";
        }
        cout<<endl;
    }
}

int main()
{
    int num[5][5];
    for (int i = 0; i < 5; i++){
        for (int j = 0; j < 5; j++){
            num[i][j] = i * j;
        }
    }
    ces(num);
    return 0;
}

2. 动态二维数组利用二维指针传递数组参数

（1）我们知道动态二维数组的第一维和第二维都是变量，因此我们利用“数组名和二维大小作为形参”这种方式失效，此处必须利用二维指针。

二维数组实参：

output(num);

二维指针作为形参：

void output(int **num)

二维数组在子函数中的使用方式：

num[i][j]即可

3. 静态二维数组也可用二维指针

二维数组实参：

output((int **)num);    //此处需要强制转化

二维指针作为形参：

void output(int **num)

二维数组在子函数中使用方式：

这样是不对的：     num[i][j]
必须这样：        *((int *)num + cols*i + j) 或
                 ((int *)num + cols*i)[j]

4. 下面给出了二维静态数组和二维动态数组的两个实例，有两处不同，在程序中用红色标识了

//二维静态数组
#include <iostream>
using namespace std;

void ces(int **num)
{
    for (int i = 0; i < 5; i++){
        for (int j = 0; j < 5; j++){
            cout<<*((int *)num+5*i+j)<<" ";           //这样可以
//            cout<<((int *)num+5*i)[j]<<" ";         //这样可以
//            cout<<num[i][j]<<" ";                   //这样不可以
        }
        cout<<endl;
    }
}

int main()
{
    int num[5][5];
    for (int i = 0; i < 5; i++){
        for (int j = 0; j < 5; j++){
            num[i][j] = i * j;
        }
    }
    ces((int **)num);                 //这样可以
//    ces(num);                       //这样不可以
    return 0;
}

//二维动态数组
#include <iostream>
using namespace std;

void ces(int **num, int m, int n)
{
    for (int i = 0; i < m; i++){
        for (int j = 0; j < n; j++){
//            cout<<*((int *)num+5*i+j)<<" ";              //这样不行
//            cout<<((int *)num+5*i)[j]<<" ";              //这样不行 
            cout<<num[i][j]<<" ";                          //这样可以
        }
        cout<<endl;
    }
}

int main()
{
    int m = 5, n = 5, i, j;
    int **num = new int*[m];
    for (i = 0; i < m; i++)
    {
        num[i] = new int[n];
    }
    for (i = 0; i < m; i++){
        for (j = 0; j < n; j++){
            num[i][j] = i * j;
        }
    }
    ces(num, m, n);                            //这样可以

//    ces((int **)num, m, n);                  //这样可以
    for (i = 0; i < m; i++)
    {
        delete[] num[i];
    }
    delete[] num;
    return 0;
}

 

5. 参考文献：

https://www.cnblogs.com/usa007lhy/p/3286186.html

https://www.cnblogs.com/L-Lotus-F/p/4377998.html

https://blog.csdn.net/ytzlln/article/details/78220226