精华内容
下载资源
问答
  • 指向函数指针 函数的类型由它的返回值和参数列表决定, 但函数不能返回一个函数类型。 01 int fce( const char*, ... ); 02 int fc( const char* ); ...
    1. 指向函数的指针
      函数的类型由它的返回值和参数列表决定, 但函数不能返回一个函数类型。
      01 int fce( const char*, ... );
      02 int fc( const char* );
      03  
      04 // point to fce
      05 typedef int (*PFCE)( const char*, ... );
      06 // point to fc
      07 typedef int (*PFC)( const char* );
      08  
      09 // Initialization
      10 PFCE pfce = fce;
      11 PFC pfc = fc;
      12  
      13 // Invoke the functions
      14 pfce();
      15 pfc();

    2. 指向重载函数的指针
      在两个函数指针类型之间不能进行类型转换, 必须严格匹配才能找到相应的函数。
      1 void ff( const char* );
      2 void ff( unsigned int );
      3  
      4 // Error: No Match, not available parameter list
      5 void (*pf)(int) = ff;
      6 // Error: No Match, not available return type
      7 double (*pf2)( const char* )) = ff;

    3. 指向类实例成员函数的指针
      指向类实例成员函数的指针必须匹配三个方面:参数类型和个数,返回类型,所属类类型。
      01 class Screen
      02 {
      03 public:
      04     int Add(int lhs, int rhs);
      05     int Del( int lhs, int rhs );
      06     void ShowNumber(int value);
      07 };
      08  
      09 typedef int (Screen::*OPE)( intint);
      10 typedef void (Screen::*SHOW)( int);
      11  
      12 OPE ope = &Screen::Add;
      13 SHOW show = &Screen::ShowNumber;
      14  
      15 Screen scr;
      16      
      17 // Invoke its own member
      18 int value = scr.Add(10, 20);
      19 scr.ShowNumber(value);
      20  
      21 // Invoke the function point
      22 value = (scr.*ope)(10, 20);
      23 (scr.*show)(value);

    4. 指向类静态成员函数的指针
      指向类静态成员函数的指针属于普通指针。
      01 class Screen
      02 {
      03 public:
      04     static int Add(int lhs, int rhs);
      05 };
      06  
      07 typedef int (*OPE)(intint);
      08  
      09 OPE ope = &Screen::Add;
      10  
      11 int value = ope(10, 20);
    展开全文
  • 函数重载函数指针

    2017-11-24 21:01:18
    重载函数指针; 什么是函数重载重载函数指针相结合; 阅读之前注意:本文阅读建议用时:22min

    重载与函数指针

    996.icu LICENSE

    • 什么是函数重载
    • 重载与函数指针相结合

    阅读之前注意:

    本文阅读建议用时:22min
    本文阅读结构如下表:

    项目下属项目测试用例数量
    什么是函数重载函数重载1
    函数重载与函数指针相结合函数重载与函数指针1

    什么是函数重载

    参考以下代码:

    #include"iostream"
    using namespace std;
    
    int myPrint(int a)//函数返回值类型不是判定函数重载的依据
    {
    	printf("a=%d\n", a);
    	return 0;
    }
    
    int myPrint(int a,int b)
    {
    	printf("b=%d\n", b);
    	return 0;
    }
    
    //int myPrint(int a, int b,int c=0)//默认参数c会导致二义性,不明确
    //{
    //	printf("b=%d\n", b);
    //	return 0;
    //}
    
    void main()
    {
    	myPrint(3, 4);
    	system("pause");
    }
    

    可以看出,函数重载即同一个函数名,但形式参数的类型或个数不同,在函数里进行的处理也就不同。值得注意的是,如果有默认参数的存在,还有仅仅只是去掉默认参数的函数,这两个函数就会引起二义性,即编译器将不知道到底执行哪一个函数。
    此外,函数重载经常应用在C++中的类的成员函数。1.

    函数重载与函数指针相结合

    参考以下代码(注意其中函数指针的定义方法):

    #include "iostream"
    using namespace std;
    
    int myPrint(int a)
    {
    	printf("%d\n", a);
    	return 0;
    }
    
    int myPrint(char *s)//重载+1
    {
    	printf("%s\n", s);
    	return 0;
    }
    
    int myPrint(int a, int b)//重载+2
    {
    	printf("a=%d,b=%d\n", a, b);
    	return 0;
    }
    
    typedef int(*pFun) (int a);//定义了新的数据类型,表示指针指向函数
    
    void main()
    {
    	pFun pF1 = myPrint;
    	pF1(3);
    	system("pause");
    }
    

    可以看到,在上述代码中,函数指针不过是一种新定义的数据类型pFun罢了,然后再用这种数据类型去定义变量pF1,即可按照函数指针这种数据类型定义的格式来调用相关的重载函数1.

    如果本文对你有帮助,不如请我一杯可乐吧
    在这里插入图片描述


    1. 测试用例基于王保明先生的讲课内容. ↩︎ ↩︎

    展开全文
  • 当使用重载函数名对函数指针进行赋值时,根据重载规则挑选与函数指针参数列表一致的候选者,严格匹配候选者的函数类型与函数指针的函数类型。 demo #include using namespace std; void myfunc(int a) { printf...

    函数重载与函数指针:

    当使用重载函数名对函数指针进行赋值时,根据重载规则挑选与函数指针参数列表一致的候选者,严格匹配候选者的函数类型与函数指针的函数类型。

    demo

    #include <iostream>
    using namespace std;
    
    void myfunc(int a)
    {
    	printf("a:%d \n", a);
    }
    
    void myfunc(char *p)
    {
    	printf("%s \n", p);
    }
    
    void myfunc(int a, int b)
    {
    	printf("a:%d \n", a);
    }
    
    void myfunc(char *p1, char *p2)
    {
    	printf("p1:%s \n", p1);
    	printf("p2:%s \n", p2);
    }
    
    // 函数指针
    
    // 声明一个函数类别
    // void myfunc(int a, int b)
    typedef void(myTypeFunc)(int a, int b);
    
    // 声明一个函数指针类型
    typedef void(*myTypeFunc0)(int a, int b); // 声明了一个指针的数据类型
    
    // 定义一个函数指针变量
    void(*myVarPFunc)(int a, int b); 
    
    int main()
    {
    	myTypeFunc *myfuncp = NULL; // 定义一个函数指针,这个指针指向函数的入口地址
    	// 并且只能定义函数指针,不能把“*”去掉!!!
    
    	myTypeFunc0 funcp = NULL; // 通过函数指针类型定义了一个函数指针
    	funcp = myfunc;
    	myfunc(1);
    
    	{
    		char buf1[] = "aadaf";
    		char buf2[] = "bbb";
    		myfunc(buf1, buf2);
    	}
    	return 0;
    }




    展开全文
  •  当使用重载函数名对函数指针进行赋值时,根据重载规则挑选与函数指针参数列表一致的候选者,严格匹配候选者的函数类型与函数指针的函数类型 #include&lt;iostream&gt; using namespace std; //函数...

        函数重载与函数指针

            当使用重载函数名对函数指针进行赋值时,根据重载规则挑选与函数指针参数列表一致的候选者,严格匹配候选者的函数类型与函数指针的函数类型

    #include<iostream>
    
    using namespace std;
    
    //函数指针  基础的语法
    
    //声明一个函数类型
    
    //typedef void(myTypeFunc)(int a, int b);//int
    
    //声明一个函数指针类型
    
    typedef void(*myTypeFunc)(int a, int b);//声明了一个指针的数据类型
    
    typedef void(*myTypeChar)(char *c, char *d);
    
    //myTypeFunc fp=NULL     //通过函数指针类型定义了一个函数指 针
    
    //定义了一个函数指针变量
    
    //void(*myVarpFunc)(int a, int b);
    
    void myfunc(int a, int b)
    
    {
    
                cout << "a="<<a<< endl;
    
                cout << "b=" << b<< endl;
    
    }
    
    void myfunc(char *p)
    
    {
    
                cout << "p="<<p<< endl;
    
    }
    
    void myfunc(char *p, char *q)
    
    {
    
                cout << "p=" << p << endl;
    
                cout << "q=" << q << endl;
    
    }
    
    //C++具有严格的类型检查,函数指针,重载函数,实参  三者的数据类型要完全相同
    
    void main()
    
    {
    
                char buff1[] = "aaa";
    
                char buff2[] = "bbb";
    
                myTypeFunc fp;//定义了一个  函数指针(参数类型为int)变量
    
                myTypeChar fp1;
    
                fp1 = myfunc;
    
                fp = myfunc;
    
                fp(1, 2);   //输出为a=1,b=2
    
                //fp(buff1, buff2); //输出报错,因为函数指针参数类型与该参数(buff1,buff2)类型不同,c++具有严格的类型检查
    
                fp1(buff1, buff2);//输出为 p=aaa,q=bbb,函数指针的参数类型要与重载函数的数据类型相同,否则报错
    
                system("pause");
    
    }

     

    展开全文
  • 函数重载:很多人认为函数重载,不就是名字相同然后返回不一样类型的函数嘛;这种理解不能说完全错误,但还是有些小问题。函数重载最大的特点就是多个函数函数名相同;那么c++编译器又是如何区分我们要调用的函数...
  • //todo/*[root@Slave02 thread]# g++ bind.cpp -o bind -g -Wall -std=gnu++11 -lpthread;./bindclass void Test::print(const ... str,int32_t i) 对比测试 std::mem_fn 和 std::bind,并调用类重载函数,1class voi...
  • 当使用重载函数名对函数指针进行赋值时,根据重载规则挑选与指针参数列表一致的候选者。严格匹配候选者的函数类型与函数指针的函数类型。 int func(int x){ return x; } int func(int a,int b){ return a + b; } ...
  • c++问题:如何在不写重载函数的情况下,将不同的函数指针作为参数传入同一个函数?
  • 重载函数”是“作用域相同函数名相同而参数表不同的函数”,它弱化了返回值,强调了函数名和参数表;  “指向函数的指针”是“指向同一类型函数的指针”,它弱化了函数名,强调了返回值和参数表——因为“函数...
  • #include <iostream> #include <stdlib.h> using namespace std; int func1(int a,int b){ cout << "func1" << endl; return 0; } int func1(int a,int b,int ...typedef int (*funcp1)(in
  • C++中函数指针遇上函数重载

    千次阅读 2018-03-05 00:38:55
    C++中函数指针遇上函数重载1、C++编译器会按照函数指针的类型自动选择重载函数test.cpp#include &lt;iostream&gt; using namespace std; void print(int a) { cout &lt;&lt; "a is " &...
  • 函数指针: 指向的是函数而非对象。和其它指针一样,函数指针指向某种特定类型。函数的类型由它的返回类型和形参类型共同决定。与函数名无关 void show(int a); //想要声明一个可以指向该函数的指针,只需用指针...
  • 函数指针 函数指针实际上代表一个函数在内存中的入口地址,要正确地定义一个函数指针,必须同时指明函数的返回值类型和函数的参数列表 定义函数指针的形式: ReturnType (* pfunc) (var - list);ReturnType是...
  • 这是一种换汤不换药的做法:我们只是声明了一个匿名的函数指针,而之前我们的函数指针是有名字的。不过,我们并不推荐这样写,而是希望以下的写法: 1 2 3 4 ...
  • 当函数重载遇上函数指针

    千次阅读 2016-08-08 09:41:18
    一旦函数指针声明时确定了参数类型,那么就是严格类型匹配的,当然因为这里没有double或者float类型的函数重载,如果参数是double或者float类型,同样可以通过上面定义的函数指针进行函数调用,这个就跟函数重载的...
  • //Qt5 通过指针函数指定connect里调用哪种重载函数 #include #include #include//滑动器 #include int main(int argc,char *argv[]) { QApplication app(argc,argv); QWidget window; window.setWindow...
  • 模板一: template<typename T> string debug_rep(const ...方式一、二都会匹配模板二,但为什么说方式一对模板二是精确匹配,方式二对模板一、二都是精确匹配,由于特例化匹配模板二,&s与sp同为指针实参有什么区别?
  • c语言中通过函数指针实现函数重载

    千次阅读 2012-06-15 11:18:31
    我们都知道重载是c++面向对象的特性。c语言中是不存在的。所谓重载简单来说就是一个函数名可以...c语言中实现重载功能,或者准确来说是类似重载的功能,可以通过函数指针的方式来实现。下面为演示代码:   typedef
  • 函数指针

    千次阅读 2019-06-05 17:21:03
    函数指针指向的函数而非对象。与其他指针一样,函数指针也指向特定的类型。函数的类型是由返回值和参数列表决定,与函数名无关。例如: //比较两个字符串的长度 bool lenghtCompare(const string &s1, const ...
  • 使用函数指针时,指针可以像函数名一样,直接加括号和参数列表调用;也可先解引用再调用 //include directories... using namespace std; void testFun() { cout&lt;&lt;"this is a test"&...
  • 一般来说,对于重载函数来说,由于顶层const不影响传入函数的对象,所有两个函数只是顶层const的区别的话,两个函数是等价的,定义为重载函数是非法的。  但是,另一方面,对于指针和引用来说,可以通过区分形参...
  • 函数对象和函数指针

    千次阅读 2019-06-16 22:08:16
    函数指针 函数指针:是指向函数的指针变量,在C编译时,每一个函数都有一个入口地址,那么这个指向这个函数的函数指针便指向这个地址。 用途:用作调用函数和做函数的参数。 声明方法:数据类型标志符 (指针...
  • 重载函数

    2021-04-02 15:53:01
    一、重载函数 (1)对于重载的函数来说, 它们应该在形参数量或形参类型上有所不同。 (2)类成员函数的声明为const和非const也是重载 (3)main函数不能重载 (4)只有返回类型不同不算重载 二、顶层const不影响传入函数的...
  • 首先看函数指针的语法,举一个最简单的例子,要创建一个函数指针,则它与它指向的函数,在参数个数类型以及返回值上都保持一致,跟重载的要求应该是一样的。Int a(int a ) {return a ; } Int (* b)(int n) ; // 函数...
  • C++函数指针

    千次阅读 2019-03-03 16:05:26
    函数指针 函数指针指向的是函数并不是对象。和其他指针一样,函数指针指向某种特定类型,函数的类型由它的返回类型和形参类型共同决定,与函数名无关。 声明指向函数的指针的语法形式:用指针替代函数名 //比较两...
  • 实现一般包括该类所需要的数据,还包括定义该类需要的但又不供一般性使用的函数。 定义类 1)先定义该类的接口,即该类所提供的操作; 2)通过这些操作,决定该类完成其功能所需要的数据,以及是否需要定义一些...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 176,742
精华内容 70,696
关键字:

重载函数指针