甚么!!你这麽传参是吧,好好

甚么!!你这麽传参是吧,好好


前言

在使用自定义函数时,会用到函数传参,今天给大家分享一下函数的传参是设计的呢??


数组参数

一维数组传参

#include <stdio.h>
void test(int arr[])//ok?
{
    
    }
void test(int arr[10])//ok?
{
    
    }
void test(int *arr)//ok?
{
    
    }
void test2(int *arr[20])//ok?
{
    
    }
void test2(int **arr)//ok?
{
    
    }
int main()
{
    
    
int arr[10] = {
    
    0};//数组
int *arr2[20] = {
    
    0};//指针数组,数组里每个元素存放的是地址
test(arr);//传入该数组的首地址
test2(arr2);//传入指针数组的首地址
}
void test(int arr[])
{
    
    }

这个应该是容易理解的,用一个同类型的数组接收,数组名表示首元素地址,相当于把地址传过去,对该地址的元素进行处理,可以验证一下,我们可以通过test函数传参过去,对主函数中的arr[]进行修改,然后在主函数中打印出arr[]函数,如果被修改,则是传地址过去,因为test函数也没有返回值,只能是通过传过去地址修改了主函数中的arr[]函数

#include <stdio.h>
void test(int arr[])//ok?
{
    
    int i;
for(i=0;i<10;i++)
{
    
    arr[i]=10-i;
}

}
int main()
{
    
    
int arr[10] = {
    
    12345678910};//数组,
test(arr);//传入该数组的首地址
for(i=0;i<10;i++)
{
    
    printf("%d",arr[i]);
}
}

在这里插入图片描述
上面情况是传地址过去

void test(int arr[10])//ok?->ok的
{
    
    }

这个情况与第一个一样不管接受的数组元素是多少个,都是传地址过去

void test(int *arr)//ok?------>OK的
{
    
    }

这个也容易理解,一级指针可以接收数组的首地址,然后通过对arr+i,就是后面的地址,加1,int类型指针一次访问4个字节,对(arr+i)进行解引用操作,得到的就是对应该地址下主函数arr[]数组对应地址的那个元素,并且可以修改。
那如果是下面这个函数,阁下又应该如何对付勒??

void test2(int *arr[20])//ok?------>ok的
{
    
    }
int main()
{
    
    
int *arr2[20] = {
    
    0};//指针数组,数组里每个元素存放的是地址
test2(arr2);//传入指针数组的首地址
}

你传过去的还是地址,用指针可以接收,可是为什么不用一级指针p呢?是因为这个是一级指针数组,数组元素的元素是int呀,这个数组里存放的都是地址,你要存放一级指针数组的地址应该用个二级指针接收啊! *p只能访问到arr2[]里面的元素(地址),而不能访问到arr2[]里面的地址解引用得到的值,因为还要解引用一次,所以可以用二级指针接收。
在这里插入图片描述
用一级指针只能访问&b,不能得到b,如果不用二级指针的话,用一级指针数组的话是可以访问到b的。传参过去拿到的是主函数数组首地址,并没有创造一个真的数组,在test2函数里面arr[1]等于主函数arr2[1],&arr[1]等于&arr2[1],这里不要看他的类型,就把他当一个数组一样,要访问b的话解引用就行
在这里插入图片描述

二维数组传参

void test(int arr[3][5])//ok?------>ok的
{
    
    }
void test(int arr[][])//ok?------->不行
{
    
    }
void test(int arr[][5])//ok?------->ok的
{
    
    }
//总结:二维数组传参,函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组,可以不知道有多少行,但是必须知道一行多少元素。
//这样才方便运算。
void test(int *arr)//ok?
{
    
    }
void test(int* arr[5])//ok?------>不行
{
    
    }
void test(int (*arr)[5])//ok?------>可以的
{
    
    }
void test(int **arr)//ok?------>不行
{
    
    }
int main()
{
    
    
int arr[3][5] = {
    
    0};
test(arr);
}
void test(int *arr)//ok?------->可以
{
    
    }

二维数组连续存放可以把arr[3][5]当成arr[15];

void test(int* arr)//ok?------->可以
{
    
    
    int i = 0;
    for (i = 0; i < 15; i++)
    {
    
    

        *(arr + i) = i;
    }
}
int main()
{
    
    
    int arr[3][5] = {
    
     0 };
    test(arr);
    int i = 0;
    for (i = 0; i < 3; i++)
    {
    
    
        int j = 0;
        for (j = 0; j < 5; j++)
        {
    
    
            printf("%d ", arr[i][j]);
        }

       
    }
}
void test(int* arr[5])//ok?------>不行

传地址过去,对于形参arr[0]对应的地址就是主函数arr[0][0]的地址,但是形参是int*类型的,和主函数的arr数组类型int不对应的

void test(int (*arr)[5])//ok?------>可以的

用数组指针接收二维数组在我之前的文章里面讲过
数组指针

void test(int **arr)//ok?------>不行

二级指针接收一级指针的地址,怎么能接收二维数组的地址呢?头给你打破咯哈哈哈哈哈哈哈哈哈
昨天写的很晚了,今天续上
|
|
|

指针传参

一级指针传参

#include <stdio.h>
void print(int *p, int sz)
{
    
    
int i = 0;
for(i=0; i<sz; i++)
{
    
    
printf("%d\n", *(p+i));
}
}
int main()
{
    
    
int arr[10] = {
    
    1,2,3,4,5,6,7,8,9};
int *p = arr;
int sz = sizeof(arr)/sizeof(arr[0]);
//一级指针p,传给函数
print(p, sz);
return 0;
}

二级指针传参

#include <stdio.h>
void test(int** ptr)//二级指针接收一级指针的地址
{
    
    
printf("num = %d\n", **ptr);
}
int main()
{
    
    
int n = 10;
int*p = &n;
int **pp = &p;
test(pp);
test(&p);
return 0;
}

ptr存放一级指针p的地址,一次解引用得到p指针的内容,也就是n的地址,再解引用一次得到n.
现在有一个疑问,有指向单个类型的指针,有指向数组的指针,有指向指针的指针,有没有指向函数的指针呢????????

函数指针

看一下这个代码

#include <stdio.h>
void test()
{
    
    
printf("hehe\n");
}
int main()
{
    
    
printf("%p\n", test);
printf("%p\n", &test);
return 0;
}

在这里插入图片描述
这两个都是函数的地址,那要怎么将函数的地址存起来呢??
指针
函数指针
定义一个指针*p,这个指针的类型应该和函数的类型一样,也就是同样的参数,同样的返回类型

void (*p)();

这个就是

void test()

的函数指针,满足上面的要求。

我们可以用这个函数指针调用这个函数

#include <stdio.h>
void test()
{
    
    
printf("hehe\n");
}
int main()
{
    
    
    void (*p)()=test;//声明函数指针并初始化
    (*p)();//p存放test的地址,*p就是该函数,调用该函数一般test();所以(*p)();就可以调用这个函数

return 0;
}

果然写不下,动动发财的小手往右滑滑呗

函数指针数组

数组是存放相同类型数据的存储空间,指针数组存放的是地址,把好多函数的地址能存在什么数组里面呢???当然是函数指针数组,这个应该怎么定义呢,我们看一下函数指针 void (*p)(),这个可以存放一个数组的地址,我们把变量p换成数组的话 void (*arr[5])(),这样就可以存放5个函数的地址了。

#include <stdio.h>
void test()
{
    
    
printf("hehe\n");
}
void test1()
{
    
    
    printf("haha\n");
}
int main()
{
    
    
    void (*arr[2])() = {
    
     &test1,&test };
    (*arr[0])();
    (*arr[1])();
return 0;
}

在这里插入图片描述
先调用了test1();在调用了test();

总结

本文分享了数组传参,指针传参,函数指针,函数指针数组,如果哪里不对的话,求大佬多多指教,谢谢大家了,点赞的大佬offer多多!!!

猜你喜欢

转载自blog.csdn.net/yyqzjw/article/details/132028016