向函数传递数组

最新推荐文章于 2024-05-23 19:55:27 发布
最新推荐文章于 2024-05-23 19:55:27 发布
阅读量2.5w 收藏 74
点赞数 17
分类专栏： c学习笔记 文章标签： 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_16709955/article/details/54799565
版权

传地址形式传数组

数组名相当于指向数组首地址的常量指针。

对于一维数组

传地址方式传数组时，若在函数声明中数组方括号中有数字，若为正数则忽略，若为负数则报错，所以一般函数声明及定义如下：

void modifyArray(int b[], int size);
void modifyArray(int b[], int size) {
    int i = 0;
    for (; i < size; i++) {
        b[i] = 0;
    }
}

使用时如下：

int array[6];
modifyArray(array, 6);

因数组代表数组第一个元素的地址，因此用数组名作为实参就可以将数组的起始地址传递给被调函数。所以当被调函数在函数体中修改数组元素时，真正修改的是存储在原存储单元中的数组元素。也可通过如下方式声明：

void modifyArray(int *b, int size);
void modifyArray(int *b, int size) {
    int i = 0;
    for (; i < size; i++) {
        b[i] = 0;
    }
}

当遇到某些情况函数中禁止修改数组元素值时，可使用const类型限定符防止被调函数修改数组元素如下：

void printArray(const int b[], int size);
void printArray(const int b[], int size) {
    int i = 0;
    for (; i < size; i++)
        printf("%d\n", b[i]);
}

多维数组

对于二维数组，测试如下：

#include <stdio.h>

void func1(int arr[2][3]);
void func2(int arr[1][3]);
void func3(int arr[][3]);
void func4(int arr[2][2]);  //note:expected 'int (*)[2]' but argument is of type 'int (*)[3]'
void func5(int arr[2][]);   //error:array has incomplete element type
void func6(int arr[][]);    //error:array has incomplete element type

void func1(int arr[2][3]) {
    int j, k;
    printf("Function1\n");
    for (j = 0; j < 2; j++) {
        for (k = 0; k < 3; k++) {
            printf("%d ", arr[j][k]);
        }
        printf("\n");
    }
}

void func2(int arr[1][3]) {
    int j, k;
    printf("Function2\n");
    for (j = 0; j < 2; j++) {
        for (k = 0; k < 3; k++) {
            printf("%d ", arr[j][k]);
        }
        printf("\n");
    }
}

void func3(int arr[][3]) {
    int j, k;
    printf("Function3\n");
    for (j = 0; j < 2; j++) {
        for (k = 0; k < 3; k++) {
            printf("%d ", arr[j][k]);
        }
        printf("\n");
    }
}

void func4(int arr[2][2]) {
    int j, k;
    printf("Function4\n");
    for (j = 0; j < 2; j++) {
        for (k = 0; k < 3; k++) {
            printf("%d ", arr[j][k]);
        }
        printf("\n");
    }
}

void func5(int arr[2][]) {  //error:array has incomplete element type
    int j, k;
    printf("Function5\n");
    for (j = 0; j < 2; j++) {
        for (k = 0; k < 3; k++) {
            printf("%d ", arr[j][k]);
        }
        printf("\n");
    }
}

void func6(int arr[][]) {   //error:array has incomplete element type
    int j, k;
    printf("Function6\n");
    for (j = 0; j < 2; j++) {
        for (k = 0; k < 3; k++) {
            printf("%d ", arr[j][k]);
        }
        printf("\n");
    }
}

int main(int argc, char const *argv[])
{
    int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};
    func1(arr);
    func2(arr);
    func3(arr);
    func4(arr);      //warning:passing argument 1 of 'func4' from incompatible pointer type
    func5(arr);      //error
    func6(arr);      //error
    return 0;
}

其中func5和func6不能通过编译，提示error:array has incomplete element type。
func4只有warning，提示传入数据应为int (*)[2]而不是int (*)[3]。输出结果为：

1 2 3
3 4 5

func1，func2，func3可以正常输出。
再次测试如下：

#include <stdio.h>
void func7(int (*arr)[3]);
void func8(int (*arr)[2]);  //note:expected 'int (*)[2]' but argument is of type 'int (*)[3]'
void func9(int (*arr)[]);

void func7(int (*arr)[3]) {
    int j, k;
    printf("Function7\n");
    for (j = 0; j < 2; j++) {
        for (k = 0; k < 3; k++) {
            printf("%d ", arr[j][k]);
        }
        printf("\n");
    }
}
void func8(int (*arr)[2]) {
    int j, k;
    printf("Function8\n");
    for (j = 0; j < 2; j++) {
        for (k = 0; k < 3; k++) {
            printf("%d ", arr[j][k]);
        }
        printf("\n");
    }
}
void func9(int (*arr)[]) {
    int j, k;
    printf("Function9\n");
    for (j = 0; j < 2; j++) {
        for (k = 0; k < 3; k++) {
            printf("%d ", arr[j][k]);   //error:invalid use of array with unspecified bounds
        }
        printf("\n");
    }
}

int main(int argc, char const *argv[])
{
    int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};
    func7(arr);
    func8(arr);   //warning:passing argument 1 of 'func8' from incompatible pointer type
    func9(arr);
    return 0;
}

func7正常输出，func8输出如下：

1 2 3
3 4 5

func9无法编译通过。
再次测试如下：

#include <stdio.h>
void func10(int **arr);
void func11(int *arr[3]);
void func12(int *arr[2]);
void func13(int *arr[]);

void func10(int **arr) {
    int j, k;
    printf("Function10\n");
    for (j = 0; j < 2; j++) {
        for (k = 0; k < 3; k++) {
            printf("%d ", arr[j][k]);
        }
        printf("\n");
    }
}
void func11(int *arr[3]) {
    int j, k;
    printf("Function11\n");
    for (j = 0; j < 2; j++) {
        for (k = 0; k < 3; k++) {
            printf("%d ", arr[j][k]);
        }
        printf("\n");
    }
}
void func12(int *arr[2]) {
    int j, k;
    printf("Function12\n");
    for (j = 0; j < 2; j++) {
        for (k = 0; k < 3; k++) {
            printf("%d ", arr[j][k]);
        }
        printf("\n");
    }
}
void func13(int *arr[]) {
    int j, k;
    printf("Function13\n");
    for (j = 0; j < 2; j++) {
        for (k = 0; k < 3; k++) {
            printf("%d ", arr[j][k]);
        }
        printf("\n");
    }
}
int main(int argc, char const *argv[])
{
    int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};
    func10(arr);
    func11(arr);
    func12(arr);
    func13(arr);
    return 0;
}

func10，func11，func12，func13编译时均warning输入数据类型不相同，运行程序时均不能正常运行。

解释如下：
对于二维数组arr，该数组有2个元素，而每个元素都是由3个int组成的数组，所以，arr的类型可以看做指向拥有3个int元素数组开头的指针。所以传递参数时形参应该声明为指向拥有3个int元素的数组的指针。即如下：

void func7(int (*arr)[3]);

等价于func1，func2，func3。func1，func2，func3其前括号的数字均被忽略。如：

void func1(int arr[2][3]);
void func2(int arr[1][3]);
void func3(int arr[][3]);

而func7中*arr外的括号并不能忽略，因为优先级[]大于*优先级，若为func11，func12，func13则表示为元素类型为int * 类型的指针数组，即为int **，与func10形参类型相同。如下：

void func10(int **arr);
void func11(int *arr[3]);
void func12(int *arr[2]);
void func13(int *arr[]);

对于func5，func6无法通过编译，编译器提示为不完整的元素类型。如：

void func5(int arr[2][]);
void func6(int arr[][]);

对于func9，并没有指明所指向的数组的界限：

void func9(int (*arr)[]);

但是传递了正确的首地址，若想正常使用，需要再func9中将其地址赋给int (*)[3]类型的指针（func10等均可如下使用），如下：

void func9(int (*arr)[]) {
    int (*a)[3] = arr;
    int j, k;
    printf("Function9\n");
    for (j = 0; j < 2; j++) {
        for (k = 0; k < 3; k++) {
            printf("%d ", a[j][k]);
        }
        printf("\n");
    }
}

func4，func8均是将int (*)[3]类型的指针赋值给了int (*)[2]的指针。如下：

void func4(int arr[2][2]);
void func8(int (*arr)[2]);

编译器首先忽略func4形参列表中arr后第一个[]内数字，认为arr为一个指向含有两个int类型元素数组的指针。
对于一个n行m列的二维数组array，单个元素大小为b个字节，其元素array[j][k]的地址计算为array + ((m * j) + k) * b，所以传二维数组时二维数组的列数不可缺少。
所以对于func4和func8，将arr看做一个指向含有两个元素数组的指针，所以arr[0][2]计算得出的元素应该是3，arr[1][0]同样计算得出的元素也是3，运算结果如下：

1 2 3
3 4 5

对于更高维的数组可以根据其地址计算方式来判断如何传入到函数中。

传值形式传数组

当结构体传递给一个函数时，是它们是传值的方式传递的，可以通过使用结构体，来按照传值的方式传递一个数组。需先创立一个以该数组为成员的结构体，然后以传值的方式传递这个结构体，这样数组就以传值的方式被传递过去。例：

#include <stdio.h>

#define SIZE 5

typedef struct
{
    int data[SIZE];
    int size;
} Array;

void modifyArray(Array);

int main(int argc, char const *argv[])
{
    int i;
    Array array;
    array.size = SIZE;
    for (i = 0; i < SIZE; i++) {
        array.data[i] = i;
    }

    modifyArray(array);

    for (i = 0; i < SIZE; i++) {
        printf("%d\n", array.data[i]);
    }
    return 0;
}

void modifyArray(Array a) {
    int i;
    for (i = 0; i < a.size; i++) {
        a.data[i] = 1;
    }
}
HAHAHA9999？
关注
  • 17
    点赞
  • 踩
  • 74
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言 向函数传递数组
inooll的博客
04-11 2万+
可以定义一个能接受数组作为函数参数的函数，然后调用这个函数时，可以将一个实际的数组传递给它。 数组作为函数参数时，其定义方式有下列三种： /*函数名param后跟一个空的[]，说明param可以接受一个数组*/ void myFunction(int param[]) { /*函数体 代码*/ } /*函数名param后跟一个非空的[size]，说明param可以接受一个大小为size的数...
@清晰掉 传递数组给函数
weixin_30678349的博客
08-19 437
一维数组 传递数组给函数的3个原则 1.函数调用时只需传递数组名。 2.在函数定义中，形参的类型必须与数组的相同，数组的大小不必指定。 3.函数原型必须定义为参数是一个数组。 1 #include <stdio.h> 2 #include <stdlib.h> 3 void sort(int x[], int m); 4 int main() ...
C语言 数组——向函数传递数组
最新发布
hangweijie的博客
05-23 295
目录把数组传给函数（Passing Arrays to Functions）向函数传递一维数组向函数传递二维数组数组在学生成绩管理中的应用例：计算每个学生的平均分
C语言 函数的传参——数组
qq_47638391的博客
09-22 2272
2、复制传递方式 ：实参为数组的指针，3、地址传递方式 ：实参为数组的指针，地址传递：删除多余空格。1、全局数组传递方式。
如何正确实现数组的函数传参（值传递/用指针进行地址传递）（C++实现）
热门推荐
Kk_1025的博客
12-03 3万+
实现一些功能时，我们经常要进行对数组的操作。 而将这些带有对数组元素进行操作的代码封装进一个函数时，我们应该采用地址传递的传参方式，以真正地实现对数组数据的更改 （若为值传递，改变的是函数中拷贝的临时数组，并不能真正改变原来传入数组的元素）。 C++中主要有两种能实现地址传递的方法： 指针 引用 此处记录了使用 指针 来传递数组进函数的一些方法。（包括一维数组的两种值传递、两种地址传递，二维数组的一种值传递、一种地址传递） 尤其需要注意函数形参的语法格式 指针 * 到底从属于形参的变量类型..
C语言传递数组给函数方式
事后不诸葛的博客
02-21 1万+
目录 方式 1 方式 2 方式 3 实例 如果想要在函数中传递一个一维数组作为参数，您必须以下面三种方式来声明函数形式参数，这三种声明方式的结果是一样的，因为每种方式都会告诉编译器将要接收一个整型指针。同样地，您也可以传递一个多维数组作为形式参数。 方式 1 形式参数是一个指针： void myFunction(int *param) { . . . } 方式 2 形式参数是一个已定义大小的数组： void myFunction(int param[10]) { . . . }
python调用c++传递数组的实例
09-19
本文将深入探讨如何在Python中调用C++函数并传递数组作为参数。 首先，Python使用`ctypes`库来与C/C++动态链接库进行交互。`ctypes`允许我们定义C数据类型，并将它们映射到Python对象。例如，`c_int * 4`表示一个...
C++ 让函数返回数组的方法
08-18
2. 传递数组指针作为参数 可以将数组指针作为参数传递给函数，例如： ```c void func(int* a) { a[0] = 1; a[1] = 2; a[2] = 3; a[3] = 4; a[4] = 5; } ``` 这样，函数可以修改数组的值，但是不能返回数组。 让...
Java初认识–函数和数组
12-22
一、函数 ... 　形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。 　实际参数：传递给形式参数的具体数值。 　return：用于结束函数。 　返回值：该值会返回给调用者。 　3、函数的应
passing-l-array-to-a-function.rar_多维传递函数_数组、函数
09-23
如何将多维数组传递给一个函数，附实例说明，得出结果
ES6函数和数组用法实例分析
01-19
ES6为我们提供了这样的解构赋值使在前后端分离时，后端返回来JSON格式的数据，前端可以直接把这个JSON格式数据当作参数，传递到函数内部进行处理。比如： let json = { a:'es6', b:'es5' } function fun({a,b='...
数组在函数间传参
karry_hahaha的博客
12-27 1172
数组在函数间传参 1、学习目标 掌握数组在函数间传参的用法 程序举例 2、函数的传参-数组 全局数组传递方式 复制传递方式 实参为数组的指针，形参为数组名（本质是一个指针变量） 地址传递方式 实参为数组的指针，形参为同类型的指针变量。 3、程序举例 编写函数，计算一个一维整形数组的所有元素的和。 第一种写法:复制传递方式 #include <stdio.h> int array_sun(int data[], int n); int main() { in
将数组作为参数传入函数
m0_64662286的博客
02-02 2725
形参列表中写int a [3] 是毫无意义的，也就是说如果我们传入了一个大小为 2 的数组，编译器没报任何错误，我们的函数接口 test (int datas[3 ]， int length) 中的 3 没起任何作用（有无后面传入的数组长度length都无所谓）sizeof( a ) / sizeof ( a[0] ) 计算数组长度，得到的答案永远是4（是一个指针所占用的内存长度）。在传参时，最好传入数组的长度，因为在test函数中，a只是个指针（指向数组首元素），若想再利用。则p[0]=a[0];
C语言函数中的数组传递
Time travel的博客
07-02 8417
#include <stdio.h> typedef unsigned char uchar; //---------------------------------------------------全局变量 uchar *t; //---------------------------------------------------子函数声明 void func3(void)...
数组在函数中的传值方法
超人不会飞
05-19 5631
数组在函数中的传值方法我们如何让一个数组在函数中传值呢？你知道的方法有几种呢？不知道也没关系，首先我们来看一个例子1 #include<stdio.h> 2 #define N 40 3 void ReadSocer(int socer[],int n); 4 int main(int argc, char const *argv[]) 5 { 6 int n; 7 int socer[N]
C 传递数组给函数的三种方式和从函数返回数组
Kilvin的博客
04-25 5289
如果想要在函数中传递一个一维数组作为参数，有三种方式来声明函数形式参数，这三种声明方式的结果是一样的，因为每种方式都会告诉编译器将要接收一个整型指针 方式 1 形式参数是一个指针 void myFunction(int *param) { . . . } 方式 2 形式参数是一个已定义大小的数组 void myFunction(int param[10]) { . . . } 方式 3 形...
C++ 传递数组给函数
qq_37650009的博客
02-25 801
 C++ 数组C++ 不允许向函数传递一个完整的数组作为参数，但是，您可以通过指定不带索引的数组名来传递一个指向数组的指针。如果您想要在函数中传递一个一维数组作为参数，您必须以下面三种方式来声明函数形式参数，这三种声明方式的结果是一样的，因为每种方式都会告诉编译器将要接收一个整型指针。同样地，您也可以传递一个多维数组作为形式参数。方式 1形式参数是一个指针：void myFunction(int ...
Python3---numpy的详细解读，小白疯狂收藏
HXAI77的博客
10-03 681
前言 近日梳理python3 的numpy的相关知识点,故自我整理成笔记发布,一是供大家评论和建议,查缺补漏自我知识框架,二是可以进一步熟悉知识,达到更好的融汇贯通的情况,希望看到的兄弟姐们可以不吝赐教,感激不尽! 1.维度 一维数组 二维数组 三维数组 2.基本属性 2.1数组创建 1)列表转换 import numpy as np list=[[1,2],[3,4],[5,6]] t=np.array (list2) print(t) 2)arange函数 import nump
java函数传递数组
10-12
在Java中，函数可以传递数组作为参数。具体实现方式如下： ```java public static void myFunction(int[] arr) { // 函数体 } ``` 在调用该函数时，可以将一个整型数组作为参数传递进去： ```java int[] myArray = {1, 2, 3, 4, 5}; myFunction(myArray); ``` 这样，在函数内部就可以使用传递进来的数组了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值