二维数组传参的三种方式

于 2024-08-21 14:07:30 发布
阅读量709 收藏 3
点赞数 9
分类专栏： 知识点 C语言 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77560238/article/details/141391919
版权

提示：文章

文章目录

前言

前期疑问：
本文目标：

一、背景

问题来源于上次考试做的一道题，题目中是在函数中将字符串分割存在二维数组中。二维数组是从函数外传进来的。但是我还想传出去。传出去的时候就出问题了。基于此，做了一下验证，其中已经写了一篇文章，在文章中验证了多次写法。最后经过多次拉扯，确定了二维数组传参和返回的一些问题。

在这篇文章中做了总结。总结为二维数组传参的三种方法。其中第三种方法还是有问题。

2024年8月21日13:59:47

今天又看了下书《C和指针》，对多维数组相关的知识看了一遍，加深了二维数组的了解，也完善了这篇文章。

二、对二维数组传参的总结

2.1

下面的代码主要是验证数组传参的方式，C和指针书籍Page159也介绍了这两种方式

第一种是DeliverArrayWithSecondPointer(int array[][6], int len)

第二种是int** DeliverArrayWithSecondPointer3(int (*array)[6], int len)

值得一提的是，这边还是验证了返回静态二维数组的方式

下面是具体的代码验证


#include "secondArrayDeliverReturn.h"
#include <stdio.h>

int** DeliverArrayWithSecondPointer3(int (*array)[6], int len);

int DeliverArrayWithSecondPointer(int array[][6], int len)
{
    printf("DeliverArrayWithSecondPointer\n");
    for(int i = 0; i < len; i++)
    {
        for(int j = 0; j < 6; j++)
        {
            printf("%d ", array[i][j]);
        }
        printf("\n");
    }
    printf("\n");

    for(int i = 0; i < len; i++)
    {
        for(int j = 0; j < 6; j++)
        {
            printf("addr:%p ", &array[i][j]);
        }
        printf("\n");
    }
    printf("\n");

    for(int i = 0; i < len; i++)
    {
        printf("addr:%p ", array[i]);
    }
    printf("\n");

    return 0;
}

int** DeliverArrayWithSecondPointer2(int array[][6], int len)
{
    printf("DeliverArrayWithSecondPointer2\n");
    for(int i = 0; i < len; i++)
    {
        for(int j = 0; j < 6; j++)
        {
            printf("%d ", array[i][j]);
        }
        printf("\n");
    }
    printf("\n");

    printf("打印全部地址\n");
    for(int i = 0; i < len; i++)
    {
        for(int j = 0; j < 6; j++)
        {
            printf("addr:%p ", &array[i][j]);
        }
        printf("\n");
    }
    printf("\n");

    printf("打印首地址\n");
    for(int i = 0; i < len; i++)
    {
        printf("addr:%p ", array[i]);
    }
    printf("\n");

    return (int **)array;           //这边直接返回，用二级指针接收，会报错
}

int secondArrayDeliverReturn()
{
    int array[5][6] = {0};
    for(int i = 0; i < 5; i++)
    {
        for(int j = 0; j < 6; j++)
        {
            array[i][j] = i * j;
        }
    }

    DeliverArrayWithSecondPointer(array, 5);
    int **ptr = DeliverArrayWithSecondPointer2(array, 5);
    for(int i = 0; i < 5; i++)
    {
        printf("**ptr addr:%p ", ptr + i);
    }
    printf("\n");

    printf("静态二维数组，形参二维数组指针，返回二级指针，在函数外注意地址访问\n");
    int **ptr3 = DeliverArrayWithSecondPointer3(array, 5);
    printf("函数外访问\n");
    for(int i = 0; i < 6; i++)
    {
        for(int j = 0; j < 6; j++)
        {
            printf("addr:%p ", ptr3 + i * 6 + j);
        }
        printf("\n");
    }
    printf("\n");
    for(int i = 0; i < 6; i++)
    {
        for(int j = 0; j < 6; j++)
        {
            printf("addr:%p ", ptr3[i * j + j]);
        }
        printf("\n");
    }
}

//DeliverArrayWithSecondPointer
//0 0 0 0 0 0
//0 1 2 3 4 5
//0 2 4 6 8 10
//0 3 6 9 12 15
//0 4 8 12 16 20
//
//addr:000000c0807ff5a0 addr:000000c0807ff5a4 addr:000000c0807ff5a8 addr:000000c0807ff5ac addr:000000c0807ff5b0 addr:00000
//0c0807ff5b4
//addr:000000c0807ff5b8 addr:000000c0807ff5bc addr:000000c0807ff5c0 addr:000000c0807ff5c4 addr:000000c0807ff5c8 addr:00000
//0c0807ff5cc
//addr:000000c0807ff5d0 addr:000000c0807ff5d4 addr:000000c0807ff5d8 addr:000000c0807ff5dc addr:000000c0807ff5e0 addr:00000
//0c0807ff5e4
//addr:000000c0807ff5e8 addr:000000c0807ff5ec addr:000000c0807ff5f0 addr:000000c0807ff5f4 addr:000000c0807ff5f8 addr:00000
//0c0807ff5fc
//addr:000000c0807ff600 addr:000000c0807ff604 addr:000000c0807ff608 addr:000000c0807ff60c addr:000000c0807ff610 addr:00000
//0c0807ff614
//
//addr:000000c0807ff5a0 addr:000000c0807ff5b8 addr:000000c0807ff5d0 addr:000000c0807ff5e8 addr:000000c0807ff600
// 从打印结果来看，DeliverArrayWithSecondPointer函数内部array变成了指向指针函数的指针一样。或者是按照数组名下标访问



//DeliverArrayWithSecondPointer2
//0 0 0 0 0 0
//0 1 2 3 4 5
//0 2 4 6 8 10
//0 3 6 9 12 15
//0 4 8 12 16 20
//
//addr:000000c0807ff5a0 addr:000000c0807ff5a4 addr:000000c0807ff5a8 addr:000000c0807ff5ac addr:000000c0807ff5b0 addr:00000
//0c0807ff5b4
//addr:000000c0807ff5b8 addr:000000c0807ff5bc addr:000000c0807ff5c0 addr:000000c0807ff5c4 addr:000000c0807ff5c8 addr:00000
//0c0807ff5cc
//addr:000000c0807ff5d0 addr:000000c0807ff5d4 addr:000000c0807ff5d8 addr:000000c0807ff5dc addr:000000c0807ff5e0 addr:00000
//0c0807ff5e4
//addr:000000c0807ff5e8 addr:000000c0807ff5ec addr:000000c0807ff5f0 addr:000000c0807ff5f4 addr:000000c0807ff5f8 addr:00000
//0c0807ff5fc
//addr:000000c0807ff600 addr:000000c0807ff604 addr:000000c0807ff608 addr:000000c0807ff60c addr:000000c0807ff610 addr:00000
//0c0807ff614
//
//addr:000000c0807ff5a0 addr:000000c0807ff5b8 addr:000000c0807ff5d0 addr:000000c0807ff5e8 addr:000000c0807ff600
//000000c0807ff5a0 000000c0807ff5a8 000000c0807ff5b0 000000c0807ff5b8 000000c0807ff5c0
// 从打印结果来看，DeliverArrayWithSecondPointer2函数内部将array返回用二级指针接收，会报错。强转之后在函数外部不能正常访问。会丢失二维数组信息。
// 目前静态数组经过传参再返回，只有在函数内部创建一个指针数组，再返回指针数组的地址，用二级指针接收可以实现。
// 还有一个问题就是二维数组传参，二维数组指针作为形参之前写的不对
// 下面验证一下

int** DeliverArrayWithSecondPointer3(int (*array)[6], int len)
{
    printf("DeliverArrayWithSecondPointer3\n");
    for(int i = 0; i < len; i++)
    {
        for(int j = 0; j < 6; j++)
        {
            printf("%d ", array[i][j]);
        }
        printf("\n");
    }
    printf("\n");

    for(int i = 0; i < len; i++)
    {
        for(int j = 0; j < 6; j++)
        {
            printf("addr:%p ", &array[i][j]);
        }
        printf("\n");
    }
    printf("\n");

    for(int i = 0; i < len; i++)
    {
        printf("addr:%p ", array[i]);
    }
    printf("\n");

    return (int **)array;
}

// DeliverArrayWithSecondPointer3打印信息
//尝试直接返回静态二维数组强制转换的二级指针，在函数外注意地址访问，是会出错的。出错的点在于即便我使用形如ptr3 + i * 6 + j方式，偏移的长度是64位指针长度8，而二维数组的偏移是4
//静态二维数组，形参二维数组指针，返回二级指针，在函数外注意地址访问
//DeliverArrayWithSecondPointer3
//0 0 0 0 0 0
//0 1 2 3 4 5
//0 2 4 6 8 10
//0 3 6 9 12 15
//0 4 8 12 16 20
//
//addr:0000009b6d5ff880 addr:0000009b6d5ff884 addr:0000009b6d5ff888 addr:0000009b6d5ff88c addr:0000009b6d5ff890 addr:00000
//09b6d5ff894
//addr:0000009b6d5ff898 addr:0000009b6d5ff89c addr:0000009b6d5ff8a0 addr:0000009b6d5ff8a4 addr:0000009b6d5ff8a8 addr:00000
//09b6d5ff8ac
//addr:0000009b6d5ff8b0 addr:0000009b6d5ff8b4 addr:0000009b6d5ff8b8 addr:0000009b6d5ff8bc addr:0000009b6d5ff8c0 addr:00000
//09b6d5ff8c4
//addr:0000009b6d5ff8c8 addr:0000009b6d5ff8cc addr:0000009b6d5ff8d0 addr:0000009b6d5ff8d4 addr:0000009b6d5ff8d8 addr:00000
//09b6d5ff8dc
//addr:0000009b6d5ff8e0 addr:0000009b6d5ff8e4 addr:0000009b6d5ff8e8 addr:0000009b6d5ff8ec addr:0000009b6d5ff8f0 addr:00000
//09b6d5ff8f4
//
//addr:0000009b6d5ff880 addr:0000009b6d5ff898 addr:0000009b6d5ff8b0 addr:0000009b6d5ff8c8 addr:0000009b6d5ff8e0
//函数外访问
//addr:0000009b6d5ff880 addr:0000009b6d5ff888 addr:0000009b6d5ff890 addr:0000009b6d5ff898 addr:0000009b6d5ff8a0 addr:00000
//09b6d5ff8a8
//addr:0000009b6d5ff8b0 addr:0000009b6d5ff8b8 addr:0000009b6d5ff8c0 addr:0000009b6d5ff8c8 addr:0000009b6d5ff8d0 addr:00000
//09b6d5ff8d8
//addr:0000009b6d5ff8e0 addr:0000009b6d5ff8e8 addr:0000009b6d5ff8f0 addr:0000009b6d5ff8f8 addr:0000009b6d5ff900 addr:00000
//09b6d5ff908
//addr:0000009b6d5ff910 addr:0000009b6d5ff918 addr:0000009b6d5ff920 addr:0000009b6d5ff928 addr:0000009b6d5ff930 addr:00000
//09b6d5ff938
//addr:0000009b6d5ff940 addr:0000009b6d5ff948 addr:0000009b6d5ff950 addr:0000009b6d5ff958 addr:0000009b6d5ff960 addr:00000
//09b6d5ff968
//addr:0000009b6d5ff970 addr:0000009b6d5ff978 addr:0000009b6d5ff980 addr:0000009b6d5ff988 addr:0000009b6d5ff990 addr:00000
//09b6d5ff998
//
//addr:0000000000000000 addr:0000000000000000 addr:0000000000000000 addr:0000000100000000 addr:0000000300000002 addr:00000
//00500000004
//addr:0000000000000000 addr:0000000000000000 addr:0000000300000002 addr:0000000200000000 addr:0000000a00000008 addr:00000
//00900000006
//addr:0000000000000000 addr:0000000100000000 addr:0000000200000000 addr:0000000300000000 addr:0000000400000000 addr:00007
//ff6198ceff7
//addr:0000000000000000 addr:0000000300000002 addr:0000000a00000008 addr:0000000400000000 addr:0000009b6d5ff880 addr:00000
//00500000006
//addr:0000000000000000 addr:0000000500000004 addr:0000000900000006 addr:00007ff6198ceff7 addr:0000000500000006 addr:00007
//ff6198cf4f7
//addr:0000000000000000 addr:0000000200000000 addr:0000000400000000 addr:000000036d5ff958 addr:0000009b6d5ff9d0 addr:00000
//00000000001

2.2

三、静态二维数组返回方式

静态二维数组返回方式目前看只有一种，就是在函数内存创建静态指针数组，将二维数组的首地址赋值给指针数组，然后使用二级指针返回，在函数外部解析地址。

四、指针+1的概念

还是疑惑为什么函数DeliverArrayWithSecondPointer3返回二级指针ptr3，对ptr3进行+1操作偏移地址为8，为什么不是偏移4，偏移4的话就能正确访问二维数组了，下面代码是验证这一问题

printf("打印二级指针+1的地址\n");
printf("%p\n",ptr3);
printf("%p\n",ptr3 + 1);
printf("sizeof(ptr3):%d\n",sizeof(ptr3));

//打印结果
//打印二级指针+1的地址
//000000f3b33ff980
//000000f3b33ff988
//sizeof(ptr3):8

查找资料，指针+1偏移的长度取决于指针指向的数据类型是什么。

总结

未完待续

晴山ぺ
关注
专栏目录
二维数组的参数传递
yang_half的博客
08-09 361
示例： ”’ cpp include “fftw3.h” include include using namespace std; define N 2 int main() { int i, j; fftw_complex *in, *out; fftw_plan p; in = (fftw_complex*) fftw_m...
C语言二维数组传参示例
10-23
C语言中，二维数组的参数传递。 例如： char str[5][100]; 如果作为参数传递，内有详细示例。 三种传参示例供参考。
二维数组传参（二维数组作为函数参数）
weixin_42322256的博客
11-23 1万+
传递参数是二维数组 二维数组传参，函数形参的设计只能省略第一个[ ]的数字； 因为对于二维数组，可以不知道有多少行，但必须知道一行多少个元素； #include<iostream> using namespace std; void test(int arr[3][4]) { // 表明数组行列数 } void test(int arr[][4]) { //省略数组列数 } /* void test(int arr[][]) { //写法错误，不可省略列数 } */ int mai
二维数组的函数传参分析
wwwqqq2014的博客
04-02 3000
二维数组的函数传参分析
二维数组传递参数
weixin_34320724的博客
11-04 689
先开始写这个小程序的时候我直接传递的是一个二维指针，然后发现编译跟链接都没有问题，但是运行的时候报了内存错误，经过查询才知道二维数组传参不能直接用二维指针定义二维数组传递参数一般有三种方法1.直接传递二维数组如“int a[][10]”（必须标注数组第二维的值）。2.二维数组第一维用指针代替“int (*a)[3]”。...
如何将二维数组作为函数的参数传递
GYTAnonymous的专栏
12-25 692
今天写程序的时候要用到二维数组作参数传给一个函数，我发现将二维数组作参数进行传递还不是想象得那么简单里，但是最后我也解决了遇到的问题，所以这篇文章主要介绍如何处理二维数组当作参数传递的情况，希望大家不至于再在这上面浪费时间。 正文：     首先，我引用了谭浩强先生编著的《C程序设计》上面的一节原文，它简要介绍了如何 将二维数组作为参数传递，原文如下(略有改变，请原谅)：     [原
参数传递二维数组
热门推荐
yunyun1886358的专栏
06-10 8万+
今天在论坛上有朋友提问：声明函数如下void function（int** pInt），意图是想参数传递一个二维数组。于是就定义了一个二维数组，比如 int[1][1]，然后调用函数。结果如何？当然是失败了，编译器提示：cannot convert parameter 1 from 'int [1][1]' to 'int **'，参数类型不匹配。上述过程我自己也试了，当然不匹配，类型完全不一样嘛。然后我就想了：如果要将一个二维数组作为形参，那么函数该怎么声明？ 来看《C++ Prim
二维数组传参
weixin_54818033的博客
03-21 1万+
本文会介绍二维数组常见的三种传参方式，以整形数组为例。 1.int arr[行数][列数] int arr[2][4] = { 1,2,3,4,0,1,2,3 }; 例如将上面的二维数组传入下方的函数 函数形参可以如下设置 void Print(int arr[2][4], int m, int n) { int i = 0,j=0; for (i = 0; i < m; i++) { for (j = 0; j < n; j++) { printf("%d ", ar
C语言中二维数组作为函数参数来传递的三种方法
08-25
C语言中二维数组作为函数参数来传递的三种方法 在C语言中，二维数组作为函数参数来传递是非常常见的操作。但是，如何正确地传递二维数组作为函数参数却是许多初学者和开发者经常混淆的地方。今天，我们将详细介绍...
[C语言]二维数组传参的格式(详细+总结)
乃成的博客
11-30 7万+
初遇二维数组作函数参数，宛如自己化身为了大头儿子。很头大。 不禁大声呐喊：该怎么声明定义，该怎么调用，又该怎么函数中操作元素和地址？ 在此，我要拨开这些问题的一些迷雾。 我相信，有心人看完后，再遇就不会怕了。 其实声明，定义是一样的。因此，只写声明。 同时,把元素外层*()剥去就代表地址。因此只写元素。 最后有总结。 二维数组作函数参数，依我看来，至少可以分成三种。 事先，在main函数中 int...
c语言字符二维数组传参,C语言函数传递二维数组
weixin_32534653的博客
05-17 1849
C语言如果给函数传递二维数组作为参数问题的产生先看一个传递二维数组的例子：#include void foo(int a[][], int m, int n) {int i = 1;int j = 1;printf("a[%d][%d]=%d\n", i, j, a[i][j]);}int main() {int a[2][3] = {{1,2,3},{4,5,6}};foo(a, 2, 3);}...
C/C++二维数组传参
max_kibble的博客
06-05 1147
C/C++二维数组传参
C/C++语言二维数组的传参方法总结
踏实每一小步，成就一大步
01-10 1269
转载 https://blog.csdn.net/gqb_driver/article/details/8886687 C/C++语言将二维数组作为参数传递容易使人迷惑且易出错，本文将常用的几种方法列出，以方便用时查阅。三种方法总结如下（VS2005/GCC验证成功）： 方法一：形参为二维数组并给定第二维长度  此方法是最简单最直观的方法，形参与实参一样，容易理解。 举例： #inclu...
C语言中如何将二维数组作为函数的参数传递
afl291529699的博客
07-16 3094
今天写程序的时候要用到二维数组作参数传给一个函数，我发现将二维数组作参数进行传递还不是想象得那么简单里，但是最后我也解决了遇到的问题，所以这篇文章主要介绍如何处理二维数组当作参数传递的情况，希望大家不至于再在这上面浪费时间。 正文： 首先，我引用了谭浩强先生编著的《C程序设计》上面的一节原文，它简要介绍了如何将二维数组作为参数传递，原文如下(略有改变，请原谅)： [原文开始]...
二维数组传参与动态声明详解
zdaiot的博客
10-15 476
二维数组传参 基本形式 二维数组在栈上分配，各行地址空间连续 定义的时候，拥有两种形式 第一种是指明行数和列数 int array[3][3] = {{1,2,3},{4,5,6},{7,8,9}}; 第二种是不指明第一维，而指明第二维 int array[][3] = {{1,2,3},{4,5,6},{7,8,9}}; 而在子函数声明的时候，有三种方式 一种是指明形参的行数和列数 int ...
c语言二维数组传参的三种方式
最新发布
10-16
在C语言中，二维数组作为参数传递给函数时，有以下三种常见的方式： 1. **按值传递** (Pass by Value): 这是最基本的方式，创建的是数组副本，改变函数内部数组的元素不会影响到主程序中的原始数组。例如： ```c void print_array(int arr[][3]) { // 函数内的操作不会改变arr本身 arr[0][0] = 5; } int main() { int my_arr[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; print_array(my_arr); // my_arr仍保持原样 } ``` 2. **指针传递** (Pass by Pointer): 使用指向数组首地址的指针可以实现修改原数组的效果，因为数组名本质上就是一个指向首元素的指针。示例： ```c void modify_array(int (*ptr)[3]) { ptr[0][0] = 5; // 直接通过指针修改数组 } int main() { int my_arr[3][3] = ...; modify_array(&my_arr[0]); // my_arr已改变 } ``` 3. **通过指针间接访问** (Indirect Access through Array of Pointers): 如果两个维度的数组大小固定，还可以通过一维数组存储二维数组的所有行指针，然后将这个指针数组传递。这种方法同样能修改原数组，但代码相对复杂一些： ```c void indirect_access(int *rows[3]) { rows[0][0] = 5; } int main() { int my_arr[3][3] = ...; int *row_ptrs[3]; for (int i = 0; i < 3; i++) { row_ptrs[i] = &my_arr[i][0]; } indirect_access(row_ptrs); // my_arr已改变 } ```
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值