【无标题】

**

类的成员函数指针，及其调用方式

**
//这个代码是成员函数指针使用的一个案例,也是我研究这个知识点的起点，如果你看完了后面的解释，感兴趣的话还可以回过头来再瞅瞅这段代码。

#include <iostream>
#include <vector>

//抽象的父类无法实例化
class Shape {
public:
    virtual double calculateArea() = 0;
};


 //子类重写父类的纯虚函数，以实现多态
class Rectangle : public Shape {
public:
    Rectangle(double w, double h) : mWidth(w), mHeight(h) {}

    virtual double calculateArea() {
        return mWidth * mHeight;
    }

private:
    double mWidth;
    double mHeight;
};

class Circle : public Shape {
public:
    Circle(double r) : mRadius(r) {}

    virtual double calculateArea() {
        return 3.14 * mRadius * mRadius;
    }

private:
    double mRadius;
};

class Calculator {
public:
    double calculateTotalArea(const std::vector<Shape*>& shapes) {
        double totalArea = 0;
        for (auto shape : shapes) {
    		//shape是父类指针但指向的是子类对象，mCalculateAreaPtr是父类的函数指针
      		//这样调用应用了成员函数指针和多态的知识点，因此看上去比较复杂。
            totalArea += (shape->*mCalculateAreaPtr)();
        }
        return totalArea;
    }

    void setCalculateAreaPtr(double (Shape::*calculateAreaPtr)()) {
        mCalculateAreaPtr = calculateAreaPtr;
    }

private:
    double (Shape::*mCalculateAreaPtr)() = nullptr;
};

int main() {
    Rectangle rect(5, 10);
    Circle circle(7);

    Calculator calculator;
    calculator.setCalculateAreaPtr(&Shape::calculateArea);

    std::vector<Shape*> shapes = { &rect, &circle };
    double totalArea = calculator.calculateTotalArea(shapes);

    std::cout << "Total area: " << totalArea << std::endl;
    return 0;
}

下面这段代码以及解释，是我自己学习之后所习得的解释，供参考。

#include <iostream>
using namespace std;
class Myclass
{
public:
static void func(int a)
{
cout << 静态成员函数调用 << endl;
}
void func2(int b)
{
cout << 非静态成员函数调用 << endl;
}
};
int main() {
//这样写不对，因为静态成员函数 不用写成成员函数指针
//void(Myclass:: * funcptr) (int) = &Myclass::func;
//静态成员函数直接使用函数指针即可调用
void (*funcptr1)(int) = &Myclass::func;
funcptr1(1);

//非静态成员函数需要借助成员函数指针才可以进行指针调用
void(Myclass:: * funcptr) (int)= &Myclass::func2;

Myclass a;
Myclass b;
Myclass* b1=&b;
//实例化对象进行调用
(a.*funcptr)(1);
//对象指针调用成员函数指针
(b1->*funcptr)(1);

return 0;

}

成员函数指针用于指向类中的非静态成员函数，其实例化的方式有点类似于函数指针，但是在其前面加上了作用域。
进行成员函数指针调用需要先实例化对象出来，或者用类指针指向已经实例化的对象，在进行调用时需要加上括号。
如下举一个例子，是从另外的地方看到的解释：
成员函数指针用于指向类中的非静态成员函数。在 C++ 中，成员函数指针的实例化方式类似于函数指针，不同的是需要指定它所属的类。具体来说，主要有两种方式进行实例化：
首先是定义时在成员函数指针类型前加上类作用域：

ReturnType (ClassName::*pointerName)(parameter types) = &ClassName::functionName;

其次是使用 typedef 给成员函数指针类型取一个别名，方便以后使用：

typedef ReturnType (ClassName::*PointerName)(parameter types);
PointerName pointer = &ClassName::functionName;

当成员函数指针实例化完成后，可以将其绑定到一个对象上并使用 .* 运算符调用类对象的成员函数；或者将其绑定到类指针上并使用 ->* 运算符调用指向的对象的成员函数。需要注意，调用成员函数时需要加上括号，就像直接调用成员函数一样。
举个例子：

#include <iostream>
using namespace std;

class MyClass {
public:
    int add(int a, int b) {
        return a + b;
    }
};

int main() {
    typedef int (MyClass::*addPointer)(int, int);
    MyClass obj;
    addPointer ptr = &MyClass::add; // 实例化成员函数指针
    // 将成员函数指针绑定到类对象上并调用
    cout << (obj.*ptr)(3, 4) << endl; // 输出 7
    // 将成员函数指针绑定到类指针上并调用
    MyClass *ptrObj = &obj;
    cout << (ptrObj->*ptr)(3, 4) << endl; // 输出 7
    return 0;
}

以上内容仅为我个人学习所总结，可能存在错误，希望大家理性看待，欢迎指正