精华内容
下载资源
问答
  • 指针常量和常量指针  要想搞清楚这一对,必须先知道const关键字;const关键字用来修饰一个变量,表示该变量是只读变量,不可以修改的;(在C语言中const修饰的变量是可以用指针来强制改变的,但在C++中是不行的;)...

            C语言中有各种比较纠结的结构,容易混淆,也经常说是面试的重点,现在就来总结下各种小纠结;


    指针常量和常量指针

            要想搞清楚这一对,必须先知道const关键字;const关键字用来修饰一个变量,表示该变量是只读变量,不可以修改的;(在C语言中const修饰的变量是可以用指针来强制改变的,但在C++中是不行的;)
            顺便说下const的几个作用:
            1、修饰变量为只读,能对不想修改的变量进行保护作用,能提高程序的健壮性
            2、const定义的常量编译器可以对其进行数据静态类型安全检查;
            3、const修饰函数形式参数:当输入参数为用户自定义类型和抽象数据类型时,将“值传递”改为“const&传递”可以提高效率;
            4、关键字const的作用是为给读你代码的人传达非常有用的信息。

            指针常量:(int* const  p)指针是常量,指针指向不可以改变,内容可以改变;
            常量指针:(int const *p)指向常量的指针,指向可以改变,但内容不可以改变;
            总结:看const修饰的是指针还是变量;

    数组指针和指针数组

            数组指针:表示指向数组的指针,一般就是说二维数组指针;表示为:int  (*ap)[11];
            指针数组:表示数组中存放的都是指针;表示为:int ×  array[11];
    演示代码:
     #include<stdio.h>
     
     int main()
     {
         int i, j;
     
     /*********指针数组*********/   
         char* array[3];
         array[0] = "yu";
         array[1] = "zhi";
         array[2] = "hui";
     
         printf("char* array:%s %s %s\n", array[0], array[1], array[2]);
     
     /*********数组指针*************/
         int intArray[3][3] = { 
             {1,2,3},
             {11,12,13},
             {21,22,23}
         };  
     
         int (*ap)[3] = intArray;
         for (i = 0; i < 3; i++)
             for (j = 0; j < 3; j++)
                 printf("(ap+%d)[%d]:%d\n", i, j, (*(ap+i))[j]);
     
         return 0;
     }
    

    函数指针和指针函数

            函数指针:指向函数的指针;表示:int  (*func)(int);
            指针函数:返回指针的函数;表示: int*  func(int);
    演示代码:
     #include<stdio.h>
    
     // 指针函数
     int* test(int *tmp)
     {
         *tmp += 10; 
         return tmp;
     }
     
     void test1(int i)
     {
         printf("int test1 i is:%d\n", i); 
     }
     
     void test2(int i)
     {
         printf("int test2 i is:%d\n", i); 
     }
     
     int main(void)
     {
         int tmp = 10; 
         printf("tmp:%d\n", (*test(&tmp)));
    
     // 函数指针,指向函数的指针
         void (*p)(int) = test1;
         (*p)(110);
     
         p = test2;
         p(119);
     
         return 0;
     }
            额外的总结下函数指针的一些问题:
            在《C陷阱和缺陷》一书中有提到一个问题:在某微处理器上,当计算机启动时,硬件调用首地址为0位置上的子例程;
            最终设计的语句是:(*  (  void (*)()  )  0 ) ();看着挺复杂的,其实还是很简单的,书上也对此进行了详细的说明;这里就大概说下吧:
            首先是构造一个函数指针:void (*)();其中省略了函数名(不习惯的话,可以随意添加一个),不传入参数,无返回值;
            然后把0强制转换为该函数指针,一定要记住:其实函数指针以及函数都是个地址而已,表示从哪个地址入口开始执行;这里强制转换和变量的强制转换一样的:( void (*)() )0;此时的函数指针就是执行 0地址处;
           最后是调用该函数指针,调用一个函数指针,一般是这样:(*func)(),这是标准的调用语句;也可以简写为:func();所以最后调用下该函数指针:(* (void (*)())0)();

    返回函数指针的函数

            返回函数指针的函数,最典型的就是 signal()函数;可以参考下:http://blog.csdn.net/yuzhihui_no1/article/details/44748585
            其实这个函数:void  (*signal(int signo, void (*func)(int) ) ) (int);如果不借用typedef  我还真不知道怎么实现它,主要是函数头不知道该怎么写;下面看下我利用typedef来实现的返回函数指针的函数:
     #include<stdio.h>
     
     int test(int i)
     {
         printf("in test!  i = %d\n", i); 
         return i;
     }
     
     typedef int (*func)(int);
     
     func test1(int i)
     {
         int (*p)(int) = test;
         printf("ret test! i = %d\n",(*p)(i));
     
         return p;
     }
         
     int main(void)
     {
         test1(1)(100);
         return 0;
     }
    运行结果:

       

    返回数组指针的函数

            返回数组的函数是什么样子?我开始绕进去了,后来仔细想了下,那不就是返回指针的函数嘛。哈哈,现在来看下返回数组指针的函数,其实就是返回个二维数组指针;
            返回数组指针的函数:返回一个指向二维数组的指针;表示为:int (*func(int  i)) [4]{};
    演示代码
    #include<stdio.h>
    #include<stdlib.h>
     
     // int (*array)[4];
     
     int (*func(int count))[4]
     {
         int (*array)[4] = malloc(4*sizeof(int));
         (*array)[0] = count*1;
         (*array)[1] = count*10;
         (*(array+1))[0] = count*100;
         (*(array+1))[1] = count*1000;
         return array;
     }
     
     int main()
     {
         int (*tmp)[4] = func(1);
         printf("array[00]:%d\n", (*tmp)[0]);
         printf("array[01]:%d\n", (*tmp)[1]);
         printf("array[10]:%d\n", (*(1+tmp))[0]);
         printf("array[11]:%d\n", (*(1+tmp))[1]);
         free (tmp);
         //free (array);
         return 0;
     }
    运行结果:


    函数指针数组

            函数指针数组:数组里面存放的都是函数指针;表示为:int (*array[3])(int);
            函数指针数组在系统设计中还是比较容易用到的,其实就是把几个函数指针存放到数组中,方便后面调用;
    演示代码:
     #include<stdio.h>
     
     void test(int i)
     {
          i *= 1;
          printf("int test i is:%d\n", i);
     }
     
     void test1(int i)
     {
         i *= 10; 
         printf("int test1 i is:%d\n", i); 
     }
     
     void test2(int i)
     {
         i *= 100;
         printf("int test2 i is:%d\n", i); 
     }
     
     void test3(int i)
     {
         i *= 1000;
         printf("int test3 i is:%d\n", i); 
     }
     
     int main(void)
     {
         void (*func[4])(int) = 
         {   
             test,
             test1,
             test2,
             test3
         };  
         (*func[0])(1);
         (*func[1])(1);
         (*func[2])(1);
         (*func[3])(1);
     
         return 0;
     }
    运行结果:
            

            转载请注明作者和原文出处,原文地址:http://blog.csdn.net/yuzhihui_no1/article/details/44748585
           若有不正确之处,望大家指正,共同学习!谢谢!!!

    展开全文
  • “指针的爱情故事”(指针\多级指针 详解,常量指针\指针常量\常量指针常量,数组指针\指针数组,函数指针\指针函数)作者:谭丙章(AlexTan) E-mail: alextanbz@gmail.com 注:转载不贴上作者信息以及原文地址,...

    “指针的爱情故事”(指针\多级指针 详解,常量指针\指针常量\常量指针常量,数组指针\指针数组,函数指针\指针函数)

    作者:谭丙章(AlexTan)
    E-mail: alextanbz@gmail.com
    注:转载不贴上作者信息以及原文地址,必追究其法律责任

    因为最近要讲课的原因,想着怎么才能让学弟学妹们把指针理解透,学指针学起来不枯燥。于是自己编写了 ”指针的爱情故事“。

    先声明:此故事纯属虚构,如有雷同,不胜荣幸!

    故事以及讲解都在代码注释里,所以就直接上代码:

    #include<iostream>
    using namespace std;
    /*-------------------------------------------指针的爱情故事---------------------------------------------*/
    
    //讲故事前,首先,介绍一下地址的概念   ps:其实地址就是变量的家啦~!  和人类世界不同的是,变量的整个一生都会待在家里!
    void address()
    {
        int baby;    //一个叫baby的int类型的变量出生了,上帝会给他在栈区分配一个家(地址)。这里的专业名字叫:声明!  知识拓展一:局部变量的家(存放位置)是在栈区,全局变量和static变量的家(存放位置)在全局数据区。
        //我们来看一看baby是在什么地方出生的!
        cout << &baby << endl;    //给baby加上“&”(取地址符),就能找到去baby家的路
        baby = 1;    //经过成长的磨练,baby长大啦!他有了自己的个性,包括价值观、爱情观、性格等等(用1来代替)。 这里的专业名字叫:定义!
        //我们来看看baby的性格、价值观、爱情观是怎样的
        cout << baby << endl;
    }
    
    /*有了地址的概念,那么我们就开始来讲讲指针,指针也许是计算机世界里最痴情的人~,就好像人类世界里的“了不起的盖茨比”。*/
    //首先是指针变量
    void pointer()
    {
        int *Gatsby;   //盖茨比出生了,同样,上帝也会给他在栈区分配一个家(地址)。
        char baby;
        int lover;  //同时,另外两个小孩儿也出生了
        //我们来看看盖茨比的家在哪
        cout << &Gatsby << endl;
        //盖茨比小时候,也以为自己和其他小孩儿(变量)一样
        baby = 'a';
        lover = 2;
        //*Gatsby = 1;
        //cout << *Gatsby << endl;
        //一次碰壁后,他才知道他与众不同!他在人生的道路上不断地寻找自己,通过他的努力,终于找到了正确的道路
        Gatsby = new int(1);     //知识拓展二:new int(1)代表从堆中给Int类型的值“1”(可以理解成结果等于1的Int类型变量)分配一个空间
        cout << *Gatsby << endl;
        //同时,他还有了一个惊奇的发现
        cout << Gatsby << endl; //他发现自己可以找到别人的家(地址)。
        //于是,他渐渐长大了,看了很多悲剧性的爱情电影,那时他就发誓,自己将来一定要好好对待一个女孩儿!懵懂的爱情在他脑中荡漾~。最开始,他遇到了baby,渐渐喜欢上了她,于是他向她表白了。
        //*Gatsby = baby;  //我喜欢你。。。一开始就被狠狠地拒绝了,可是,他不是那种轻易放弃的人
        //Gatsby = baby;    //结果,他直接在全班同学面前出糗了,很尴尬~!  于是他就开始反思,也许是他方法用得不对,于是他又去寻找不同的方法
        //*Gatsby = &baby;    //还是惹来同学的笑话
        //Gatsby = &baby;     //一次次地失败,最终把他打击得实在是没有信心了....于是他就想:“也许他们俩根本就不适合!”
        //他放弃了baby... 果然,没过多久,他就遇到了另外一个女孩儿,并且是一见钟情!他有了上一次的经验,一下就找准了方法
        *Gatsby = lover;         //我喜欢你... 批注:这里只是给指针赋值,把lover的值赋给指针,并没有让指针指向lover
        cout << &lover << endl;
        cout << Gatsby << endl;
        cout << *Gatsby << endl; 
        Gatsby = &lover;         //渐渐的...我喜欢你,变成了我爱你...盖茨比把lover的家,lover的个性都深深地烙印在了自己的心底。 批注:指针指向lover。
        cout << &lover << endl;  //lover的家
        cout << Gatsby << endl;  //lover的家
        cout << *Gatsby << endl; //lover的个性
        lover = 3;    //即使lover的个性或者是外貌改变了,盖茨比也始终爱着她
        cout << *Gatsby << " " << lover << endl;
        *Gatsby = 4;  //lover或许是因为盖茨比的爱而感动,或许是因为其他,lover也爱上了盖茨比
        //他们形影不离,你变我也跟着变,彼此都住在对方的心底
        cout << *Gatsby << " " << lover << endl;
    }
    
    //尽管盖茨比他们彼此已经非常非常相爱了,但是,现实最终打败了他们,不过,盖茨比却得到了升华~
    void multipointer()
    {
        int lover = 2;
        int *Gatsbyago=&lover; //以前的盖茨比只是纯粹的爱上lover。知识拓展三:声明这里初始化可以这样写,其他地方必须得这样写:Gatsbyago=&lover,代表Gatsbyago指针指向lover。
        //知识拓展四:如果指针未被初始化(未指向一个地址),那么也不能进行*Gatsbyago = 3 之类的操作,指针本身的地址只能指向一个地址,不能存放普通值。
        int family=3;
        int *lovers = &family; //lovers爱自己的家人
        int **Gatsbynow;  //如今的盖茨比
        cout << &lovers << " " << &family << " " << lovers << " " << &Gatsbynow << endl;
        Gatsbynow = &lovers;
        cout << **Gatsbynow << " " << *Gatsbynow << " " << Gatsbynow << " " << &Gatsbynow << endl;
        //如果family改变,其他所有人都跟着改变
        family = 4;
        cout << family << " " << *lovers << " " << **Gatsbynow << endl;
        //如今的盖茨比,不仅爱着lovers,他还爱着他爱人所爱的所有人。正所谓:爱屋及乌...
        /*-----------------------------END------------------------------*/
        //*Gatsbynow = &lover;  //知识拓展五:清楚二级指针 **xxx(二级指针所指向的“一级指针指向的地址的值”),*xxx(一级指针所指向的地址),xxx(一级指针的地址)代表什么后,可以进行篡改操作,这样的篡改同时会把lovers一级指针所指向的地址改变(即,盖茨比的爱人爱的人变了,他所爱的人同样跟着变)
        //cout << family << " " << *lovers << " " << **Gatsbynow << endl;
        //多级指针同理
    }
    
    /*------------------------常量指针、指针常量、常量指针常量------------------------*/
    
    void ConstPointer()
    {
        const int a = 1; //常量变量
        //a = 2; //非法操作:常量不能被改变
        int b = 2;
        int c = 3;
        const int *pointer = &a; //常量指针,是一个指针,即可以理解为指向常量的指针,常量的值不能变,指针指向的地址可以变
        //*pointer = 4; //非法操作
        //pointer = &b; //合法操作
        int const *pointer2 = &b; //常量指针的另外一种声明方式
        //*pointer2 = 4; //非法操作
        //pointer2 = &c;  //合法操作
        int *const pointer3 = &c; //指针常量,是一个常量,即可以理解为指针是常量,指针指向的地址的值可以变,指针指向的地址不可以变,
        //*pointer3 = 4; //合法操作
        //pointer3 = &b; //非法操作
    
        const int *const pointer4 = &a; //常量指针常量,全都是常量,不管是指针指向的地址,还是值都不能被改变
        //*pointer4 = 8;  //非法操作
        //pointer4 = &b;  //非法操作    
    }
    
    /*------------------------------------数组指针、指针数组---------------------------*/
    
    void ArrayPointer()
    {
        //顾名思义,数组指针:是一个指针,这个指针是指向数组的指针;指针数组:是一个数组,这个数组是存放指针(地址)的数组
        int *a[4]; //指针数组
        cout << &a << endl;
        int b[4] = { 1, 2, 3, 4 };
        //给指针数组赋值
        for (int i = 0; i < 4; i++) // int 
        {
            a[i] = &b[i];
        }
        //输出:
        for (int i = 0; i < 4; i++)
        {
            cout << *a[i] << " ";
        }
        cout << endl;
        int (*c)[4];//数组指针
        c = &b; //数组指针指向b这个数组
        //输出:
        for (int i = 0; i < 4; i++)
        {
            cout << (*c)[i] << " ";
        }
    }
    
    /*------------------------------指针函数、函数指针-------------------------*/
    
    int *f1(int a, int b) //指针函数
    {
        int *c;
        if (a > b)
        {
            c = &a;
            cout << &a << endl;
            return c;
        }
        else
        {
            c = &b;
            cout << &b << endl;
            return c;
        }
    }
    int(*f2)(int a, int b); //声明函数指针
    int max(int a, int b)   //普通函数
    {
        if (a > b)
            return a;
        else
            return b;
    }
    void FuncPointer()
    {
        //同样,顾名思义,指针函数:是一个函数,不过这个函数返回的类型是一个指针;函数指针:即是一个指针,不过这个指针指向的是一个函数
        int a = 1, b = 2;
        cout << f1(a,b) <<endl;  //调用指针函数,输出的是地址,如果输出 *f1(a,b) 将输出值。
        f2 = max;  //函数指针指向max函数
        cout << (*f2)(a, b) << endl;    //通过函数指针调用函数
    }
    
    /*----------------------------------主函数----------------------------------*/
    
    int main()
    {
        //address(); //地址
        //pointer(); //一级指针
        //multipointer(); //多级指针
        //ConstPointer(); //常量指针、指针常量、常量指针常量
        //ArrayPointer(); //数组指针、指针数组
        //FuncPointer();   //函数指针、指针函数
        return 0;
    }

    建议不懂的同学把代码一步一步调试一下,如果还有什么不懂的欢迎评论留言!

    最后留下一句话(ps:也是自己编的):

    程序猿的我爱你,是像指针那样,爱你胜过爱自己,把两个地址都连在了一起,有了你,我才有存在的价值;如果你爱着别人,那么我就是多级指针,爱你所爱的人,当然包括你~!

    展开全文
  • 比如 函数指针 函数是描述 本质是指针,这个指针指向函数地址 (那本质和描述的区别是?描述变了还是同一大类,本质变了就不是同一大类了) ===================================================================...
    
    
    注意一下:
    往往中文属于里形式如AB ,那么A是描述,B是本质。
    比如 数据库管理系统 数据库管理是描述 系统是本质 
    比如 函数指针 函数是描述 本质是指针,这个指针指向函数地址
    
    (那本质和描述的区别是?描述变了还是同一大类,本质变了就不是同一大类了)
    ======================================================================

    【函数指针】        在程序运行中,函数代码是程序的算法指令部分,它们和数组一样也占用存储空间,都有相应的地址。可以使用指针变量指向数组的首地址,也可以使用指针变量指向函数代码的首地址,指向函数代码首地址的指针变量称为函数指针。

    1.函数指针定义

    函数类型 (*指针变量名)(形参列表);

    “函数类型”说明函数的返回类型,由于“()”的优先级高于“*”,所以指针变量名外的括号必不可少,后面的“形参列表”表示指针变量指向的函数所带的参数列表。

    例如:

    int (*f)(int x);

    double (*ptr)(double x);

    在定义函数指针时请注意:      函数指针和它指向的函数的参数个数和类型都应该是—致的;

    函数指针的类型和函数的返回值类型也必须是一致的。

    2.函数指针的赋值

    函数名和数组名一样代表了函数代码的首地址,因此在赋值时,直接将函数指针指向函数名就行了。

    例如,

    int func(int x);   /* 声明一个函数 */

    int (*f) (int x);    /* 声明一个函数指针 */

    f=func;            /* 将func函数的首地址赋给指针f */

    赋值时函数func不带括号,也不带参数,由于func代表函数的首地址,因此经过赋值以后,指针f就指向函数func(x)的代码的首地址。

    3.通过函数指针调用函数

    函数指针是通过函数名及有关参数进行调用的。

    与其他指针变量相类似,如果指针变量pi是指向某整型变量i的指针,则*p等于它所指的变量i;如果pf是指向某浮点型变量f的指针,则*pf就等价于它所指的变量f。同样地,*f是指向函数func(x)的指针,则*f就代表它所指向的函数func。所以在执行了f=func;之后,(*f)和func代表同一函数。

    由于函数指针指向存储区中的某个函数,因此可以通过函数指针调用相应的函数。现在我们就讨论如何用函数指针调用函数,它应执行下面三步:

    首先,要说明函数指针变量。

    例如:int (*f)(int x);

    其次,要对函数指针变量赋值。

    例如: f=func;    (func(x)必须先要有定义)

    最后,要用 (*指针变量)(参数表);调用函数。

    例如:    (*f)(x);(x必须先赋值)

    【例】任意输入n个数,找出其中最大数,并且输出最大数值。

    main()

    {

            int f();

            int i,a,b;

            int (*p)();    /* 定义函数指针 */

            scanf("%d",&a);

            p=f;            /* 给函数指针p赋值,使它指向函数f */

            for(i=1;i<9;i++)

            {                 scanf("%d",&b);

                    a=(*p)(a,b);    /* 通过指针p调用函数f */

            }

            printf("The Max Number is:%d",a)

    }

    f(int x,int y)

    {

        int z;

        z=(x>y)?x:y;

        return(z);

    }

    运行结果为:

    343 -45 4389 4235 1 -534 988 555 789↙

    The Max Number is:4389

    【指针函数】

    一个函数不仅可以带回一个整型数据的值,字符类型值和实型类型的值,还可以带回指针类型的数据,使其指向某个地址单元。

            返回指针的函数,一般定义格式为:

            类型标识符    *函数名(参数表)

    int *f(x,y);

    其中x,y是形式参数,f是函数名,调用后返回一个指向整型数据的地址指针。f(x,y)是函数,其值是指针。

    如:char *ch();表示的就是一个返回字符型指针的函数,请看下面的例题:

    【例】将字符串1(str1)复制到字符串2(str2),并输出字符串2.

    #include "stdio.h"

    main()

    {

        char *ch(char *,char *);

        char str1[]="I am glad to meet you!";

        char str2[]="Welcom to study C!";

        printf("%s",ch(str1,str2));

    }

    char *ch(char *str1,char *str2)

    {

        int i;

        char *p;

        p=str2          if(*str2==NULL) exit(-1);

        do

        {

            *str2=*str1;

            str1++;

            str2++;

        }while(*str1!=NULL);

        return(p);

    }

    通过分析可得

    函数指针是一个指向函数的指针,而指针函数只是说明他是一个返回值为指针的函数,

    函数指针可以用来指向一个函数。

    【指针常量】
    一个被声明为“char *const p”形式的指针,不能修改为指向内存中另外一处的地址,但可以修改它所指向的地址处的内容。
    【常量指针】
    一个被声明为“const char * p”形式的指针,可以修改为指向内存中另外一处的地址,但不能修改它所指向地址处的内容。
    【指向常量的常量指针】
    一个被声明为“const char * const p”形式的指针,地址和内容一旦确定,都不能修改。
    //const 离谁近,谁就不能修改!
    展开全文
  • 所以指针本身也可以是常量指针也可以指向常量,下面区分一下。 1. 指向常量指针(pointer to const) 指向常量指针不能用于改变所指对象的值。 const double pi = 3.14; const double *cptr = &amp;pi...

    0. 指针与引用

    指针是对象,即在内存中占有实际内存。而引用只是一个对象的别名,本身不占有实际内存,不是对象。所以指针本身也可以是常量,指针也可以指向常量,下面区分一下。

    1. 指向常量的指针(pointer to const)

    指向常量的指针不能用于改变所指对象的值。

    const double pi = 3.14;

    const double *cptr = &pi;  // 正确

    double *ptr = &pi;  // 错误

    要想存放常量对象的地址,只能使用指向常量的指针!但和常量引用一样,指向常量的指针所指向的对象可以不是常量!

    也就是说,所谓指向常量的指针只是它自己觉得,它指向的是一个常量,所以自觉地不去改变所指向对象的值。但所指向的对象可以通过其他方式去改变。

    这也就是为什么定义函数时,在函数内部不会改变的形参尽可能的定义为指向常量的指针或者常量引用!这样会提高函数的灵活性,即也可以接受常量参数,也可以接受非常量参数。否则就不能接受常量参数,比如字面值和const对象。(《C++Primer 第5版》p192)。而且,如果把函数不会改变的形参定义为普通引用,会给调用者一种误导,好像函数可以修改它的实参的值一样,毕竟普通引用形参做参数可以改变实参的值。

     

    2. 常量指针(const pointer)

    指针本身也可以是常量,常量指针必须初始化,一旦初始化完成,它的值即存储的地址,就不能改变了。

    int i = 0;

    int * const p = &i;  // 正确:p 将一直指向i

    int m = 0;

    p = &m;   // 错误!

    const int n = 0;

    int * const q = &n; // 错误。原因参考1. pointer to const

     

     

     

    展开全文
  • 常量参数和函数调用

    2020-03-22 07:49:06
    常量参数是普通参数的一种,但是在函数调用中,地址或地址指向的值,或者两者,可以加const,那么在函数调用中就不会改变你不想改变的东西。举例如下: void function(const charp,int n) 大家都知道,在变元传递时...
  • 常量函数只可以调用常量函数

    千次阅读 2013-08-22 13:32:55
    Class CTest { public:    CTest();  ~CTest();   BOOL Fun() const;  double FunB() const; }; BOOL Fun() const {  FunB(); //常量函数只可以调用常量函数 } double FunB() const {
  • 两种叫法: 常量指针 和 指针常量 关于两种网上说法不一,书上说法也不一致,所以,我的建议是一般别用这两个词,但是在具体的语义下需要能看懂就行。 我们换一个说法来说明这两个问题: 顶层const 和 底层...
  • 关于指针、数组、常量等相关联的内容,常常有一些拗口又难以区分的概念,比如指针数组、数组指针、二重指针、二维数组、常指针、指向常量指针指针函数函数指针、“函数指针类型”。本文给出了我自己对这些概念...
  • 指针常量和常量指针

    千次阅读 2008-08-22 14:23:00
    一:指针常量和常量指针常量指针常量指针就是指向常量的指针,指针所指向的地址的内容是不可修改的。指针常量定义"const int * pi=&a;"告诉编译,*pi是常量,不能将*pi作为左值进行操作。所以这里的指针还是一...
  • C++ 指针常量、常量指针和常指针常量 2014年11月26日 22:12:41 To-Big_Fish 阅读数:4324 https://blog.csdn.net/yujin753/article/details/41523005 1、指针常量 如果在定义指针变量时候,指针变量前用const...
  • 常量指针 常量指针是指向常量的指针,指针指向的内存地址的内容是不可修改的。 常量指针定义“const int *p=&a;”告诉编译器,*p是常量,不能将*p作为左值进行操作。但这里的指针p还是一个变量,它的内容存放常量的...
  • 指针常量和常量指针的区别

    千次阅读 2016-08-06 18:48:41
    指针常量是指定义的指针只能在定义的时候初始化,之后不能改变其值,格式如下: ...常量指针的值不能改变,但是其指向的内容却可以改变。 char a[5]="abcd"; char *const b =a; b[0] = 'c'; 这样子 字符串a就
  • 大话 函数指针指针函数

    千次阅读 热门讨论 2015-01-07 09:19:47
    (2)函数指针是指向函数的指针变量,即本质是一个指针变量,是一个指向函数(可能是代码区)的首地址的指针,正如我们都知道,数组名就是指向数组第一个元素的常量指针(详见《数组拾遗》)。同理,对于一个函数而...
  • 在类中,形如 Test combine(const Test &amp;latter) const { num += latter.num;...当Test的对象调用combine函数时,隐式指针this会指向调用函数的对象,this指针默认为常量指针,即Test *const类...
  • C++常量指针this

    千次阅读 2015-12-17 15:33:11
    在成员函数内部可以用指针常量this来访问与成员函数调用相关联的对象(this是一个关键字)。 假设我们已经设计了一个File类,它有一个成员函数copy,该函数定义如下: void File::copy(File& dest) { if(this =...
  • C++中的指针、数组指针指针数组、函数指针指针函数 本文从初学者的角度,深入浅出地详解什么是指针、如何使用指针、如何定义指针、如何定义数组指针函数指针,并给出对应的实例演示;接着,区别了数组...
  • 在面试中我们经常会被面试官问到什么是常量指针,什么又是指针常量。可能第一次被问到都会有些懵逼(大神略过)。我今天就来讲一讲这二者的区别。 下面开始正题。。。。 指针常量 指针常量:顾名思义它就是一个...
  • 有时候我们希望定义一种常量,它的值不能被修改,这个常量既可以防止程序其他地方不小心修改这个值,也能让程序员比较方便的调整这个值的大小。 以往我们很容易想到#define宏定义,现在使用const是个更为不错的选择...
  • 1.指针的优势:  ①可以直接访问硬件 访问速度快  ②提高空间的利用率  ③指针使用地更加灵活  空间分配 访问效率  指针保存的是地址 (4字节) 直接 快  数组保存的是一片连续的空间  定位 加减 ...
  • C语言-函数指针函数名的区别

    千次阅读 多人点赞 2016-01-01 11:39:44
    记得大学时老师曾说函数函数名是函数的入口的指针,之前看block通过clang编译...首先先定义一函数以及一个指向盖函数函数指针,并分别对他们进行调用。 #include void fun(int x); int main(int argc, const char
  • C++-指针常量和常量指针

    千次阅读 2007-07-12 20:11:00
    // 指针常量和常量指针//1)指针常量可以通过指针改变变量的值 Int x = 2; Int * const point = &x; *point = 4; //now x = 4 void main() ...{ char * const str = "china"; *str = ...
  • C语言-函数指针函数名的区别***

    千次阅读 多人点赞 2018-06-11 13:48:46
    记得大学时老师曾说函数函数名是函数的入口的指针,之前看block通过clang编译生成的C...首先先定义一函数以及一个指向盖函数函数指针,并分别对他们进行调用。 //VS 2017 void fun(int& x); //定义函数f...
  • const是一个C语言的关键字,它限定一...因为指向常量指针有时候会指向常量,所以它具有这个性质:“不能靠解引用改变它指向的对象的值”,以此保护它所指向的常量常量性: *pa =d; // 不可行(d是已经声明过的整型
  • 彻底搞定C指针函数名与函数指针

    千次阅读 2013-11-18 14:19:11
    函数名与函数指针 一 通常的函数调用  一个通常的函数调用的例子: //自行包含头文件 void MyFun(int x); //此处的申明也可写成:void MyFun( int ); int main(int argc, char* argv[]) {  MyFun(10);...
  • 指针数组与数组指针   当我们在学习指针与数组时总会遇到两个令人容易混淆的概念:数组指针指针数组。   在这里数组指针是指向数组的指针,其本质为指针指向的对象是数组。由于数组的形式多样所以数组指针的...
  • 今天在写一个类模板的时候遇到了const常量对象与const成员函数调用的问题,仔细捉摸了一番记录下来,简略代码如下: h文件 class MyVector { public: MyVector(const MyVector& vec); int size(); private: ...
  • 函数指针指针函数

    千次阅读 2009-09-06 23:01:00
    函数指针是指向函数的指针变量。 因而“函数指针”本身...有了指向函数的指针变量后,可用该指针变量调用函数,就如同用指针变量可引用其他类型变量一样,在这些概念上一致的。函数指针有两个用途:调用函数和做函数
  • 指针函数指针

    千次阅读 2016-04-10 17:36:20
    指针 void pointers指针void 是一种特殊类型的指针。void 指针可以指向任意类型的数据,可以是整数,浮点数甚至字符串。...它的应用之一是被用来给函数传递通用参数:// integer increaser #incl
  • 函数指针指针函数疑惑解析

    千次阅读 2014-02-11 10:52:16
    函数指针所指向的函数,必须为全局函数或类的静态函数函数指针是指向函数起始地址的指针,一般可以认为是函数名的变量形式, 如:void f(int i) {printf("%d", i-1);}  //函数,f是常量void g(int i) {printf...
  • c++函数指针函数对象

    千次阅读 2019-04-07 17:29:05
    C++ 函数指针函数类型一、 导述二、c++成员函数在内存中的存储方式新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 182,342
精华内容 72,936
关键字:

常量指针调用函数