C++中用成员函数指针模拟多态

1.成员函数指针的用法

#include <iostream>
using namespace std;
class base
{
public:
   int test(int lhs,int rhs)
    {
        cout<<"base test"<<endl;
        return 1;
    }
};
class derived:public base
{
public:
    int test(int lhs,int rhs)
    {
        cout<<"derived test"<<endl;
        return 2;
    }
};
int main()
{
    base *p;
    derived d;
    int (base::*baseFunction)(int,int);
    int (derived::*derivedFunction)(int,int);
    //基类指针指向子类对象＋基类成员函数指针调用基类成员函数
    p=&d;
    baseFunction=&base::test;
    (p->*baseFunction)(1,2);//相当于d.base::test(int,int);
    //基类指针指向子类对象＋基类成员函数指针调用子类成员函数
    p=&d;
    baseFunction=(int (base::*)(int,int))&derived::test;
    (p->*baseFunction)(1,2);//相当于d.test(int,int);
    return 0;
}

输出

base test

derived test

2.成员函数指针模拟多态

#include <iostream>
using namespace std;
class base
{
public:
    base()
    {
        virtualFunctionPointer=&base::test;
    }
    ~base()
    {
        
    }
    int (base::*virtualFunctionPointer)();

    int test()
    {
        //判断是否为基类实例，防止无限递归
        if(virtualFunctionPointer==&base::test)
        {
            cout<<"base"<<endl;
            return 1;
        }
        //子类对象通过基类指针调用test，多态
        else
           return (this->*virtualFunctionPointer)();
      
    }

};
class derived:public base
{
public:
  
    derived()
    {
        virtualFunctionPointer=(int (base::*)())&derived::test;
    }
    ~derived()
    {
        
    }
    int test()
    {
        cout<<"derived"<<endl;
        return 2;
    }

};
int main()
{
    derived d;
    base *p=&d;
    cout<<p->test()<<endl;
    base b;
    p=&b;
    cout<<p->test()<<endl;

    return 0;
}

 输出：

derived

2

base

1