精华内容
下载资源
问答
  • Error:指向绑定函数指针只能用于调用函数

    千次阅读 多人点赞 2020-10-08 00:14:03
    Error:指向绑定函数指针只能用于调用函数 调用函数的时候没有加上括号。

    Error:指向绑定函数的指针只能用于调用函数

    调用函数的时候没有加上括号。

    展开全文
  • 主要介绍了C++指向函数的指针用法,对函数指针的声明、优先级、指针类型等概念做了较为详尽的分析,需要的朋友可以参考下
  • c++ const指针函数调用

    千次阅读 2018-08-14 11:07:44
    在我的博客...是用非const的基类指针指向派生类对象,如果通过该指针调用函数则发生的动态绑定,如果我们定义一个const指针,指向派生类的对象,如果派生类里定义了同名的虚函数和 cons...

      在我的博客http://blog.csdn.net/caoyan_12727/article/details/52064958中,已经讨论了动态绑定和静态绑定,以及在缺省参数情况下虚函数的绑定情况。一般情况下,我们

    是用非const的基类指针指向派生类对象,如果通过该指针调用虚函数则发生的动态绑定,如果我们定义一个const指针,指向派生类的对象,如果派生类里定义了同名的虚函数和

    const函数,会发生什么调用???

    测试1:

    #include<iostream>
    #include<vector>
    #include<map>
    #include<sstream>
    using namespace std;
     
    class A{
    public:
    	virtual void f(){
    		cout << "A::f()" << endl;
    	}
    	void f() const{
    		cout << "A::f() const" << endl;
    	}
    };
    class B : public A{
    public:
    	void f(){
    		cout << "B::f()" << endl;
    	}
    	void f() const{
    		cout << "B::f() const" << endl;
    	}
    };
     
    void g(const A* a){
    	a->f();
    }
    int main(){
    	B bb;
    	A aa;
    	A const*ptr = &aa;
    	ptr->f();
    	A *ptr1 = &aa;
    	ptr1->f();
    	//派生类
    	B const*ptr2 = &bb;
    	ptr2->f();
    	B *ptr3 = &bb;
    	ptr3->f();
     
    	A* a = new B();
    	a->f();
    	A const*a1 = new B();
    	a1->f();
    	g(a);
    	delete a;
    	return 0;
    }
    

    结果:


    测试2:

    将类A进行修改:

    class A{
    public:
    	virtual void f(){
    		cout << "A::f()" << endl;
    	}
    	virtual void f() const{
    		cout << "A::f() const" << endl;
    	}
    };
    
     

    结果:

    可以看出:

    (1)const指针智能调用类的const函数,如果用const指针调用非const函数将会报错,非const指针调用const函数编译器不会报错。

    (2)const与虚函数并存的时候,const指针只能调用const函数,测试1中,由于const f()不是虚的,所以对const调用时静态绑定,调用的是基类的const函数。在测试2中将

    const f()设置为虚函数时,由于派生类重写const f(),所以调用派生类的const f()。

     

    转自: https://blog.csdn.net/caoyan_12727/article/details/52493555

    展开全文
  • 函数指针的初始化 函数如下: int CompareString(const string&amp; str1, const string&amp; str2) { return str1.compare(str2); } 函数的初始化有两种方式: 第一种,也是最普遍的方式: int...

    函数指针的初始化

    函数如下:

    int CompareString(const string& str1, const string& str2)
    {
        return str1.compare(str2);
    }

    函数的初始化有两种方式:

    第一种,也是最普遍的方式:

    int (*CompareFunction)(const string&, const string&) = CompareString;

    第二种,是使用 typedef 定义函数类型,这种写法有助于对代码的理解:

    typedef int (*CompareFunctionType)(const string&, const string&);
    CompareFunctionType CompareFunction = CompareString;

    函数指针赋值

    函数名可以理解为该类型函数的指针。当然,取地址操作符作用于函数名上也能产生指向该类型函数的指针。也就是说下面两种赋值都是可行的:

    CompareFunctionType CompareFunction = CompareString;
    CompareFunctionType CompareFunction = &CompareString;

    函数调用

    无论是用函数名调用,还是用函数指针调用,还是用显式的指针符号调用,其写法是一样的:

    CompareString("abc", "cba");
    CompareFunction("abc", "cba");
    (*CompareFunction)("abc", "cba");

    函数指针的数组

    对于函数指针的数组,强烈建议使用typedef方式定义类型之后再使用,不然影响代码的阅读性,继续以以上例子为例:

    //without typedef
    int (*CompareFunctionArray[3])(const string&, const string&);
    //with typedef
    CompareFunctionType CompareFunctionTypeArray[3];

    函数指针用做函数返回值的类型

    到这一步,会发现 typedef 是多么的好用了。不然我是完全读不懂下面语句的意思的:

    //without typedef
    int (*func(int*, int))(const string&, const string&);

    上面的声明,将func(int*, int)声明为一个函数,返回值为函数指针,函数类型为int (*)(const string&, const string&)。多么的晦涩啊!如果写成 typedef 就不用这么纠结了,足见 typedef 的作用:

    CompareFunctionType func(int*, int);

    上面所有的内容总结了普通函数指针的声明、定义以及调用,还有函数指针数组,函数指针用作返回值等。但是作为C++的研读,我发现我漏掉了一个最重要的内容,就是指向类成员的指针,这里将做相应补充。指向类成员的指针总的来讲可以分为两大类四小类(指向数据成员还是成员函数,指向普通成员还是静态成员),下面一一做介绍:

    指向类的普通成员的指针(非静态)

    指向类成员函数的指针

    简单的讲,指向类成员函数的指针与普通函数指针的区别在于,前者不仅要匹配函数的参数类型和个数以及返回值类型,还要匹配该函数指针所属的类类型。总结一下,比较以下几点:
    1. 参数类型和个数
    2. 返回值类型
    3. 所属的类类型(特别之处)

    究其原因,是因为非静态的成员函数必须被绑定到一个类的对象或者指针上,才能得到被调用对象的this指针,然后才能调用指针所指的成员函数(我们知道,所有类的对象都有自己数据成员的拷贝,但是成员函数都是共用的,为了区分是谁调用了成员函数,就必须有this指针,this指针是隐式的添加到函数参数列表里去的)。明白了这点,接下来就简单了。

    声明:与普通函数作为区分,指向类的成员函数的指针只需要在指针前加上类类型即可,格式为:

    typedef 返回值 (类名::*指针类型名)(参数列表);

    赋值:只需要用类的成员函数地址赋值即可,格式为:

    指针类型名  指针名 = &类名::成员函数名;

    注意:这里的这个&符号是比较重要的:不加&,编译器会认为是在这里调用成员函数,所以需要给出参数列表,否则会报错;加了&,才认为是要获取函数指针。这是C++专门做了区别对待。

    调用:调用方法也很简单,针对调用的对象是对象还是指针,分别用.和->进行调用,格式为:

    (类对象.*指针名)(参数列表);
    (类指针->*指针名)(参数列表);

    注意:这里的前面一对括号是很重要的,因为()的优先级高于成员操作符指针的优先级。

    下面举个简单的例子就一目了然了:

    class A;
    typedef void (A::*NONSTATICFUNCPTR)(int);    //typedef
    
    class A
    {
    public:
        void NonStaticFunc(int arg)
        {
            nonStaticMember = arg;
            cout<<nonStaticMember<<endl;
        }
    private:
        int    nonStaticMember;
    };
    
    int main()
    {
        NONSTATICFUNCPTR funcPtr= &A::NonStaticFunc;
    
        A a;
        (a.*funcPtr)(10);        //通过对象调用
    
        A *aPtr = new A;
        (aPtr->*funcPtr)(10);    //通过指针调用
    
        return 0;
    }

    指向类数据成员的指针

    成员函数搞懂了,数据成员也就easy了,只要判断以下两点是否一致即可:
    1. 数据成员类型
    2. 所属的类类型

    另外,声明、赋值还有调用方法等这些是和前面类似的,再举个例子吧:

    class A;
    typedef int (A::*NONSTATICDATAPTR);        //typedef
    
    class A
    {
    public:
        A(int arg):nonStaticMember(arg){}
        int    nonStaticMember;
    };
    
    int main()
    {
        NONSTATICDATAPTR dataPtr= &A::nonStaticMember;
    
        A a(10);
        cout<<a.*dataPtr;        //通过对象引用
    
        A *aPtr = new A(100);
        cout<<aPtr->*dataPtr;    //通过指针引用
    
        return 0;
    }

    运行结果,当然是各自输出10100啦。

    指向类的静态成员的指针

    类的静态成员和普通成员的区别在于,他们是不依赖于具体对象的,所有实例化的对象都共享同一个静态成员,所以静态成员也没有this指针的概念。所以,指向类的静态成员的指针就是普通的指针。看下面的例子就明白了:

    typedef const int *STATICDATAPTR;
    typedef int (*STATICFUNCPTR)();        //跟普通函数指针是一样的
    
    class A
    {
    public:
        static int StaticFunc() { return staticMember; };
        static const int staticMember = 10;
    };
    
    int main()
    {
        STATICDATAPTR dataPtr = &A::staticMember;
        STATICFUNCPTR funcPtr = &A::StaticFunc;
    
        cout<<*dataPtr;            //直接解引用
        cout<<(*funcPtr)();
    
        return 0;
    }

    最后注明一下,显然的,要使用(&类名::成员名)获取指向成员的指针,首先这个成员必须是对外可见的哦,即public的,不然是没有权限获取的。

    总结

    写到此,简单总结一下就是:
    1. 静态的和普通的函数指针没啥区别;
    2. 非静态的加一个类局限一下即可。

    不知道以后还会不会有函数指针相关的内容,先到此完结吧。有错误欢迎指正,我会及时修改。

    相关文档

    C++成员函数指针的应用

    展开全文
  • 指向函数指针 指向函数指针的数组

    1、指向函数的指针


    对于一个函数只能做两件事情:调用它,或是取得它的地址。
    可以取得函数的地址并赋值给指向函数的指针,并在以后使用这个指针调用该函数。

    void fun(int num)
    {
    	cout << num << endl;
    }
    
    void (*pfun)(int num);//pfun此时就是一个函数指针
    
    int main()
    {
    	int value = 100;
    	
    	pfun = &fun;//获得函数fun的地址
    	pfun(value);//等价于调用 fun(value);
    	
    	//取地址运算符&可以不要;
    	pfun = fun;
    	pfun(value);//也是等价于调用 fun(value);
    
    	return 0;
    }

    指向函数的指针的声明中也需要给出参数类型和返回值类型。指向函数的指针只能被参数类型和返回值类型都一样的函数赋值。

    比如:
    void (*pfun)(string);
    void f1(string){}
    int f2(string) {}
    void f3(int){}
    pfun = f1;//正确
    pfun = f2;//不正确,返回值类型不同
    pfun = f3;//不正确,参数类型不同


    2、指向函数的指针的数组

    typedef void (*PF)();
    PF edit_opts[] = {&f1, &f2, &f3};//edit_opts就是指向函数指针的数组,数组里面每个元素的类型都是void (*PF)();
    展开全文
  • C++类成员函数指针使用介绍

    万次阅读 多人点赞 2019-09-21 16:07:49
    在之前写过的博客中有介绍过函数指针和指针函数的区别和简单用法(文章在这里),当时的Demo非常简单,都是C语言的写法,但是当在C++中直接像C那样使用类成员函数指针时就会报错:reference to non-static member ...
  • 代码功能 ...在命令行输出调用对应函数名的函数计算结果,例如: log10(1000) = 3 完整源码// C++ code#include #include #include <map>typedef double (* PtrFun) (double x);class FunctionEn
  • 通过对象名调用虚函数,在编译阶段就能确定调用的是哪一个类的虚函数,所以属于静态关联,如果通过基类指针调用函数,在编译阶段无法从语句本身确定调用哪一个类的虚函数,只有在运行时,指针指向某一具体对象后,...
  • 详解函数指针和类成员函数指针

    千次阅读 多人点赞 2017-11-12 21:35:56
    函数指针,顾名思义即指向函数的指针。 如果要问,为什么能用一个指针指向一个函数呢?我觉得要理解这个问题,以及要理解后面的函数指针和类成员函数指针,没有什么比从计算机原理的角度来理解更容易了。这里就简要...
  • C++利用对象、引用、指针调用函数函数实现原理说明: 每个类的大小比起所有成员数据多4个字节,表明有虚函数的类的大小还要加上一个紧缩的空指针类型的大小。这说明了该在包含虚函数的类中,编译系统自动加入了...
  • class A { public: void FuncA() { printf( "FuncA called\n" );...再次说明了,子类中被重写的虚函数的运行方式是动态绑定的,与当前指向类实例的父类指针类型无关,仅和类实例对象本身有关。
  • //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...
  • void Date::setMonth( int mn ) {   month = mn; // 这三句是等价的   this->month = mn;... Please choose the right statement of "this" pointer:(下面关于this指针哪个描述是正确的) A.
  • 如何使用指向类的成员函数指针(详解!)

    万次阅读 多人点赞 2014-01-14 22:13:22
    我们首先复习一下"指向函数指针"如何使用?  void print()  {  }  void (*pfun)(); //声明一个指向函数指针,函数的参数是 void,函数的返回值是 void  pfun = print; //赋值一个指向函数指针  (*pfun)(); ...
  • 函数指针是通过指向函数的指针间接调用函数。相信很多人对指向一般函数的函数指针使用的比较多,而对指向类成员函数的函数指针则比较陌生。 普通函数指针 通常我们所说的 函数指针 指的是指向...
  • 静态多态:程序在编译阶段就可以确定调用哪个函数。这种情况叫做静态多态。比如重载 动态多态:在运行期间才可以确定最终调用函数。需要通过虚函数+封装+继承实现。 虚函数 1、虚函数都必须有定义 2、虚函数...
  • 一、函数指针(不是类的... 2、函数指针的作用: (1)、调用函数:调用的时候,用该指针变量代替函数名即可 (2)、将该函数作为其他函数的参数,即将该函数名作为其他函数的形参 3、指向函数的指针变量定义为: ...
  • 1. 消息的多态性  C++把类看作类型,把以public方式(严格讲:只有public方式)继承的派生类看做基类的子类型,这样就使得在C++面向对象程序中存在下面的三种多态: ...(但是派生类的指针只能指向或引用派生类
  • 使用空指针调用成员函数会如何? 举个例子:base是基类,里面有两个函数:non-virtual func2 以及 virtual func1; derived是派生类,使用public继承自base,里面有四个函数:virtual func1,non-virtual func3,non...
  •  顾名思义,函数指针指向函数之指针,它与其他普通类型指针一样,所占内存为4个字节(32位系统)。所不同的是其内部存储了函数的地址而非数据地址,函数指针可以实现对参数类型、参数顺序、返回值都相同的函数进行...
  • 当然,使用做多的是,在外面封装一下函数,然后把类实体,如this作为参数传递进去,然后在函数内通过this调用成员方法。 但这样做比较别扭,额外写不少不少代码,而boost的function和bind恰恰解决了这个...
  • 使用类的静态函数成员的函数指针、使用类的普通函数成员的指针、定义函数指针数组类型、使用函数指针实现后绑定以及在结构体中定义函数指针。如果您对以上这几个主题都很了解,那么恭喜您,这篇文章不适合您啦~。在...
  • golang中对象方法作为函数指针

    千次阅读 2017-05-09 13:22:13
    函数作为指针不是什么新鲜事,其它的语言也是可以的,golang当然也可以,譬如type FT func(int) func Fa(int){} func Test(FT){}Test(Fa) //pass function as parameter但是像下面这样,对象实例的方法是否可以...
  • C++虚函数指针虚函数表

    千次阅读 多人点赞 2017-07-10 22:25:57
    C++的多态可以分为静态多态和动态多态。函数重载和运算符重载实现的多态属于静态...2)带纯虚函数的类叫虚基类也叫抽象类,这种基类不能直接生成对象,只能被继承,重写虚函数后才能使用,运行时动态动态绑定!   2.
  • namestring//给结构体绑定一个字段,用以说明结构体和结构体指针绑定函数的区别 } 2.给结构体绑定函数 func (test Test) function(){ test.name = "结构体" } 3.给结构体指针绑定函数 func(test *Test) ...
  • 指向函数指针(一)

    万次阅读 多人点赞 2012-04-16 00:08:03
    之所以想写一篇函数指针的文章,源于函数指针在C/C++编程中使用的广泛性,而对于一些初级编程者来说对函数指针的使用或许有些迷惑,而一旦在适当的时候使用了函数指针,会使代码简洁有力。本篇介绍的是函数指针的...
  • 改变函数内部this指针指向函数 通过apply和call改变函数的this指向,他们两个函数的第一个参数都是一样的表示要改变指向的那个对象;第二个是传入的参数,apply是数组,而call则是arg1,arg2…这种形式。 通过...
  • 在基类中定义了public虚函数,在派生类中将其重写,但是设置为private,为什么通过基类指针仍然可以发生动态绑定调用派生类中的private虚函数? 例子如下: class Base { public: // public虚函数 virtual void ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 137,971
精华内容 55,188
关键字:

指向绑定函数的指针只能用于调用函数