精华内容
下载资源
问答
  • 函数指针、函数名、二维数组指针形参时的要注意的地方
  • 数组指针作为形参传递

    千次阅读 2019-04-17 00:02:59
    数组作为函数形参时,数组的地址可以用做函数调用的实参。 可以通过数组地址的传递,在函数内可以对该数组进行访问和修改。 eg: #include <stdio.h> #define SIZE 10 /* 形式1 */ void func_1(const char ...

    原文链接:https://blog.csdn.net/yhl_jxy/article/details/77145439

    当数组作为函数形参时,数组的地址可以用做函数调用的实参。

    可以通过数组地址的传递,在函数内可以对该数组进行访问和修改。

    eg:

    #include <stdio.h>
    #define SIZE 10
     
    /* 形式1 */
    void func_1(const char a[SIZE]) {
        printf("获取数组的第一个元素=%c\n", a[0]);
        printf("char a[SIZE]: %d\n", sizeof(a));/* 输出形参的字节长度 */
    }
     
    void func_2(const char a[10000]) {/* 数组容量是否符合,不影响形参传递 */
        printf("获取数组的第一个元素=%c\n", a[0]);
        printf("char a[10000]: %d\n", sizeof(a));/* 输出形参的字节长度 */
    }
    /* 形式2 */
    void func_3(const char a[]) {
        printf("获取数组的第一个元素=%c\n", a[0]);
        printf("char a[]: %d\n", sizeof(a));/* 输出形参的字节长度 */
    }
    /* 形式3 */
    void func_4(const char * a) {
        printf("获取数组的第一个元素=%c\n", a[0]);
        printf("char * a: %d\n", sizeof(a));/* 输出形参的字节长度 */
    }
     
    /*
        测试数组的形参传递:
        以上三种形式传递一位数组形参,对于编译器来说,
        最后都处理为char型指针,实质上都是一样的。
        写成形式1可以提高程序的可读性。
     */
    int main(void){
        char a_char[SIZE] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'};
        char * p_char = a_char;
     
        /* 函数调用 */
        func_1(a_char);
        func_2(p_char);
        func_3(a_char);
        func_4(p_char);
    }
    

    运行结果:
    在这里插入图片描述

    以上还只是访问,如果想在函数里面修改数组,或者指针指向的内容时,需要去掉c++中的·const限制,如下:

    #include <stdio.h>
    #define SIZE 10
    
    /* 形式1 */
    void func_1(char a[SIZE]) {
    	printf("获取数组的第一个元素=%c\n", a[0]);
    	a[0] = 'c';
    	printf("char a[SIZE]: %d\n", sizeof(a));/* 输出形参的字节长度 */
    }
    
    void func_2(char a[10000]) {/* 数组容量是否符合,不影响形参传递 */
    	printf("获取数组的第一个元素=%c\n", a[0]);
    	a[0] = 'l';
    	printf("char a[10000]: %d\n", sizeof(a));/* 输出形参的字节长度 */
    }
    /* 形式2 */
    void func_3(const char a[]) {
    	printf("获取数组的第一个元素=%c\n", a[0]);
    	printf("char a[]: %d\n", sizeof(a));/* 输出形参的字节长度 */
    }
    /* 形式3 */
    void func_4(const char * a) {
    	printf("获取数组的第一个元素=%c\n", a[0]);
    	printf("char * a: %d\n", sizeof(a));/* 输出形参的字节长度 */
    }
    
    /*
    测试数组的形参传递:
    以上三种形式传递一位数组形参,对于编译器来说,
    最后都处理为char型指针,实质上都是一样的。
    写成形式1可以提高程序的可读性。
    */
    int main(void) {
    	char a_char[SIZE] = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j' };
    	a_char[0] = 'z';
    	char * p_char = a_char;
    
    	/* 函数调用 */
    	func_1(a_char);
    	func_2(p_char);
    	func_3(a_char);
    	func_4(p_char);
    
    }
    

    运行结果:
    在这里插入图片描述
    上面的例子中,其实你还以随意组合指针与数组作为参数传递,只要等级一样,都可以正常运行。比如:

    func_1(p_char);
    func_2(p_char);
    func_3(p_char);
    func_4(p_char);
    

    在此,我还想奉上几句话,或者几个案例,以便加深理解。如下:




    关于C语言中函数传入指针来修改指针指向的内容的问题

    以前自己的理解是如果想让函数修改传入变量的值,就是要给函数传入指向这个变量的指针的。
    但是我在递归创建二叉树的时候,定义结构体时已经有了结构体指针,教程里写的是给创建函数传入了指向这个结构体指针的指针,为什么这里要传入二级指针呢?按照我以前的理解,传入结构体指针就可以改变结构体的值了。

    如果只是要改变指针指向的值, 那么传入结构体指针即可。
    传入二级指针,一般是要在函数内分配内存, 也就是改变指针本身的指向。
    比如 struct A *p; 函数参数设置为struct A **q; 传入&p
    在函数中有类似于*q=xxxx;这样的调用的情况。
    追问
    也就是说,如果只是要改变指针指向的值,用一级指针即可,如果要改变它指向的地址,就比如二叉树的创建过程中生成新结点的过程,就是要用二级指针了是吧?
    追答
    是的。 
    更扩展来说, 要在函数中,通过参数传回类型为T的值, 那么就要用T*来做参数。 
    如果T是int, 那么参数int*
    如果T是int *, 那么参数是int**
    如果T是int **, 那么参数就是int ***
    。。。
    



    c++,函数里形参是指针,在函数里改变指针所指向的地址时,主函数里实参地址是不会改变的,那如果我想改变它该怎么办

    例如:

    void ff(Bitnode *x,Bitnode *bt)
    {
    x=bt;
    }
    int main
    {
    myclass b;//maclass 是我自己写的一个类
    
    myclass *c;
    
    ff(c,&b);
    
    }
    

    这样写的话主函数里的c指针地址不会变

    网友1:
    把指针的地址传过去

    void ff(Bitnode **x,Bitnode *bt)
    {
    *x=bt;
    }
    int main
    {
    myclass b;//maclass 是我自己写的一个类
    myclass *c;
    ff(&c,&b);
    }
    

    网友2:
    楼主你好
    用c++的引用吧
    void ff(Bitnode *&x,Bitnode *bt)//改成引用
    {
    x=bt;
    }
    希望能帮助你哈

    网友3:
    用二级指针,将函数改为下面的形式:

    void ff(Bitnode **x,Bitnode *bt)
    {
    *x=bt;
    }
    

    调用时用ff(&c,&b);

    网友4:
    用二级指针 **c; 传参数的时候传*c就好了

    网友5:
    引用传递的是内存的别名,引用不占用内存 ,指针传递的是某一块内存的地址,而指针本身也是需要内存存储的 ,所以如果你想在函数里改变内存的内容传递内存的引用就行了




    关于C语言数组作为函数的实参和形参的问题
    关于C语言数组作为函数的实参和形参的问题如图,我将数组mark全部赋值,然后将它的值传递给函数的形参。程序没有问题,但我的问题是:函数的实参是mark?mark不是首地址吗,它是如何把所有10个元素的值赋给形参score[10]的?然后还有一个问题,形参是一个数组我该怎么理解?相当于定义这个函数中有10个没有值的参数等待赋值?

    在这里插入图片描述
    网友1:
    个人觉得, 形参和实参这种叫法让人摸不着头脑
    调用子函数时实际上是把数组的首地址传递给子函数, 子函数中的参数score这个变量得到这个地址, 就这么简单

    网友2:
    函数传递数组的话,其实传递收地地址就好,把数组首地址传给函数的形参(这个形参务必定义为对应类型的指针),形参可以以指针的形式访问数组的内容,也可以直接用数组的方式访问

    网友3:
    你可以把数组形参改成指针形参试试

    更多请参考:
    https://blog.csdn.net/yhl_jxy/article/details/77145439
    https://www.cnblogs.com/qquan/articles/4940043.html
    https://www.cnblogs.com/li-peng/p/4116349.html

    展开全文
  • 数组指针作为函数形参时,能作为函数实参的是二维数组,数组指针 c.当二维数组作为函数形参时,能作为函数实参的是二维数组,数组指针 d.当指针数组作为函数形参时,能作为函数实参的是指针数组,二级指针,一级...

    1、传参规则:

    a.当二级指针作为函数形参时,能作为函数实参的是二级指针,指针数组,一级指针的地址
    b.当数组指针作为函数形参时,能作为函数实参的是二维数组,数组指针
    c.当二维数组作为函数形参时,能作为函数实参的是二维数组,数组指针
    d.当指针数组作为函数形参时,能作为函数实参的是指针数组,二级指针,一级指针的地址

    2、实例验证:

    #include <stdio.h>
    #include <stdlib.h>
    
    void fun1(int **pp)
    {
        printf("fun1\n");
    }
    void fun2(int(*a_p)[5])
    {
        printf("fun2\n");
    }
    void fun3(int t_d_a[][5])
    {
        printf("fun3\n");
    }
    void fun4(int *p_a[5])
    {
        printf("fun4\n");
    }
    
    int main()
    {
        int *p_a[5];          //指针数组
        int **pp = NULL;      //二级指针
        int *p = NULL;        //一级指针
        int t_d_a[5][5];      //二维数组
        int a[5];             //一维数组
        int(*a_p)[5] = &a;    //数组指针
    
        fun1(p_a);
        fun1(pp);
        fun1(&p);
        //fun1(t_d_a);
        //fun1(a_p);
        printf("\n");
    
        //fun2(p_a);
        //fun2(pp);
        //fun2(&p);
        fun2(t_d_a);
        fun2(a_p);
        printf("\n");
    
        //fun3(p_a);
        //fun3(pp);
        //fun3(&p);
        fun3(t_d_a);
        fun3(a_p);
        printf("\n");
    
        fun4(p_a);
        fun4(pp);
        fun4(&p);
        //fun4(t_d_a);
        //fun4(a_p);
        printf("\n");
    
        system("pause");
        return 0;
    }

    以上代码我放开注释的任意一条语句,都会报错为形参与实参的类型不兼容。
    PS:调试环境为vs2013

    展开全文
  • 2.c++形参传入数组指针时,需要传入数组的长度 #include <iostream> using namespace std; int* getSortedArray(int *array,int length);//函数声明,排序后返回数组 bool sortedOK(int *array,int length);//...

    1.c++不能返回具体的数组,只能返回数组的首地址
    2.c++形参传入数组指针时,需要传入数组的长度

    #include <iostream>
    using namespace std;
    int* getSortedArray(int *array,int length);//函数声明,排序后返回数组
    bool sortedOK(int *array,int length);//检查数组是否完成排序
    int main(){
        int array[]={2,8,6,9,3};//声明并赋值    
        getSortedArray(array,5);//排序,从小到大排序    
        //循环打印出排好序的数组    
        for(int i=0;i<sizeof(array)/sizeof(array[0]);i++)    
        {     
           cout <<array[i] <<endl;    
        }    
        return 0;
    }
    
    int* getSortedArray(int *array,int length)
    {    
        int length_array=sizeof(array)/sizeof(array[0]);    
        bool ok=false;        
        while(!ok)    
        {     
           for(int i=0;i<length-1;i++)        
           {       
                if(array[i]>array[i+1])            
                {           
                     int a=array[i];                
                     array[i]=array[i+1];                
                     array[i+1]=a;            
                 }        
            }        
            ok=sortedOK(array,5);    
        }        
        return array;
    }
    
    bool sortedOK(int *array,int length)
    {    
        for(int i=0;i<length-1;i++)    
        {    
            if(array[i]>array[i+1])        
            {            
                return false;        
            }    
        }    
        return true;
    }
    

    打印结果

    2
    3
    6
    8
    9
    
    展开全文
  • C语言中数组指针 作为形参

    千次阅读 2015-06-05 21:33:48
    在修改程序的过程中,看到两种将数组作为形参的方法,于是搜了一下,找了一下比较全面地介绍数组指针的文章。 先写下我遇到的两种方式: 方式1: void filter_c(long double *,long double *,float *,int);//函数...

    2015 0605

    在修改程序的过程中,看到两种将数组作为形参的方法,于是搜了一下,找了一下比较全面地介绍数组指针的文章。

    先写下我遇到的两种方式:

    方式1:

    void filter_c(long double *,long double *,float *,int);//函数声明

    filter_c(NAFF_b,NAFF_a,RealTimeSignal_filter,len_new);//函数应用

    void filter_c(long double b[ ],long double a[ ],float x[ ],int number)//函数定义

    {.............................}


    方式2:

    void select_sort(float *, int);//函数声明

    select_sort(Buff_Flow, MaxSize);//函数应用

    void select_sort(float *x, int n)//函数定义

    {..............................}


    原文地址:http://blog.sina.com.cn/s/blog_90832a850100wksp.html

    数组元素
        数组元素可以用作函数实参,但不能用作形参。因为形参是在函数被调用时临时分配存储单元的,不可能为一个数组元素单独分配存储单元。
    在用数组元素作函数实参时,把实参的值传给形参,是单向的“值传递”过程。
    数组名
    数组名作函数实参时,向形参(数组名或指针变量)传递的是数组首元素的地址。形参数组可以不指定大小,在定义数组时在数组后面跟一个空的方括号形参数组名实际上是一个指针变量,并不是真正的开辟一个数组空间。相应的,定义实参数组时必须要指定数组大小,因为要开辟相应的存储空间。
    例如:
    #include <stdio.h>
    int main()
    {
    void fun(int arr[],int n);
    void output_fun(int * arr,int n);
    int array[10];

    fun(array,10);
    output_fun(array,10);
    return 0;
    }
    void fun(int arr[],int n)
    {
    int i;
    for(i=0;i<n;i++)
    scanf_s("%d",&arr[i]);
    }
    void output_fun(int * arr,int n)
    {
    int i;
    for(i=0;i<n;i++,arr++)
    printf("%-2d",* arr);
    }
    //void fun(int arr[],int n)和void fun(int * arr,int n)等价。//这里就是程序中遇到的两种方式。
    指针与指针变量
    一个变量的地址称为该变量的指针。
    如果有一个变量是专门用来存放另一个变量的地址(即指针),则它称为指针变量。
    指针变量就是地址变量,指针变量的值就是地址。
    指针变量作为函数参数
    主调函数的实参是指针变量,在函数调用时,将实参变量的值传递给形参变量,这里依然是单向的值传递,但是传递的内容是实参的地址。这就与数组名的传递是一样的道理。
    不能通过执行调用函数来改变实参指针变量的值,但可以改变实参指针变量所指变量的值。
    归纳:数组名与指针变量
    (1)形参和实参都用数组名;
    (2)实参用数组名,形参用指针变量;
    (3)实参和形参都用指针变量;
    (4)实参为指针变量,形参用数组名。
    值得注意的是:如果用指针变量作为实参,必须先使指针变量有确定值,指向一个已定义的对象。
    数组元素的指针
    引用数组元素可以用下标法(如a[i]),也可以用指针法(如*(a+i)或*(p+i))。下面这几种写法等价,都是使指针变量p指向数组a的首地址。其中a为已定义的数组名。
    (1)int * p=&a[0];
    (2)int * p=a;
    (3)int * p;p=a;
    (4)int * p;p=&a[0];
    在指针指向数组元素时,可以对指针进行以下运算:
    加一个整数(+或+=);
    减一个整数(-或-=);
    自加运算;
    自减运算;
    两个指针相减,如p1-p2(只有p1和p2都指向同一数组中的元素时才有意义)。
    指针就是地址,两个指针相减可知道它们所指向元素的相对距离。地址不能相加,如p1+p2是无实际意义的。
    二维数组a[][]
    二维数组名(如a)是指向行的。因此a+1中的“1”代表一行中全部元素所占的字节数。
    一维数组名(如a[0],a[1])是指向列元素的。a[0]+1中的1代表一个a元素所占的字节数。
    在指向行的指针前面加一个*,就转换为指向列的指针。如,*a和*(a+1),分别指向a数组的0行0列的元素和1行0列的元素。
    在指向列的指针前面加&,就成为指向行的指针。如,a[0]指向的是0行0列元素的指针,在前面加一个&之后,由于a[0]与*(a+0)等价,因此&a[0]与&*a等价,也就是与a等价,它指向二维数组的0行。
    指向多维数组的指针变量
    (1)指向数组元素的指针变量
    举个例子,指向二维数组元素的指针变量
    #include <stdio.h>
    int main(void)
    {
    void input_output_array_fun(int *);
    int a[3][4];
    int * pointer;
    pointer=a[0]; //这里使指针变量pointer指向0行0列元素地址。
    input_output_array_fun(pointer);
    return 0;
    }
    void input_output_array_fun(int * p)
    {
    int i;
    for(i=0;i<12;i++)
    scanf_s("%d",p+i);
    for(i=0;i<12;i++)
    {
    printf("%-5d",*(p+i));
    if((i+1)%4==0)printf("\n");
    }//for
    }
    (2)指向由m个元素组成的一维数组的指针变量
    如int (* p)[4],p的类型是int(*)[4],p被定义为指向一维整型数组的指针变量,一维数组有4个元素,因此p的基类型是一维数组,其长度为16字节。
    #include <stdio.h>
    int main(void){
    void input_output_array_fun(int (* p) [4]);
    int a[3][4];
    int (* pointer)[4];
    pointer=a; //这里使指针变量pointer指向0行。
    input_output_array_fun(pointer);
    return 0;
    }
    void input_output_array_fun(int (* p)[4]){
    int i,j;
    for(i=0;i<3;i++)
    for(j=0;j<4;j++)
    scanf_s("%d",*(p+i)+j);
    for(i=0;i<3;i++)
    for(j=0;j<4;j++)
    {
    printf("%-5d",*(*(p+i)+j));
    if(j==3)printf("\n");
    }//for(i=0;)
    }
    通过指针引用字符串
    通过字符数组名或者字符指针变量可以输出一个字符串,而对一个数值型数组,是不能企图用数组名输出它的全部元素的,只能逐个输入。
    字符数组从键盘输入的时候调用gets_s()函数;
    数值型数组从键盘输入的时候调用scanf_s()函数。
    字符指针变量和字符数组的比较
    (1)字符指针变量中存放的是地址。字符数组由若干个元素组成,每个元素中存放一个字符。
    (2)可以对字符指针变量赋值。不能对字符数组名赋值。如:
    char *a;
    a="I care."; //合法
    char str[10];
    str="I care."; //非法
    str[0]="I";//合法。一旦字符数组没有在初始化时赋值,只能逐个赋值。
    (3)初始化。
    字符指针变量:
    char *a="I care.";
    等价于
    char *a;
    a="I care.";
    字符数组:
    char str[10]="I care."; //合法
    不等价于
    char str[10];
    str[]="I care.";//不能用赋值语句对字符数组中全部元素整体赋值。
    (4)字符指针变量在编译时,只分配一个存储单元(用来存放字符串的起始地址)。字符数组在编译时会分配若干存储单元,以存放各元素的值。
    (5)指针变量的值是可以改变的。数组名代表一个固定的值(数组首元素的地址),不可改变。
    (6)字符指针变量所指向的字符常量中的内容是不可以被取代的(不能对它们再赋值),字符数组中各元素的值是可以改变的。如:
    char a[]="you.";
    char *b="you.";
    a[1]='a'; //合法
    b[1]='a'; //非法
    (7)引用数组元素时,字符数组可以用下标法引用一个数组元素(如a[2]),也可以用地址法(如*(a+2)引用数组元素a[2])。如果定义了字符指针变量p,并使它指向了数组a的首元素,则可以用指针变量带下标的形式引用数组元素(如p[5]),同样可以用地址法(如*(p+5))引用数组元素a[5]。
    (8)用指针变量指向一个格式字符串,能轻松实现可变格式输出函数。如:
    char *p;
    p="a=%d,b=%f\n";
    printf(p,a,b);
    相当于
    printf("a=%d,b=%f\n",a,b);
    使用字符数组也能达到这一目的,但只能在定义数组时初始化或逐个对元素赋值的方法。显然指针变量指向字符串的方式更为方便。

    展开全文
  • C语言—W10 用数组指针作为形参实参,对数组元素进行操作 我们以最简单的对数组元素的大小进行排列为例: #include <stdio.h> #include <stdlib.h>//函数srand、rand的头文件 #include <time.h>//...
  • #include "stdafx.h" void cmdsend(unsigned int * info); int main() { unsigned int senddata[5];...如上面程序所示,我想将数组sendata完整的输出,现在只能打印出8,2....在使用 *info 指针作为形参的前提下。
  • 指针数组在函数传递里的用法,一定是指针数组名做实参,指针数组名做形参么,还是可以实参指针形参也是指针
  • 数组作实参 指针作形参 排序
  • 多维数组指针和函数形参

    千次阅读 2014-07-21 10:51:52
    如果为一维数组数组大小可以不写,数组名在形参中退化为指针 void foo(int a[]) { } 调用: int *p; int a[10]; p=a; void foo(p); void foo(a); 是合理的 如果为二维数组,第一维可以不写,但第...
  • C++中指针数组的学习,包括指针中常见问题,以及一维数组二维数组通过数组形参来进行函数传参,动态数组等问题
  • 指针数组做函数形参

    千次阅读 2018-10-23 13:43:00
    在设计函数过程中,想要函数参数传入一个指针数组,多为字符串数组,在函数形参的设计上有两种思路,具体以下列两种应用场景为说明 一、字符串处理函数strsort 从程序设计角度来看,将多个字符串传递给函数处理时...
  • 数组作为形参知识点 1.数组的维度必须是一个常量表达式 int main(void) { constexpr int i = 20; int j = 5;//不是常量表达式 int arr1[i];//正确 int arr2[j];//错误 system("pause"); return 0...
  • 问题及代码: /* ...* 者:单昕昕 *完成日期:2014年12月15日 *版 本 号:v1.0 * *问题描述:求字符串的长度。 *程序输入:无。 *程序输出:字符串的长度。 */ #include #include usin
  • C++中关于二维数组作为函数参数传递的问题 文章转自:http://www.cnblogs.com/LeeZz/p/5084498.html 在做数据结构迷宫实验的时候,要生成一个二维数组存储迷宫数据,为了保证程序的模块化,将生成部分...
  • void f(int b[]) //数组做函数形参 {  cout } void main() { int a[5]={1,2,3,4,5};  cout  f(a); } 程序运行结果输出的两个值(实参数组地址和形参数组地址)是一样的。 说明当实参和形参都是数组...
  • 问题及代码:/* ...* 者:单昕昕 *完成日期:2014年12月15日 *版 本 号:v1.0 * *问题描述:去除字符串中指定字符。 *程序输入:要删除的指定字符。 *程序输出:删除后的字符串。 */ #include #inc
  • 当我们操作指针时,当碰到几类让我们
  • 时间:2017/06/01 20:49 指向一维、二维数组指针 例:int vector[10], *vp=vector;...②为何不合法,vp的初始化是有问题的,因为vector并不是一个指向整型的指针,而是指向一个指向整型数组指针
  • int (*pArr)[] = {1,2,3,4};这个是数组指针
  • 虽然大多数时候都可以相互用最大的差别就是指针可以改变,可以通过指针改变指向内容的值,但数组名不行 举个例子:(分别作为形参) int num[10], *p; p = num;//此时p指向数组的第一个元素 在主函数里调用两个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 68,108
精华内容 27,243
关键字:

数组指针作形参