C++ 使用指向成员运算符的指针？

我遇到了以下代码，但无法理解以下概念的重要性。请帮忙

#include <iostream>
using namespace std;

class cl 
{

public:
    cl(int i) { val=i; }
    int val;
    int double_val() { return val+val; }

};

int main()
{
    int cl::*data; // data member pointer
    int (cl::*func)(); // function member pointer
    cl ob1(1), ob2(2); // create objects
    cl *p1, *p2;
    p1 = &ob1; // access objects through a pointer
    p2 = &ob2;
    data = &cl::val; // get offset of val
    func = &cl::double_val; // get offset of double_val()
    cout << "Here are values: ";
    cout << p1->*data << " " << p2->*data << "\n";
    cout << "Here they are doubled: ";

    cout << (p1->*func)() << " ";
    cout << (p2->*func)() << "\n";
    return 0;
}

#包括
使用名称空间std；
类别cl
{
公众：
cl（int i）{val=i；}
int-val；
int double_val（）{return val+val；}
};
int main（）
{
int cl:：*data；//数据成员指针
int（cl:：*func）（；//函数成员指针
cl ob1（1），ob2（2）；//创建对象
cl*p1，*p2；
p1=&ob1；//通过指针访问对象
p2=&ob2；
data=&cl:：val；//获取val的偏移量
func=&cl:：double\u val；//获取double\u val（）的偏移量
CUT
指向成员的指针是C++中的一个特殊小部件，它只告诉你一个你想要的类中的成员而不涉及任何对象。你需要把一个指针和一个对象实例组合起来，以获得一个实际的成员，无论它是一个数据还是一个函数成员。
将指向成员的指针视为“偏移量”。此外，请记住指向成员的指针不是指针
我们可以重写您的代码，使其更加清晰：

struct Foo
{
    int a;
    int b;
    double f(int, int);
    double g(int, int);
};

int main()
{
    int Foo::*ptm = &Foo::a;
    double (Foo::*ptmf)(int, int) = &Foo::f;

    Foo x, y, z;

    int numbers[] = { x.*ptm, y.*ptm, z.*ptm }; // array of Foo::a's

    ptm = &Foo::b;                              // reseat the PTM

    int more[] = { x.*ptm, y.*ptm, z.*ptm };    // array of Foo::b's


    double yetmore[] = { (x.*ptmf)(1,2), (y.*ptmf)(1,2) };

    ptmf = &Foo::g;

    double evenmore[] = { (x.*ptmf)(1,2), (y.*ptmf)(1,2) };
}

请注意，我们如何使用指向成员的指针来仅引用类成员，并且我们可以使用它从不同的对象中获取相同的相对类成员

（相比之下，我们还可以形成一个指向实际对象成员的实指针：
int*p=&x.a；
。这是因为成员-
int
实际上是一个整数。但是我们不能对成员函数做任何类似的操作，因为成员函数不是函数（例如，您不能调用它们）。）

确保你理解类和对象之间的区别，这应该变得非常清楚！
哪一个概念？？？请清楚地陈述你的问题，然后你会希望得到合适的答案。这个概念是通过称呼来称呼一个方法。请考虑阅读一些书。我想这个问题会对你有帮助：@ OAOD：指针-成员运算符概念：）