精华内容
下载资源
问答
  • c++ 函数指针

    万次阅读 多人点赞 2019-06-15 21:41:38
    函数指针基础: 1. 获取函数的地址 2. 声明一个函数指针 3.使用函数指针来调用函数 获取函数指针: 函数的地址就是函数名,要将函数作为参数进行传递,必须传递函数名。 声明函数指针 声明指针时,必须指定...

    函数指针基础:

    1. 获取函数的地址

    2. 声明一个函数指针

    3.使用函数指针来调用函数

    获取函数指针:

    函数的地址就是函数名,要将函数作为参数进行传递,必须传递函数名。

    声明函数指针

    声明指针时,必须指定指针指向的数据类型,同样,声明指向函数的指针时,必须指定指针指向的函数类型,这意味着声明应当指定函数的返回类型以及函数的参数列表。

    例如:

    double cal(int);   // prototype
    double (*pf)(int);   // 指针pf指向的函数, 输入参数为int,返回值为double 
    pf = cal;    // 指针赋值

    如果将指针作为函数的参数传递:

    void estimate(int lines, double (*pf)(int));  // 函数指针作为参数传递 

    使用指针调用函数

    double y = cal(5);   // 通过函数调用
    double y = (*pf)(5);   // 通过指针调用 推荐的写法 
    double y = pf(5);     // 这样也对, 但是不推荐这样写 

    函数指针的使用:
     

    #include <iostream>
    #include <algorithm>
    #include <cmath>
    
    using namespace std;
    
    double cal_m1(int lines)
    {
    	return 0.05 * lines;
    } 
    
    double cal_m2(int lines)
    {
    	return 0.5 * lines;
    }
    
    void estimate(int line_num, double (*pf)(int lines))
    {
    	cout << "The " << line_num << " need time is: " << (*pf)(line_num) << endl; 
    }
    
    
    
    int main(int argc, char *argv[])
    {
    	int line_num = 10;
    	// 函数名就是指针,直接传入函数名
    	estimate(line_num, cal_m1);
    	estimate(line_num, cal_m2); 
    	return 0;
    }
    

    函数指针数组:
    这部分非常有意思:

    #include <iostream>
    #include <algorithm>
    #include <cmath>
    
    using namespace std;
    
    // prototype   实质上三个函数的参数列表是等价的 
    const double* f1(const double arr[], int n);
    const double* f2(const double [], int);
    const double* f3(const double* , int);
    
    
    
    int main(int argc, char *argv[])
    {
    	double a[3] = {12.1, 3.4, 4.5};
    	
    	// 声明指针
    	const double* (*p1)(const double*, int) = f1;
    	cout << "Pointer 1 : " << p1(a, 3) << " : " << *(p1(a, 3)) << endl;
    	cout << "Pointer 1 : " << (*p1)(a, 3) << " : " << *((*p1)(a, 3)) << endl;
    	
    	const double* (*parray[3])(const double *, int) = {f1, f2, f3};   // 声明一个指针数组,存储三个函数的地址 
    	cout << "Pointer array : " << parray[2](a, 3) << " : " << *(parray[2](a, 3)) << endl;
    	cout << "Pointer array : " << parray[2](a, 3) << " : " << *(parray[2](a, 3)) << endl;
        cout << "Pointer array : " << (*parray[2])(a, 3) << " : " << *((*parray[2])(a, 3)) << endl;
        
    	return 0;
    }
    
    
    const double* f1(const double arr[], int n)
    {
    	return arr;     // 首地址 
    } 
    
    const double* f2(const double arr[], int n)
    {
    	return arr+1;
    }
    
    const double* f3(const double* arr, int n)
    {
    	return arr+2;
    }
    
    

    这里可以只用typedef来减少输入量:

    typedef const double* (*pf)(const double [], int);  // 将pf定义为一个类型名称;
    pf p1 = f1;
    pf p2 = f2;
    pf p3 = f3;

     

    展开全文
  • C++函数指针

    千次阅读 2019-03-03 16:05:26
    函数指针 函数指针指向的是函数并不是对象。和其他指针一样,函数指针指向某种特定类型,函数的类型由它的返回类型和形参类型共同决定,与函数名无关。 声明指向函数的指针的语法形式:用指针替代函数名 //比较两...

    函数指针

    函数指针指向的是函数并不是对象。和其他指针一样,函数指针指向某种特定类型,函数的类型由它的返回类型形参类型共同决定,与函数名无关

    声明指向函数的指针的语法形式:用指针替代函数名

    //比较两个string对象的长度
    bool lengthCompare(const string &,const string &);
    
    //pf就是指向函数的指针,该函数的形参为const string的引用,返回值为bool类型
    bool (*pf) (const string &,const string &);
    //pf前面有个*,表示为指针;右侧是形参列表,则表示pf指向的是函数;再观察左侧,函数返回类型是bool值
    
    //*p两端的括号不能省略
    bool *pf(const string &,const string &);
    //声明名为pf的函数,函数返回类型为bool*

    1、使用函数指针:

    把函数名当一个值使用时,该函数自动转换为指针

    //pf为指针,函数名当值使用,函数自动转换为地址,取地址符可要可不要
    pf=lengthCompare;		//pf指向lengthCompare函数
    pf=&lengthCompare;		//与上式等价,取地址符可要可不要

    可以直接使用指向该函数的指针,无须提前解引用指针

    bool b1=pf("hello","goodbye");			//调用lengthCompare函数
    bool b2=(*pf)("hello","goodbye");		//等价调用
    bool b3=lengthCompare("hello","goodbye");//等价调用

    可以为函数指针赋予nullptr,表示该指针没有指向任何一个函数。

    2、重载函数的指针:

    使用重载函数的指针,形参列表函数返回类型都必须要与重载函数中的某一个精准匹配

    void ff(int *);
    void ff(unsigned int);
    
    void (*pf1)ff(unsigned int);//pf1指向ff(unsigned int)
    void (*pf2)ff(int)=ff;		//错误:没有任何一个ff与pf2的形参列表匹配
    double (*pf3)ff(int *)==ff;	//错误:ff和pf3的返回类型不同

    3、函数指针形参:

    和数组类似,虽然不能定义函数类型的形参,但是形参可以是指向函数的指针。这时的形参看起来是函数类型,实际上是被当指针使用

    //第三个形形参看起来是函数类型,但是它会自动转换为指向函数的指针
    void useBigger(const string &s1,const string &s2,bool pf(const string &,const string &));
    
    //等价的声明:显式地将形参定义为指向函数的指针
    void useBigger(const string &s1,const string &s2,bool (*pf)(const string &,const string &));
    
    //把函数作为实参使用,它也会转换为指针
    useBigger(s1,s2,lengthCompare);

    使用类型别名和decltype简化函数指针的代码:

    //Func函数类型的别名
    typedef bool Func(const string &,const string &);
    //FuncP函数指针类型的别名
    typedef book (*FuncP)(const string &,const string &);

    decltype得到的是函数类型,只有在前面加上*才能得到指针

    //Func自动地转换为函数指针
    void useBigger(const string &,const string &,Func);
    void useBigger(const string &,const string &,FuncP);

    编译器自动地将Func表示的函数类型转换为指针

    4、返回指向函数的指针:

    使用类型别名可以定义函数类型,也可以定义指向函数类型的指针。

    using F=int(int*,int);//F是函数类型,不是指针
    using PF=int(*)(int*,int);;//PF是函数指针类型
    
    PF f1(int);//正确:PF是指向函数的指针,f1返回的是函数的指针
    F f1(int);//错误:F是函数类型,f1不能返回函数类型
    F *f1(int);//正确:显式地将返回类型转换为函数的指针
    
    int (*f1(int))(int*,int);//f1有形参列表,所以f1是个函数;f1前面有*,所以f1返回的是一个指针;指针的类型本身也包含形参列表,因此指针指向函数,该函数的返回类型为int
    
    //尾置返回类型
    auto f1(int)->int(*)(int*,int);

    使用auto和decltype用于函数指针类型:
    decltype得到的类型,需要加上*得到函数指针,auto直接得到函数指针。

    几个简单的demo:

    练习 6.54:

    函数指针
    int func(int,int);

    vector<decltype(func)*> vF;

    练习 6.55:

    函数指针

    #include<iostream>
    #include<vector>
    using namespace std;
    
    int func1(int a, int b)		//加法
    {
    	return a + b;
    }
    int func2(int a, int b)		//减法
    {
    	return a - b;
    }
    int func3(int a, int b)		//乘法
    {
    	return a * b;
    }
    int func4(int a, int b)		//除法
    {
    	if (b != 0)
    		return a / b;
    	else
    	{
    		cout << "除数不能为0!" << endl;
    		return 0;
    	}
    }
    
    int main(void)
    {
    	system("color 50");
    	//函数名当值使用时自动转换为指针,即int(*)(int,int);decltype得到的类型为int()(int,int),加上*变成函数指针了
    	decltype(func1)* p1 = func1, * p2 = func2, * p3 = func3, * p4 = func4;
    	//vector装的是类型为int (*)(int,int)的函数指针
    	vector<decltype(func1)*> vF = { p1,p2,p3,p4 };
    	system("pause");
    }

    练习 6.56:

    函数指针

    #include<iostream>
    #include<vector>
    using namespace std;
    
    int func1(int a, int b)		//加法
    {
    	return a + b;
    }
    int func2(int a, int b)		//减法
    {
    	return a - b;
    }
    int func3(int a, int b)		//乘法
    {
    	return a * b;
    }
    int func4(int a, int b)		//除法
    {
    	if (b != 0)
    		return a / b;
    	else
    	{
    		cout << "除数不能为0!" << endl;
    		return 0;
    	}
    }
    //第三个形参为函数指针
    void Compute(int a, int b, int(*p)(int, int))
    {
        //使用函数指针无须解引用,直接调用即可
    	cout << p(a, b) << endl;
    }
    int main(void)
    {
    	system("color 50");
    	int i = 5, j = 10;
    	//函数名当值用自动转换为指针,函数指针指向的类型为int(int,int)
    	decltype(func1)* p1 = func1, * p2 = func2, * p3 = func3, * p4 = func4;
    	//vector装的是类型为int (*)(int,int)的函数指针
    	vector<decltype(func1)*> vF = { p1,p2,p3,p4 };
    	for (auto it : vF)
    	{
    		Compute(i, j, it);
    	}
    	system("pause");
    }
    展开全文
  • C++ 函数指针

    千次阅读 2018-08-12 21:16:48
    函数指针   与数据项相似,函数也有地址。函数的地址是存储其机器语言代码的内存的开始地址。它允许在不同的时间传递不同的函数地址。 使用函数指针需要三步: 1. 获取函数的地址: 只要使用函数名(后面不跟...

    函数指针

     

    与数据项相似,函数也有地址。函数的地址是存储其机器语言代码的内存的开始地址。它允许在不同的时间传递不同的函数地址。

    使用函数指针需要三步:

    1. 获取函数的地址: 只要使用函数名(后面不跟参数)即可获得函数地址。

     

    2. 声明一个函数指针

    声明指向某种数据类型的指针时,必须指定指针指向的类型。同样,声明指向函数的指针时,也必须指定指向的函数类型。这意味着声明应指定函数的返回类型以及函数的特征标(参数列表)。

    这是将pam 替换为了(*pf)。pf就是指针函数。

    正确的声明pf 后,便可以将相应的函数地址赋给它。pf = pm;

    注意:pam()的特征标和返回值类型必须于 pf 相同,否则编译器将拒绝这种赋值。

     

    3. 使用函数指针来调用函数

    pf 扮演的角色与函数名相同,因此使用 (*pf) 时,只需将它看做函数名即可:

    double x = pam(4);

    double y = (*pf) (5);

    实际上C++也允许像使用函数名那样使用pf:

    double y = pf(5);

     

     

    深入探讨函数指针

    下面的一些函数原型:

    假设声明一个指针,它可指向这三个函数之一:

    auto 自动类型推断只能用于单值初始化,不能用于初始化列表。

     

    来看下面的输出语句:

    (*p1)(av, 3)和p2(av, 3)都调用指向的函数,并将av, 3作为参数。因此显示的是这两个函数的返回值,返回值类型为const double * (即double值的地址),为查看地址中的实际值,需要使用解引用运算符。

     

    也可建立一个指针数组函数:

    如何来调用函数呢?

     

    展开全文
  • C++函数指针、指针函数、返回值为函数指针的函数浅谈 引言 函数指针、指针函数是C中重要而容易混淆的概念,博主将通过两个实例来说明这两个截然不同的概念。 而返回值为函数指针的指针函数就更难理解了,放在文章的...

    C++函数指针、指针函数、返回值为函数指针的函数浅谈

    引言

    函数指针、指针函数是C中重要而容易混淆的概念,博主将通过两个实例来说明这两个截然不同的概念。
    而返回值为函数指针的指针函数就更难理解了,放在文章的最后来介绍。

    函数指针

    函数指针是一种特殊的 指针,它指向函数的入口。
    例如int (*add)(int, int);定义了一个函数指针add,用于指向返回值为int,并且有两个int参数的函数,下面用实例来说明

    /**
     * 作者:lyn
     * 时间:2018.10.30
     * 此程序用来演示函数指针
     */
    #include<iostream>
    using namespace std;
    
    int addfunc(int a, int b) {
            return a + b;
    }
    int main() {
            int (*add)(int, int) = addfunc;
            //两种方法都可以
            //int (*add)(int, int) = &addfunc;
    
            int result = (*add)(1, 2);
            //两种方法都可以,建议使用第一种
            //int result = add(1, 2);
            cout << "通过函数指针调用函数进行计算结果:" << result << endl;
            result = addfunc(1, 2);
            cout << "通过直接调用函数进行计算结果:" << result << endl;
            return 0;
    }
    

    在这里插入图片描述

    指针函数

    指针函数是一种返回值为指针的 函数
    例如A *createA();声明了一个返回值为指向A类型的指针的,参数列表为空的函数(这句话读起来可能有一··绕口),实例说明

    /**
     * 作者:lyn
     * 时间:2018.10.30
     * 该程序用来演示指针函数
     */
    #include<iostream>
    using namespace std;
    class A {
            public:
                    A(int a) {
                            this->a = a;
                    }
                    int getA(){
                            return a;
                    }
            private:
                    int a;
    };
    
    //返回值为指向类型A的指针的函数
    A *createA() {
            return new A(1);
    }
    
    int main(){
            //创建一个指向A类型的指针,并调用createA创建一个A类型的对象
            A* b = createA();
            //通过指针调用类的方法
            cout << "b->a = " << b->getA() << endl;
            return 0;
    }
    

    在这里插入图片描述

    返回值为函数指针的函数

    其实在搞懂了函数指针和指针函数后,这个概念并不难懂,其实这就是一个复杂一点的指针函数,因为他的返回值为函数指针。
    先给一个例子:

    /*
    *本例是SGISTL源码中的一个函数,比普通的返回值为函数指针的函数要更复杂一点
    *因为本例中函数的参数也是一个函数指针
    */
    void (* set_malloc_handler(void (*f)()))()
    

    我们把例子从里往外看
    void (*f)()是一个函数指针,它用于指向一个返回值为void,无参数列表的函数
    * set_malloc_handler(void (*f)())这是一个指针函数,返回值为指针,它有一个参数,参数为一个函数指针(返回值为void,无参数列表的函数)
    void (* set_malloc_handler(void (*f)()))()这是一个指针函数,返回值为函数指针(返回值为void,无参数列表的一个函数),它有一个参数,参数为一个函数指针

    展开全文
  • c++函数指针

    2014-03-30 23:55:11
    函数指针:指向函数的指针。函数的地址是存储其机器语言代码的内存的开始地址。 函数的地址表示:直接用函数名表示即可。如:int fun(int n) 这个函数的地址就是fun。 ②使用函数指针的步骤:ⅰ.获取函数的地址 ...
  • C++函数指针学习

    千次阅读 2019-03-30 16:09:58
    C++函数指针学习 博客搬家,原地址:https://langzi989.github.io/2017/09/08/C++函数指针学习/ 使用函数指针的优点 使用函数指针有助于我们设计出更优秀,更简洁更高效的程序。在下面的情景中我们常用到函数指针: ...
  • C#和c++之间相互传递函数指针C++和C#之中都有很多callback method,可以相互调用吗,怎么传递,是我表弟的问题. 1.定义c++ dll ,导出方法 // sort.cpp : 定义 DLL 应用程序的导出函数。 // #include "stdaf...
  • c++函数指针和函数对象

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

    2014-11-07 16:00:29
    C++函数指针: 我先来写一个类object,规定函数指针指向的必须是object的成员,或其子类的成员。 class object{ public: void (object::*p)(); }; 好,然后我们再来写一个类hello继承于类object。写一...
  • C++函数指针和std::function对象

    千次阅读 2018-10-08 22:22:02
    C++函数指针和std::function对象 这篇博文中通过实现对String字符串大小写转换为列来说明C++中函数指针和std::function对象的使用。 我们在博文《C++实现一个简单的String类》中的自定义的String类为基础,再添加两...
  • C#委托传递给C++函数指针

    千次阅读 2018-10-24 23:37:05
    C#委托传递给C++函数指针 原创作者游蓝海,转载请注明出处 最近在Unity中集成一些C++库,跨语言交互的时候遇到了一个坑——不能直接将extern方法的参数声明为委托类型。 因为将方法作为参数传递的时候,C#会自动...
  • 1、函数指针:指向函数的指针,指针函数,返回值是指针的函数。 函数指针声明举例: int (*pf)(int &, int &); //pf指向一个函数,该函数参数是两个int类型的引用,返回值是int类型 int TestFun(int &...
  • C/C++ 函数指针

    千次阅读 多人点赞 2018-06-02 17:01:19
    一、定义 函数指针是指向函数的指针变量。 因此“函数指针”本身首先应是指针变量,只不过该指针变量指向函数。扩展:函数指针和指针函数的区别? 他们只是名字比较像。函数指针是指向函数的指针变量,本质是一个...
  • C/C++函数指针与指针函数

    千次阅读 2018-12-20 15:39:02
    面试的时候,经常有面试官问这个问题,在Linux内核里面也是经常被使用的,在看很多大神的代码里面,我们也经常遇到函数指针与指针函数,一样,如果你自己没问题了,就不用往下看了。   定义 我们看个代码 int ...
  • C/C++函数指针用法总结

    千次阅读 2014-12-02 16:48:05
    C++函数指针 一函数指针介绍   函数指针指向某种特定类型,函数的类型由其参数及返回类型共同决定,与函数名无关。举例如下: int add(int nLeft,int nRight);//函数定义   该函数类型为int(int,int),要想...
  • 01 //C/C++ 函数指针调用函数 02 #include 03 using namespace std; 04   05 voi
  • 函数指针数组则是类似于数组的形式,只不过形式与函数指针类似 参考链接:https://blog.csdn.net/armyshen/article/details/8799310 代码 #include&lt;stdio.h&gt; #include&lt;string.h&gt; #...
  • C/C++代码中常见函数指针的使用,C++中经常碰到函数对象这种用法,在此简单总结。 1.函数指针 函数指针(function pointer)就是指向某函数的指针变量,即指向所谓的函数入口地址。函数指针的基本作用就是调用函数,...
  • C++函数指针、函数指针数组

    千次阅读 2013-04-14 12:23:04
    1、函数指针 数组名是指向第一个数组元素常量指针;同理,函数名也是指向函数的第一条指令的常量指针 int (*p)(int);//声明一个指针p,它指向一个函数,这个函数带有一个int型参数,并且返回值为int型 int fun...
  • C++ 函数指针和函数类型

    千次阅读 2018-04-12 23:06:09
    函数指针和函数类型 函数指针指向的是函数而非对象。和其他指针类型一样,函数指针指向某种特定类型。 函数类型由它的返回值和参数类型决定,与函数名无关。 bool length_compare(const string &amp;, ...
  • 定义一个函数指针,指向的函数有两个int形参并且返回一个函数指针,返回的指针指向一个有一个int形参且返回int的函数? A:int (*(*F)(int, int))(int) B: int (*F)(int, int) C:int (*(*F)(int, int)) D:*(*F)...
  • C/C++函数指针与指针函数等区别

    千次阅读 2018-01-10 17:40:29
    (1)函数指针与指针函数(1)函数指针一种特殊的指针,它指向函数的入口;/* * 定义一个函数指针p,只能指向返回值为int,形参为两个int的函数 */ int (*p)(int,int);/* * 求最大值 * 返回值是int类型,...
  • 读《STL源码剖析》第八章 两种取地址的方式不同 http://www.runoob.com/w3cnote/cpp-func-pointer.html
  • C++函数指针简介

    千次阅读 2015-10-24 12:33:33
    1.函数指针简介1.1函数指针的用法简单回顾函数指针的用法。#include &lt;iostream&gt; using namespace std;int add(int i,int j) { return i+j; } int main() { //用法一 int(*addP)(int,int)=...
  • 功能:探究函数指针函数指针数组的定义及用法 输入示例: Input 2 numbers & 1 operator(0-max, 1-min, 2-sum): 1 9 2 输出示例: 10 -------------------------------------------...
  • C++函数指针和回调函数

    千次阅读 2019-03-06 23:44:32
    什么是函数指针 函数指针就是指向函数的指针,指向某种特定的类型。函数的类型由它的返回类型和形参类型共同决定,与函数名无关,例如: bool lengthCompare(const string &amp;amp;, const string &amp;...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,598
精华内容 17,839
关键字:

c++函数指针

c++ 订阅