精华内容
下载资源
问答
  • 数组名做函数参数(转)

    万次阅读 2011-04-14 12:54:00
    可以用数组名作函数参数,此时实参与形参都应用数组名(或指针变量)。 例2:有一个一维数组score,内放10个学生成绩,求平均成绩。 float average(float array[10]){     int i;   float aver,sum=...

    可以用数组名作函数参数,此时实参与形参都应用数组名(或指针变量)。

    2:有一个一维数组score,内放10个学生成绩,求平均成绩。

    float average(float array[10]){

          

          int i;

          float aver,sum=array[0];   

               for(i=1; i<10; i++)sum=sum+array[i];

               aver=sum/10;

               return aver;

    }

     

    main(){

          

        float score[10],aver;     

             int i;

             printf("input 10 scores:/n");

             for(i=0; i<10; i++)scanf("%f",&score[i]);

             printf("/n");

             aver=average(score);//数组名作为函数参数

             printf("average score is %5.2f",aver);

    }

     

     

    说明:

    l         用数组名称作函数参数,应该在主调函数和被调函数分别定义数组,本例中array是形参数组名,score是实参数组名,分别在其所在的函数中定义,不能只在一方定义。

    l         实参数组与形参数组类型应该保持一致(这里都为float型),如不一致,结果将出错。

    l         在被调用函数中声明了形参数组的大小为10,但在实际上,指定其大小是不起任何作用的,因为C编译器对形参数组大小不做检查,只是检查实参数组的首地址传给形参数组。因此,score[n]array[n]指的是同一单元。

    l         形参数组也可以不指定大小,在定义数组时在数组名后面跟一个空的方括号,有时为了在被调用函数中处理数组元素的需要,可以另设一个参数,传递需要处理的数组元素的个数,上例可以改写为下面的形式:

     

    float average(float array[], int n){

          int i;

          float aver,sum=array[0];   

               for(i=1; i<n; i++)sum=sum+array[i];

               aver=sum/n;

               return aver;

    }

     

    main(){

        float score_1[5]={98.5,97,91.5,60,55};      

        float score_2[10]={67.5,89.5,99,69.5,77,89.5,76.5,54,60,99,5};      

             printf("the average of class A is %6.2f/n", average(score_1, 5));

             printf("the average of class B is %6.2f/n", average(score_2, 10));

    }

     

    可以看出,两次调用average函数时,需要处理的数组元素是不同的,在第一次调用时用一个实参5传递给形参n,表示求前面5个学生的平均分数。第二次调用时,求10个学生平均分。

     

    l         最后应该说明一点:用数组名作为函数实参的时,不是吧数组元素的值传递给形参,而是把实参数组的起始地址传递给形参数组,这样两个数组就共占同一段内存单元。见下图:

     

    起始地址1000

       a[0]              a[1]            a[2]          a[3]         a[4]           a[5]          a[6]         a[7]          a[8]       a[9]

    2

    4

    6

    8

    10

    12

    14

    16

    18

    20

              b[0]             b[1]             b[2]          b[3]         b[4]           b[5]          b[6]         b[7]         b[8]       b[9]

     

    假如a的起始地址为1000,则b数组的起始地址也是1000,显然ab同占一段内存单元,a[0]b[0]同占一个内存单元……。由此,我们可以看到,形参数组中各个元素的值如果发生变化会使实参数组元素的值同时发生变化,从上图是很容易理解的。这一点与变量做函数参数的情况是不同的,务必注意!在程序设计中可以有意识地利用这一点,改变实参数组元素(如排序)。

    最后,再给出一个例子:用选择排序法对数组中,10个整数按有小到大排序。所谓选择排序就是先将10个数中最小的数与a[0]对换;再将a[1]a[9]中最小的数与a[1]对换……,每比较一轮,我们可以找出一个未经排序的数中最小的一个。共比较9论。

    a[0]     a[1]   a[2]    a[3]    a[4]

                                        3        6        1         9       4

                                        1        6        3         9       4

                                        1        3        6         9       4

                                        1        3        4         9       6

                                        1        3        4         6       9

     

    我们可以看到在执行函数调用语句sorta10);之前和之后,a数组各元素的值是不一样的。原来是无序的,执行sorta10)之后是有序的。这也就是所谓的形参数组改变也可以使实参数组随之改变。

     

    现在,我们已经知道了,当用数组名作函数参数时,如果形参数组中各元素的值发生了变化,实参数组元素的值也随之变化。那么这是为什么呢?如果你学过指针,这个问题就很容易来回答。

    我们先看数组元素做实参时的情况。如果已经定义了一个函数,其原型为:

    Void swap(int x, int y);

    假设函数的作用是将两个形参(xy)的值进行交换,现在我们这样调用这个函数:

    Swap(a[1], a[2]);

    用数组元素a[1], a[2]做实参的情况与变量做实参时一样,是“值传递”方式,我们将a[1], a[2]的值单向传递给xy。当xy的值改变时a[1], a[2]的值并不改变。

    我们现再看用数组名作函数参数的情况。前面已经介绍,实参数组名代表该数组首元素的地址。而形参是用来接收从实参传递过来的数组首元素的地址。因此形参应该是一个指针变量。实际上,C编译器都是将形参数组名作为指针变量来处理的。例如:

    我们定义一个被调函数f(int arr[], int n);,实际上,编译器是把arr按照指针变量来处理的,这相当于将函数f的首地址写成:fint *arrint n)。以上两种写法是等价的。

    实际上,我们经常用这种方法调用一个函数来改变实参数组的值。

    这里,给出一个表格,用于比较变量名作为函数参数和数组名作为函数参数。

     

    实参类型

    变量名

    数组名

    要求形参的类型

    变量名

    数组名或指针变量

    传递的信息

    变量的值

    实参数组首元素的地址

    通过函数调用能否改变实参的值

    不能

     

    注意:

    l         在用数组名做函数实参的时候,既然实际上相应的形参是指针变量,为什么还允许使用形参数组的形式呢?

    这是因为在C语言中,用下标法和指针法都可以访问一个数组,而且用下标法比较直观,便于理解。因此许多人愿意用数组名做形参,以便与实参数组对应。但从应用的角度讲,用户可以认为有一个形参数组,从实参数组那里得到起始地址,因此形参数组与实参数组共占一段内存单元,在调用函数期间,如果改变了形参数组的值,也就改变了实参数组的值。当然,在主调函数中我们可以使用这些改变了的值。实际上,对C语言比较熟悉的专业人士,往往比较喜欢用指针变量做形参。

    l         再强调一点:实参数组名代表一个固定的地址,或者说是一个指针型常量,而形参数组并不代表一个固定的地址值。作为指针变量,在函数调用开始时,它的值等于实参数组起始地址,但在函数执行期间,它可以再被赋值。例如:

        f(arr[], int n){

       printf("%d/n", *arr);  //输出array[0]的值

       arr=arr+3;

       printf("%d/n", *arr);  //输出array[3]的值

    }

    展开全文
  • 数组专题 1、数组初始化: 数组元素的个数可以显示或隐式指定 int main() { int a[10] = {1,2};//其他没初始化元素,编译器默认帮你初始化为0   int b[] = {1, 2};//编译器隐式...
    


    1、数组初始化:

    数组元素的个数可以显示或隐式指定

    int main()

    {

    int a[10] = {1,2};//其他没初始化元素,编译器默认帮你初始化为0

            int b[] = {1, 2};//编译器隐式指定长度为两个元素

            int c[20] = {0};

            for (i=0; i<10; i++)

            {

                      printf("%d ", a[i]);

            }

            memset(a, 0, sizeof(a));

            getchar();

    }

     

    2、数组名理解难点

    int a[10]={1,2};

       printf("&a:%d,a:%d\n",&a,a);

       printf("&a+1:%d,a+1:%d\n", &a+1, a+1);

    1. 数组首元素地址与数组地址:数组名a代表元素首地址,&a代表数组地址。

    2. 数组首元素地址=数组地址即:a=&a

    3. &a+1代表的是加一个数组长度sizeof(a)a+1代表的是加一个数组元素长度sizeof(a[0])

    4. 一维数组名是一个指针常量

    5. 二维数组名是一个数组指针,多维数组名也是一个数组指针,是指向一个低维数组的指针

    char array[10][30];

            (array+i)          //相当于i行的首地址      //二级指针

            *(array+i)    //一维数组的首地址          //一级指针

            *(array+i)+j    //相当于第i行第j列的地址  &array[i][j]

            *(*(array+i)+j)  //相当于第i行第j列的地址  array[i][j]

    6、多维数组在物理内存中是线性存储的,只是编译器帮我们优化了

     

     

     

    2、初学者数组类型三大难题

    数组类型

    数组指针:数组是一个指针,该指针是指向一个数组的指针(数组类型和数组指针的关系)

    指针数组:指针是数组元素,也就是数组元素中存储的都是指针

     

    1、       数组类型

    C语言中的数组有自己特定的类型,数组的类型由元素类型和数组大小共同决定

    1、定义一个数组类型:用数组定义变量

    void main12()

    {

            int i = 0;

            //定义一个数组类型

            typedef int MyArrayType[5];    //int

            MyArrayType myArray;        //int myArray[5];

            for (i=0; i<5; i++)

            {

                      myArray[i] = i +1;

            }

            for (i=0; i<5; i++)

            {

                      printf("%d \n", myArray[i]);

            }

            system("pause");

    }

    2、定义一个数组类型,用数组顶一个数组类型的指针

    void main13()

    {

            int i = 0;   

            typedef int MyArrayType[5];   //定义一个数组类型 

    MyArrayType *pArray = NULL; //定义了一个数组类型的指针

    Int a[5]={0};

    pArray = &a;

    for (i=0; i<5; i++)          //我通过数组指针的方式来操作a[5]这块内存

            {

                      (*pArray)[i] = i+1;       //a[i] = i+1;

            }

            for (i=0; i<5; i++)

            {

                      printf("%d \n", (*pArray)[i]);

            }       

            system("pause");

    }

     

    2、       数组指针

    定义数组指针

    int i = 0;

            //这个是定义了一个类型,这个类型是数组类型

            typedef int MyArrayType[5]; //int

    //这个是定义了一个类型,定义了一个指针类型,定义了一个指向数组的指针类型。。。。

            typedef int (*MyPArrType)[5] ; //数组指针

            MyPArrType myPoint;        //

    int b[5]; 

    myPoint = &b;             //变量取地址给指针赋值

            for (i=0; i<5; i++)

            {

                      (*myPoint)[i] = i+1;

            }

            for (i=0; i<5; i++)

            {

                      printf("%d  ", (*myPoint)[i]);

            }       

            system("pause");

    }

     

            1):typedef int MyArrayType[5];    //定义一个数组类型

                      MyArrayType *pArray = NULL;   //定义了一个数组类型的指针

    //这个是定义了一个类型,定义了一个指针类型,定义了一个指向数组的指针类型

            2):typedef int (*MyPArrType)[5] ; //数组指针

                      MyPArrType myPoint; //int b[5];

            3):int (*myArrayPoint)[5] ;   //告诉编译给我开辟四个字节内存

     

    5、指针数组

    1、指针数组与数组指针容易混淆

    Char *p1[] = {“123”,”456”,”789”};

    []优先级高,先与p结合成为一个数组,再由char*说明这是一个字符型指针数组

    //这是一个指针数组、数组3*4、三个一维数组的首地址存放在以指针作为元素的数组

    Char (*p2)[] = {“123”,”456”,”789”};

    //编译器只分配4个字节,是一个指针,编译不通过、错误的方式

    2、指针数组做函数参数退化

    int printfArray(char *buf [30]);

    int printfArray(char *buf[]);

    int printfArray(char **buf);

    1. 指针数组的两种用途

      菜单

            命令行

    2. 指针数组自我结束的三种方法

      char*   c_keyword[] = {   "while", "case","static","do",'\0'};

    char*  c_keyword[] = {"while", "case","static","do",0};

    char*  c_keyword[] = {"while", "case","static","do",NULL};

     

     

     

    6、当多维数组当做函数参数的话的时候会退化为指针

    退化原因的本质是因为程序员眼中的二维内存,在物理内存上是线性存储

    //总结:函数调用的时候,把数组首地址和有效数据长度传给被调用函数才是最正确的做法

    一维数组做函数参数退化过程

    //int a[10] -=-->int a[] ---->int *a

    //数组做函数形参的时候,如果在形参中定义int a[10]语句,

    //c/c++编译器会做优化,技术推演如下

    //int a[10] -=-->int a[] ---->int *a

     

    一维数组做函数参数退化过程

    char buf[10][30])—char buf[][30])----char (*buf)[30])

     

    int printfArray(char buf[10][30]);

    int printfArray(char buf[][30]);

    int printfArray(char (*buf)[30]);

    这三者效果是一样的,也就验证了数组做函数参数退化为指针

    第一种做法

    int printfArray(int a[])

    {

            int i = 0;

            printf("排序之前\n ");

            for (i=0; i<10; i++)

            {

                      printf("%d ", a[i]);

            }

            return 0;

    }

    第二种写法

    int printfArray04(int *a, int num)

    {

     

            int i = 0;

            printf("排序之前\n ");

            for (i=0; i<num; i++)

            {

                      printf("%d ", a[i]);

            }

            return 0;

    }                                                              

     

    1、 C语言中只会以机械式的值拷贝的方式传递参数(实参把值传给形参)

    int fun(char a[20], size_t b)
    {
       printf("%d\t%d",b,sizeof(a));
    }

    原因1:高效

    原因2
    C
    语言处理a[n]的时候,它没有办法知道n是几,它只知道&a[0]是多少,它的值作为参数传递进去了
    虽然c语言可以做到直接int fun(char a[20]),然后函数能得到20这个数字,但是,C没有这么做。

    2、二维数组参数同样存在退化的问题

    二维数组可以看做是一维数组

    二维数组中的每个元素是一维数组

    二维数组参数中第一维的参数可以省略

    void f(int a[5]) ====void f(int a[]); === void f(int* a);

    void g(int a[3][3])==== void g(int a[][3]); ==== void g(int (*a)[3]);

    3、等价关系

            

            数组参数                                              等效的指针参数

            

    一维数组 char a[30]                                  指针 char*

    指针数组 char *a[30]                               指针的指针 char **a

    二维数组 char a[10][30]                          数组的指针 char(*a)[30]

     

     

     

    7、数组操作基础以及中括号本质

    //c语言里面没有字符串这种类型。通过字符数组来模拟字符串

    //C风格字符串是以零结尾的字符串

    //操作数组的方法:下标法和指针法

     

    void main()

    {

            int i = 0;

            char *p = NULL;

            //通过字符串初始化字符数组并且追加\0

            char buf4[] = "abcd";       

            for (i=0; i<strlen(buf4); i++)

            {

                      printf("%c", buf4[i]); //p[]

            }       

            //[] *的本质到底是什么?

            //*p 是我们程序员手工的(显示)去利用间接赋值

            //[] 只不过是,c/c++编译器帮我们做了一个*p的操作。。。。。。

            // buf4[i]======> buf4[0+i] ====>  *(buf4+i)

            //===*(buf4+i)   --> bu4[i];

            printf("\n");

            p = buf4;

            for (i=0; i<strlen(buf4); i++)

            {

                      printf("%c", *(p+i)); //*p

            }

            system("pause");

    }

    void main12()

    {

            //字符数组初始化

            //指定长度如果定义的长度剩余部分补充0

            char buf1[100] = {'a', 'b', 'c'};

            //不指定长度

            char buf2[] = {'a', 'b', 'c'};

            char buf3[] = {'a', 'b', 'c','\0'};

            //通过字符串初始化字符数组并且追加\0

            char buf4[] = "abcd";

            printf("%s\n", buf4 );

            printf("sizeof(buf4): %d\n ", sizeof(buf4));

    //注意sizeof是对数据类型进行大小测量也就是数组类型包括了\0

            printf("strlen(buf4): %d \n", strlen(buf4));//strlen是求字符串的长度不包括\0

     

            system("pause");

    }

    展开全文
  • 数组名作为函数参数(1)

    千次阅读 2014-11-11 17:32:23
    9.5.4 数组名作为函数参数(1) 在前面章节介绍函数时,曾介绍过用数组名作函数的实参和形参的情况。在学习指针变量之后,可以从指针角度对这种参数的传递进行理解。 数组名就是数组的首地址,当实参向形参...

    9.5.4  数组名作为函数的参数(1)

    在前面章节介绍函数时,曾介绍过用数组名作函数的实参和形参的情况。在学习指针变量之后,可以从指针角度对这种参数的传递进行理解。

    数组名就是数组的首地址,当实参向形参传送数组名时,实际上就是传送数组的地址,形参得到该地址后就与主调函数中的实参指向同一数组。这样,在被调函数中对数组元素的值进行修改返回主调函数后,通过实参同样可以访问到。这就解决了C函数只能使用return语句返回一个值的问题。当函数需要返回多个值给主调函数时,可使用数组作为函数的形参。

    同样,指针变量的值也是地址。在调用形参为数组的函数时,也可将指针作为实参传递给函数。

    1.一维数组作参数

    当向函数传递一维数组作实参时,只需要将数组名填入函数的形参部分即可。例如,编写一个函数,用于向屏幕中显示一个字符串。

    【程序9-15】

     
    1. #include <stdio.h>  //头文件  
    2. #include <stdlib.h> 
    3.  
    4. int main()  
    5. {  
    6.     void puts1(char s[]);  
    7.     char s1[]="Hello,C Programer!";  
    8.  
    9.     puts1(s1);      //输出字符串  
    10.     putchar('\n');  //输出换行符  
    11.  
    12.     system("pause");  
    13.     return 0;  
    14. }  
    15.  
    16. void puts1(char *s) //自定义函数  
    17. {  
    18.      for(i=0;s[i]!='\0';i++)  
    19.          putchar(*s++);  

    编译执行这段程序,得到如下结果,如图9-30所示。

     
    图9-30  执行结果

    在该程序中,编写自定义函数puts1(),用来输出一个字符串。在puts1()函数的定义部分,定义了该函数的形参为一个一维数组,该一维数组中保存着一个字符串。在函数中使用putchar()库函数逐个输出数组中的字符,直到字符串结束为止。字符串的最后一个字符为'\0',所以第14行的循环以s[i]!='\0'作为条件。

    在main()函数中,调用puts()函数,将字符数组名s1作为实参传给函数,参数的传递过程相当于一个赋值语句

     
    1. s=s1

    即将main()函数中的数组名s1(数组的首地址)传给形参中的数组名s。前面介绍过,数组名是一个指针常量,不允许修改其值。在C语言中,当函数的形参设置为数组时,C编译器会将其转换为指针。例如,本例中函数puts1()的函数头中将形参定义为数组s,实质是函数头与以下形式等价:

     
    1. void puts1(char *s) 

    为了检验这种情况,可将函数puts1()代码改写为以下形式:

     
    1. void puts1(char s[])  
    2. {  
    3.      for(;*s!='\0';)  
    4.          putchar(*s++);  

    在函数头部分,形参仍然采用数组形式,但在函数体的代码中,即可以使用s++来修改数组首地址,逐个输出其值。如果数组s不是函数的形参,而是函数内部定义的数组,则不允许使用这种方式。

    其实,在C语言程序设计中,程序员更喜欢用指针方式编写这类程序。例如,将puts1()函数改写为以下形式,应该更易读易懂。

     
    1. void puts1(char *s)  
    2. {  
    3.      while(*s!='\0')  
    4.          putchar(*s++);  

    而表达式*s!= '\0'更可以精简为*s,因为当*s的值为'\0'时,表达式的值也就为0,循环结束;当*s的值不为0时,循环继续执行。在C语言中,类似这样的比较运算都可简写,省去关系表达式运算的环节,可提高程序的效率,同时使程序更简洁。修改后的程序如下:

     
    1. void puts1(char *s)  
    2. {  
    3.      while(*s)  putchar(*s++);  

    修改后的函数与程序9-15中函数完成相同的功能,main()函数不需要进行任何修改,即可得到同样的结果。

    2.二维数组作参数

    一维数组作为参数时比较简单,上面的例子演示了其使用方法。在使用一维数组作为参数时,也可使用指针的方式访问数组中的数据。

    也可根据需要向函数传递二维数组作为实参,有两种方法:一是使用指向数组元素的指针变量,其本质就是将二维数组作为一维数组来使用;二是使用指向一维(行)数组的指针变量。

    下面的程序演示使用指向一维数组的指针变量传递参数的形式。该程序让用户输入一个矩阵,然后计算矩阵对角线数据之和。

    【程序9-16】

     
    1. #include <stdio.h>  //头文件  
    2. #include <stdlib.h> 
    3.  
    4. #define M 4  
    5.  
    6. void read(int a[][M],int n);  
    7. int sum(int a[][M],int n);  
    8.  
    9. int main()  
    10. {  
    11.     int a[M][M];  
    12.  
    13.     read(a,M);  
    14.     printf("矩阵对角线元素之和为:%d\n",sum(a,M));  
    15.  
    16.     system("pause");  
    17.     return 0;  
    18. }  
    19.  
    20. void read(int a[][M],int n)  
    21. {  
    22.      int i,j;  
    23.      for(i=0;i<n;i++)  
    24.      {  
    25.          printf("请输入矩阵第%d行的%d个数据:",i+1,n);  
    26.          for(j=0;j<n;j++)  
    27.              scanf("%d",&a[i][j]);  
    28.       }  
    29. }  
    30.  
    31. int sum(int a[][M],int n)  
    32. {  
    33.      int i,s=0;  
    34.      for(i=0;i<n;i++)  
    35.          s+=a[i][i];  
    36.      return s;  
    37.  } 

    展开全文
  • 若用数组名作为函数调用时的实参,则实际上传递给形参的是数组首地址。数组首地址数组第一个元素的地址。数组名字本身就是一个指针,它是一个指针常量,指向的地址不变。比如定义了一个数组变量,编译器就会在内存中...

    若用数组名作为函数调用时的实参,则实际上传递给形参的是数组首地址。

    数组首地址数组第一个元素的地址。数组名字本身就是一个指针,它是一个指针常量,指向的地址不变。

    比如定义了一个数组变量,编译器就会在内存中划分了一块地址空间给它,数组名这个指针常量就指向了这块内存空间的首地址,而数组首元素就存在这段内存空间的首地址处,即这段内存空间的首地址跟数组首元素的内存地址是一样的。

    09f5610d0b416e60d98ebc2d36514bb0.png

    扩展资料:

    形参的作用是实现主调函数与被调函数之间的联系,通常将函数所处理的数据,影响函数功能的因素或者函数处理的结果作为形参。

    没有形参的函数在形参表的位置应该写void.main 函数也可以有形参和返回值,其形参也称为命令行参数,由操作系统在启动程序时初始化,其返回值传递给操作系统。

    两者关系:

    在一般传值调用的机制中只能把实参传送给形参,而不能把形参的值反向地传送给实参。因此在函数调用过程中,形参值发生改变,而实参中的值不会变化。而在引用调用的机制当中是将实参引用的地址传递给了形参,所以任何发生在形参上的改变实际上也发生在实参变量上。

    展开全文
  • 1 数组作为参数 我们可以将数组作为参数,传入到函数中,其实就...就是用数组作为函数参数; 又如, [java] view plain copy public class ArrayPar { public static void printArray(int []
  • 数组作为函数参数使用方法总结

    千次阅读 2019-10-24 22:07:43
    C/C++数组作为函数参数使用方法总结 一维数组作为函数参数的三种方法方法1:形参与实参都用数组方法2:形参与实参都用对应数组的指针; 方法3:实参用数组名,形参用引用; 二维数组作为函数参数的四种方法...
  • 引入数组就不需要在程序中定义大量的变量,大大减少程序中变量的数量,使程序精炼,而且数组含义清楚,使用方便,明确地反映了数据间的联系。许多好的算法都与数组有关。熟练地利用数组,可以大大地提高编程和解题的...
  • 1. 二维数组的存储方式及访问方式 二维数组中元素按行存储,所以利用数组下标对元素进行访问时,需要知道数组的列数。 例如: 定义二维数组 int graph[7][7],当需要访问数组元素graph[3]...2. 二维数组作为函数参数
  • 数组作为函数参数

    千次阅读 2018-02-03 21:57:55
    数组作为函数参数 数组元素的作用与变量相当,一般来说,凡是变量可以出现的地方,都可以用数组元素代替。因此,数组元素也可以用作函数实参,其用法与变量相同,向形参传递数组元素的值。此外,数组名也可以作实参...
  • 栈上分配的数组和堆上分配的数组在内存排列上可能不相同,直接定义数组是存储在程序的堆栈区,数据占用连续的区间;而动态申请的数组是在系统的远堆上(far heap),除最后一维的元素是连续存放的外,其他维上的...
  • C语言二维数组作为函数参数传递

    万次阅读 多人点赞 2018-06-07 21:43:37
    二维数组作为函数参数,实参可以直接使用二维数组名,在被调用函数中可以定义形参所有维数的大小,也可以省略以为大小的说明。例如: void find(char a[3][10]); void find (char a[ ][10]); 也可以使用数组...
  • C 语言不允许返回一个完整的数组作为函数参数。但是,您可以通过指定不带索引的数组名来返回一个指向数组的指针。 如果您想要从函数返回一个一维数组,您必须声明一个返回指针的函数,如下: int *myFunction(void...
  • 如果想通过一个一维数组作为函数参数,就必须声明函数形式参数,使用以下三种方式与所有三个声明方法之一产生类似的结果,因为每一种方式告诉编译器,一个整数指针将会要被接收。类似的方式,可以使用多维数组形式...
  • matlab定义数组和相关函数

    万次阅读 2019-11-04 19:44:50
    在matlab中对数组的定义较为灵活,因为特殊矩阵较多,所以有许多特定的定义方法。比较常见的有三种: 普通数组定义:用和C语言类似的定义方法,用分号隔开每行数据。 全零数组定义:zeros(x,y),x代表行数,y...
  • 二维数组作为参数函数定义及调用方法 Geophoenix C语言编程的过程中,不可避免的会碰到二维或二维以上的数组作为函数的形参的情况,在以前的编程过程中,习惯了动态数组的应用,很是使用直接定义高维数组。...
  • 第二种实现形式——形参是指针,实参是数组名: #include  void maxminvalue(int *b, int n);/*propotypes*/ int max, min; void main() {  int i, a[] = {21,34,11,45,89,26,87,39,63,50}, n;  n...
  • 主要给大家介绍了关于C语言中二维数组作为函数参数来传递的三种方法,文中通过示例代码介绍的非常详细,对大家学习或者使用C语言有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • iOS基础知识:数组作为函数参数

    千次阅读 2015-11-04 19:56:47
    数组作为函数参数:  1.定义语法:   返回值类型  函数名(类型 数组名[]){     函数体;  } 例如: void array(int str[]){ str[0]=10; str[1]=20; }     注意:参数数组名中括号的长度,可
  • 数组作为函数参数传递

    万次阅读 2018-03-08 20:34:51
    由于数组不能复制,所以无法编写使用数组类型形参的函数,因为数组会被自动转化为指针。 一、一维数组 1.三种定义形式: &nbsp; [cpp] view plain copy print?void&nbsp;printvalues(int...
  • 用VC6.0的MFC编程,一直对结构体作为函数参数的问题比较头疼,一直回避,今天又遇到了,于是查找资料解决一下心头的疑问,一直用指针来处理结构体,所以对于函数的形参也用指向结构体的指针来传递。 完成目的:初始...
  • array_values() 定义和用法 array_keys() 函数返回包含数组中所有键的一个新数组。 如果提供了第二个参数,则只返回键值为该值的键。 如果 strict 参数指定为 true,则 PHP 会使用全等比较 (===) 来严格检查键值...
  • 文章目录一:数组元素作为函数的实参二:数组名作为函数的实参关于数组作为函数参数调用的讨论关于函数定义的参数表的讨论获取二维数组的行和列更高维数组作为函数参数同二维数组类似参考文档 一:数组元素作为函数...
  • 数组名,指针变量作函数参数的四种情况 2016年10月02日 13:43:49 阅读数:2154 函数的参数可以是变量,也可以是数组。当整个数组作为函数的参数时,实际上是数组的地址作为参数。由于实参可以是表达式,数组元素...
  • 理解:定义了一个数组,而它的每个元素的类型是一个指向字符/字符串的指针。 元素表示:char *a[i] char *(a[i])是一样的,因为[]优先级高于* 思考:是否可以这样理解 (char*)arr[4]? 深入理解: 数组...
  • C/C++中数组名作为函数形参

    千次阅读 2014-05-26 15:34:29
    在C或者C++中求一个数组的大小的方法为sizeof(数组名) / sizeof(数组的第一个元素),对于int array[ ] = {1, 2, 3, 4, 5};数组的大小也就为sizeof(array) / sizeof(array[0])。但是对于如下程序,输出结果会怎么样...
  • 指针 与 数组 ( 指针 | 数组 | 指针运算 | 数组访问方式 | 字符串 | 指针数组 | 数组指针 | 多维数组 | 多维指针 | 数组参数 | 函数指针 | 复杂指针解读)
  • c++中数组作为参数传入函数

    万次阅读 多人点赞 2019-04-15 19:23:38
    1.我们除了要将数组名传入函数外,为了规范化,我们还要将数组的大小也要作为参数传入,而不是在函数内部去定义大小。即下面这种形式: int sum_arr (int att[] , int size) 2.我们学习c的时候知道数组...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 628,858
精华内容 251,543
关键字:

数组名做函数参数的定义方法