在C++中,函数指针与成员函数指针完全是两个概念,并且相互之间在任何情况下,无法转换!
我们来看这么一个类:
A::f1()的指针我们需要这样定义:
A::f2()的指针我们这样定义:
如果他们的形参列表不一致,则强制转换在编译期间没有问题,但是运行时会抛出异常。
这是因为形参列表不一样意味着强制转换后,某些函数无法得到某些必须的参数。所以,这种转换应该是需要避免的。
A::f3()和f4()尽管一个是静态成员函数,一个是普通函数,但是他们的指针定义却是一样的:
作为参数的时候,他们既可以加上“&”来写:“&A::f3”, “&f4”;
也可以不用“&”:“A::f3”, “f4”。
这是在A类定义域外的情况。在A定义域内,比如在写A的成员函数的时候,静态成员函数甚至可以不需要加上A的定义域符号“A::”,直接可以使用“&f3”或者“f3”。
我们把剩下的程序补充完整:
1、成员函数的指针与对象是不绑定的。也就是说,尽管我也很希望如果a是A的对象,a.f1()的指针要是能表示成a.f1(或者“&(a.f1)”)多好?但是这是不允许的,至少现在是不允许的。我们要调用A::f1()方法,还得指定其对象,所以,这实际上与调用静态成员函数与普通函数是一样的。
2、静态成员函数可以代替普通函数被调用函数指针(非成员函数指针)的函数调用。但是静态成员函数有一个好处,就是可以被类私有保护起来——当然,最好是有其他公共成员将其作用对外连接起来的时候。
我们来看这么一个类:
#include
<
iostream
>
class A
{
private :
int a;
public :
A( int _a): a(_a)
{}
void f1() const
{
std::cout << " call f1, a = " << a << std::endl;
}
int f2() const
{
std::cout << " call f2, a = " << a << std::endl;
return 0 ;
}
static void f3( const A & _a)
{
std::cout << " call f3, " ;
_a.f1();
}
friend void f4( const A & _a)
{
std::cout << " call f4, a = " << _a.a << std::endl;
}
};
其中函数A::f1()和A::f2()是毫无疑问的成员函数;A::f3()也是成员函数,但是他是静态成员函数;f4()是A类的友元函数,他实际上就是一个普通的函数。
class A
{
private :
int a;
public :
A( int _a): a(_a)
{}
void f1() const
{
std::cout << " call f1, a = " << a << std::endl;
}
int f2() const
{
std::cout << " call f2, a = " << a << std::endl;
return 0 ;
}
static void f3( const A & _a)
{
std::cout << " call f3, " ;
_a.f1();
}
friend void f4( const A & _a)
{
std::cout << " call f4, a = " << _a.a << std::endl;
}
};
A::f1()的指针我们需要这样定义:
typedef
void
(A::
*
pcf)()
const
;
作为参数的时候必须这样写“&A::f1”。
A::f2()的指针我们这样定义:
typedef
int
(A::
*
ptf)()
const
;
尽管A::f2()与A::f1()的返回类型不同,但是他们的形参列表是一样的,所以,指针可以通过强制转换进行转换。
如果他们的形参列表不一致,则强制转换在编译期间没有问题,但是运行时会抛出异常。
这是因为形参列表不一样意味着强制转换后,某些函数无法得到某些必须的参数。所以,这种转换应该是需要避免的。
A::f3()和f4()尽管一个是静态成员函数,一个是普通函数,但是他们的指针定义却是一样的:
typedef
void
(
*
pf)(
const
A
&
);
这也就是为什么调用函数指针的函数可以直接调用静态成员函数指针的原因。
作为参数的时候,他们既可以加上“&”来写:“&A::f3”, “&f4”;
也可以不用“&”:“A::f3”, “f4”。
这是在A类定义域外的情况。在A定义域内,比如在写A的成员函数的时候,静态成员函数甚至可以不需要加上A的定义域符号“A::”,直接可以使用“&f3”或者“f3”。
我们把剩下的程序补充完整:
void
call_A(pcf pF,
const
A
&
_a)
{
(_a. * pF)();
}
void call_A(pf pF, const A & _a)
{
( * pF)(_a);
}
int main( int argc, char * argv[])
{
A a( 10 );
call_A( & A::f1, a);
ptf __f2 = & A::f2;
pcf _f2 = (pcf)(__f2);
call_A(_f2, a);
call_A(A::f3, a);
call_A(f4, a);
return 0 ;
}
可以看到的情况是:
{
(_a. * pF)();
}
void call_A(pf pF, const A & _a)
{
( * pF)(_a);
}
int main( int argc, char * argv[])
{
A a( 10 );
call_A( & A::f1, a);
ptf __f2 = & A::f2;
pcf _f2 = (pcf)(__f2);
call_A(_f2, a);
call_A(A::f3, a);
call_A(f4, a);
return 0 ;
}
1、成员函数的指针与对象是不绑定的。也就是说,尽管我也很希望如果a是A的对象,a.f1()的指针要是能表示成a.f1(或者“&(a.f1)”)多好?但是这是不允许的,至少现在是不允许的。我们要调用A::f1()方法,还得指定其对象,所以,这实际上与调用静态成员函数与普通函数是一样的。
2、静态成员函数可以代替普通函数被调用函数指针(非成员函数指针)的函数调用。但是静态成员函数有一个好处,就是可以被类私有保护起来——当然,最好是有其他公共成员将其作用对外连接起来的时候。