精华内容
下载资源
问答
  • 当你想传递一个实参到一个函数中,经过改变再拿来使用的话,需要这样 想改变int a 的值需要传递a的地址 &a(a的指针)0的值 想改变int *a 指针的内容,需要传递 &a(就是指针指针) 原因是 传递一个实参...

    当你想传递一个实参到一个函数中,经过改变再拿来使用的话,需要这样

    1. 想改变int a 的值需要传递a的地址 &a(a的指针)0的值
    2. 想改变int *a 指针的内容,需要传递 &a(就是指针的指针)

    原因是 传递一个实参到一个函数中 会产生一个副本,在函数中所做得操作都是对副本进行的,但是这个副本不会传出来,但是副本指向的东西改变还是有作用的

    例如传递一个指针,
    在这里插入图片描述

    Void change(int *a)
    {
     *a = 100;
     a = 300;
    }
    Int main ()
    {
    Int *a;
    *a = 10;
    Change (a);
    Printf (“%d”,*a);
    Printf (“%d”,a);
    }
    

    在函数change中会产生一个副本_a 和 a 指向同一位置,你改变_a 指向这个位置的内容10变成100 ,因为a也指向这里,所以 *a =100

    但是如果你改变副本指针_a本身的话,指针_a 会改变,但是指针a还是指向原来的位置

    传递2级指针可以改变1级指针的内容
    在这里插入图片描述

    Void mymalloc(char **s)
    {
     *s=(char*)malloc(100);
    }
    Int main ()
    {
    char*a = NULL;
    mymalloc (&a);;
    }
    

    想对一级指针a操作,必须取启a的指针(二级指针),这样在mymalloc函数中会有一个副本2级指针指向指针a, 因为都指向a, 所以对副本的二级指针指向的a操作,a就会发生变化

    展开全文
  • 1、一级指针和二级指针 2、函数指针传递的例子 3、什么时候需要传递二级指针? 4、二级指针在链表中的使用 1、一级指针和二级指针 一级指针:即我们一般说的指针,就是内存地址; 二级指针:指向指针的指针,...

    主要内容:

    1、一级指针和二级指针

    2、函数指针传递的例子

    3、什么时候需要传递二级指针?

    4、二级指针在链表中的使用

    1、一级指针和二级指针

    一级指针:即我们一般说的指针,就是内存地址;

    二级指针:指向指针的指针,就是地址的地址;

    如:

    int a=1;

    int *p=&a;  // p为a变量的地址,通过*p可以得到a的值

    int **q=&p;   // q为p指针的地址,通过**q可以得到a的值 

    2、函数指针传递的例子

    程序1:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    #include<stdio.h>

     

    void  fun(int  *p){

        int  b=100;

        p=&b;

    }

     

    int main(){

        int  a=10;

        int  *q;

        q=&a;

        printf("%d\n",*q);

        fun(q);

        printf("%d\n",*q);

        return  0;

    }

    运行结果:

    10

    10

    程序2:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    #include<stdio.h>

     

    void  fun(int  **p){

        int  b=100;

        *p=&b;

    }

     

    int main(){

        int  a=10;

        int  *q;

        q=&a;

        printf("%d\n",*q);

        fun(&q);

        printf("%d\n",*q);

        return  0;

    }

    运行结果:

    10

    100

    程序3:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    #include<stdio.h>

    #include<stdlib.h>

     

    void  myMalloc(char  *s){

         s=(char*)malloc(100);

    }

     

    int main()

    {

         char  *p=NULL;

         myMalloc(p);

         if(p==NULL)

            printf("P is not changed!\n");

         else{

            printf("P has been changed!\n");

            free(p);

         }

         return 0;

    }

    运行结果:

    P is not changed!

    程序4:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    #include<stdio.h>

    #include<stdlib.h>

     

    void  myMalloc(char  **s){

         *s=(char*)malloc(100);

    }

     

    int main()

    {

         char  *p=NULL;

         myMalloc(&p);

         if(p==NULL)

            printf("P is not changed!\n");

         else{

            printf("P has been changed!\n");

            free(p);

         }

         return 0;

    }

    运行结果:

    P has been changed!

    3、什么时候需要传递二级指针?

    通过上述例子,我们可以看到,在某些情况下,函数参数传递一级指针时,在函数体内对指针做变动,也不会对原始指针产生变化,而传递二级指针时,则可以,这是为什么呢?

    在传递一级指针时,只有对指针所指向的内存变量做操作才是有效的;

    在传递二级指针时,只有对指针的指向做改变才是有效的;

    下面做简单的分析:

    在函数传递参数时,编译器总会为每个函数参数制作一个副本,即拷贝;

    例如:

    void fun(int *p),指针参数p的副本为_p,编译器使_p=p,_p和p指向相同的内存空间,如果在函数内修改了_p所指向的内容,就会导致p的内容也做相应的改变;

    但如果在函数内_p申请了新的内存空间或者指向其他内存空间,则_p指向了新的内存空间,而p依旧指向原来的内存空间,因此函数返回后p还是原来的p。

    这样的话,不但没有实现功能,反而每次都申请新的内存空间,而又得不到释放,因为没有将该内存空间的地址传递出来,容易造成内存泄露。

    void fun(int **p),如果函数参数是指针的地址,则可以通过该参数p将新分配或新指向的内存地址传递出来,这样就实现了有效的指针操作。

    如果觉得二级指针比较难理解,也可以通过函数返回值的形式来传递动态内存(切记不能返回栈内存),如:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    #include<stdio.h>

    #include<stdlib.h>

     

    char* myMalloc(){

         char *s=(char*)malloc(100);

         return s;

    }

     

    int main()

    {

         char  *p=NULL;

         p=myMalloc();

         if(p==NULL)

            printf("P is not changed!\n");

         else{

            printf("P has been changed\n");

            free(p);

         }

         return 0;

    }

    知道了上述这些,就不难理解上面四个小程序的执行结果了。

    4、二级指针在链表中的使用

    在链表或者树的操作中,也需要用到二级指针,

    比如创建链表的头指针:

    在初始化链表函数中,传入头指针,并在函数中为该指针分配空间,此时就应该使用二级指针,如void initLinklist(Node **head);

    而在添加删除结点的过程中,我们并没有改变函数参数指针的指向,而是通过传入的指针如Node *head,找到要删除结点的位置,并未对该指针做改变,因此退出函数后,该指针无影响。

    展开全文
  • 二级指针作为函数参数申请内存

    千次阅读 2015-11-04 22:19:56
    0:声明:这篇文章转自林锐的《高质量的C/C++编程指南》,如果想看电子版文档,请去下载【去下载】1:如果函数参数是一个指针,不要指望用该指针去申请动态内存。示例7-4-1 中,Test 函数的语句 GetMemory(str, ...

    0:声明:这篇文章转自林锐的《高质量的C/C++编程指南》,如果想看电子版文档,请去下载【去下载】

    1:如果函数的参数是一个指针,不要指望用该指针去申请动态内存。示例7-4-1 中,Test 函数的语句 GetMemory(str, 200)并没有使 str 获得期望的内存,str 依旧是 NULL,为什么?

    [html]  view plain copy
    1. void GetMemory(char *p, int num)   
    2. {   
    3.      p = (char *)malloc(sizeof(char) * num);   
    4. }   
    5. void Test(void)   
    6. {   
    7.      char *str = NULL;   
    8.      GetMemory(str, 100);  // str 仍然为 NULL   
    9.      strcpy(str, "hello");  // 运行错误   
    10. }   
    11. 示例7-4-1 试图用指针参数申请动态内存   


    毛病出在函数 GetMemory中。编译器总是要为函数的每个参数制作临时副本,指针参数 p 的副本是 _p,编译器使 _p =p。如果函数体内的程序修改了_p 的内容,就导致参数 p 的内容作相应的修改。这就是指针可以用作输出参数的原因。在本例中,_p 申请了新的内存,只是把_p 所指的内存地址改变了,但是 p 丝毫未变。所以函数 GetMemory并不能输出任何东西。事实上,每执行一次 GetMemory 就会泄露一块内存,因为没有用free 释放内存。 如果非得要用指针参数去申请内存,那么应该改用“指向指针的指针”,见示例7-4-2。

    [html]  view plain copy
    1. void GetMemory2(char **p, int num)   
    2. {   
    3.     *p = (char *)malloc(sizeof(char) * num);   
    4. }  
    5. void Test2(void)   
    6. {   
    7.      char *str = NULL;   
    8.      GetMemory2(&str, 100); // 注意参数是 &str,而不是 str   
    9.      strcpy(str, "hello");    
    10.      cout<< str << endl;   
    11.      free(str);    
    12. }   
    13. 示例7-4-2用指向指针的指针申请动态内存  

    由于“指向指针的指针”这个概念不容易理解,我们可以用函数返回值来传递动态内存。这种方法更加简单,见示例7-4-3。

    [html]  view plain copy
    1. char *GetMemory3(int num)   
    2. {   
    3.      char *p = (char *)malloc(sizeof(char) * num);   
    4.      return p;   
    5. }  
    6. void Test3(void)   
    7. {   
    8.      char *str = NULL;   
    9.      str = GetMemory3(100);   
    10.      strcpy(str, "hello");   
    11.      cout<< str << endl;   
    12.      free(str);    
    13. }   
    14. 示例7-4-3 用函数返回值来传递动态内存   

    用函数返回值来传递动态内存这种方法虽然好用,但是常常有人把return 语句用错了。这里强调不要用return语句返回指向“栈内存”的指针,因为该内存在函数结束时自动消亡,见示例7-4-4。

    [html]  view plain copy
    1. char *GetString(void)   
    2. {   
    3.      char p[] = "hello world";   
    4.      return p;  // 编译器将提出警告   
    5. }   
    6. void Test4(void)   
    7. {   
    8.     char *str = NULL;   
    9.     str = GetString(); // str 的内容是垃圾   
    10.     cout<< str << endl;   
    11. }   
    12. 示例7-4-4 return语句返回指向“栈内存”的指针   

    用调试器逐步跟踪 Test4,发现执行 str = GetString 语句后 str 不再是 NULL 指针,但是 str 的内容不是“hello world”而是垃圾。 如果把示例7-4-4改写成示例7-4-5,会怎么样? 

    [html]  view plain copy
    1. char *GetString2(void)   
    2. {   
    3.      char *p = "hello world";   
    4.      return p;   
    5. }   
    6. void Test5(void)   
    7. {   
    8.      char *str = NULL;   
    9.      str = GetString2();   
    10.      cout<< str << endl;   
    11. }   
    12. 示例7-4-5 return语句返回常量字符串  

    函数 Test5 运行虽然不会出错,但是函数 GetString2 的设计概念却是错误的。因为GetString2 内的“hello world”是常量字符串,位于静态存储区,它在程序生命期内恒定不变。无论什么时候调用 GetString2,它返回的始终是同一个“只读”的内存块。 
    展开全文
  • 1. 指针作为函数参数 2. 指向一维数组的指针以及指针数组 3. 指向函数的指针 —— 1. 指向变量的指针/指针变量 2. 指向数组的指针/数组指针 3. 指向字符串的指针/字符指针 4. 指向函数的指针/函数指针 5. 指向结构体...

    本博文为半摘记性质。
    ——
    声明:知识点引自《全国计算机等级考试-上机考试新版题库 二级C》,部分例程修改自https://www.runoob.com/cprogramming/c-tutorial.html 菜鸟教程,另有部分零散资料转自互联网,内容有一定改动,并非全文转载。
    本人尊重各位的知识成果,大幅引用的文章原文网址已在各小节末尾给出。
    ——
    C语言在线运行工具:http://c.jsrun.net/

    编译预处理与指针

    本文要点:

    1. 指针作为函数参数
    2. 指向一维数组的指针以及指针数组
    3. 指向函数的指针

    1指针

    https://www.jb51.net/article/80775.htm 简单总结C语言中各种类型的指针的概念

    指针基础

    预备知识
    定义一个变量a,C语言规定a表示存储单元中的数据,&a表示存储单元的地址。a存储单元中的数据可以是一个普通数值,也可以是另一个存储单元的地址。

    ——

    关于指针和指针变量:存在两种概念混用的情况,严格来讲:

    1. 系统为每一个内存单元分配一个地址值,C/C++把这个地址值称为“指针”。如有int i=5;,存放变量i的内存单元的编号(地址)&i被称为指针。
    2. “指针变量”则是存放前述“地址值”的变量,也可以表述为,“指针变量”是存放变量所占内存空间“首地址”的变量(因为一个变量通常要占用连续的多个字节空间)。比如在int i=5;后有一句int *p=&i;,就把i的指针&i赋给了int *型指针变量p,也就是说p中存入着&i。所以说指针变量是存放指针的变量。

    星号* 的作用是解引用,即 *运算符给出指针变量p中存储的地址上存储的值。定义指针变量时加星号是为了防止和普通变量搞混。
    p为指针变量中存储的地址,*p为指针访问值。要注意指针自己也是有地址的,因此又有了二级指针的概念(**p)。

    https://blog.csdn.net/qq_26606969/article/details/82872693 C语言中“指针”和“指针变量”的区别,以及如何区分 * 得用法

    指针变量的定义形式

    类型名 *指针变量名1,*指针变量名2,...;
    

    指针变量的赋值方式

    int *p;
    p=&a;
    等价于:int *p=&a; 
    

    注意:

    1. 指针变量只能保存同型元素的地址。对于类型不同的指针变量,其内容(地址值)增1,减1所跨越的字节数是不同的,因此基类型不同的指针变量不能混合使用。
    2. 指针变量在使用前必须赋初值。如果没有确切的地址可以赋值,为指针变量赋一个 NULL 值是一个良好的编程习惯。赋为 NULL 值的指针被称为空指针
    int  *ptr = NULL;
    
    1. 指针变量不能存放字符串,只有字符数组提供其存放的空间;不过字符串可以赋值给字符指针变量:p=“abcd”;双引号做了3件事:
      1.申请了空间(在常量区),存放了字符串 2. 在字符串尾加上了’/0’ 3.返回地址
      这里就是将 返回地址 赋值给了指针变量。
      当需要多个字符串时可以采用指针数组(见后文)。

    https://blog.csdn.net/ss19890125/article/details/48689385 C语言中,为什么字符串可以赋值给字符指针变量

    指针变量的算数运算

    1. 可以对指针变量进行四种算术运算:++、–、+、-。

    指针变量的每一次递增,它其实会指向下一个元素的存储单元;指针变量的每一次递减,它都会指向前一个元素的存储单元。
    在程序中常使用指针变量代替数组,因为指针变量可以递增,而数组不能递增,数组可以看成一个指针常量。
    注意:函数指针运算不能参与算术运算。

     int  var[] = {10, 100, 200};
     int  *ptr;   
       ptr = var;
       ptr++;
    结果为*ptr=100
    
    1. 指针可以用关系运算符进行比较,如 ==、< 和 >。

    指向指针的指针(二级指针)

    定义形式:

    类型名 **指针变量名1,**指针变量名2,...;
    

    赋值形式:

    int  var=3000,*ptr,**pptr;
       ptr = &var;//ptr存着var的地址
       pptr = &ptr;//pptr存着ptr的地址
       ____
       *pptr=ptr=var's address
       **pptr=*ptr=3000
    

    指向XX的指针

    有:

    1. 指向变量的指针/指针变量(见前文)
    2. 指向数组的指针/数组指针(见下文)
    3. 指向字符串的指针/字符指针(见下文)
    4. 指向函数的指针/函数指针(见下文)
    5. 指向结构体的指针/结构指针
      (见https://blog.csdn.net/weixin_45263626/article/details/105520031 结构指针)

    https://blog.csdn.net/qq_36243846/article/details/74929207 c语言常见的几种指针用法

    指向一维数组的指针

    同理可得出指向二维数组的指针

    指向一维数组的指针定义形式(定义+赋值):

    类型名 (*指针名)[数组长度] = &数组名[数组长度];//指针名加括号是为了同指针数组区分
    //数组长度指访问的二维数组中每行的元素个数
    

    注意: 注意区分指向数组的指针(见本章)和指向数组元素的指针(见【指针的算数运算】)。

    int array[5] = {1, 2, 3, 4, 5}; // 定义数组
    int *intptr = array; // 即ptr = &array[0],定义指向数组元素的指针,同理也可定义其它数组元素,例如:ptr = &array[1]
    int (*arrayptr)[5] = &array; // 定义指向数组的指针
    

    通过指向数组的指针访问数组的元素:

    (*arrayptr)[n] == array[n]
    

    二维数组实际上就是元素为一维数组的数组,二维数组名可以看做 指向其第一个元素(一维数组) 的指针,而一维数组可以看做一个1 x n的二维数组,即只有一个元素的二维数组。
    arrayptr指向了该二维数组的第一个元素(相当于二维数组名) ,所以有:

    arrayptr[0][0] == array[0]
    同理arrayptr[0][1] == array[1]...
    

    通过下标运算符 arrayptr[0] 获得二维数组的第一个元素(实际上就是array数组), 然后再次利用下标运算符 arrayptr[0][0] 获取array数组的第一个元素.
    ——
    指向一维数组的指针可以作为函数的形参,来接收二维数组的首地址,在函数中按行访问二维数组。

    https://blog.csdn.net/qq_31504597/article/details/79966023 C语言之指向一维数组的指针

    指向字符串的指针

    char *指针名;
    指针名 = “字符串”;//不需要加&
    或:char *指针名 = “字符串”
    

    指向函数的指针

    注意与指针函数的区别。

    一个函数的函数名就是一个函数指针,通常是被隐式地转换的。函数的调用可以通过函数名,也可以通过指向函数的指针来调用。

    函数指针变量的声明格式有多种,标准格式(少见)为:

    类型 (*指针变量名)();//类型标识符指函数的返回值类型
    //该声明中采用括号将星号和指针变量名包围起来,这个括号很重要。如果没有它,则为函数原型,而不是指针定义。
    //最后的空括号表示指针变量所指的是一个函数    
    //类似数组指针                       
    

    另一声明格式(常用)为:

    类型 (*指针变量名)(参数类型1,参数类型2);
    例:int (*p)(int,int);//形参可省
    或:int (*p)(int a,int b);//形参保留
    

    可以将函数入口地址(函数名) 赋予指针变量,以此来调用此函数。

    函数指针变量 =  函数名;
    

    用函数指针变量形式调用函数的一般形式(调用形式)为:

    (*指针变量名)(实参表);
    

    实例:

    #include <stdio.h>
    
    int max(int a, int b)
    {
        return a > b ? a : b;
    }
    
    int main(void)
    {
        int (*p)(int, int); //函数指针的定义   
        p = max;    //函数指针初始化
    
        int ret = p(10, 15);    //函数指针的调用
        //int ret = (*max)(10,15);
        //int ret = (*p)(10,15);
        //以上两种写法与第一种写法是等价的,不过建议使用第一种方式
        printf("max = %d \n", ret);
        return 0;
    }
    
    

    函数指针变量不能参与算术运算。

    回调函数(callback)
    函数指针的一个非常典型的应用就是回调函数。
    回调函数就是一个通过函数指针调用的函数
    如果你把函数的指针(地址)作为参数传递给另一个函数(登记回调函数),当这个指针被用来调用其所指向的函数时,则该函数为回调函数。
    回调函数不是由该函数的实现方直接调用,而是在特定的事件或条件发生时(触发回调事件)由另外的一方间接调用的(调用回调函数),用于对该事件或条件进行响应(响应回调事件)。

    回调函数的优势待补充

    指针函数

    注意函数指针与指针函数的区别。指针函数是指一个函数的返回值类型为指针。
    声明格式为:

    *类型标识符 函数名(形参表)
    例:int *fun(int x,int y);
    

    在调用指针函数时,需要一个同类型的指针来接收其函数的返回值。
    实例:

    int *func_sum(int n)
    {
        if (n < 0)
        {
            printf("error:n must be > 0\n");
            exit(1);
        }
        static int sum = 0;
        int *p = &sum;
        for (int i = 0; i < n; i++)
        {
            sum += i;
        }
        return p;
    }
    
    int main(void)
    {
        int num = 0;
        printf("please input one number:");
        scanf("%d", &num);
        int *p = func_sum(num); //在调用指针函数时,需要一个**同类型的指针**来接收其函数的返回值。
        printf("sum:%d\n", *p);
        return 0;
    }
    
    

    https://blog.csdn.net/u010280075/article/details/88914424 指针函数和函数指针

    指针数组

    指针数组可以保存多个地址。
    当数组的基类型为指针类型时其定义形式为:

    类型名 *数组名[常量表达式];
    

    数组指针变量加减一个整数可使指针移动指向后面或前面的数组元素。

    指针数组存放的是数据的地址,多用于保存多个字符串的首地址

    int main ()
    {
       const char *names[] = {      //注意同字符数组的区别
                       "Zara Ali", //不需要二维数组,每个数组元素只是一个字符串的首地址
                       "Hina Ali",
                       "Nuha Ali",
                       "Sara Ali",
       };
       int i = 0;
       for ( i = 0; i < 4; i++)
       {
          printf("Value of names[%d] = %s\n", i, names[i] );
       }
       return 0;
    }
    结果:
    Value of names[0] = Zara Ali
    Value of names[1] = Hina Ali
    Value of names[2] = Nuha Ali
    Value of names[3] = Sara Ali
    

    指针作为函数参数

    一级指针作为函数参数

    在c语言中实参和形参之间的数据传输是单向的“值传递”方式,也就是实参可以影响形参,而形参不能影响实参。但当指针变量作为函数的参数时,可以改变实参值
    • 要实现这一功能,实参可以是变量的地址(&a)或指向变量的指针变量(p);利用指针变量作为函数的形参时,形参接收的是地址值
    此外return语句只能返回一个数据,用指针变量作为函数的参数,此时调用函数就可以修改多个参数值。

    void swap(int *p1, int *p2){  //*p1=&a,*p2=&b
        int temp;  //临时变量
        temp = *p1;
        *p1 = *p2;
        *p2 = temp;
    }
    int main(){
        int a = 66, b = 99;//或加上*q1=&a,*q2=&b;
        swap(&a, &b);//swap(q1,q2);这是因为q1=&a,q2=&b
        printf("a = %d, b = %d\n", a, b);
        return 0;
    }
    运行结果:a=99,b=66;
    

    指针作为被调函数形参可以更改主调函数中数据的原因是函数调用时实参的地址传递给相应的形参,借助指针的访问,可以访问或改变主调函数中的数据。

    优点: 指针作为函数参数的好处在于效率高,因为C语言的参数传递调用方式要求把参数的一份拷贝传递给函数,必须把结构体占用的内存空间复制到堆栈中,以后再丢弃。

    二级指针作为函数参数

    模仿上一例的操作方法,仍用一级指针,指针变量q指向a,现在让指针变量q指向b。

    int a = 66, b = 99;
    void swap(int *p1){  
    
        p1 = &b;
     
    }
    int main(){
        int *q1=&a;
    swap(q1); 
        printf("*q1 = %d\n", *q1);
        return 0;
    }
    结果:*q1=66
    

    测试失败,指针变量q1没有改变。这是因为:

    *p1=q1,q1=&a;
    所以*p1=&a;
    接着*p1=&b;
    

    第三步操作并没有涉及到指针变量q1,由于函数没有返回值,函数的作用相当于0。
    现改用二级指针:

    int a = 66, b = 99;
    void swap(int **p1){  //p1=&a,p2=&b
    
        *p1 = &b;
     
    }
    int main(){
        int *q1=&a;
    swap(&q1);
        printf("*q1 = %d\n", *q1);
        return 0;
    }
    结果:*q1=99
    

    测试成功,这是因为:

    **p1=&q1;
    *p1=q1=&a;
    *p1=&b;
    因此 q1=&b;
    

    一级指针作为函数参数的例子中涉及到了两个指针,可以直接交换地址;而第二个例子则不行。

    更多参考:
    http://blog.csdn.net/majianfei1023/article/details/46629065 二级指针的作用详解

    指针数组作为函数参数

    没什么特别的。

    展开全文
  • c语言中的二级指针函数参数

    千次阅读 2018-03-27 11:19:43
    //如果函数参数是指针,不能用一级指针函数参数实现申请动态内存 void getMemory(char *p, int num) { p = (char *)malloc(sizeof(char)*num); } void main() { char *str = NULL; getMemory(str, 20); ...
  • 二级指针函数参数

    2019-03-31 11:19:47
    二级指针函数参数
  • 深入阐述一级指针和二级指针的概念,解决函数传递时值传递和引用传递带来的困惑
  • 引用博文:...当指针作为函数参数传递时,在函数内部重新申请了一个新指针,与传入指针指向相同地址。在函数内部的操作只能针对指针指向的值。#include &lt;iostream&gt; using namespace st...
  • 在上一篇文章《C函数的“传值调用”和“传址调用”的深入分析》我们分析了函数参数的使用,对于一级指针,理解起来相对容易,而二级指针参数的理解相对难一些,我们先说一下二级指针作为函数形参的目的。 二级指针...
  • 二级指针,二维数组函数参数传递

    千次阅读 2018-05-14 12:05:55
    二级指针作为函数形参时,能作为函数实参的是二级指针,指针数组,一级指针的地址 当数组指针作为函数形参时,能作为函数实参的是二维数组,数组指针 当二维数组作为函数形参时,能作为函数实参的是二维数组,数组...
  • 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;; } ...
  • //C语言二级指针函数参数改变该指针的指向 #include void change_pointer(char **pp) { char *str="the pointer has been changed! \n"; *pp=str; } int main(int argc, char **argv) { char *p=NULL;
  • 函数指针函数名、维数组指针做形参时的要注意的地方
  • 为什么要使用二级指针

    千次阅读 多人点赞 2020-06-15 16:05:06
    所以,当我们定义了一个指向指针的指针的时候(pointer to pointer),我们也称之为二级指针,那针对于这个二级指针来说,第一级指针存放的是指向的变量的地址,第二级指针存放的是第一级指针的地址。可以用下面这张图...
  • int (*p[num])( char*,int,int );...然后今天主要理一下函数指针数组和二级指针函数指针数组 函数指针数组中,存放的一定要是相同返回值类型,以及相同参数列表的函数指针,这样数组可...
  • 指针和引用 作为函数参数

    千次阅读 2018-11-05 18:23:11
    * 有两个作用,一个是作为标识符来表示这是一个指针(声明变量时的等号左边),也就是说存放的是地址,另外一个是作为运算符来取值(赋值等号左边)。 int *p=NULL; int a = 1; p = &amp;amp;a; cout&amp;lt;&...
  • 二级指针和指针引用函数传参(C++)

    万次阅读 多人点赞 2016-10-23 13:18:18
    函数的使用过程中,我们都明白传值和传引用会使实参的值发生改变。那么能够通过传指针改变指针所指向的地址吗?在解决这个问题之前,也许我们应该先了解指针非常容易混淆的三个属性: ①.指针变量地址(&p) ...
  • 二级指针作为形参简单实例分析

    千次阅读 2018-08-20 16:36:27
    指针是程序数据在内存中的地址,而指针变量是用来保存这些地址的变量。   举例 int c=2,d=3; int *pc=&amp;c; pc是指针变量的存储内容,也就是c的地址 *pc就是对指针的解引用,取出这个c这个地址里面的值 ...
  • 指针作为函数参数传递一维数组 C 语言中声明了一个数组TYPE array[n],则数组名称array 就有了两重含义: 第一,它代表整个数组,它的类型是TYPE[n]; 第,它是一个常量指针,该指针的类型是TYPE*,该指针指向的...
  • 指针数组作为函数参数的传递

    千次阅读 2020-03-14 20:34:54
    指针数组作为函数参数的传递 想了解指针数组作为函数参数传递,就必须清楚指针数组的概念,指针数组是一个一维数组,存放的是(int、char、short、long、double、float)+*的内容,也即数组中的每个元素存放的是一个...
  • C指针作为函数参数引用

    千次阅读 2016-03-03 21:09:32
    C指针作为函数参数引用
  • 关于函数传值调用(二级指针)

    千次阅读 2017-08-15 20:49:34
    同样,当我们想通过p来修改str的时候,其实我们需要将 p 和 str 当成一个指针来看待,这时候,只有通过二级指针,才能将 str “带到” p 之后指向的地方: 在 char *p =str; 后,p 和 str 的值是一样的了,...
  • 在之前的文章 《二级指针作为函数形参的深入理解》 我们分析了二级指针的使用,这里我们再简单的的做个小结。 一级指针作为入参 一级指针作为入参,在函数内部是要对该指针进行 简介引用,操作一级指针指向的内存...
  • 指针作为函数参数 交换两个数的位置 */ /* 指针作为函数参数 交换两个数的位置 */ #include <stdio.h> changeData(int a,int b){ int c; c=a; a=b; b=c; printf("a=%d",a); printf("b=%d...
  • 二级指针作为函数形参时,能作为函数实参的是二级指针,指针数组,一级指针的地址 b.当数组指针作为函数形参时,能作为函数实参的是二维数组,数组指针 c.当二维数组作为函数形参时,能作为函数实参的是二维数组...
  • 指针参数传递实质及二级指针使用

    千次阅读 多人点赞 2016-10-01 20:59:23
     好了,我们来看一下,test函数的形参使用的是二级指针,我们把a的地址传给了p,即p指向了a;指针a指向的是数组b,即保存的是b的首地址,见第二个程序第一张图;二级指针p指向一级指针a,所以*p的值就是a的首地址,...
  • c语言二级指针函数指针

    千次阅读 2016-07-19 00:23:43
    0: 什么是二级指针:让你去寻宝,给你一个地址,到那个地址以后发现宝贝还是一个地址。二级指针就是指针的指针保存的是指针的地址 二级指针,前面有两个星号, 1: 函数指针,函数作为一个参数进行传递,函数...
  • 指针作为函数参数传递一维数组 C 语言中声明了一个数组TYPE array[n],则数组名称array 就有了两重含义: 第一,它代表整个数组,它的类型是TYPE[n]; 第,它是一个常量指针,该指针的类型是TYPE*,该指针指向...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 156,583
精华内容 62,633
关键字:

二级指针作为函数参数