精华内容
下载资源
问答
  • 常量指针调用函数
    2021-01-25 23:55:28

    函数指针与函数名的关系

    1. 函数名是函数指针常量
    2. 函数指针是函数指针变量

    调用函数的多种书写形式

    1. 定义:void Fun(int)
    2. 调用:Fun(10),(*Func)(10)
    3. 解释:函数名就是函数指针常量,为了方便使用才允许用Fun(10)的方式来使用函数名

    函数指针的多种赋值方式

    1. 定义:void (*pFun)(int)
    2. 用函数指针pFun调用void Fun(int)函数的四种方式:
    // First way
    pFun = &Fun;
    (*pFun)(10);
    
    // Second way
    pFun = Fun;
    pFun(10);
    
    // Third way
    pFun = &Fun;
    pFun(10);
    
    // Fourth way
    pFun = Fun;
    (*pFun)(10);
    
    1. 解释:函数指针既可以被用函数名来赋值,也可以被用函数名取地址的方式来赋值;函数指针调用函数时,既可以用解引用函数指针的方式来调用,也可以直接用函数指针变量名的方式来调用
    更多相关内容
  • 所以指针本身也可以是常量指针也可以指向常量,下面区分一下。 1. 指向常量指针(pointer to const) 指向常量指针不能用于改变所指对象的值。 const double pi = 3.14; const double *cptr = &pi...

    0. 指针与引用

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

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

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

    const double pi = 3.14;

    const double *cptr = π  // 正确

    double *ptr = π  // 错误

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

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

    这也就是为什么定义函数时,在函数内部不会改变的形参尽可能的定义为指向常量的指针或者常量引用!这样会提高函数的灵活性,即也可以接受常量参数,也可以接受非常量参数。否则就不能接受常量参数,比如字面值和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

     

     

     

    展开全文
  • 指针常量和常量指针  要想搞清楚这一对,必须先知道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
           若有不正确之处,望大家指正,共同学习!谢谢!!!

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

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

    什么是常量参数?常量参数是普通参数的一种,但是在函数调用中,地址或地址指向的值,或者两者,可以加const,那么在函数调用中就不会改变你不想改变的东西。举例如下:
    void function(const charp,int n)
    大家都知道,在变元传递时,仅仅是值传递,比如将一个char
    pa型地址传递给以上函数,那么pa的值传递过去,被调函数可以用这个值做任何事情,但是和pa没有任何关系,因为改变pa的值就是两种方法,一种是直接对pa赋新值,但是pa不存在与被调函数中,第二种方法是对pa存在的地址上的东西(即pa)进行修改,但是没有传递pa地址。这里函数调用的基础,一定要理解。
    上面的参数很多时候不好理解,const charp,怎么理解呢?p就是我们定义的一个指针,因为前面有指针符号
    先不管它是啥指针,但我们最终要的指针变量就是p,再看是什么来修饰这个指针,也就是它的类型,类型就是修饰它的东西。 在p前面的东西就是, 他是const char,那么他就是指向cong char 类型的指针,const char又是什么呢?指向字符常量的指针,那么合起来就是指向字符常量的指针的指针,函数调用时,如果又把char
    pa的值传递给被调函数,那么在void function(const charp,int n)里面,p是地址,那么可以用*p改变p数组中的元素,也就是const char型地址,但是不能用p改变任何东西,因为参数已经有类型了,p是指向const char型指针,也就是数组p的元素指向字符串常量,也就是p[i]或(p+i)不能改变其地址上的字符串。
    第二种情况:
    void function(charconstp,int n)
    这个参数也可以和上面一样理解,看看我们要的是啥,修饰它的是啥,很显然,我们要的是p,p又是个指针,因为前面有指针符号,那再往前是什么呢?是constchar,它来修饰(p),上面的参数是指向charconst类型的指针,charconst又是什么呢?是字符型常量指针(地址值是常量),合起来就是指向字符型常量指针的指针,那么p[i]就是常量指针,p[i]的值不能被改变。p[i]不能被改变,但是p[i]可以改变,这是最终数据。
    第三种情况:
    void function(const char
    constp,int n)
    运用以上技巧,可以这么理解,我们要的是
    p,这是一个指针,修饰它的是:
    const char*const,那么就是指向字符常量的常量指针,合起来,p是指向指向字符常量的常量指针的指针。这里面不但数组p的元素不可改变,p的元素指向的值也不可改变。
    第四部分想分享的是,函数调用中、涉及函数调用,举个例子:
    int function1(int x)
    {
    function2(intx)
    }
    上面例子中,function2拥有了在function1中的参数,那么如果调用function1的函数,传递给function1的变元是3,那么function2中由function1 传递给function2的变元也是3,刚开始看到上面的结构会感觉奇怪,但这就是普通的函数调用,被调函数只能接受主调函数传递给她的参数

    展开全文
  • 指针数组与数组指针   当我们在学习指针与数组时总会遇到两个令人容易混淆的概念:数组指针指针数组。   在这里数组指针是指向数组的指针,其本质为指针指向的对象是数组。由于数组的形式多样所以数组指针的...
  • C++ 指针常量、常量指针和常指针常量 2014年11月26日 22:12:41 To-Big_Fish 阅读数:4324 https://blog.csdn.net/yujin753/article/details/41523005 1、指针常量 如果在定义指针变量时候,指针变量前用const...
  • 函数返回值为指针类型的总结

    万次阅读 多人点赞 2018-08-23 22:34:17
    因为如果你多次调用这个函数返回多个指针,但这几个指针实际上指向同一块地址,改变任何一个的内容将改变所有指针的内容, 这样也不是很多情况所需要的。 char* GetString(void) { static char p[]="hello ...
  • C语言-函数指针函数名的区别***

    千次阅读 多人点赞 2018-06-11 13:48:46
    记得大学时老师曾说函数函数名是函数的入口的指针,之前看block通过clang编译生成的C...首先先定义一函数以及一个指向盖函数函数指针,并分别对他们进行调用。 //VS 2017 void fun(int& x); //定义函数f...
  • 指针作为函数返回值

    千次阅读 2020-04-20 22:58:09
    转载自:指针作为函数返回值 指针作为函数返回值 C语言允许函数的返回值是一个指针(地址),我们将这样的函数称为指针函数。下面的例子定义了一个函数 strlong(),用来返回两个字符串中较长的一个: #include <...
  • (1)下面这个错误的意思是我在我的非const成员中调用了const成员函数,这是会报错的!!!! In file included from circularListWithHeader.cpp:1:0: circularListWithHeader.h: In instantiation of ‘T& ...
  • C++常量指针this

    2020-02-12 08:17:59
    在每一个成员函数中都包含一个常量指针,我们称其为this指针,该指针指向调用函数的对象,其值为该对象的首地址。通过该指针,我们可以在成员函数函数体内访问对象。其中this是C++的一个关键字。 #include<...
  • 课程内容:第3章:存储类与auto、static、register关键字指令、常量、变量的生命周期变量与函数的作用域链接域与extern、static关键字声明的意义第4章:存储空间、符号、地址一级指针与多级指针指针与段错误void *...
  • } //拷贝构造函数,参数const:不可以修改传进来的P对象 //引用的本质是指针常量 Person &p = Person *const p ; Person(const Person& p) { age = p.age; cout 拷贝构造函数!" ; } //析构函数 ~Person()...
  • 一:指针常量和常量指针常量指针常量指针就是指向常量的指针,指针所指向的地址的内容是不可修改的。指针常量定义"const int * pi=&a;"告诉编译,*pi是常量,不能将*pi作为左值进行操作。所以这里的指针还是一...
  • C语言根据函数指针得到其函数

    万次阅读 2019-02-22 10:59:42
    这次遇到的需求是需要知道函数指针指向的函数的名称是什么。感觉是不是有点儿像java里的反射,可以知道运行时的类是啥。 解决方法 方法一:内核态、printk()函数 如果是在内核态中,那么可以通过printk()函数来...
  • 3、一级指针传参 当一个函数的参数部分为一级指针的时候,函数能接收什么参数 4、二级指针传参 五、函数指针 1、函数指针变量 - 存放函数的地址 2、类型 变量 3、调用 4、有趣的代码 六、函数指针数组 实现加减乘除 ...
  • 今天在写一个类模板的时候遇到了const常量对象与const成员函数调用的问题,仔细捉摸了一番记录下来,简略代码如下: h文件 class MyVector { public: MyVector(const MyVector& vec); int size(); private: ...
  • 常量函数常量对象的使用

    千次阅读 2018-07-18 21:24:35
    常量函数形式:int fun(void) const; 注意:const int fun(void) 不是常量函数,只是函数的返回值为常量 #include &lt;iostream&gt; using namespace std; class DEMO { private:  int a; public:  DEMO...
  • 指针作为函数的参数:当我们调用一个函数的时候,如果这个函数的参数是一个指针,那么我们就必须要为这个指针传递一个和指针类型相同的普通变量的地址,这个时候,在函数的内部去访问参数指针指向的变量的时候,其实...
  • 类的常量成员函数(const member function)是类的成员函数,其定义的方式是将const关键字放在成员函数参数列表之后。要说明常量成员函数的用途,首先从类成员的隐式参数this说起。 1 this参数 1.1 this参数介绍 ...
  • 如下例所示,函数strlen会修改形参指针str,但是main函数调用函数strlen返回后,实参指针str仍然指向字符串"nowisthetime"的首地址。 此外,strlen函数的形参const char *str是一个指向常量指针,而实参char *str...
  • 比如 函数指针 函数是描述 本质是指针,这个指针指向函数地址 (那本质和描述的区别是?描述变了还是同一大类,本质变了就不是同一大类了) ===================================================================...
  • C++的常量成员函数

    2017-02-15 22:10:33
    常量成员函数分析
  • 一、返回指针函数  指针也是C语言中的一种数据类型,因此一个函数的返回值肯定可以是指针类型的。 返回指针函数的一般形式为:类型名 * 函数名(参数列表)  比如下面这个函数,返回一个指向char类型变量的...
  • (1)调用函数;(2)做函数的参数. 下面介绍一下用【函数指针】来调用strcpy函数,并分析其中的三个疑问。 char a[5] = {0}; char* (*pFunc)(char*, const char*); //因为strcpy是一个指针,故要用(*pFunc) //...
  • 指针函数指针

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

    千次阅读 2020-02-06 11:23:09
    假如想把一个字符串从一个函数“传递”到另一个函数...定义一个函数 copy_string 用来实现字符串复制的功能,在主函数中调用函数函数的形参和实参可以分别用字符数组名或字符指针变量。分别编程,以供分析比较。...
  • c++函数指针函数对象

    千次阅读 2019-04-07 17:29:05
    C++ 函数指针函数类型一、 导述二、c++成员函数在内存中的存储方式新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个...
  • 总结: 1.常量数据成员,形式:const Type m_tData; 1)常量数据成员,需要在构造函数列表中给出,构造函数中可以用常量赋值,也可以实例化的时候...3.返回常量的函数,可以是常量指针,指针常量,常量,形式: const
  • 【C语言进阶】⑥函数指针详解

    千次阅读 多人点赞 2022-04-21 11:55:10
    一、函数指针 1.概念 函数指针:首先它是一个指针,一个指向函数指针,在内存空间中存放的是函数的地址; 请看示例: int main(){ int a = 10; int*pa = &a; char ch = 'c'; char* pc = &ch; int arr[10...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 208,843
精华内容 83,537
热门标签
关键字:

常量指针调用函数