精华内容
下载资源
问答
  • 数组指针作为形参传递

    千次阅读 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

    展开全文
  • p的和c的地址不同 但是p中的指针 p->vul指向的地址和s->data的地址相同 , 所以p->vul->data += 2会引起s->data值的变化 在函数中对结构体中指针操作 会使原结构体中指针指向的数据值发生变化 简而言之 指针p->vul==...

    如下是我的测试代码

    typedef struct node1
    {
    	int data;
    	struct node1 *vul;
    }intnode;
    int main()
    {
         intnode *c,*s;
    	c= (intnode *)malloc(sizeof(intnode));
    	c->data = 5;
    	s = (intnode *)malloc(sizeof(intnode));
    	s->data = 8;
    	c->vul = s;
    	s->vul= NULL;
    	printf("%d\n", &s);
    	printf("%d\n", &s->data);
    	printf("%d\n", &c);
    	printf("%d\n", c->vul);
    	test_pointer(*c);
    	printf("%d\n",&s->data);
    	printf("%d\n", &s);
    }
    

    函数

    int test_pointer(intnode a)
    {
    	intnode *p;
    	p = &a;
    	p->data= p->data + 1;
    	p->vul->data += 2;
    	printf("%d\n", &a);
    	printf("%d\n", p->vul);
    	printf("%d\n", &p->vul->data);
    }
    

    结果
    16120524 &s
    19552776 &s->data
    16120536 &c
    19552776 c->vul
    16120308 &a
    19552776 p->vul
    19552776 &p->vul->data
    19552776 &s->data
    16120524 &s

    可以看出当传入为形参时,相当于在内存中拷贝了一份原 在p中 p的和c的地址不同 但是p中的指针 p->vul指向的地址和s->data的地址相同 ,
    所以p->vul->data += 2会引起s->data值的变化

    在函数中对结构体中指针操作 会使原结构体中指针指向的数据值发生变化

    简而言之 指针p->vul==c->vul指向的是s->data的地址

    展开全文
  • 我想编写子函数readData读取文件中的数据,主函数中申请空间databuffer用于存储数据。 第一次调用子函数获取数据长度,然后申请空间,再次调用子函数将数据写入以申请的空间中。 但是调试总达不到效果。 代码如下: ...
  • (1)用指针传递参数,可以实现对实参进行改变的目的,是因为传递过来的是实参的地址,因此使用*a实际上是取存储...(2)引用作为函数参数进行传递时,实质上传递的是实参本身,即传递进来的不是实参的一个拷贝,因此对形
    (1)用指针传递参数,可以实现对实参进行改变的目的,是因为传递过来的是实参的地址,因此使用*a实际上是取存储实参的内存单元里的数据,即是对实参进行改变,因此可以达到目的。在使用的过程中需要通过对地址的解引用来操作其所指向的变量,同时可以通过指针的自增自减移动从而改变所指向的值,灵活度较大。

    (2)引用作为函数参数进行传递时,实质上传递的是实参本身,即传递进来的不是实参的一个拷贝,因此对形参的修改其实是对实参的修改.因而函数返回后作出的修改会依旧存在,引用传递可以节省复制所需要的时间和空间。


    (3)对于二重指针的使用情况:对于链表和树或char*字符串时,这些本身就是指针类型,当需要通过形参带回变化后的结果时,又要使用指针作参数,所以使用二重指针作为形参。如果函数传参采用一级指针时,解引用时只能改变该指针指向的头或根结点,而不能影响整个链表或树这个结构。

    定义链表结构时,LinkList(也就是LNode *)H代表的是整个链表,函数传址调用时,实参传递的是地址值。当采用二级指针形参LinkList *L(也就是LNode **)时,要传递链表的起始地址&H给形参L,而采用一级指针形参LNode *L时,传递的是头结点的地址&(*H)(也就是头指针H)。

    针对以上情况也可以使用指针的引用来代替二重指针,以下是分别用二重指针和指针引用作为形参的示例程序:

    #include<iostream>
    using namespace std;


    void test(int **p)      //以指针类型变量的地址作为形参
    {
    int a=1;
    *p=&a;                 //*p作为一个指针变量存放的是变量a的地址
    cout<<*p<<" "<<**p<<endl;
    }


    int main(void)
    {
        int *p=NULL;                    //定义指针类型的变量p
        test(&p);                       //通过指针地址作为形参传递改变了指针p的内容
        if(p==NULL)           
        cout<<"指针p为NULL"<<endl;
    system("pause");
        return 0;
    }


    下面是利用形参为指针的引用的函数:

    #include<iostream>
    using namespace std;
    void test(int *&p)
    {
        int a=1;
        p=&a;
        cout<<p<<" "<<*p<<endl;
    }


    int main(void)
    {
        int *p=NULL;
        test(p);               
        if(p==NULL)             
        cout<<"指针p为NULL"<<endl;
    else
        cout<<p<<" "<<*p<<endl;
        system("pause");
        return 0;
    }

    可以看出利用指针的引用相较二重指针达到了相同的功能,但比使用二重指针要简单明了(与一重指针相似)









    展开全文
  • (1)用指针传递参数,可以实现对实参进行改变的目的,是因为传递过来的是实参的地址,因此使用*a实际...(2)引用作为函数参数进行传递时,实质上传递的是实参本身,即传递进来的不是实参的一个拷贝,因此对形参的修改...

    (1)用指针传递参数,可以实现对实参进行改变的目的,是因为传递过来的是实参的地址,因此使用*a实际上是取存储实参的内存单元里的数据,即是对实参进行改变,因此可以达到目的。在使用的过程中需要通过对地址的解引用来操作其所指向的变量,同时可以通过指针的自增自减移动从而改变所指向的值,灵活度较大。

    (2)引用作为函数参数进行传递时,实质上传递的是实参本身,即传递进来的不是实参的一个拷贝,因此对形参的修改其实是对实参的修改.因而函数返回后作出的修改会依旧存在,引用传递可以节省复制所需要的时间和空间。

     

    (3)对于二重指针的使用情况:对于链表和树或char*字符串时,这些本身就是指针类型,当需要通过形参带回变化后的结果时,又要使用指针作参数,所以使用二重指针作为形参。如果函数传参采用一级指针时,解引用时只能改变该指针指向的头或根结点,而不能影响整个链表或树这个结构。

    定义链表结构时,LinkList(也就是LNode *)H代表的是整个链表,函数传址调用时,实参传递的是地址值。当采用二级指针形参LinkList *L(也就是LNode **)时,要传递链表的起始地址&H给形参L,而采用一级指针形参LNode *L时,传递的是头结点的地址&(*H)(也就是头指针H)。

    针对以上情况也可以使用指针的引用来代替二重指针,以下是分别用二重指针和指针引用作为形参的示例程序:

    #include<iostream>
    using namespace std;
    
    
    void test(int **p)      //以指针类型变量的地址作为形参
    {
        int a=1;
        *p=&a;                 //*p作为一个指针变量存放的是变量a的地址
        cout<<*p<<" "<<**p<<endl;
    }
    
    
    int main(void)
    {
        int *p=NULL;                    //定义指针类型的变量p
        test(&p);                       //通过指针地址作为形参传递改变了指针p的内容
        if(p==NULL)           
        cout<<"指针p为NULL"<<endl;
        system("pause");
        return 0;
    } 

    下面是利用形参为指针的引用的函数:

    #include<iostream>
    using namespace std;
    void test(int *&p)
    {
        int a=1;
        p=&a;
        cout<<p<<" "<<*p<<endl;
    }
    
    
    int main(void)
    {
        int *p=NULL;
        test(p);               
        if(p==NULL)             
        cout<<"指针p为NULL"<<endl;
        else
        cout<<p<<" "<<*p<<endl;
        system("pause");
        return 0;
    }
    

      

    可以看出利用指针的引用相较二重指针达到了相同的功能,但比使用二重指针要简单明了(与一重指针相似)

     

     

    来源

     

    转载于:https://www.cnblogs.com/skullboyer/p/9050636.html

    展开全文
  • 所以,函数指针变量是一种变量类型,也可以作为函数的形参变量。程序测试例子如下: 程序运行结果如下: 可以看到,函数func1的定义如下: voidfunc1(void(*pfunc)(int)) 其中形参的定义是 void(*pfunc...
  • 指针函数作为形参这个知识点我是能看懂的,但是之后我就在想一个问题, <code>void estimate(int, double (* ptr)(int));</code></pre> 这个函数的参数列表中有函数地址作为参数并使用指针指向这个...
  • C++中函数作为形参传递

    千次阅读 2015-11-05 23:34:15
    规定:没有括号的函数名被认为是一个指向该函数的函数指针 如:void add(), 这里的add就是指向该函数的指针 语法:函数返回值的类型 + 作为指针的函数名 + 该函数的参数 如:void (*visit) (int a, int b) ...
  • int (*pArr)[] = {1,2,3,4};这个是数组指针
  • 把一个指针作为参数时,指针不能为未指向地址的值,必须为一个指向确定地址的值 参数为取地址符或者指针的指针 函数内为空指针分配空间,退出函数后,函数中的赋值仍然存在 例子 struct StructA { char* a; char...
  • 为什么一个指针变量作为形参传递给一个函数后,在函数体内改变这个指针的指向,但函数结束后这个指针的指向没有发生变化? 现在有如下一段代码,其中指针p指向a,a的值为10,接着调用Fun函数,Fun函数的意图是将...
  •   从概念上来说一下这几种函数传参方式及区别:  1、值传递形参是实参的拷贝,改变函数形参的值并不会影响外部...【值传递过程中,被调函数形参作为被调函数的局部变量来处理,即在函数内的栈中开辟内存空
  • c语言使用指针函数形参传递二维数组

    千次阅读 多人点赞 2018-06-14 21:29:23
    C语言中,我们经常会使用到二维数组作为函数形参,常用的就是用指针函数参数传递二维数组,有两种基本方法,如下: 1、传递“数组指针” #include &amp;lt;stdio.h&amp;gt; void output( int (*pa)...
  • C语言指针作为形参的一些问题

    千次阅读 2016-04-12 11:54:38
    C语言中指针是个非常麻烦的事件,函数的形参、实参值传递也是个比较绕脑的概念,指针函数作为形参进行数据传递,比较常用的方式是把数组的首地址或者变量地址通过指针传给函数,还有函数中申请一段空间通过形参...
  • C++数组作为形参传递函数

    千次阅读 2018-03-15 20:33:26
    以下三种形式等价void function(const ...//这里维度表示期望有10个,并不代表真实为10个以上三个函数等价于将数组的头指针const int*类型传递函数,但是不知道数组的长度。有以下方法解决。 1.使用标记指定数组长度
  • 一个指针变量作为作为形参传递给一个函数后,函数返回的类型还是这个形参,为什么这个指针的地址没有发生变化? 代码如下: class Node { public: Node(void); ~Node(void); int num; float price; ...
  • 函数指针作为某个函数的参数进行传递 #include <iostream> using namespace std; typedef int(*FunType)(int, int);//定义一个函数指针类型 int mf(int temp1, int temp2) { return 1; } void testfunc...
  • 有时候,我们定义的函数需要...//传递形参后就可以直接在函数体当中使用已经定义过的形参的数据。 函数的设计应该遵从一个函数实现一个功能的原则, 传入的参数让函数实现更为丰富的功能 类型名就是指定函数的...
  • 数组名和指针作为形参

    千次阅读 2014-09-15 15:43:04
    1.用数组名做函数参数 f(int arr[],int n)① 调用时采用:f(arr,10) 由于数组名代表的是数组的地址,所以用数组名做参数...在用指针变量做形参以接受实参数组名传递的地址时,有两种方法: ①采用和一维数组相同的
  • 指针形参形参传递详解

    千次阅读 2015-06-16 18:55:01
    一、用二级指针作为函数参数,有两种典型情况: 1.需要传递一级指针的数组时: 例如标准C的main函数: int main(int argc, char*[] argv),数组最高维可以退化,char*[] argv等价于char** argv。这里argv...
  • C语言指针作为形参动态申请空间

    千次阅读 2016-09-29 21:50:39
    程序由一个主函数和两个子函数构成;子函数为getData()和check()。getData用来读取数据,将数据存入内存,将内存地址返回给主函数。check负责检查数据传递是否正确。
  • 【C基础】当指针作为函数形参,实参可能是____? 当函数形参为一级指针时,实参可以是:变量的地址、一级指针变量。 当函数形参为二级指针时,实参可以是:一级指针的地址,二级指针变量、指针数组int* parr...
  • 数组作为函数形参传递时,并没有像其他类型一样进行了复制(传递非引用),而是默默地将数组名转换为指向其第一个元素的指针。这正是数组的两个特殊性质:1不能复制数组,2悄悄转换为指针。 在传递引用数组的时候,...
  • 但是若是函数形参指针变量的话在调用函数时将变量的地址传递指针,在函数内部对函数进行解引用改变指针的值那么相应实参的值也会被更改。这就是所谓的传址传参。这种传参方式可以让函数函数外边的变量建立起...
  • 数组作为函数形参传递时,相当于指针,而指针的长度是4个字节,因此显示4, 函数中需要知道数组大小时,需要传入两个参数,一个参数传数组名,另一个传数组大小。 如:int test(char a[],int n); 转载于:...
  • 引用和指针指针作为形参时的区别 形参的工作原理 形参是传值作用,如果形参不进行引用的话,把函数调用时的参数的值,传递给形参。如果形参进行引用,那么就相当于把函数调用时的参数,在子函数里面起了个别名...

空空如也

空空如也

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

函数指针作为形参传递