精华内容
下载资源
问答
  • 本文主要讲了c语言指针变量作为函数参数传递,下面一起来学习一下
  • c++之指针作为函数参数传递的问题

    万次阅读 多人点赞 2018-09-30 11:23:51
      原创文章,转载请注明出处,谢谢! 作者:清林,博客名:飞空静渡 ...其实,对于C 或者C++ ,最难的一块地方估计就是指针了。指针是强大的,但也是很多人载在这里的地方。   前段时间写了一篇文章《...

    转自:http://blog.csdn.net/fjb2080/article/details/5623427

     

    原创文章,转载请注明出处,谢谢!
    作者:清林,博客名:飞空静渡

     

    博客地址:http://blog.csdn.net/fjb2080

     

    其实,对于C 或者C++ ,最难的一块地方估计就是指针了。指针是强大的,但也是很多人载在这里的地方。

     

    前段时间写了一篇文章《C ++之 数组与指针的异同 》对C 和C ++中的指针做了一个初步的讲解。这次将讲解一下指针作为函数参数传递的问题。

     

    很多人对于指针的使用是有所了解的,但还是经常会载在指针的问题上,是因为还不够了解指针的本质,其实如果了解指针的本质,对指针的使用也就一目了然了。

     

    作为C 的初学者,经常会遇到指针作为函数参数传递的两个经典的问题。这里,我将透过指针的本质来来讲解这两个问题,这样以后无论你遇到什么样的指针问题,如果你以这样的方法来分析指针也许就迎刃而解了!

     

    首先,第一个问题是这样的:

    写一个函数,交换两个参数中的值。

     

    初学者往往会这样写:

     

    void exchange(int x, int y)

    {

    int p=x;

    x = y;

    y = p;

    }

     

    之后,你会查找资料了解到应该这样写:

    void exchange(int *x, int *y)

    {

    int *p=x;

    *x = *y;

    *y = *p;

    }

     

    第二个问题是,写一个给某个指针分配内存的函数:

    初学者往往是这样写:

    void my_malloc(void* p, int size)

    {

    p = malloc(sizeof(int)*size);

    }

     

    然后又查在资料,知道应该这么写:

    void my_malloc(void** p, int size)

    {

    *p = malloc(sizeof(int)*size);

    }

     

    虽然,网上很多这样的讨论,也有很多人做过很多的解释,但始终都无法给出一个令人一目了然,并可以长久记住的说法,这篇文章就是想试图解决这样的问题,给初学者一个原理性的了解!

     

    首先,一定一定记住一点, 指针和变量一样,也是有地址的,只不过变量的值被解释成一个值,而指针的值被解释成一个地址。

     

    下面,我们看一下代码:

    void main()

    {

    int x;

    int *p;

    }

     

    我们看这个函数的内存结构:

     

    这是一个函数的栈结构,我们可以看到,变量和指针都占用了4 个字节。而且,由于我们对它们没有初始化,所以变量x 和指针p 里的内容都是随机的,就是说x 的值是不确定的,p 有可能指向某个内存地址,如果现在对p 操作也许会导致程序崩溃。

     

    其实,我们记住了,指针也是有地址的 这个概念,很多问题就迎刃而解了。

     

    下面,我来分析一下,指针作为函数参数传递的情况。

    如果,我们的代码是这样的,你看会怎么样:

     

    int main(int argc, char* argv[])

    {

    int *a = new int(10);

    func(a);

     

    return 0;

    }

     

    第一个要说的当然是:指针也是有地址的。

    第二个要说的是:当给一个函数的参数传递一个变量是,这个变量是复制过去的。

     

    对于第二点,我们在理解void exchange(int x, int y) 函数想交换这两个变量的的值时就应该理解了。

    例如:

    int a;

    int b;

    exchange(a,b);

    不能交换a 和b 的值,因为此时exchange(a,b) 中的a 和b 并不是原来的a 和b 变量,它们只不过是被复制过去了。

     

    有了这两个概念,就不难理解指针作为函数参数传递的问题。

     

    首先,我们来看下上面的代码中的a 指针和p 指针的内存结构。

    我们看到,当我们以a 作为func 函数的参数传递进去的时候,函数复制了这个指针,但这两个指针的内容是一样的,也就是说是指向同一个内存,即10 。

     

    如果你还不了解的话,我就通过一段代码和测试再来说明:

     

     

    [cpp] view plain copy

     print?

    1. #include <stdio.h>  
    2. void func(int* p)  
    3. {  
    4.     printf("*p = %d/n", *p);  
    5.     printf("&p = %p/n", &p);  
    6. }  
    7. int main(int argc, char *argv[])  
    8. {  
    9.     int *a = new int(10);  
    10.     printf("*a = %d/n", *a);  
    11.     printf("&a = %p/n", &a);  
    12.     func(a);  
    13.     return 0;  
    14. }  

     

     

     

    编译:g++ -g -Wall test1.cpp

    运行:./a.out

    输出:

    *a = 10

    &a = 0xbfd4447c

    *p = 10

    &p = 0xbfd44460

     

    我们看到输出,a 指向的地址的值和p 指向的地址里的值是一样的,都是10 。然而,对于指针a 和p 来说,它们自身的地址是不一样的,所以我们看到,函数func 复制了指针a 给p ,它们的值一样,但有不同的地址,是不同的指针。

     

    我们再进一步:

     

    [cpp] view plain copy

     print?

    1. #include <stdio.h>  
    2. void func(int* p)  
    3. {  
    4.     printf("*p = %d/n", *p);  
    5.     printf("&p = %p/n", &p);  
    6.     printf("&*p = %p/n", &*p);  
    7. }  
    8. int main(int argc, char *argv[])  
    9. {  
    10.     int *a = new int(10);  
    11.     printf("*a = %d/n", *a);  
    12.     printf("&a = %p/n", &a);  
    13.     printf("&*a = %p/n", &*a);  
    14.     func(a);  
    15.     return 0;  
    16. }  

     

     

     

    编译输出:

    *a = 10

    &a = 0xbfe1c77c

    &*a = 0x94b6008

    *p = 10

    &p = 0xbfe1c760

    &*p = 0x94b6008

     

    我们可以进一步看到,a 指针所指向的值的地址和p 指针所指向的值的地址是一样的,都是 0x94b6008 ,就如同上图所示,为了加深印象,再看一下这个图 ,然后再对比一下程序输出 ,然后在体会一下我在上面提到的两点 ,一点是:指针是有地址的 。另一点是:函数的参数是复制过去的 。

     

     

     

    说到这里,我们再回到文章开始时提到的两个问题,一个是交换问题:

     

    void exchange(int *x, int *y)

    {

    int *p=x;

    *x = *y;

    *y = *p;

    }

     

    那么这样为什么可以交换:

    int a = 2;

    int b = 3;

    exchange(&a, &b);

     

    上我们以a 和b 的地址传递给exchange 函数时,函数复制了这两个地址,并赋值给x 和y 这个两个指针,这两个指针是指向变量a 和b 的,它们的图形如下:

     

    那么,当我们反引用指针时:

    int *p=x;

    *x = *y;

    *y = *p;

     

    我们操作的是a 和b 里面的变量的值,所以,我们交换a 和b 的值就成功了。

     

    我们再来看下第二个问题:

    void my_malloc(void* p, int size)

    {

    p = malloc(sizeof(int)*size);

    }

    当这样时:

    int *a;

    my_malloc(a, 10);

    为什么这个会失败!

     

    下面,我来分析一下:

    当我们调用my_malloc(a, 10); 函数,而函数还没执行到p = malloc(size); 语句时,情况是这样的:

     

    我们看到a 和p 的指针的值都是一样的,都是指向某个不确定的地址。

    这时,我们执行这个语句:

    p = malloc(sizeof(int)*size);

    我们把这个语句分开两部分来看,一个是先执行malloc(sizeof(int)*size) ,然后在执行赋值语句,把malloc(sizeof(int)*size) 的返回值付给p 。

    第一步:先执行malloc(sizeof(int)*size) ;(这里我们只考虑malloc 分配内存成功的情况)

     

    第二步:把执行malloc(sizeof(int)*size) 的返回值付给了p ,如下图:

     

    由上图,我们可以知道,这就是为什么,我们还是不能给a 分配地址的了。

     

    下面我们来分析这个:

    void my_malloc(void** p, int size)

    {

    *p = malloc(sizeof(int)*size);

    }

     

    int *a;

    my_malloc(&a , 10);

    这样执行,为什么会成功!

     

     

    我们看到,当执行函数

    my_malloc(void** p, int size);

    但还没有执行

    *p = malloc(sizeof(int)*size);

    语句时,它们的内存结构图如下所示:

     

    其实这里,我们可以把二维指针和一维指针当成和变量一样,也是有地址的。只不过它的解释不一样而已。

    变量:里面的值是一个数值。

    一维指针:里面的值是个地址,而这个地址里的值是个数值。

    二维指针:里面的值是个地址,而这个地址里的值也是个地址。

     

    那么,我看着图来解释p :

    p 里面是一个地址,这个地址是&a ,即是a 指针的地址值,而a 指针地址里面的值也是个地址,这个地址是指向一个不确定的地方,说得坳口,慢慢对比图来理解就会好了!

     

    执行malloc(size) 后的图如下:

     

    然后在执行赋值语句:

    *p = malloc(sizeof(int)*size);

    后,如下图所示:

     

    然后,我们就给指针a 分配内存成功了。

     

    本文的pdf下载地址:c++之指针作为函数参数传递的问题.pdf

    展开全文
  • C语言指针作为函数参数传递学习(一)

    万次阅读 多人点赞 2018-12-01 00:18:34
    1. 数组或者一维指针函数形参 1.1传入的指针为NULL 比如下面的例子,很多人都会理解错: #include &amp;lt;stdio.h&amp;gt; void test(char *string) { string = &quot;hello world&quot;; } ...

    1. 一维指针做函数参数

    传入的指针为NULL

    比如下面的例子,很多人都会理解错:

    #include <stdio.h>
    
    void test(char *string)
    {
    	string = "hello world";
    }
    int main()
    {
    	char *str = NULL;
    	test(str);
    	printf("str=%s\n",str);
    	
    	return 0;
    	
    }
    

    是不是觉得输出应该是:str=hello world.事实上并不是
    输出结果是(操作系统:win10):
    在这里插入图片描述
    具体过程如下:
    在这里插入图片描述
    开始str指针指向NULL,并将该地址作为形参传入函数test(),最开始string指针也是指向NULL,接着讲“hello world”地址传给了string,此时string的指针不再指向NULL,而是指向“hello world”这个字符串的地址。为了验证这个,可以在代码里加一些打印信息验证:

    #include <stdio.h>
    
    void test(char *string)
    {
    	printf("string未操作之前的的指针:%p\n",string);
    	string = "hello world";
    	printf("string未操作之后的的指针:%p\n",string);
    }
    int main()
    {
    	char *str = NULL;
    	printf("传入test函数之前str的指针:%p\n",str);
    	test(str);
    	printf("str=%s\n",str);
    
    	getchar();
    	return 0;
    	
    }
    
    

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

    2.那要实现在test函数中改变str的指针指向地址怎么办?

    2.1 返回string指针,这个很好理解

    #include <stdio.h>
    
    char *test(char *string)
    {
    	string = "hello world";
    	return string;
    }
    int main()
    {
    	char *str = NULL;
    	str = test(str);
    	printf("str=%s\n",str);
    
    	getchar();
    	return 0;
    }
    
    

    结果:
    在这里插入图片描述
    2.2 用二维指针

    #include <stdio.h>
    
    void test(char **string)
    {
    	*string = "hello world";
    }
    int main()
    {
    	char *str = NULL;
    	test(&str);
    	printf("str=%s\n",str);
    
    	getchar();
    	return 0;
    }
    
    

    结果:
    在这里插入图片描述
    具体分析如下图:
    在这里插入图片描述
    过程:
    1.定义一个字符串指针str,str本身的地址是100,值为0(即NULL,一般的编译器NULL的地址是0)。
    2.取str的地址100传给string,此时string的值是100,地址为200
    3.这里假设“hello world”字符串的地址是300,接下来就是改变一级指针指向的内容的地址,由0变成300。

    针对评论区的留言,再一起讨论学习下:
    问题:为什么传入形参的是指针,在test函数调用后,main函数中str的内容没有改变?
    先看几个例子:

    #include <stdio.h>
    #include <string.h>
    
    void test(char *string)
    {
    	char *testString = "world";
    	
    	printf("111 string addr:%p,   testString addr:%p\n",string,testString);
    	string = testString;
    	printf("222 string addr:%p,   testString addr:%p\n",string,testString);
    	
    }
    int main(void)
    {
    	char *str ="china";
    
    	test(str);
    	printf("333 str addr:%p,      str is:%s\n",str,str);
    	
    	return 0;
    }
    

    结果(因为用的是64位系统,所以地址是8位,这里地址显示的6位,因为前面两位是0,所以默认省略了):
    在这里插入图片描述
    形参都是值传递。但是这个值如果是指针的话,是可以改变指针指向内容的值,即实参的值。这个要弄清两个概念:指针和指针指向的数据。
    这个例子中形参的值是实参的地址,并不是实参的值,所以形参的值的改变只是指针的改变,即指向数据的
    地址
    改变,并不是指针指向数据的改变。所以我们发现在main函数中,str的值没有改变。
    我们先再看一个例子:

    #include <stdio.h>
    #include <string.h>
    
    void test(char *string)
    {
    	printf("111 addr:%p, content:%s\n",string,string);
    	strncpy(string,"world",6);//连带把字符串结尾复制过去
    	printf("222 addr:%p, content:%s\n",string,string);
    	
    }
    int main(void)
    {
    	char *str ="china";
    
    	test(str);
    	printf("333 addr:%p, content:%s\n",str,str);
    	
    	return 0;
    }
    
    

    结果:
    在这里插入图片描述
    编译没有任何问题。但是运行却崩溃了,为什么呢?
    这个又是一个需要注意的点:指针指向的常量存储区是不允许修改的,这个实参和形参的地址都是指向字符串的地址,是const类型的,所以不能修改。
    原来的程序稍作修改:

    #include <stdio.h>
    #include <string.h>
    
    void test(char *string)
    {
    	printf("111 addr:%p, content:%s\n",string,string);
    	strncpy(string,"world",6);//连带把字符串结尾复制过去
    	printf("222 addr:%p, content:%s\n",string,string);
    	
    }
    int main(void)
    {
    	char str[] ="china";//修改这里,用字符数组存储,这样指针就指向栈区的内容了
    
    	test(str);
    	printf("333 addr:%p, content:%s\n",str,str);
    	
    	return 0;
    }
    
    

    结果:
    在这里插入图片描述
    我们可以看到,地址没有改变,但是内容已经被修改了。

    总结:
    形参都是值传递
    1.这个值是指针的话,在被调用的函数(test)中,如果指针的值,不会改变实参的值。
    2.如果改变指针指向的内容时,会改变实参的值。
    注意:在传递的过程中如果是const类型的指针是不允许修改的。

    展开全文
  • 1.值传递 swap1 #include <stdio.h> void swap1(int x,int y){ int t; t=x; x=y; y=t; } int main() { int a=1,b=2; swap1(a,b); printf("s1:a=%d,b=%d\n",a,b); return 0; } 显然,这是无法改变a...

    1.值传递

    #include <stdio.h>
    
    void swap1(int x,int y){
    	int t;
    	t=x;
    	x=y;
    	y=t;
    }
    int main()
    {
    	int a=1,b=2;
    	swap1(a,b);	printf("s1:a=%d,b=%d\n",a,b);
    	return 0;
    }
    
    
    

    显然,这是无法改变a,b的值的,只能改变形参x,y的值。

    2.传地址

    swap1

    #include<stdio.h>
    
    void swap1(int *px,int *py){
    	int *t;
        printf("s1:px=%p,py=%p\n",px,py);//交换前,打印函数函数形参的值
    
    	t=px;
    	px=py;
    	py=t;
        printf("s1:px=%p,py=%p\n",px,py);//交换后,打印函数函数形参的值
    
    }
    int main()
    {
    	int a=1,b=2;
    	int *pa=&a,*pb=&b;
        printf("s1:pa=%p,pb=%p\n",pa,pb);//交换前,打印a,b的地址
    	swap1(pa,pb);
    	printf("s1:a=%d,b=%d\n",*pa,*pb);//交换后,打印a,b的值
        printf("s1:pa=%p,pb=%p\n",pa,pb);//交换后,打印a,b的地址
     	return 0;
    }
    
    

    结果

    s2:pa=000000000061FE0C,pb=000000000061FE08
    s2:px=000000000061FE0C,py=000000000061FE08
    s2:px=000000000061FE08,py=000000000061FE0C
    s2:a=1,b=2
    s2:pa=000000000061FE0C,pb=000000000061FE08
    

    解析:
    由结果可以发现,形参都是值传递,此时,swap2函数的实参值是a,b的地址,在swap函数内部,px,py作为形参拷贝了a,b的地址,所以前两个输出的地址相同。但是在函数内部,t是一个指向整数的指针,交换时实际上是交换的形参py,px的地址,但并没有改变地址对应的数值,也就是说主函数里

    a=1;
    &a=000000000061FE0C;
    
    b=2;
    &b=000000000061FE08
    

    方框里的值一直没有改变,只是在swap方框下方的px,py的值
    在这里插入图片描述
    所以这样不会改变实参的值。
    如果想要改变主函数的实参的值,应该如下

    swap2

    void swap2(int *px,int *py){//注意与swap1对比
    	int t;
    	t=*px;
    	*px=*py;
    	*py=t;
    }
    int main()
    {
    	int a=1,b=2;
    	int *pa=&a,*pb=&b;
    	swap2(pa,pb);
    	printf("s2:a=%d,b=%d\n",a,b);
     	return 0;
    }
    
    
    

    此时,swap2中改变的是a,b地址所储存的值,因为对于一个同一个变量,一般其地址是在定义时就给定了的,程序中不会改变,所以这样自然改变了a,b的值。
    在这里插入图片描述
    此时px,py的值不变,但是px,py所指的值改变。

    展开全文
  • 关于指针作为函数参数传递的理解

    千次阅读 2019-04-23 17:30:01
    本来已经把指针和引用的知识都捋清楚了,但是中午编程遇到了一个传递数组的问题,一下想得多了点,然后又。。。。 被值传递指针传递,引用传递,地址传递这几个概念弄晕了。看了十来篇博客,什么说法都有。参考...

    本来已经把指针和引用的知识都捋清楚了,但是中午编程遇到了一个传递数组的问题,一下想得多了点,然后又。。。。

    被值传递,指针传递,引用传递,地址传递这几个概念弄晕了。看了十来篇博客,什么说法都有。参考课本和菜鸟教程还有一些优秀博客上的观点,加上自己实操,得出下面一些自己对指针传递的理解。

    以下是本人粗浅理解,不知是否表述清晰,若有疑问或高见,请在评论区留言指正。

    见代码:

     

     

     

    见运行结果:

    “在习惯上,很多情况下指针和地址这两个术语可以混用” ----摘自《C语言程序设计》蓝皮书

    由上面运行结果分析得知:

    实质上指针传递传递的是一个地址值,但是到底是说成值传递,还是地址传递,很多博客和网上的答疑中回答不一,但我更倾向于前者,是值的传递。

    分析上面的程序:

    1.传递的实参是一个地址,即指针;

    2.函数中用一个指针变量b接收实参指针;

    3.输出 形参指针存的值 和 实参变量的值进行对比,发现是一样的;

    4.但是输出 形参指针本身的地址,和实参变量的值(即实参指针&a),发现是不一样的,说明形参指针b,和实参指针&a是两个独立的指针,只不过 形参指针b,是(实参变量)实参指针&a的一个副本(拷贝)【被调函数的形参作为被调函数的局部变量处理,会在栈中开辟内存空间以存放由主调函数传递进来的实参值,从而形成了实参的一个副本(替身)】

    指针b中存的值是&a,但是指针b它本身是一个另外独立存在的指针,它的自己本身的地址肯定会跟&a不一样的,都不是同一个东西。这就是和 引用传递 的关键区别所在。

    5.但是形参指针变量b 它存储了实参变量传过来的地址&a,自然就会指向&a这个地址指向的值a(初始化为10)。因此,在函数中输出形参指针变量指向的变量的值,就发现就是10.

    6.在改变了形参指针变量b所指的变量的值后,改成999,输出后可以发现,也会改变原来地址&a中存的变量值,因为b和&a指向的是同一块地址。

    7.但是在函数中改变b存储的地址,改变它的指向,这个对实参是没有影响的,根据输出可以发现,b变了,但&a还是没有变。因为形参指针和实参指针是两个独立的指针,改变其中一个的指向对另外一个没有影响。

    综上,得出总结:

    形参指针和实参指针是两个独立的指针,形参指针是实参指针的副本,他们指向的地址是一模一样的,因此通过他们其中任何一个改变他们指向的变量的值,这个值都会改变(本来两个指针变量指向的变量的值是10 ,后来通过修改形参指针指向的变量值,改成999,两个指针变量指向的变量的值都变成了999);但是,改变形参本身存储的地址值,这个对实参变量是没有影响的,不过就是你形参不和我实参指向同一块地址了而已。

    即:除了引用传递是地址传递外,普通变量的传递,指针传递,都是值传递。

     

    *****************************************************************************************************************************

    根据优秀博客中的论述,关于指针传递和引用传递可有以下理解:

    指针传递参数本质上是值传递的方式,它所传递的是一个地址值。值传递过程中,被调函数的形式参数作为被调函数的局部变量处理,即在栈中开辟了内存空间以存放由主调函数放进来的实参的值,从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的任何操作都是作为局部变量进行,不会影响主调函数的实参变量的值。(这里是在说实参指针本身的地址值不会变)

    而在引用传递过程中,被调函数的形式参数虽然也作为局部变量在栈中开辟了内存空间,但是这时存放的是由主调函数放进来的实参变量的地址(int &a的形式)。被调函数对形参的任何操作都被处理成间接寻址,即通过栈中存放的地址访问主调函数中的实参变量。正因为如此,被调函数对形参做的任何操作都影响了主调函数中的实参变量。

    引用传递和指针传递是不同的,虽然它们都是在被调函数栈空间上的一个局部变量,但是任何对于引用参数的处理都会通过一个间接寻址的方式操作到主调函数中的相关变量。而对于指针传递的参数,如果改变被调函数中的指针地址,它将影响不到主调函数的相关变量。如果想通过指针参数传递来改变主调函数中的相关变量,那就得使用指向指针的指针,或者指针引用。

    **************************************************************

    算了,上面这篇博客写得太好了,太多想粘贴的了,我还是直接上链接吧:

    传指针和传指针引用的区别/指针和引用的区别(本质)

    https://www.cnblogs.com/x_wukong/p/5712345.html

    这篇博客也是转载了别人的,可以点击这篇博客的上方链接去看原汁原味的博客。

     

    还有一篇直接将讲:C++函数的参数三种传值方式为:值传递、地址传递(指针传递,引用传递)

    https://blog.csdn.net/liang841451955/article/details/80241074

     

    还有一篇也不错:详解c++指针的指针和指针的引用

    https://www.cnblogs.com/li-peng/p/4116349.html

     

    此外,附上菜鸟教程的C++指针教程链接:很适合我这种水平的菜鸟巩固基础。

    http://www.runoob.com/cplusplus/cpp-pointers.html

    ******************************************************************************************************************************

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • C++ 指针作为函数参数传递的问题

    千次阅读 2019-09-24 16:02:17
    写一个函数,交换两个参数中的值。 初学者往往会这样写: void exchange(int x, int y) { int p=x; x = y; y = p; } 之后,你会查找资料了解到应该这样写: void exchange(int *x, int *y) { int *p=x; ...
  • 引用博文:...当指针作为函数参数传递时,在函数内部重新申请了一个新指针,与传入指针指向相同地址。在函数内部的操作只能针对指针指向的值。#include &lt;iostream&gt; using namespace st...
  • 二维数组指针作为函数参数传递

    千次阅读 2017-03-25 23:24:00
    以前二维数组作为函数参数传递我都是这么写的void def(int a[][10])。传递一个二维数组a,(其中第二维要确定大小)其实想一想挺合理的... 后来,发现还有这种写法 void def(int(*a)[10]); /* *****************...
  • 在C++中,通过多维数据的指针作为函数参数传递源程序
  • c++之指针作为函数参数传递的问题的pdf版本 博客:http://blog.csdn.net/fjb2080 欢迎访问!
  • 指针作为函数参数传递 (转载)

    万次阅读 2012-07-20 13:57:05
    这几天在学习C过程中,在使用指针作为函数参数传递的时候出现了问题,根本不知道从何得解:源代码如下:  createNode(BinNode *tree,char *p)  {  tree = (BinNode *) malloc(sizeof(BinNode));  tree->data =...
  • 指针作为函数参数传递一维数组 C 语言中声明了一个数组TYPE array[n],则数组名称array 就有了两重含义: 第一,它代表整个数组,它的类型是TYPE[n]; 第二,它是一个常量指针,该指针的类型是TYPE*,该指针指向的...
  • 使用指针变量作为函数参数|地址传递指针传递实例总结地址传递传递错误写法1错误写法2 地址传递 指针类型可以作为函数参数的类型,这时视为把变量的地址传入函数。如果在函数中对这个地址的元素进行改变,原先的...
  • 结构体、结构指针作为函数参数

    千次阅读 2019-05-20 07:19:25
    结构体、结构指针作为函数参数 结构体、结构体指针作为函数的参数现在应用的非常广泛,但一些细微之处还需要引起注意。本文将讨论其作为形参和实参的区别。 结构体作为参数 将结构体作为函数的参数,目的是通过...
  • 指针数组作为函数参数传递

    千次阅读 2020-03-14 20:34:54
    想了解指针数组作为函数参数传递,就必须清楚指针数组的概念,指针数组是一个一维数组,存放的是(int、char、short、long、double、float)+*的内容,也即数组中的每个元素存放的是一个地址。 了解了指针数组的本质...
  • 指针作为函数参数主讲人张静 函数的参数不仅可以是整型实型字符型等数据还可以是指针类型它的作用是将一个地址值传递给被调函数中的形参指针变量即在函数调用时确定形参指针的指向指针作为函数参数pointer_1ap2p1&b&...
  • 今天做C++作业遇到一个问题,需要写一个函数(在链表中添加新的节点)将结构体指针作为形参,结果发现传递之后无法改变结构体的值,链表的长度还是没变。通过查询资料,发现把形参改为对结构体指针的应用即可解决问题...
  • 在两个程序中都想通过GetMemory函数改变str指针变量里的地址,第一个程序直接用了str指针变量作为函数参数,第二个使用了指向str的指针作为函数参数。 第二个程序能正常运行的原因是: 在用指针作为参数传递给...
  • c语言指针作为函数参数

    万次阅读 多人点赞 2018-07-09 22:00:43
    指针变量作为参数也不例外,但是可以改变实参指针变量所指向的变量的值。 #include &lt;stdio.h&gt; void swap1(int x,int y),swap2(int *px,int *py),swap3(int *px,int *py); int main(vo...
  • #include &lt;stdio.h&gt; #include &lt;string.h&gt; struct student { int age; char sex; char name[30];...void inputstudent(struct student *ps)//对结构体变量输入时必须传地址 ...n...
  • 结构体作为函数参数传递

    千次阅读 2019-08-23 10:46:48
    结构变量是一个标量,它可以用于其他标量可以使用的任何场合,但把结构体作为参数传递给一个函数要注重效率 例如下面这样一个结构体: #define PRODUCT_SIZE 20 typedef struct{ char product[PRODUCT_SIZE]; ...
  • c++之指针和引用作为函数参数传递时的区别

    千次阅读 多人点赞 2020-06-03 09:15:57
    之前写过c++之值传递、引用传递、指针传递,今天再单独区分一下指针和引用作为函数参数传递时的区别。 本文参考浅谈C++中指针和引用的区别 一、指针作为函数参数传递时 1、类似于值传递,传入函数的指针只是原指针的...
  • 为了区别问题,特写了一个用指针作为参数函数做了对比,如下: ``` int main() { void print(char *p); int name = 5; int *n; n = &name; printf("n的地址为:%d\n", &n); printf("n指向的...
  • 指针作为函数参数进行传递的时候,本质上还是进行的“值传递”,也就是复制了一个新的指向该地址的指针变量
  • C语言 | 函数指针作为函数参数

    万次阅读 多人点赞 2019-08-05 08:22:38
    函数指针有两种常用的用法,一种是作为结构体成员,关于函数指针作为结构体成员的用法可移步至上一篇【C语言笔记】函数指针作为...当函数指针作为参数传递的时候,这时接收参数传递函数通常需要根据这个指针调...
  • 指针函数作为参数传递(经典小实例) 指针函数作为参数传递(经典小实例)
  • char *toUpper(char *a) {   char *b = a; //保留最初地址,因为后面的循环会改变字符串最初的地址   int len = 'a' - 'A';   while (*a != '\0' && *a != ' ') {   ... 
  • 使用回调函数实际上就是在调用某个函数(通常是API函数)时,将自己的一个函数(这个函数为回调函数)的地址作为参数传递给那个函数。而那个函数在需要的时候,利用传递的地址调用回调函数,这时你可以利用这个机会...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 352,871
精华内容 141,148
关键字:

指针作为函数参数传递