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

最新推荐文章于 2024-07-31 18:19:40 发布
最新推荐文章于 2024-07-31 18:19:40 发布
阅读量418 收藏
点赞数
原文链接：https://blog.csdn.net/alex1997222/article/details/81983073?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522158669926519724811831199%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=158669926519724811831199&biz_id=0&utm_sou
版权

C++扩展了指针在类中的使用,使其可以指向类成员,这种行为是类层面的,而不是对象层面的。

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

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


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     class Student {
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     public:
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	Student(
     
     string n,
     
     int nu):name{n},num{nu}{}
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     void  dis(int idx) {
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     cout << idx << 
     
     " " << name << 
     
     " " << num << 
     
     endl;
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	}
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  9. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     public:
    
    
    
   
   
  10. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     string name;
    
    
    
   
   
  11. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     int num;
    
    
    
   
   
  12. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     };

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

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

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

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

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

对象.*成员对象指针

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

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


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     Student s1("zhangsan", 100);
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     Student* ps1 = &s1;
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     Student s2("zhangsan", 100);
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     Student* ps2 = &s2;
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     string Student::*pstr1 = &Student::name;
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
    
    
    
   
   
  9. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
    
    
    
   
   
  10. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     cout << s1.*pstr1 << 
     
     endl;   
     
     //不同的对象可以调用同一个指针
    
    
    
   
   
  11. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     cout << ps1->*pstr1 << 
     
     endl;
    
    
    
   
   
  12. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     cout << s2.*pstr1 << 
     
     endl;   
    
    
    
   
   
  13. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     cout << ps2->*pstr1 << 
     
     endl;

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

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

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

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


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     (s1.*pdis)(
     
     10);
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     (ps1->*pdis)(
     
     20);

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


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #include <iostream>
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     using 
     
     namespace 
     
     std;
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     struct Point
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     {
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     int add(int x, int y) {
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     return x + y;
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	}
    
    
    
   
   
  9. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  10. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     int minNus(int x, int y) {
    
    
    
   
   
  11. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     return x - y;
    
    
    
   
   
  12. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	}
    
    
    
   
   
  13. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  14. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     int multi(int x, int y) {
    
    
    
   
   
  15. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     return x * y;
    
    
    
   
   
  16. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	}
    
    
    
   
   
  17. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  18. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     int div(int x, int y) {
    
    
    
   
   
  19. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     return x / y;
    
    
    
   
   
  20. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	}
    
    
    
   
   
  21. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }; 
    
    
    
   
   
  22. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  23. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     //提供公共接口
    
    
    
   
   
  24. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     int oper(Point& p, int(Point::*pp)(int, int), int x, int y) {  
     
     //指向函数成员的指针
    
    
    
   
   
  25. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     return (p.*pp)(x, y);
    
    
    
   
   
  26. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }
    
    
    
   
   
  27. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  28. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     typedef int(Point::*PF)(int, int);
    
    
    
   
   
  29. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  30. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     int main() {
    
    
    
   
   
  31. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  32. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	Point p;
    
    
    
   
   
  33. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	PF padd = &Point::add;
    
    
    
   
   
  34. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     cout << oper(p, padd, 
     
     10, 
     
     20) << 
     
     endl;
    
    
    
   
   
  35. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  36. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	padd = &Point::minNus;
    
    
    
   
   
  37. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     cout << oper(p, padd, 
     
     500, 
     
     20) << 
     
     endl;
    
    
    
   
   
  38. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	system(
     
     "PAUSE");
    
    
    
   
   
  39. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }

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


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #include <iostream>
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     using 
     
     namespace 
     
     std;
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     class Game {
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     public:
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	Game() {
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		PSkill[
     
     0] = &Game::SkillOne;
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		PSkill[
     
     1] = &Game::SkillTwo;
    
    
    
   
   
  9. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		PSkill[
     
     2] = &Game::SkillThree;
    
    
    
   
   
  10. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		PSkill[
     
     3] = &Game::SkillFour;
    
    
    
   
   
  11. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	}
    
    
    
   
   
  12. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  13. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     void select(int index) {
    
    
    
   
   
  14. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     if (index >= 
     
     0 && index <= 
     
     3) {
    
    
    
   
   
  15. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     			(
     
     this->*PSkill[index])();
    
    
    
   
   
  16. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		}
    
    
    
   
   
  17. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	}
    
    
    
   
   
  18. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  19. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     private:
    
    
    
   
   
  20. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     void SkillOne() { 
     
     cout << 
     
     "Use skill one.." << 
     
     endl; }
    
    
    
   
   
  21. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     void SkillTwo() { 
     
     cout << 
     
     "Use skill Two.." << 
     
     endl; }
    
    
    
   
   
  22. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     void SkillThree() { 
     
     cout << 
     
     "Use skill Three.." << 
     
     endl; }
    
    
    
   
   
  23. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     void SkillFour() { 
     
     cout << 
     
     "Use skill Four.." << 
     
     endl; }
    
    
    
   
   
  24. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  25. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     enum {
    
    
    
   
   
  26. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		NC = 
     
     4   
     
     //技能数量
    
    
    
   
   
  27. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	};
    
    
    
   
   
  28. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  29. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     void (Game::*PSkill[NC])();
    
    
    
   
   
  30. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     };
    
    
    
   
   
  31. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  32. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     int main() {
    
    
    
   
   
  33. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  34. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  35. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	Game newOne;
    
    
    
   
   
  36. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	newOne.select(
     
     2);
    
    
    
   
   
  37. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	newOne.select(
     
     0);
    
    
    
   
   
  38. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	newOne.select(
     
     3);
    
    
    
   
   
  39. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  40. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	system(
     
     "PAUSE");
    
    
    
   
   
  41. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     }

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

  •                     <li class="tool-item tool-active is-like "><a href="javascript:;"><svg class="icon" aria-hidden="true">
                        <use xlink:href="#csdnc-thumbsup"></use>
                    </svg><span class="name">点赞</span>
                    <span class="count">2</span>
                    </a></li>
                    <li class="tool-item tool-active is-collection "><a href="javascript:;" data-report-click="{&quot;mod&quot;:&quot;popu_824&quot;}"><svg class="icon" aria-hidden="true">
                        <use xlink:href="#icon-csdnc-Collection-G"></use>
                    </svg><span class="name">收藏</span></a></li>
                    <li class="tool-item tool-active is-share"><a href="javascript:;" data-report-click="{&quot;mod&quot;:&quot;1582594662_002&quot;}"><svg class="icon" aria-hidden="true">
                        <use xlink:href="#icon-csdnc-fenxiang"></use>
                    </svg>分享</a></li>
                    <!--打赏开始-->
                                            <!--打赏结束-->
                                            <li class="tool-item tool-more">
                        <a>
                        <svg t="1575545411852" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="5717" xmlns:xlink="http://www.w3.org/1999/xlink" width="200" height="200"><defs><style type="text/css"></style></defs><path d="M179.176 499.222m-113.245 0a113.245 113.245 0 1 0 226.49 0 113.245 113.245 0 1 0-226.49 0Z" p-id="5718"></path><path d="M509.684 499.222m-113.245 0a113.245 113.245 0 1 0 226.49 0 113.245 113.245 0 1 0-226.49 0Z" p-id="5719"></path><path d="M846.175 499.222m-113.245 0a113.245 113.245 0 1 0 226.49 0 113.245 113.245 0 1 0-226.49 0Z" p-id="5720"></path></svg>
                        </a>
                        <ul class="more-box">
                            <li class="item"><a class="article-report">文章举报</a></li>
                        </ul>
                    </li>
                                        </ul>
            </div>
                        </div>
        <div class="person-messagebox">
            <div class="left-message"><a href="https://blog.csdn.net/alex1997222">
                <img src="https://profile.csdnimg.cn/6/5/0/3_alex1997222" class="avatar_pic" username="alex1997222">
                                        <img src="https://g.csdnimg.cn/static/user-reg-year/2x/4.png" class="user-years">
                                </a></div>
            <div class="middle-message">
                                    <div class="title"><span class="tit"><a href="https://blog.csdn.net/alex1997222" data-report-click="{&quot;mod&quot;:&quot;popu_379&quot;}" target="_blank">alex1997222</a></span>
                                        </div>
                <div class="text"><span>发布了317 篇原创文章</span> · <span>获赞 71</span> · <span>访问量 19万+</span></div>
            </div>
                            <div class="right-message">
                                        <a href="https://bbs.csdn.net/topics/395528712" target="_blank" class="btn btn-sm btn-red-hollow bt-button personal-messageboard">他的留言板
                    </a>
                                                        <a class="btn btn-sm  bt-button personal-watch" data-report-click="{&quot;mod&quot;:&quot;popu_379&quot;}">关注</a>
                                </div>
                        </div>
                </div>
Junoxiang
关注
c++之指向类成员的指针
qq_36822217的博客
03-30 286
1. 指向成员变量的指针 - 定义格式 § 数据类型 类名::*指针名 § 例如 int A::*pParam; - 赋值/初始化 § 数据类型 类名::*指针名 = &类名::非静态数据成员 § int A::*pParam = &A::param - 解引用 § <类对象名>.*<非静态数据成员指针> § <类对象指...
C++指向类成员函数的指针
热门推荐
Charon
01-14 1万+
     最近在开发中用到了函数指针，于是想整理了一下有关函数指针的概念。O(∩_∩)O~     首先 函数指针是指向一组同类型的函数的指针；而类成员函数我们也可以相似的认为，它是指向同类中同一组类型的成员函数的指针，当然这里的成员函数更准确的讲应该是指非静态的成员函数。前者是直接指向函数地址的，而后者我们从字面上也可以知道 它肯定是跟类和对象有着关系的。     函数指针实例：ty
C++ 指向类成员的指针
最新发布
gopher9511的博客
07-31 403
C++扩展了指针在类中的使用，使其可以指向类成员(数据成员和函数成员)，这种行为是类层面的，而不是对象层面的。指向非静态数据成员的指针在定义时必须和类相关联，在使用时必须和具体的对象关联。由于类不是运行时存在的对象。因此，在使用这类指针时，需要首先指定类的一个对象，然后，通过对象来引用指针所指向的成员。指向类成员的指针，具有指针的形而不具体指针的实，或者，确切意义上说，不指是指针。指向类成员的指针，本质存放的不是地址，存放的偏移量。
C++指向类成员(数据、函数)的指针
漫步云端
08-20 4163
指向【类】的成员的指针包含两种： ★指向【类】的数据成员的指针 ★指向【类】的成员函数的指针 注意：指向的是【类的成员】，和类发生关系 ★★★指向非静态公有数据成员的指针，在定义时必须和类相关联，在使用时必须和对象相关联 1、指向类的数据成员的指针1.1 定义+初始化的格式： 数据类型 类型:: *指针名 = &类型:: 非静态公有数据
指向类成员的指针
weixin_34395205的博客
04-04 105
13.1.9  指向类成员的指针 在C++语言中，可以定义一个指针，使其指向类成员或成员函数，然后通过指针来访问类的成员。这包括指向属性成员的指针和指向成员函数的指针。 1．指向数据成员的指针 在C++语言中，可以定义一个指针，使其指向类成员。当属性成员为静态和非静态时，指针的使用也有不同。其中，指向非静态数据成员的指针定义格式如下： 1. &lt;数据类型&gt;&lt;类名&gt;...
C++指向类成员的函数指针
weixin_43488671的博客
06-17 3483
定义：类成员函数指针（member function pointer），是 C++ 语言的一类指针数据类型，用于存储一个指定类具有给定的形参列表与返回值类型的成员函数的访问信息。基本上要注意的有两点：1、函数指针赋值要使用 & 2、使用 .* (实例对象)或者 ->*（实例对象指针）调用类成员函数指针所指向的函数 下面看两个例子：对于 nonstatic member function （非静态成员函数）取地址，获得该函数在内存中的实际地址对于 virtual function（虚函数）, 其地址在编译时期
C++获取类的成员函数的函数指针详解及实例代码
08-31
在C++编程语言中，获取类的成员函数的函数指针是一项重要的技术，它允许我们动态地调用对象的成员函数。下面将详细介绍这一概念，并通过实例代码进行解析。 首先，我们需要理解成员函数指针的概念。成员函数是类的...
C++指向类成员函数的指针详细解析
09-05
这种指针与普通函数指针的主要区别在于，它需要一个对象实例来调用成员函数，因为成员函数是绑定到特定类的对象上的。下面将详细解释这个概念，并给出一些示例。 首先，我们来看一个简单的函数指针的例子。函数指针...
指向类成员函数的指针其实并非指针
09-05
在C++中，指向类成员的指针是一个特殊的数据类型，它并不像常规的指针那样直接指向内存中的一个具体位置。尤其对于指向非静态成员的指针，它实际上是一个抽象的概念，它标识了类中特定成员的位置，而非某个特定对象...
C++中指向类成员指针的用法
网络资源是无限的
04-05 3013
C++中，指向类的成员指针包含两种： (1).指向类的成员函数的指针： 类型 (类名::* 函数成员指针名)(参数表); 函数成员指针名 = &类名::函数成员名; 也可将以上两条语句调整为一条语句： 类型 (类名::* 函数成员指针名)(参数表) = &类名::函数成员名; 类成员函数指针，是C++语言的一类指针数据类型，用于存储一个指定类具有给定的形参列表与返回值类型的成员函数的访问信息。 使用::*声明一个成员指针类型，或者定义一个成员指针变量。使...
C++指向成员函数的指针
weixin_30709061的博客
11-15 185
C++指向函数的指针定义方式为： 返回类型 （*指针名）（函数参数列表），例如 void （*p）（int）是指向一个返回值为void 参数为int类型的函数。 而若想定义一个指向类成员函数的函数指针该怎么定义呢？对成员函数指针的使用。 （1）非静态成员函数 定义方式：返回类型 （类名::*指针名）（函数参数列表）例如void （A::*p）（int）是一个指向A类中成员函数的函数指针。 ...
Item 15.指向类数据成员的指针
力为的博客
04-13 1086
Item 15. Pointers to Class Members Are Not PointersPointers to Class Members：指向类成员的指针注：本条中只涉及到非静态的数据成员--------------------------------------------------------1、类成员的指针之声明：　class C {  public:    //...  
C++ 指向类成员函数的指针
xhchen的博客
04-17 175
在 C++ 中，指向类成员函数的指针是指向类或结构体成员函数的指针。它可以用于在该类或结构体的对象上调用成员函数。指向成员函数的指针使用作用域解析运算符（::）和取地址运算符（&）声明
C++ | 指向类成员的指针
ThinPikachu的博客
09-22 328
#include<iostream> using namespace std; class Test { public: void func() { cout << "call Test::func" << endl; } static void static_func() { cout << "call Test::static_func" << endl; } int ma; static int mb; };...
C++指向类成员的指针
chenchen_fcj程序猿的博客
07-18 764
指向类成员 以前C定义指针 int a; int *p=&amp;a; void func(); void (*pf)()  = &amp;func; 而在这里本质也是相同（去掉类名 :: 就是上面的形式）， 定义如下： 成员类型   类名 :: * 指针名 =  &amp;类名 :: 成员名； 函数返回类型 （类名 :: *函数指针名）(参数列表)  = &amp; 类名 ::...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值