精华内容
下载资源
问答
  • 指针数组在函数传递里的用法,一定指针数组名做实参,指针数组名形参么,还是可以实参指针,形参指针
  • 数组名和指针作为形参

    千次阅读 2014-09-15 15:43:04
    由于数组名代表的是数组的地址,所以用数组名做参数的时候,其实是进行一个地址传递,会改变整个数组的值,所以①式也可以等价于: f(int *arr,int n) 2.多维数组名作为函数的参数 在用指针变量做形参以...

    1.用数组名做函数参数

    f(int arr[],int n)①

    调用时采用:f(arr,10)

    由于数组名代表的是数组的地址,所以用数组名做参数的时候,其实是进行一个地址传递,会改变整个数组的值,所以①式也可以等价于:

    f(int *arr,int n)



    2.多维数组名作为函数的参数

    在用指针变量做形参以接受实参数组名传递的地址时,有两种方法:

    ①采用和一维数组相同的方法,本质上把多维数组当做一维数组来用

    ②用指向一维数组的指针变量

    下面一个例子来表示:


    #include "stdio.h"
    #define M 4
    #define N 4
    void rectmul(int (*p)[4],int (*q)[4],int m,int n);
    void main()
    {
     int a[M][N]={{1,2,3,4},{5,6,7,8},{4,3,2,1},{8,7,6,5}};
     int b[M][N]={{1,1,1,1},{2,2,2,2},{3,3,3,3},{4,4,4,4}};
     
     rectmul(a,b,M,N);
    }
    void rectmul(int (*p)[4],int (*q)[4],int m,int n)
    {
     int i,j,k,s,r,num=0;
     int sum=0;
     for (i=0;i<m;i++)
     {
      for (j=0;j<n;j++)
      {
       
       for (s=0,r=0;s<n,r<m;s++,r++)
       {
        sum=sum+(p[i][s])*(q[r][j]);
       }
       
                printf("%d ",sum);
       num++;
       if (num%4==0)
       {
        printf("\n");
       }
       sum=0;
      }
     }
    }

     

    PS:(*p)[4]与*p[4]的区别

    前者是表示:指向一个一维数组的指针,代表了这个指针指向的是一个数组,且这个数组的大小是4

    后者是表示:一个指针数组。

     

    在函数体内,可以直接用p[][]来表示数组中的元素,这是因为

    p[i][j]=*(p[i]+j)=*(*(p+i)+j)

    展开全文
  • 可以用二维数组名作为实参或者形参,在被调用函数中对形参数组定义时可以可以指定所有维数的大小,也可以省略第一维的大小说明,如:  void Func(int array[3][10]);  void Func(int array[][10]);  二者都...
    可以用二维数组名作为实参或者形参,在被调用函数中对形参数组定义时可以可以指定所有维数的大小,也可以省略第一维的大小说明,如:

        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);

      其实多维数组和二维数组原理是一样的,大家可以自己扩充的多维数组,这里不再赘述。

    展开全文
  • C++数组名

    2019-07-22 20:54:47
    (2)数组名有时可以转换为指向该数组的指针常量 (3)数组名可能失去其数据结构内涵 ,数组名作为函数形参时,全面沦落为一个普通指针! (4) 指向数组的指针则另外一种变量类型,仅仅意味着数组的存放地址(数组的...


    原文:https://www.cnblogs.com/fenghuan/p/4775023.html

    1.概述

    (1)数组名的内涵在于数组名指代一种数据结构:数组
    (2)数组名有时可以转换为指向该数组的指针常量
    (3)数组名可能失去其数据结构内涵 ,数组名作为函数形参时,全面沦落为一个普通指针
    (4) 指向数组的指针则是另外一种变量类型,仅仅意味着数组的存放地址(数组的地址就是第一个元素的地址)!

    2.数组名的内涵:数组

    #include <iostream>
    using namespace std;
    int main()
    {
    	char str[10];
    	char* pStr = str;
    	cout << "sizeof(str): \t" << sizeof(str) << endl;
    	cout << "sizeof(pStr): \t" << sizeof(pStr) << endl;
    	system("pause");
    	return 0;
    }
    


    说明:数组名str的内涵为一种数据结构,即一个长度为10的char型数组,所以sizeof(str)的结果为这个数据结构占据的内存大小:10字节。

    3.数组名可转换为指针常量

    数组名可以转换为指向其指代实体的指针,但它只能被看作一个指针常量,不能被修改。

    #include<iostream>
    using namespace std;
    int main()
    {
    	int arr_int[10];
    	for (int i = 0; i < 9; i++) { arr_int[i] = i; }
    
    	//数组名的可转换为指向其指代实体的指针(指针常量),即指向数组的指针
    	cout << "arr_int: " << arr_int << endl;
    
    	//取一个数组名的地址所产生的是一个指向数组的指针(相当于取数组存放的地址)
    	cout << "&arr_int: " << &arr_int << endl;
    
        cout << "&(arr_int[0]): " << &(arr_int[0]) << endl;//证明数组的地址即为第一个元素的地址
    	cout << "&(arr_int[1]): " << &(arr_int[1]) << endl;
    	system("pause");
    }
    
    

    在这里插入图片描述

    4.数组名作为函数形参时,相当于普通指针

    #include <iostream>
    using namespace std;
    void arrayTest(char str[])//数组名做参数,不能改为char* str
    {
    	cout << "sizeof(str):" << sizeof(str) << endl;
    }
    int main()
    {
    	char str1[10] = "I love U.";
    	arrayTest(str1);
    }
    

    在这里插入图片描述

    展开全文
  • 数组形参

    2014-05-05 16:42:54
    实际上,这三种形式等价的,在使用数组做参数时,编译器会自动将数组名转换为指向数组第一个元素的指针,为什么呢?这要从参数的传递方式说起,参数有三种传递方式,按值传递,按指针传递,按引用传

    如何使用数组参数

    如果一个函数以一维数组为参数,我们可以这样声明这个函数

    void func(int* a) ;
    
    void func(int a[]) ;
    
    void func(int a[3]) ;

    实际上,这三种形式是等价的,在使用数组做参数时,编译器会自动将数组名转换为指向数组第一个元素的指针,为什么呢?这要从参数的传递方式说起,参数有三种传递方式,按值传递,按指针传递,按引用传递,分别如下

    void Test(int a) ;
    
    void Test(int* a) ;
    
    void Test(int& a) ;

    第一种方式传递的是a的一个副本

    第二种方式传递的是指向a的指针的一个副本

    第三种方式传递的是指向a的引用的一个副本

    既然都是副本,那么就存在拷贝到过程,但是,数组是不能直接拷贝的,也就是不能像下面这样

    int a[3] = {1, 2, 3} ;
    
    int b[](a) ;    // error
    
    int b[3] ;
    
    b = a ;            // error
    
    
    不能用一个数组初始化另一个数组,也不能将一个数组直接赋值给另外一个数组,如果想复制数组,唯一的办法就是逐个元素复制。
    
    int a[3] = {1, 2, 3} ;
    
    int b[3] ;
    
    for (int i = 0; i < 3; ++i)
    
    {
    
        b[i] = a[i] ;
    
    }
    

    既然数组不能拷贝,那么参数该如何传递呢?于是编译器就将数组名转换成了指向第一个元素的指针,指针是可以拷贝的。但是这也引发了另外一个问题。我们无法只通过数组名得知数组元素的个数。看下面的代码

    void Test(int a[3])
    
    {
    
        for (int i = 0; i < 5; ++i)
    
        {
    
            cout << a[i] << endl ;
    
        }
    
    }

    明明只传递了三个元素的数组,为什么输出5个元素?前面已经说了,数组被转换成了指向第一个元素的指针,所以上面的代码和下面的相同

    void Test(int* a) //我只知道a是个指针,跟本不知道a指向多少个元素
    
    {
    
        for (int i = 0; i < 5; ++i)
    
        {
    
            cout << a[i] << endl ;
    
        }
    
    }

    编译器根本不知奥数组a有多少个元素,它甚至不知道a是数组!如何解决呢,一种办法是再加一个参数,指定元素个数

    void Test(int* a, int n)
    
    {
    
        for (int i = 0; i < n; ++i)
    
        {
    
            cout << a[i] << endl ;
    
        }
    
    }

    另外一种办法是传递数组的引用,这才是本文的重点,唉,前面这么多废话:(

    void Test(int (&a)[3])
    
    {
    
        for (int i = 0; i < 3; ++i)
    
        {
    
            cout << a[i] << endl ;
    
        }
    
    }

    这样写数组a就不会被转换为指针了,而且有了元素个数的信息,调用的时候,也必须传递一个含有3个元素的数组

    int a[3] = {1, 2, 3} ;
    
    Test(a) ;    // ok
    
    int b[1] = {1} ;
    
    Test(b) ;    // error, can not convert parameter a from int[1] to int(&)[3]
    
    
    


    定义数组的引用:
            类型名 (&变量明)[N];
            
    实例:
            int int_array[10];
            int (&int_ref)[10] = int_array;
            这样就得到了一个数组的应用

            在函数的声明中用数组的引用定义,就不怕数组退化了。如下
            for_each( int (&int_ref)[10] )
            {
                     for( int i=0; i<10; ++i )
                             std::cout << int_ref[i] << std::endl;
             }

             int main( int argc, char* argv[] )
             {
                     int int_array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }
             
                     for_each( int_array );
                     return 0;
              }

              在上面的代码中,如果你传入不是10个元素的数组,是编译通不过的。代码的安全性提高了。 

    作者:zdd
    出处:http://www.cnblogs.com/graphics/
    本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利.
    展开全文
  • 数组名 a 的副本做形参可以改变数组 a 中元素的值<传递的地址> const 修饰 不允许改变数组元素的值 const 变量只可以在定义时被赋值,形参在本质上也如此,因为形参在函数被调用时才拥有自己的存储空间...
  • 数组名做实参——函数调用

    千次阅读 2019-03-28 20:54:31
    可以只有数组名这一个实参 由于数组名的值没有任何关于数组元素个数的信息,所以在使用数组名作为实参时, 通常还需要另外一个实参,就是这个数组元素的个数 例题:本题的主要目的演示如何通过函数...
  • 形参可以是数组名,也可以是指针变量,它们用来 接收实参传来的地址。如果形参是数组名,它代表 的是形参数组首元素的地址。 在调用函数时,将实 参数组首元素的地址传递给形参数组名。这样,实 参数组和形参数组就...
  • 数组名不是指针

    2021-02-21 20:55:02
    数组名通常可以隐式转换为指针,表示数组第一个元素的地址,常量,无法作为左值。 在自定义函数中,如果形参中有数组,那自定义函数中的数组名就“沦落”为指针,可以作为左值,使用sizeof()运算符、&运算符...
  • 数组名作为函数参数

    2019-05-09 21:20:54
    要确定一个一维数组需要知道什么信息?一个数组的首地址,另一个是数组的长度。这样就可以唯一的确定一个数组了,因为数组是连续存放的,只要知道...当数组名作为函数的实参时,形参列表中也应定义相应的数组(或...
  • 参考链接: 数组名作为函数参数 指针数组和数组指针,二维数组和二级指针作为...在下面的函数中,a作为数组名可以直接作为reverse的形参,如果在main函数中定义一个指针变量*p,让p = a,然后写reverse(p,9),结果也
  • 数组名与指针的不同

    2010-02-11 13:59:00
    第二是数组名作为形参时,数组名会被转成一个普通的指针,这是编译器的一种优化,因为我们用4字节指针可以解决的问题,不需要创建同原数组等大的数组来拷贝原数组的内容,只需要一个指针指向原数组的空间即可。...
  • 一、实参是一个已知行和列的二维数组时,实参传递直接是数组名形参接收可以是: 1.二维数组 void func1(int arr[10][10]); void func1(int arr[][10]);//必须指定列数 2.一维数组指针 void func2(int (*parr)[10...
  • 多维数组指针和函数形参

    千次阅读 2014-07-21 10:51:52
    如果为一维数组,数组大小可以不写,数组名形参中退化为指针 void foo(int a[]) { } 调用: int *p; int a[10]; p=a; void foo(p); void foo(a); 合理的 如果为二维数组,第一维可以不写,但第...
  • 数组名和指针

    2012-03-20 23:20:17
    数组名不是指针,数组名可以理解为一个地址常量,比如:int a=1; 其中1一个常量,a一个变量。而数组就相当于这里的1;所以数组名是不能像指针一样进行++之类操作的。 如果一个函数以数组作为形参时如:void ...
  • 数组名、指针区别

    2013-08-05 21:58:00
    1)数组名指代的实体一种数据结构,这种数据结构就是数组。如int a[10]相当于int[10] a, aint[10]数据结构...2)数组名可以转换成指针。 3)作为函数形参数组名就是指针。 转载于:https://www.cnblogs.com/y...
  • 4.当函数形参使用数组名是,其会被转换成一个单纯的指针。 以下证明上面四点的论据: 1. 首先数组名不是指针,这很容易证明。 #include <string.h> #include <stdio.h> int main() { ...
  • 数组

    2016-12-01 19:50:18
    数组名作为函数参数时传递给形参是数组的指针,而且在子函数中无法用 sizeof 取得 数组的大小,所以有需要时可以用另一个参数传递数组的大小。数组作为形参可以写成 int  f(int a[]) 或者 ...
  • C++数组形参

    2013-07-31 12:59:08
    在学习过程中遇到以下问题: Access Violation :非法访问 ...由于数组名代表的是数组的地址,所以用数组名做参数的时候,其实是进行一个地址传递,会改变整个数组的值,所以①式也可以等价于: f(int *arr,in
  • 在 C 中,当二维数组作为实参向形参传递时,会自动...而在 C++ 中,我们可以巧用模板来推导二维数组的类型(可以自动确定二维数组的维度长度),这样我们就可以做到直接使用二维数组名传参的函数,这样的话,尽管
  • 数组名也可以作实参和形参,传递的是数组的起始地址。 用数组元素作函数实参 由于实参可以是表达式,而数组元素可以是表达式的组成部分,因此数组元素当然可以作为函数的实参,与用变量作实参一样,将数组元素的...
  • (2)数组名的外延在于其可以转换为指向其指代实体的指针,而且一个指针常量;(3)指向数组的指针则另外一种变量类型(在WIN32平台下,长度为4),仅仅意味着数组的存放地址(4)数组名作为函数形参时,在函数体内,...
  • 2、数组名可以隐式转换为指向数组实体的指针,而且一个指针变量 3、指向数组的指针则一种变量类型,意味着数组的存放首地址 4、数据名作为函数形参时,其全面沦落为一个普通指针,失去其常量性 解释如下: 1...
  • 除了可以用数组元素作为函数参数外,还可以数组名作为函数参数(包括实参和形参)应当注意的是:用数组元素作为实参时传递的是数组元素的值,而用数组名作为函数的实参,向形参(函数名或指针变量)传递的是数组首...
  • 函数的参数可以是变量,也可以是数组。当整个数组作为函数的参数时,实际上是数组的地址作为参数。由于实参可以是表达式,数组元素也可以是表达式的一部分,因此,数组元素可以作为函数的实参,这时对应的形参应该是...
  • 二维数组形参

    2015-07-15 11:46:45
    可以用二维数组名作为实参或者形参,在被调用函数中对形参数组定义时可以可以指 定所有维数的大小,也可以省略第一维的大小说明,如:  void Func(int array[3][10]);  void Func(int array[][10]);  ...
  • Func ( char str[100] )函数中数组名作为函数形参时,在函数体内,数组名失去了本身的内涵,仅仅只是一个指针;在失去其内涵的同时,它还失去了其常量特性,可以作自增、自减等操作,可以被修改。  数组...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 792
精华内容 316
关键字:

形参可以是数组名