C++指向类成员/函数的指针

指向类成员/函数的指针的本质并不是取地址.而是利用了对象地址的偏移量

我们创建了一个类,假设我们要使用指针指向类中的成员

 
 

   
   

    
    

   
   
   
   

    
    

     
     class Student {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     public:
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	Student(
     
     string n,
     
     int nu):name{n},num{nu}{}
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     void  dis(int idx) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
		
     
     cout << idx << 
     
     " " << name << 
     
     " " << num << 
     
     endl;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     public:
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     string name;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int num;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     };
    
    
   
   
 
 

我们可以这么做:string * ss1 = &s1.name;但是这样做是没有意义的,这样会破坏类的封装,这样这个类就没有存在意义了

C++提供了指向类成员的指针: 变量类型 类名::*pointer = &类名::变量名;

在这个类中,我们可以这么使用

string Student::*pstr1 = &Student::name;
 
 

想要具体使用指针,我们还是要使用类的对象去调用,这是一种新的运算符,叫做指向类的指针

对象.*成员对象指针

指向对象指针->*成员对象指针

在本案例中可以这么使用:

 
 

   
   

    
    

   
   
   
   

    
    

     
     Student s1("zhangsan", 100);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     Student* ps1 = &s1;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     Student s2("zhangsan", 100);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     Student* ps2 = &s2;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     string Student::*pstr1 = &Student::name;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     cout << s1.*pstr1 << 
     
     endl;   
     
     //不同的对象可以调用同一个指针
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     cout << ps1->*pstr1 << 
     
     endl;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     cout << s2.*pstr1 << 
     
     endl;   
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     cout << ps2->*pstr1 << 
     
     endl;
    
    
   
   
 
 

指向类成员的指针用的不多,一般用的较多的是指向类成员函数的指针

返回值类型 (类名::*ptr)(函数参数) = &类名:: 成员函数

void (Student::*pdis)(int) = &Student::dis;
 
 

调用方法与成员对象指针类似: 因为优先级问题要加上括号

 
 

   
   

    
    

   
   
   
   

    
    

     
     (s1.*pdis)(
     
     10);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     (ps1->*pdis)(
     
     20);
    
    
   
   
 
 

以下提供两个成员函数指针的案例

 
 

   
   

    
    

   
   
   
   

    
    

     
     #include <iostream>
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     using 
     
     namespace 
     
     std;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     struct Point
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int add(int x, int y) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
		
     
     return x + y;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int minNus(int x, int y) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
		
     
     return x - y;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int multi(int x, int y) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
		
     
     return x * y;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     int div(int x, int y) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
		
     
     return x / y;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }; 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     //提供公共接口
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     int oper(Point& p, int(Point::*pp)(int, int), int x, int y) {  
     
     //指向函数成员的指针
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     return (p.*pp)(x, y);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     typedef int(Point::*PF)(int, int);
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     int main() {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	Point p;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	PF padd = &Point::add;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     cout << oper(p, padd, 
     
     10, 
     
     20) << 
     
     endl;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	padd = &Point::minNus;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     cout << oper(p, padd, 
     
     500, 
     
     20) << 
     
     endl;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	system(
     
     "PAUSE");
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   
 
 

在这个案例中,我们使用成员函数指针实现了一个公共接口

 
 

   
   

    
    

   
   
   
   

    
    

     
     #include <iostream>
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     using 
     
     namespace 
     
     std;
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     class Game {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     public:
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	Game() {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     		PSkill[
     
     0] = &Game::SkillOne;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     		PSkill[
     
     1] = &Game::SkillTwo;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     		PSkill[
     
     2] = &Game::SkillThree;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     		PSkill[
     
     3] = &Game::SkillFour;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     void select(int index) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
		
     
     if (index >= 
     
     0 && index <= 
     
     3) {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     			(
     
     this->*PSkill[index])();
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     		}
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	}
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     private:
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     void SkillOne() { 
     
     cout << 
     
     "Use skill one.." << 
     
     endl; }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     void SkillTwo() { 
     
     cout << 
     
     "Use skill Two.." << 
     
     endl; }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     void SkillThree() { 
     
     cout << 
     
     "Use skill Three.." << 
     
     endl; }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     void SkillFour() { 
     
     cout << 
     
     "Use skill Four.." << 
     
     endl; }
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     enum {
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     		NC = 
     
     4   
     
     //技能数量
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	};
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
	
     
     void (Game::*PSkill[NC])();
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     };
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     int main() {
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	Game newOne;
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	newOne.select(
     
     2);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	newOne.select(
     
     0);
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	newOne.select(
     
     3);
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     	system(
     
     "PAUSE");
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     }
    
    
   
   
 
 

这个案例中,假设我们不想让外界知道类内部的函数名,我们可以是用指向成员函数的指针数组将它们封装起来,加强了隐蔽性

最后

以上就是柔弱故事为你收集整理的C++指向类成员/函数的指针的全部内容，希望文章能够帮你解决C++指向类成员/函数的指针所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。