在C++中，数据成员指针是指向类或结构体成员变量的指针。通过使用数据成员指针，可以访问类的私有或保护成员变量。

下面是一个示例代码，演示如何定义和使用数据成员指针：

#include <iostream>  
  
class MyClass {  
public:  
    int public_data;  
  
private:  
    int private_data;  
  
public:  
    MyClass(int a, int b) : public_data(a), private_data(b) {}  
  
    void print_data() {  
        std::cout << "Public data: " << public_data << std::endl;  
        std::cout << "Private data: " << private_data << std::endl;  
    }  
};  
  
int main() {  
    MyClass obj(10, 20);  
    std::cout << "Before modification:" << std::endl;  
    obj.print_data();  
  
    // Modify private data using data member pointer  
    int MyClass::*ptr = &MyClass::private_data;  
    obj.*ptr = 30;  
  
    std::cout << "After modification:" << std::endl;  
    obj.print_data();  
  
    return 0;  
}

在上面的代码中，定义了一个名为MyClass的类，其中包含一个公共成员变量public_data和一个私有成员变量private_data。还定义了一个构造函数和一个print_data函数来输出成员变量的值。在main函数中，创建了一个MyClass对象obj，并使用数据成员指针修改私有成员变量private_data的值。最后，再次调用print_data函数来输出修改后的成员变量的值。

在C++中，成员函数指针是指向类的成员函数的指针。它允许通过指针来调用类的成员函数。

下面是一个示例代码，演示如何定义和使用成员函数指针：

#include <iostream>  
  
class MyClass {  
public:  
    void (MyClass::*func_ptr)() {  
        std::cout << "This is a member function pointer." << std::endl;  
    } = nullptr; // 定义一个空的成员函数指针  
  
    void myFunction() { // 一个普通的成员函数  
        std::cout << "This is myFunction." << std::endl;  
    }  
  
    void setFuncPtr(void (MyClass::*fptr)()) { // 设置成员函数指针  
        func_ptr = fptr;  
    }  
  
    void callFuncPtr() { // 调用通过指针调用的成员函数  
        (this->*func_ptr)();  
    }  
};  
  
int main() {  
    MyClass obj;  
    obj.setFuncPtr(&MyClass::myFunction); // 设置成员函数指针指向myFunction  
    obj.callFuncPtr(); // 调用通过指针调用的成员函数，输出"This is myFunction."  
    return 0;  
}

在上面的代码中，定义了一个名为MyClass的类。该类包含一个空的成员函数指针func_ptr，一个普通的成员函数myFunction，一个设置成员函数指针的函数setFuncPtr和一个调用通过指针调用的成员函数的函数callFuncPtr。在main函数中，创建了一个MyClass对象obj，并使用setFuncPtr函数将func_ptr指向myFunction。然后，使用callFuncPtr函数通过指针调用成员函数，输出"This is myFunction."。

在C++中，可以将成员函数作为可调用对象（callable object）使用。这可以通过使用函数指针或std::function对象来实现。

以下是一个使用函数指针的示例：

#include <iostream>  
  
class MyClass {  
public:  
    void myFunction(int x) {  
        std::cout << "The value of x is: " << x << std::endl;  
    }  
};  
  
int main() {  
    MyClass obj;  
    void (MyClass::*func_ptr)(int) = &MyClass::myFunction; // 定义成员函数指针  
    (obj.*func_ptr)(5); // 调用成员函数  
    return 0;  
}

在上面的示例中，定义了一个名为MyClass的类，其中包含一个名为myFunction的成员函数。还定义了一个名为func_ptr的成员函数指针，该指针指向MyClass类的myFunction成员函数。在main函数中，创建了一个MyClass对象obj，并使用成员函数指针来调用myFunction成员函数，传递参数5。输出将是"The value of x is: 5"。

下面是一个使用std::function的示例：

#include <iostream>  
#include <functional>  
  
class MyClass {  
public:  
    void myFunction(int x) {  
        std::cout << "The value of x is: " << x << std::endl;  
    }  
};  
  
int main() {  
    MyClass obj;  
    std::function<void(MyClass*, int)> func = &MyClass::myFunction; // 定义可调用对象  
    func(&obj, 5); // 调用成员函数  
    return 0;  
}

在上面的示例中，定义了一个名为MyClass的类，其中包含一个名为myFunction的成员函数。还定义了一个名为func的可调用对象，该对象可以接受一个MyClass对象的指针和一个整数参数。在main函数中，创建了一个MyClass对象obj，并将可调用对象func设置为指向MyClass类的myFunction成员函数。然后，使用可调用对象来调用myFunction成员函数，传递参数5。输出将是"The value of x is: 5"。