您现在的位置: 365建站网 > 365学习 > C++类成员函数指针的作用和调用

C++类成员函数指针的作用和调用

文章来源:365jz.com     点击数:253    更新时间:2018-10-26 08:44   参与评论

一.什么是函数指针?

函数指针,顾名思义即指向函数的指针。

  void print()
  {
  }
  void (*pfun)(); //声明一个指向函数的指针,函数的参数是 void,函数的返回值是 void
  pfun = print;   //赋值一个指向函数的指针
  (*pfun)();    //使用一个指向函数的指针

比较简单,不是吗?为什么*pfun需要用()扩起来呢?

因为*的运算符优先级比()低,如果不用()就成了*(pfun()).

指向类的成员函数的指针不过多了一个类的限定而已!

  class A
  {
  void speak(char *, const char *); 
  };
  
  void main()
  {
  A a;
  void (A::*pmf)(char *, const char *);//指针的声明
  pmf = &A::speak; //指针的赋值
  }

一个指向类A 成员函数的指针声明为:


void (A::*pmf)(char *, const char *);


声明的解释是:pmf是一个指向A成员函数的指针,返回无类型值,函数带有二个参数,参数的类型分别是char *和const char *。除了在星号前增加A::,与声明外部函数指针的方法一样。一种更加高明的方法是使用类型定义:例如,下面的语句定义了PMA是一个指向类A成成员函数的指针,函数返回无类型值,函数参数类型为char *和const char *:


typedef void(A::*PMA)(char *,const char *);


PMA pmf= &A::strcat;//pmf是 PMF类型(类A成员指针)的变量


如果要问,为什么能用一个指针指向一个函数呢?我觉得要理解这个问题,以及要理解后面的函数指针和类成员函数指针,没有什么比从计算机原理的角度来理解更容易了。这里就简要回顾一下相关知识。


众所周知,计算机(图灵机)执行程序的基本流程就是:取指令->执行指令->取下一条指令->……。取指令的位置由一个寄存器PC决定。开机时,PC通常指向0(这条指令常常是一条跳转指令。在ARM架构中,一般位置0是复位中断向量。总之都是要实现一个跳转),随后,如果没有碰到跳转指令,则PC自加一个字长执行下一条指令,否则根据跳转指令(JB,JMP,CALL等)跳转到给定位置(即改写PC)执行。


常见的C语言程序中,if、while、for等带判断条件的指令是由条件跳转语句完成(ARM架构下指令为B,原理都是一样的)。以一个简单的条件跳转指令举例:



if ( a == 0 )

00CD52D5  cmp        dword ptr [a],0  ;比较

00CD52D9  jne        main+34h (0CD52E4h)  ;根据结果跳转到0CD52E4h(if语句块后)

goto、break、while语句则一般是jmp无条件跳转指令实现的。如以下程序:

while ( a!=0 )

008E52DF  cmp        dword ptr [a],0 

008E52E3  je         main+40h (08E52F0h) 

{

}

008E52E5  jmp        main+2Fh (08E52DFh) 

可以看出来,跳转指令,无论是有无条件,无论寻址方式如何,其实都只是做了一件事——改变PC的值,跳转到指定位置。这个位置是由编译器给定的值,在此过程中,不会做除了改变PC以外的任何事情。


CALL指令相对于跳转指令则不同。从设计目的的角度来说,CALL是为了实现函数调用。函数调用与一般的跳转相比,除了改变PC还需要考虑调用结束后恢复PC值返回原位置。高级语言中,都是使用堆栈来处理这问题:调用函数时,将返回的位置和传递参数压栈后跳转;调用结束时,弹出参数和返回位置随后跳回。现代处理器中,CALL指令除了跳转,还负责将返回位置压栈,相应的RET语句则集成了弹出返回位置和跳转。


CALL指令的寻址方式也有多种(跳转语句同理)。概括性地说,有三种方式:相对转移(给PC加减一定值)、绝对转移(直接给PC赋值)、间接转移(将寄存器中的地址赋值给PC)。顺便一说,在RISC处理器中,往往只有最后一种。


相对转移、绝对转移的目标地址,都是很简单地直接在指令当中给出。换句话说,跳转地址是在编译阶段就由编译器给定了。


但是,有的时候我们需要在运行时动态地改变跳转地址。而相对转移、绝对转移是无法改变跳转地址的。所以,为了达到这一目的,一般来说,是先将跳转地址addr存入一个寄存器(或内存中一个位置),而后CPU从这个寄存器中取出地址addr进行跳转。这个地址,也就是我们所说的函数指针。


我们进行的各种函数调用,本质上都是操作这一个地址,无论它是固化在指令中还是存储在寄存器中。而每一个函数名,就如同数组名一样,实际上都是一个地址。所以,理所当然地如同一般的指针变量一样,我们也可以有一个函数指针变量。


二.函数指针的使用

1.一般函数函数指针

一般的函数指针形如:


int( *pf )( char, int, float );


这是一个有三个分别为char,int,float输入参数,返回值为int的函数指针变量pf。为什么*pf需要用()呢?因为*的运算符优先级比()低,如果不用()就成了*(pf())了。


先举一个最简单的例子:


voidNormalFunc()

{

cout << "Normal Func"<< endl;

}

void( *pfunc )();

pfunc =NormalFunc;

pfunc();//输出”Normal Func”


稍复杂的如下


int NormalFunc(char c, int i, float f )

{

cout << "Normal Func"<< c << i << f << endl;

return 0;

}

int( *pfunc)(char,int ,float );

pfunc =NormalFunc;

pfunc(1,2,3);


如果觉得这样定义太麻烦,可以用typedef做一个重命名。如:


typedef int(*I_PFUNC_C_I_F )( char, int, float );//随手命名,一般情况下别这样

I_PFUNC_C_I_Fpfunc;

pfunc =NormalFunc;


总之,函数指针和函数必须有着完全相同的类型(包括参数、返回值、调用约定_stdcall和_cdecl)。


这样有什么好处呢?


【动态调用、函数查找表】


二.类成员函数函数指针

对于类的成员函数,其指针与一般函数指针有着很大的区别。主要原因是类成员函数都隐含了一个this指针,调用时,编译器对其处理方式与一般函数不同,实际的汇编代码也不一样。因此,为了避免错误,编译器是不允许将类成员函数赋值给一般函数指针的。


实际的汇编代码分析见第四节,这里我就只从使用的角度来解析:如何使用类成员函数指针?


1.  常规操作方法(推荐)

简单来说,就是在指针前加入一个域限定符,并指定成员函数对应的类实例。


class mc:public empty

{

public:

       mc()

       {

        //构造函数中数组初始化,必须指定域

              maps[0]= &mc::On_WM_PAINT;

              maps[1]= &mc::On_WM_DESTORY;

       }

       typedefLRESULT (_stdcall mc:: *PCFUNC)( HWND, UINT, WPARAM, LPARAM );//类成员函数指针,必须指定域

       LRESULT_stdcall On_WM_PAINT(HWND, UINT, WPARAM, LPARAM)

       {

              cout<< "ON_WM_PAINT" << endl;

              return0;

       }

       LRESULT_stdcall On_WM_DESTORY( HWND, UINT, WPARAM, LPARAM )

       {

              cout<< "ON_WM_DESTORY" << endl;

              return0;

       }

       PCFUNCmaps[2];//类成员函数指针数组

       voidtest()

       {

              (this->*maps[1])(NULL, NULL, NULL, NULL );//类内部调用

       }

};


使用时,在类内部需要加入this指针,在类外部则一定要指定对应的类实例:


 


      mcmyclass;//声明类实例

       mc::PCFUNCpcfunc = myclass.maps[0];//声明一个类成员函数指针变量

       (myclass.*pcfunc )( NULL, NULL, NULL, NULL );//调用第0个函数输出“ON_PAINT”

       myclass.test();//内部调用,输出“ON_DESTORY”


     

2.  静态函数(不推荐)

以上都是对非静态函数的使用方法。对于静态函数,则要容易得多。因为静态函数实际上就是一个作用域在类内部的普通函数,没有隐含的this指针。但是相应的,静态函数只能使用内部的静态变量。因此并不推荐。


示例如下:


class mc

{

public:

       mc()

       {

              maps[0]= &mc::On_WM_PAINT;//不需要指定域

              maps[1]= &mc::On_WM_DESTORY;

       }

       typedefLRESULT (_stdcall *PCFUNC)( HWND, UINT, WPARAM, LPARAM );//可见这里不需要指定域

       staticint i; 

       static LRESULT _stdcallOn_WM_PAINT(HWND, UINT, WPARAM, LPARAM)//需要static标识符

       {

              cout<< "ON_WM_PAINT" << endl;

              returni; //static函数只能使用static变量

       }

       staticLRESULT _stdcall On_WM_DESTORY( HWND, UINT, WPARAM, LPARAM )

       {

              cout<< "ON_WM_DESTORY" << endl;

              return0;

       }

       PCFUNCmaps[4];

       voidtest()

       {

              maps[1](NULL, NULL, NULL, NULL );//不需要指定域

       }      

};


使用时也不需要指定域:


mc::PCFUNCpcfunc = myclass.maps[0];

       myclass.test();

       pcfunc(NULL, NULL, NULL, NULL );


3.  友元函数(较为推荐)

可见,静态成员函数的最大限制在于其只能使用static成员变量,这使得其极其难以使用。一个好的折衷办法是使用友元函数。相应的,友元函数能够操作类中的所有成员,不过不一样的是必须显式指定类实例指针。



class mc

{

public:

       mc()

       {

              maps[0]= On_WM_PAINT;//同样不需要指定域

              maps[1]= On_WM_DESTORY;

       }

       typedefLRESULT( _stdcall *PCFUNC )(mc&,HWND, UINT, WPARAM, LPARAM );//为了能够操作成员变量,必须传递类的引用或者指针

       staticint i;

       friendLRESULT _stdcall On_WM_PAINT(mc&src,HWND, UINT, WPARAM, LPARAM )

       {

              cout<< "ON_WM_PAINT" << endl;

              returnsrc.a;//这样就能通过类的引用操作成员变量,private限定的也可以

       }

       friendLRESULT _stdcall On_WM_DESTORY(mc&src, HWND, UINT, WPARAM, LPARAM )

       {

              cout<< "ON_WM_DESTORY" << endl;

              returnsrc.a;

       }

       PCFUNCmaps[4];

       voidtest()

       {

              maps[1](*this,NULL, NULL, NULL, NULL );//内部调用需要使用this指针

       }

private:

       int a;

};


在其它地方使用时,也不需要指定域。


       mcmyclass;

       mc::PCFUNCpcfunc = myclass.maps[0];

       myclass.test();

       pcfunc(myclass, NULL, NULL, NULL, NULL );

       On_WM_PAINT(myclass, NULL, NULL, NULL, NULL );//是的,即使是不用函数指针,也不需要.或者->,其实友元函数就是一个普通函数而已。


如果不想在参数里面加一个引用,那么可以将这个类的指针放进一个全局变量里。如:


mc*mc_handle=nullptr;//全局变量

友元函数中:

friend LRESULT _stdcall On_WM_PAINT(mc&src, HWND, UINT, WPARAM, LPARAM )

{

       cout<< "ON_WM_PAINT" << endl;

       returnmc_handle->a;//通过全局变量操作

}


主函数中:



mc myclass;

mc_handle=&myclass;//如果不初始化的话,哼哼……

On_WM_PAINT( myclass, NULL, NULL, NULL,NULL );


【如果这个类只会有一个实例,可以使用“单件”设计模式】


【如果觉得用起来比较麻烦,还可以声明友元类而不是友元函数】


4.  C++11特性:std::function和std::bind(这么高端的操作为什么你不来试试?)

C++在<functional>中引入了function和bind,使得能够更加容易地进行动态绑定。


简单的实现如下:



class mc

{

public:

       mc()

       {

              fr[0] = bind( &mc::On_WM_PAINT,this,

                     placeholders::_1,placeholders::_2, placeholders::_3, placeholders::_4 );//绑定方式

       }

       LRESULT_stdcall On_WM_PAINT(  HWND, UINT,WPARAM, LPARAM )

       {

              cout<< "ON_WM_PAINT" << endl;

              returna;

       }

       LRESULT_stdcall On_WM_DESTORY( HWND, UINT, WPARAM, LPARAM )

       {

              cout<< "ON_WM_DESTORY" << endl;

              returna;

       }

function<LRESULT _stdcall( HWND, UINT, WPARAM,LPARAM )>fr[4];//定义方式

};


这样,调用时只需要:


mc myclass;

       myclass.fr[0]( NULL, NULL, NULL, NULL );//调用就是这么简单


5.用宏定义来解放我们(让读代码的人蛋疼去吧)

如果嫌弃上面的这么一大堆东西写起来太费劲,不妨使用下面这种宏定义:



#define ON_WMESSAGE(msgname)  LRESULT _stdcall On_##msgname( HWND hwnd,UINTuMsgID,WPARAM wParam,LPARAM lParam )//宏定义

#define MAP_ON_WMESSAGE(msgname)       {msgname,On_##msgname}

ON_WMESSAGE( WM_PAINT );

ON_WMESSAGE( WM_DESTROY );

ON_WMESSAGE( WM_LBUTTONDBLCLK );

ON_WMESSAGE( WM_COMMAND );

 

struct sWM_CB

{

       UINTuMsgID;

       LRESULT(_stdcall*WndProc )( HWND , UINT , WPARAM , LPARAM );

};

struct sWM_CB WM_CB_Maps[] = { 

       MAP_ON_WMESSAGE(WM_PAINT ),

       MAP_ON_WMESSAGE(WM_DESTROY ),

       MAP_ON_WMESSAGE(WM_LBUTTONDBLCLK ),

       MAP_ON_WMESSAGE(WM_COMMAND ), };


以上宏定义中的##实际上是就是将宏定义参数中的字符直接连接的意思。所以,在这里,ON_WMESSAGE( WM_PAINT )等效语句实际上是:


LRESULT_stdcall On_WM_PAINT( HWND hwnd,UINT uMsgID,WPARAM wParam,LPARAM lParam )


MAP_ON_WMESSAGE( WM_PAINT )实际上是:


{ WM_PAINT, On_WM_PAINT }


结合上以上的function,bind等,实际上构成了C++除了面向对象、面向过程、泛型模板之外的第四种编程——lamada元编程。如果去仔细探究windows.h源码,会发现这种编程方式到处都是。


#include <iostream>
using namespace std;
 
class Person
{
public:
/*这里稍稍注意一下,我将speak()函数设置为普通的成员函数,而hello()函数设置为虚函数*/
int value;
void speak()
{
cout << "I am a person!" << endl;
printf ("%d\n", &Person::speak); /*在这里验证一下,输出一下地址就知道了!*/
}
virtual void hello()
{
cout << "Person say \"Hello\"" << endl;
}
Person()
{
value = 1;
}
 
};
 
 
 
class Baizhantang: public Person
{
public:
void speak()
{
cout << "I am 白展堂!" << endl;
}
virtual void hello()
{
cout << "白展堂 say \"hello!\"" << endl;
}
Baizhantang()
{
value = 2;
}
};
 
typedef void (Person::*p)();//定义指向Person类无参数无返回值的成员函数的指针
typedef void (Baizhantang::*q)();//定义指向Baizhantang类的无参数无返回值的指针
 
int main()
{
Person pe;
int i = 1;
p ip;
ip = &Person::speak;//ip指向Person类speak函数
(pe.*ip)();//这个是正确的写法!
 
//--------------------------------------------
//result : I am a Person! 
// XXXXXXXXXX(表示一段地址)
//--------------------------------------------
 
/*
*下面是几种错误的写法,要注意!
*pe.*ip();
* pe.(*ip)();
*(pe.(*ip))();
*/
 
Baizhantang bzt;
q iq = (void (Baizhantang::*)())ip;//强制转换
(bzt.*iq)();
 
//--------------------------------------------
//result : I am a Person!
// XXXXXXXXXX(表示一段地址)
//--------------------------------------------
 
/*有人可能会问了:ip明明被强制转换成了Baizhantang类的成员函数的指针,为什么输出结果还是:
* I am a Person!在C++里面,类的非虚函数都是采用静态绑定,也就是说类的非虚函数在编译前就已经
*确定了函数地址!ip之前就是指向Person::speak函数的地址,强制转换之后,只是指针类型变了,里面
*的值并没有改变,所以调用的还是Person.speak函数,细心的家伙会发现,输出的地址都是一致的.
*这里要强调一下:对于类的非静态成员函数,c++编译器会给每个函数的参数添加上一个该类的指针this,这也
*就是为什么我们在非静态类成员函数里面可以使用this指针的原因,当然,这个过程你看不见!而对于静态成员
*函数,编译器不会添加这样一个this。
*/
iq = &Baizhantang::speak;/*iq指向了Baizhantang类的speak函数*/
ip = (void (Person::*)())iq;/*ip接收强制转换之后的iq指针*/
(bzt.*ip)();
 
//--------------------------------------------
//result : I am 白展堂!
//--------------------------------------------
 
(bzt.*iq)();//这里我强调一下,使用了动态联编,也就是说函数在运行是才确定函数地址!
 
//--------------------------------------------
//result : I am 白展堂!
//--------------------------------------------
 
/*这一部分就没有什么好讲的了,很明白了!由于speak函数是普通的成员函数,在编译时就知道
*到了Baizhantang::speak的地址,因此(bzt.*ip)()会输出“I am 白展堂!”,即使iq被强制转换
*成(void (Person::*)())类型的ip,但是其值亦未改变,(bzt.*iq)()依然调用iq指向处的函数
*即Baizhantang::speak.
*/
 
 
/*好了,上面讲完了普通成员函数,我们现在来玩一点好玩的,现在来聊虚函数*/
ip = &Person::hello;/*让ip指向Person::hello函数*/
(pe.*ip)();
 
//--------------------------------------------
//result : Person say "Hello"
//--------------------------------------------
 
(bzt.*ip)();
 
//--------------------------------------------
//result : 白展堂 say "Hello"
//--------------------------------------------
 
/*咦,这就奇怪了,为何与上面的调用结果不类似?为什么两个调用结果不一致?伙伴们注意了:
*speak函数是一个虚函数,前面说过虚函数并不是采用静态绑定的,而是采用动态绑定,所谓动态
*绑定,就是函数地址得等到运行的时候才确定,对于有虚函数的类,编译器会给我们添加一个指针
*vptr,指向一个虚函数表vptl,vptl里面存放着虚函数的地址,子类继承父类的时候,也会继承这样
*一个指针,如果子类复写了虚函数,那么该表中该虚函数地址将会由父类的虚函数地址替换成子类虚
*函数地址,编译器会把(pe.*ip)()转化成为(pe.vptr[1])(pe),加上动态绑定,结果会输出:
*       Person say "Hello"   
*(bzt.*ip)()会被转换成(bzt.vptr[1])(pe),自然会输出:
*白展堂 say "Hello"
*ps:这里我没法讲得更详细,因为解释起来肯定是很长很长的,感兴趣的话,我推荐两本书你去看一看:
*第一本是侯捷老师的<深入浅出MFC>,里面关于c++的虚函数特性讲的比较清楚;
*第二本是侯捷老师翻译的<深度探索C++对象模型>,一听名字就知道,讲这个就更详细了;
*当然,不感兴趣的同学这段解释可以省略,对与使用没有影响!
*/
 
iq = (void (Baizhantang::*)())ip;
(bzt.*iq)();
 
//--------------------------------------------
//result : 白展堂 say "Hello"
//--------------------------------------------
system("pause");
return 0;
}

三.还有这种操作的函数指针(原创)

实际上,对于计算机(特指冯诺依曼架构)而言,不管是int、char,还是什么指针、指令,其实都是一样的一个数,它们对CPU都没什么区别,让他们有区别的是我们对它的处理方式。


函数指针也是一样的,理论上,我们可以对函数指针赋任何值。但是编译器会阻止我们,不允许我们胡乱赋值。可是,别忘了,C/C++语言之所以能够称为接近底层的高级语言,其中一个原因就是它有着一个极其强大、危险,同时也是魅力十足的特性,就是“强制类型转换”。


四.进阶部分:

可能你会问,平常写程序都是直接写成如func()这样的形式啊,并没有感觉在操作一个指针。实际上,这是因为编译器已经帮我们实现了这一功能,并不需要我们操心。在VS的DEBUG模式,_cdecl调用约定下,一个简单的函数调用如下:


步骤1,使用CALL指令压栈跳转:


func();


00974F8D E8 92C4 FF FF       call        func (0971424h)


步骤二,对应地址实际上是存储了一个跳转指令,执行跳转:


func:


00971424 E9 E737 00 00       jmp         func (0974C10h) 


步骤三,随后跳转到的才是实际的函数部分,函数首先将当前寄存器状态压栈保护起来,执行程序,最后恢复现场并RET返回。


void func( void)


{


00974C10 55                   push        ebp 


00974C11 8BEC                mov         ebp,esp 


00974C13 81 ECC0 00 00 00    sub         esp,0C0h 


00974C19 53                   push        ebx 


00974C1A 56                   push       esi 


00974C1B 57                   push        edi 


00974C1C 8D BD40 FF FF FF    lea         edi,[ebp-0C0h] 


00974C22 B9 3000 00 00       mov         ecx,30h 


00974C27 B8 CCCC CC CC       mov         eax,0CCCCCCCCh 


00974C2C F3AB                rep stos    dword ptr es:[edi] 


i++;


00974C2E A0 80F6 97 00       mov         al,byte ptr ds:[0097F680h] 


00974C33 0401                add         al,1 


00974C35 A2 80F6 97 00       mov         byte ptr ds:[0097F680h],al 


}


00974C3A 5F                   pop         edi 


00974C3B 5E                   pop         esi 


00974C3C 5B                   pop         ebx 


00974C3D 8BE5                mov         esp,ebp 


00974C3F 5D                   pop         ebp 


00974C40 C3                   ret 


可以看出来,实际上相当繁琐。这主要是因为DEBUG模式下编译器没有进行优化。在RELEASE模式下:没有步骤二,直接跳转到函数体(我猜测DEBUG模式下多加入的步骤2是为了使用跳转表存储所有的函数,方便调试);不会将所有寄存器压栈,只会将函数中用到的压栈;对于短函数,会直接内联嵌入,不会进行函数调用。


如果是函数指针,则步骤1的跳转将变为:


pfunc();


01195EFF 8BF4                mov         esi,esp 


01195F01 FF 1520 03 1A 01    call        dword ptr ds:[11A0320h] 


可以看出,实际上就是根据内存中地址进行了间接地址调用。DEBUG模式下,还会有以下两句:


01195F07 3BF4                cmp         esi,esp 


01195F09 E8 2BB4 FF FF       call        __RTC_CheckEsp (01191339h) 


这是检查堆栈是否发生溢出用的,如果函数调用的压栈、出栈中发生错误使得前后堆栈位置不一致,则会调用__RTC_CheckEsp函数进行错误处理。


而这一过程中有个问题,那就是我放入这个函数指针变量的数字,怎么保证它是一个函数呢?比如,要是我让pfunc=0x12345678,那会出现什么结果呢?


很遗憾,事实上是,CPU根本无法保证它是一个函数。对于CPU来说,数据、指令都是一样的。对一个数字0x12345678来说,究竟是把它看作一个整数,还是4个char,还是一个float的一半,还是一个函数的地址,完全取决于编译器和你。换句话说,一个数字究竟发挥什么作用,不是取决于其本身,而是取决于它的身份。这个身份有个名字——数据类型。


嗯,这句话如果推广的话,能说出很多看起来有哲理的话来呢。不过打住吧,我不想再打更多无关的字了(没看我连函数指针的用法都懒得写了吗?快进入让人激动的部分吧)


对于C++这样的静态语言来说,当程序编译完成,编译器就无法对程序做出任何改变了。所以,为了阻止你搞破坏,它就只能在编译时阻止你。换句话说,就是必须做到“类型匹配”。所以,C++要求所有的变量都需要声明才能使用,这个过程实际上就是一个“给定身份的过程”。对于特定的指针,也就是特定的“身份”,编译器会有不同的一套处理方式。比如,对于int型指针来说,pi++实际上是pi+=4。而对于char型指针来说,pi++则是pi+=1。


如:


charstr[4]=”abc”;


int *pi=str;


这是不行的,编译器会识别出类型匹配错误,不允许通过编译。


对于函数指针,如:


void func(int)


{


//…


}


void(*pfunc)(int,int);


pfunc=func;


pfunc();


也是不行的。对于func来说,在函数调用时会压栈1次传递1个参数,而pfunc,则会压栈2次。如果编译器让以上程序通过编译,则函数会压栈2次传递参数,返回时却只会弹出1次。而在栈参数下的值,是程序应该返回的位置,即调用时存储的CALL语句的下一条指令。如果少弹出一次,则会将第一个参数作为返回位置,换句话说,程序就“跑飞”了。这是非常严重的错误。因此,编译器不会允许这样的赋值。


编译器花了这么大的力气,看起来好像能够堵住所有漏洞了。可是,C/C++语言之所以能够称为接近底层的高级语言,其中一个原因就是它有着一个极其强大、危险,同时也是魅力十足的特性,就是“强制类型转换”。


类型转换非常常见。最常见的是每一本教材都会讲的“隐式类型转换”。如:


int a=


【/d1reportAllClassLayout】


【Union联合体】


【地址保护(80286加入)】


【NULL和nullptr】


【空类大小为1】


// ConsoleApplication34.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <iostream>
using namespace std;
class Parent 
{
public:
    Parent()
    {
        //cout << "我是爹" << endl;
    }
    virtual void print() 
    {
        cout << "我是爹" << endl;
    
    }
private:
    int a;
};
class Child :public Parent 
{
public:
    Child()
    {
    
    }
    void print() 
    {
        cout << "我是儿子" << endl;
    }
private:
    int b;
};
int main()
{
    //返回值类型 (域作用符::*函数指针名称)(方法参数签名) 下面这个是无参的
    //void (Child::*fptr)(); 无参的
    //void (Child::*fptr)(int,int);有参的,自行领悟吧
    //解释:无返回值类型 作用域是属于Child类的函数指针 即:是指向Child类的任何无参成员函数的函数指针
    void (Child::*fptr)();
    //最终绑定 指向 Child类的print函数的函数指针
    fptr= &Child::print;;
    Child arr[] = { Child(),Child(),Child() };
    //Parent *p;
    //Child* c;
    //p = arr;
    //c = arr;
    //p->print();
    //c->print();
    //p++;
    //c++;
    //p->print();
    //c->print();
    //p++;
    //c++;
    //p->print();
    //c->print();
    
    (*arr.*fptr)();  //相当于 arr[0].print();
    (*(arr+1).*fptr)();
    (*(arr + 2).*fptr)();
    system("pause");
    return 0;
}


如对本文有疑问,请提交到交流论坛,广大热心网友会为你解答!! 点击进入论坛


发表评论 (253人查看0条评论)
请自觉遵守互联网相关的政策法规,严禁发布色情、暴力、反动的言论。
用户名: 验证码: 点击我更换图片
最新评论
------分隔线----------------------------