精华内容
下载资源
问答
  • 指向函数指针 函数的类型由它的返回值和参数列表决定, 但函数不能返回一个函数类型。 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);
    展开全文
  • 函数重载:很多人认为函数重载,不就是名字相同然后返回不一样类型的函数嘛;这种理解不能说完全错误,但还是有些小问题。函数重载最大的特点就是多个函数的函数名相同;那么c++编译器又是如何区分我们要调用的函数...
    函数重载:很多人认为函数重载,不就是名字相同然后返回不一样类型的函数嘛;
    这种理解不能说完全错误,但还是有些小问题。

    函数重载最大的特点就是多个函数的函数名相同;那么c++编译器又是如何区分我
    们要调用的函数到底是那个呢?
    如果你思考到这里的话,应该不难理解为什么说函数的返回值不是函数重载的决定
    因素了:当调用函数的时候,首先得把函数参数传进去,编译器才会去检索到底是
    用哪一个函数的吧?换句话说,编译器无法预判你到底想要返回什么结果,只用得
    知你传入参数是什么样子的,它才会自动检索匹配调用有相同参数的函数。
    因此,我们不难得出结论:
    函数重载是由函数名字和参数(类型/个数)决定的。

    举个例子:
    void myfun(int a, int b)
    {
        cout << "a = " << a <<endl;
        cout << "b = " << b <<endl;
    }
    int myfun(int a, int b)
    {
        cout << "a = " << a <<endl;
        cout << "b = " << b <<endl;
    }
    如果这两个函数写在一起,编译器会报错(自己跑一下,实践是检验真理的唯一标准),
    原因很简单:它只有返回类型不一样,名字,和传入数据类型都一样(你把自己想象成
    c++编译器我给你两个这样的函数,你也无法出我要调用哪一个吧?)

    再来个有默认参数的例子:
    void myfun(int a, int b,int = 0)
    {
        cout << "a = " << a <<endl;
        cout << "b = " << b <<endl;
    }
    void myfun(int a, int b)
    {
        cout << "a = " << a <<endl;
        cout << "b = " << b <<endl;
    }
    思考:如果我调用函数是写成myfun(1, 2);
    那么请问:我想调用那个函数?
    也许我只是懒得写第三个参数,就让他默认为0就好;
    也许我就只想调用有两个参数的那个函数呢!

    还好c++编译器对这种二义性问题进行了检查,它分辨不出来的时候会报错!

    看看函数指针:
    #include <iostream>
    using namespace std;

    //函数重载
    void myfun(int a, int b)
    {
        cout << "a = " << a <<endl;
        cout << "b = " << b <<endl;
    }

    void myfun(double a, double b)
    {
        cout << "a = " << a <<endl;
        cout << "b = " << b <<endl;
    }

    void myfun(char * p)
    {
        cout << "p = " << p <<endl;
    }

    //函数的返回类型不是决定函数重载的要素
    //函数的名字和参数(类型/个数)才是
    //如果只是函数返回类型不同则编译会报错
    //如下面的例子
    /*
    int myfun(int a, int b)
    {
        cout << "a = " << a <<endl;
    }
    */

    //函数指针
    //申明一个函数类型
    typedef void (myTypeFunc)(int a, int b);     //int
    //  myTypeFunc *myfuncp = NULL;     //定义一个函数指针,这个指针指向函数的入口地址

    //声明一个函数指针类型
    typedef void(*myPTypeFunc)(int a, int b);    //声明了一个指针的数据类型
    //myPTypeFunc fp = NULL;        //通过函数指针类型,定义了一个函数指针

    //定义一个函数指针变量
    void (*myPfunc)(int a, int b);
    int main()
    {
        //fun(1,2);
       
        myPTypeFunc fp;     //  定义了一个函数指针变量
       
        fp = myfun;
        fp(1, 2);
        fp(1.0, 2.0);
        return 0;
    }

    展开全文
  • #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
    #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 c){
    	cout << "func2" << endl;
    	return 0;
    }
    
    typedef int (*funcp1)(int,int);
    typedef int (*funcp2)(int,int,int);
    
    int main(){
    	int a = 0,b = 0,c = 0;
    	funcp1 f1 = func1;
    	funcp2 f2 = func1;
    	f1(1,2);//func1
    	f2(1,2,3);//func2
    	system("pause");
    	return 0;
    }
    
    展开全文
  • c语言中通过函数指针实现函数重载.pdf
  • 当使用重载函数名对函数指针进行赋值时,根据重载规则挑选与指针参数列表一致的候选者。严格匹配候选者的函数类型与函数指针函数类型。 int func(int x){ return x; } int func(int a,int b){ return a + b; } ...

    笔记:

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

    int func(int x){
    	return x;
    }
    int func(int a,int b){
    	return a + b;
    }
    int func(const char* s){
    	return strlen(s);
    }
    typedef int(*PFUNC)(int a);//int(int a);
    int main()
    {
    	int c = 0;
    	PFUNC p = func;
    	c = p(1);
    	cout << c << endl;
    	return 0;
    }
    


    void myfunc(int a,int b){
    	printf("a:%d,b:%d",a,b);
    }
    void myfunc(double a, double b){
    	printf("a:%f,b:%f", a, b);
    }
    
    
    
    //函数指针 基础语法
    //声明一个函数类型
    //void myfunc(int a,int b);
    typedef void(myTypeFunc)(int a, int b);
    //myTypeFunc *myfuncp=NULL;定义一个函数指针,这个指针指向函数的入口地址。
    
    //声明一个函数指针类型
    typedef void(*myPTypeFunc)(int a,int b);//声明了一个指针的数据类型
    //myPTypeFunc fp=NULL;通过 函数指针类型 定义了一个函数指针
    
    //定义一个函数指针变量
    void(*myVarPFunc)(int a, int b);
    
    int main()
    {
    	myPTypeFunc fp;//定义了一个函数指针变量
    	fp = myfunc;
    	fp(1,2);
    	return 0;
    }



    展开全文
  • 重载函数”是“作用域相同函数名相同而参数表不同的函数”,它弱化了返回值,强调了函数名... 如果仅有返回值不同,则它们是不同类型的函数,它们的地址不可以交叉给指针赋值,但是它们不属于重载而属于错误声明;
  • 1。多继承 基类 派生类(还要有多个父类) 第二条:涉及构造和析构 通过实例化一个对象体现构造和析构 还要有函数重载 第三个:基类 派生类的关系 以及如何访问抽象... 还要有函数重载 指针 指针悬挂 无参函数等问题....
  • 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 " &...
  • 函数重载概念本质

    千次阅读 2015-06-08 19:47:45
    1 函数重载概念 函数重载(Function Overload) 用同一个函数名定义不同的函数 当函数名和不同的参数搭配时函数的含义不同 2 函数重载的判断标准 函数重载至少满足下面的一个条件: 参数个数不同 参数类型...
  • 函数重载遇上函数指针

    千次阅读 2016-08-08 09:41:18
    一旦函数指针声明时确定了参数类型,那么就是严格类型匹配的,当然因为这里没有double或者float类型的函数重载,如果参数是double或者float类型,同样可以通过上面定义的函数指针进行函数调用,这个就跟函数重载的...
  • Triangle T1(3);
  • const 参数重载const 成员函数重载

    千次阅读 2017-10-18 20:59:01
    const 参数重载《C++ primer》一书中这样描述:“可基于函数的引用形参是指向 const 对象还是指向非 const 对象,实现函数重载。将引用形参定义为 const 来重载函数是合法的,因为编译器可以根据实参是否为 const ...
  • 函数重载和const形参的函数重载

    千次阅读 2014-09-04 22:09:34
    1、函数重载和重复声明的区别 如果两个函数声明的返回类型和形参表完全匹配,则将第二个函数声明视为第一个的重复声明。如果两个函数的形参表完全相同,但返回类型不同,则第二个声明是错误的: Record ...
  • //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...
  • C语言实现函数重载

    万次阅读 多人点赞 2016-03-18 11:30:26
    C++如何实现重载C++ 实现函数重载很大程度上依赖编译器对函数名的 Mangling(损坏,破坏),即 C++ 的源代码被编译后同名的重载函数名字会被破坏,一般是在原函数名前后加上特定的字符串(g++编译器中通过在函数名...
  • C++ | 函数重载

    万次阅读 2018-04-05 17:31:36
    目录 目录 函数重载是什么 可以构成重载的要求 ...缺省参数让我们在参数数目不同时可以调用同一个函数(不清楚的可以看下我 C++ 零碎知识点集合 那篇博客),而函数重载让我们能够使用多个同名函数。 (...
  • c语言中通过函数指针实现函数重载

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

    千次阅读 2016-06-26 20:02:20
    什么是函数重载函数重载即为允许在同一作用域内,一组函数可以拥有相同函数名,不同的参数(参数个数,大小),这组函数就叫做重载函数。 注意:重载函数必须在同一作用域内,不在则不算。 两个重载函数: 1...
  • 3.函数重载 3.1 非成员函数重载 3.2 成员函数重载 3.3 函数的默认参数 3.4 内联函数 4.常量引用 4.1 const的最初动机 4.2 const与指针 4.3 const函数 4.4 const类 4.5 引用(&amp;) 4.6 复制...
  • 函数重载与重复声明

    千次阅读 2018-05-17 15:21:24
    参数个数或类型不同,则认为是重载 // 重载函数 void print( const string &amp; ); void print( vector&lt;int&gt; &amp; );2.函数返回类型和参数表完全相同,则认为第二个函数是第一个函数的...
  • 1.对双目运算符而言,成员函数重载运算符的函数参数表中只有一个参数,而用友元函数重载运算符函数参数表中含有两个参数。  对单木运算符来说,成员函数重载运算符的函数参数表中没有参数,而用友元函数重载运算符...
  • 函数重载

    2019-04-11 21:53:34
    函数重载(Function Overload):用同一个函数名定义不同的函数,当函 数名和不同的参数搭配时函数的含义不同。 3.4.1 重载规则 1,函数名相同。 2,参数个数不同,参数的类型不同,参数顺序不同,均可构成重载。 3,...
  • C++的函数重载

    万次阅读 多人点赞 2018-07-11 13:44:56
    ——每个现象后面都隐藏一个本质,关键在于我们是否去挖掘 ...函数重载的重要性不言而明,但是你知道C++中函数重载是如何实现的呢(虽然本文谈的是C++中函数重载的实现,但我想其它语言也是类似的)
  • 将函数名作为指向函数的指针,有助于理解为什么ECMAScript中没有函数重载的概念,需要的朋友可以参考下
  • C++ 虚函数和函数重载

    千次阅读 2014-07-23 19:34:59
    函数重载 如何讲函数重载: What——函数重载是什么? why——为什么要用函数重载,没有函数重载会怎样? how——举例说明怎么使用函数重载 ***********************************************************...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 175,840
精华内容 70,336
关键字:

函数重载与指针函数