精华内容
下载资源
问答
  • 指针作为函数参数主讲人张静 函数的参数不仅可以是整型实型字符型等数据还可以是指针类型它的作用是将一个地址值传递给被调函数中的形参指针变量即在函数调用时确定形参指针的指向指针作为函数参数pointer_1ap2p1&b&...
  • 本文主要讲了c语言指针变量作为函数参数传递,下面一起来学习一下
  • 结构体、结构指针作为函数参数

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

    结构体、结构指针作为函数参数

    结构体、结构体指针作为函数的参数现在应用的非常广泛,但一些细微之处还需要引起注意。本文将讨论其作为形参和实参的区别。

    结构体作为参数

    将结构体作为函数的参数,目的是通过makeinfo()函数调用去改变person结构体中letters的值。

    情形1

    #include<stdio.h>

    #include<string.h>

    struct namect{

        char fname[20];

        char lname[20];

        int letters;

    };

    struct namect getinfo(void);

    struct namect makeinfo(struct namect);

    void showinfo(struct namect);

    int main(void)

    {

        struct namect person;

        person=getinfo();

        person=makeinfo(person);

        //makeinfo(person);

        showinfo(person);

        return 0;

    }

    struct namect  getinfo(void)

    {

        struct namect temp;

        printf("please enter you first name.\n");

        gets(temp.fname);

        printf("please enter you last name.\n");

        gets(temp.lname);

        return temp;

    }

    struct namect makeinfo(struct namect info)

    {

        info.letters=strlen(info.fname)+strlen(info.lname);

        return info;

    }

    void showinfo (struct namect info)

    {

        printf("%s %s ,your name contains %d letters .\n",info.fname,info.lname,info.letters);

    }

    程序的运行结果图如下:

    https://img-blog.csdn.net/20150905161616908

    情形2

    如果将person=makeinfo(person)改为makeinfo(person),则运行结果如下:

    https://img-blog.csdn.net/20150905161005090

    结构体指针作为参数

    将结构体指针作为函数的参数,从而直接去改变letters的值,相关代码如下:

    #include<stdio.h>

    #include<string.h>

    struct namect{

        char fname[20];

        char lname[20];

        int letters;

    };

    struct namect getinfo(void);

    void  makeinfo(struct namect *pst);

    void showinfo(struct namect);

    int main(void)

    {

        struct namect person;

        person=getinfo();

        //person=makeinfo(person);

        //makeinfo(person);

        makeinfo(&person);

        showinfo(person);

        return 0;

    }

    struct namect  getinfo(void)

    {

        struct namect temp;

        printf("please enter you first name.\n");

        gets(temp.fname);

        printf("please enter you last name.\n");

        gets(temp.lname);

        return temp;

    }

     void makeinfo(struct namect *pst)

    {

        pst->letters=strlen(pst->fname)+strlen(pst->lname);

    }

    void showinfo (struct namect info)

    {

        printf("%s %s ,your name contains %d letters .\n",info.fname,info.lname,info.letters);

    }

    程序运行结果如下:

    https://img-blog.csdn.net/20150905161616908

    在情形二与情形一比较,虽然表面上看起来情形二调用makeinfo(person)函数后,好像改变了person结构体中letters的值。但实质上调用makeinfo(person)函数中,结构体person只是作为一个形式参数,函数会创建一个新的结构体**infoperson中的值被复制到新的info结构体中,之后函数的所有处理过程都是针对这个**info结构体副本。自然而然得到的 letters的值只是存储在info中,而没有存在person结构体中。这就是为什么我们看到Letters是一个随机值的原因。

    结构体指针作为函数的参数,因为传送的实质就是person结构体的地址,也就是person结构体本身。makeinfo(&person)函数调用,通过使用指针pst定位把计算得到的值放在person结构体中,当然能改变其中letters的值。

    我们可以用形参和实参来类比理解,传结构体相当于一个形参(形式上的参数,只是起到一个原件的作用,之后的处理都是针对其复印件而言,要想改变原件必须对原件进行赋值),传结构体指针相当于一个实参(实实在在的参数,一般是传输相关参数的地址值,改变都是对它本身而言)。

    结构作为参数的优点

    1. 编程风格更加的直接、清晰。
    2. 由于其改变的是副本,所以比处理原始数据相比更加的安全。

    结构体指针作为参数的优点

    1. 只需要传递一个单个地址即可;
    2. 处理数据更加的方便,效率较高。

    但是两者也有各自的缺点,结构作为参数有时候比较浪费空间和时间,结构体指针缺少对数据的保护。

    通常,为追求效率常使用结构指针作为参数,当需要保护现场或者为发生某些不必要的意外时候使用const限制,传递结构值是处理小型结构经常用到的方法,通常传递指针或只将所需的成员作为参数传递。

    展开全文
  • 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类型的指针是不允许修改的。

    展开全文
  • 结构体指针作为函数参数:结构体变量名代表的是整个集合本身,作为函数参数时传递的整个集合,也就是所有成员,而不是像数组一样被编译器转换成一个指针。如果结构体成员较多,尤其是成员为数组时,传送的时间和空间...

    结构体指针作为函数参数:
    结构体变量名代表的是整个集合本身,作为函数参数时传递的整个集合,也就是所有成员,而不是像数组一样被编译器转换成一个指针。如果结构体成员较多,尤其是成员为数组时,传送的时间和空间开销会很大,影响程序的运行效率。所以最好的办法就是使用结构体指针,这时由实参传向形参的只是一个地址,非常快速。

     

    #include<stdio.h>
    struct stu{
            char *name;
            int score;
    } stus[]={
            {"zhangsan1",65},
            {"zhangsan2",98}
    };
    void averge(struct stu *,int);
    int main(){
    
            int len=sizeof(stus)/sizeof(struct stu);
            printf("start...\n");
            //数组名可以认为是一个指针
            averge(stus,len);
    
    }
    void averge(struct stu *stus,int len){
            char *name;
            int score;
            int sum=0;
            for(int i=0;i<len;i++){
                    name=stus[i].name;//第一种形式
                    score=(*(stus+i)).score;//第二种形式
                    sum+=score;
                    printf("%s...%d \n",name,score);
            }   
        
            printf("平均分:%d...\n",sum/len);
    }

     

    展开全文
  • 指针作为函数参数的函数定义和调用 函数定义:void printmsg(int * pointer) {…} “()”里为定义的指针pointer 实际调用:printmsg(&address); “()”里为输入的地址address ...
  • 二级指针作为函数参数

    千次阅读 2018-12-05 09:24:46
    1.用一级指针实现strlen int my_strlen1(char *str) { int count = 0; int i = 0; if (NULL == str) { return -1; } while (*str != '\0') { str++; count++; }...
  • 关于指针作为函数参数传递的理解

    千次阅读 2019-04-23 17:30:01
    本来已经把指针和引用的知识都捋清楚了,但是中午编程遇到了一个传递数组的问题,一下想得多了点,然后又。。。。 被值传递,指针传递,引用传递,地址传递这几个概念弄晕了。看了十来篇博客,什么说法都有。参考...
  • 形参都是值传递,此时,swap2函数的实参值是a,b的地址,在swap函数内部,px,py作为形参拷贝了a,b的地址,所以前两个输出的地址相同。但是在函数内部,t是一个指向整数的指针,交换时实际上是交换的形参py,px的...
  • C++用指向函数的指针作为函数参数

    千次阅读 2018-12-05 19:42:12
    示例: #include &lt;iostream&gt; using namespace std; int add(int x, int y){ return x + y; } int sub(int x, int y){ ...int operation(int x, int y, int(*function)(int, int)){ return func...
  • 指针作为函数参数:为什么需要指针做参数: 1. 需要数据双向传递时(引用也可以达到此效果) 2. 需要传递一组数据,只传首地址运行效率比较高example:#include &lt;iostream&gt; using namespace std; ...
  • 函数指针作为形参,即可实现函数名作为参数,由另一个函数调用。   一、 定义某一函数的指针类型: 就像自定义数据类型一样,我们也可以先定义一个函数指针类型,然后再用这个类型来申明函数指针变量。 我...
  • C语言程序设计 第10章 指针 第4讲指针作为函数参数 328677005 C语言课程交流群 1. 指向变量的指针作为函数的参数 提纲 2. 指向数组的指针作为函数的参数 3. 指向字符串的指针作为函数的参数 1. 指向变量的指针作为...
  • 结构体指针作为函数参数时,调用时传递的是指向一个结构体变量的指针(即 结构体变量的地址);结构体变量作为函数参数时,调用时传递的结构体变量本身。 即一个结构体A,当它的指针作为参数传入函数func,那么在...
  • 指针:内容为0的指针(因为空指针里面不放置内容);或者是地址为0的指针。 NULL实际上就是整数0。NULL可以用来代表空指针。 int * p2 = 0; 表示p2指向地址0。  不能写*pn = 。。int n=* pn;这种表达是...
  • 引用博文:...当指针作为函数参数传递时,在函数内部重新申请了一个新指针,与传入指针指向相同地址。在函数内部的操作只能针对指针指向的值。#include &lt;iostream&gt; using namespace st...
  • 只是为了说明用指向数组的指针函数参数而举的例子。用函数average求总平均成绩,用函数search找出并输出第i个学生的成绩。有些网上给出的方法有bug,这个是我自己修改过的程序。
  • 二维数组指针作为函数参数传递

    千次阅读 2017-03-25 23:24:00
    以前二维数组作为函数参数传递我都是这么写的void def(int a[][10])。传递一个二维数组a,(其中第二维要确定大小)其实想一想挺合理的... 后来,发现还有这种写法 void def(int(*a)[10]); /* *****************...
  • C指针作为函数参数引用

    千次阅读 2016-03-03 21:09:32
    C指针作为函数参数引用
  • 琢磨着用c++写个排序二叉树,被c++蹩脚的语法折腾得不要不要的,最要命的地方就是我将main函数里面的结构体传递给函数的时候,在函数里面做的修改不会使得main函数里的实参也变化,见鬼了,讲道理不是指针传递会修改...
  • 用指向一维数组的指针变量即二维数组的行指针作为函数参数,实现矩阵转置。 按如下函数原型编程计算并输出m×n阶矩阵的转置矩阵。 其中,m和n的值由用户从键盘输入。已知m和n的值都不超过10。 void Transpose(int (*...
  • 本文内容出自《高质量C、C++编程指南》。阅读之后理解,然后通过自己的话和例子讲清楚,...1、数组作为函数参数进行传递时,该数组自动退化为同类型的指针。 2、指针参数是如何传递内存的 3、使用指针参数传递内存
  • 如何正确使用指针(指针作为输出型参数)与结构体指针作为函数参数 外部定义一个结构体类型指针变量,使用##结构体指针里面的内嵌指针,返回值,双重指针##方式进行地址传递
  • 本文主要介绍在 C/C++ 编程语言中,指针变量作为函数参数的用法示例。 1 示例1 示例代码如下: #include <stdio.h> #include <stdlib.h> int main() { /* 函数声明 */ int swap(int *p1, int *...
  • 指针作为函数参数传递 (转载)

    万次阅读 2012-07-20 13:57:05
    这几天在学习C过程中,在使用指针作为函数参数传递的时候出现了问题,根本不知道从何得解:源代码如下:  createNode(BinNode *tree,char *p)  {  tree = (BinNode *) malloc(sizeof(BinNode));  tree->data =...
  • 1、函数指针 函数指针用于指向一个函数 函数名是函数体的入口地址 ...parameter list为指向函数参数类型列表 例: #include <windows.h> #include <stdio.h> #include <iostre
  • 类型名*函数名(函数参数表列); 其中,后缀运算符括号"()"表示这是一个函数,其前缀运算符星号"*"表示此函数为指针型函数,其函数值为指针,即它带回来的值的类型为指针,当调用这个函数后,将得到一个"指向返回值...
  • 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...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 436,779
精华内容 174,711
关键字:

指针作为函数参数