正文

C++中的指针2008-06-28 22:18:00

【评论】 【打印】 【字体: 】 本文链接:http://blog.pfan.cn/rickone/36334.html

分享到:

C++的指针有4种:指向数据,指向函数,指向成员数据和指向成员函数;为什么不分两种,指向数据和指向函数,这个前2种和后2种不能一对一。可以这么分,指向非成员和指向成员,指向成员的简称成员指针。以下一一说明。

1,指向数据的指针

非常简单。例如:

int a = 100;
int *p = &a;
cout<<*p<<endl;

2,指向函数的指针

函数名可以看成是一个单身函数对象,取值后是函数的入口地址,如:

void foo(int a)
{
}

foo看成是一个类型是void (int)的单身对象,但是对名字foo取值后,它会退化成相应的指针类型void (*)(int)。注意那个括号不能少。当然如果对foo取地址也是这个类型(取两次?没考虑过~~哇靠~太绝了吧)。

所以指向函数的指针,申明起来比较怪,像这样:

void (*pf)(int) = &foo;

申明一个类型是void (*)(int)的函数指针pf,并初始化为&foo,这里的函数参数类型形式和返回类型要和foo的声明一致。再多一个例子吧:

int foo2(float a,double b)
{
    return 0;
}

int (*pf2)(float,double) = &foo2;

函数指针的使用,两种方式:

(*pf)(100);

即,先引用*,打括号,再传实参调用,或者直接,pf(100)。

函数指针的意义:一个函数可以看成是一个策略,对于一个问题,可以采用不同的策略和方法,这种对策略的选择推迟到运行期,即用一个变量保存起来,在程序跑起来的时候,决定使用什么策略,其本质即是动多态,对一个函数的调用延迟到运行时决定。

3,指向成员数据的指针

在要说成员指针之前,要先明确一个概念:名称的受限。C++有一套自己的名称查找机制,一个名称可以是一个类名,对象名,函数名等。受限是指是否用::,->,.中的一种符号作用。

看一般的成员数据访问:

struct A{int a;};

A a;
A* p=&a;
cout<<a.a<<p->a<<endl;

当然类A的定义和下面三条语句不是在一起的,a.a是正确的名称,第一个a没有受限,指对象a,第二个a受限了,是在一个前提下进一步指成员A::a,这里就是a的成员A::a。再举个例子:

struct A
{
    A(int a)
    {
        this->a=a;
    }
    int a;
};

受限的名称要受前面的名称作用,如果a没有确定,那a.a就不能确定,确定a可以使用指针,当然确定a.a也可以使用指针,即成员指针。题外话,在模板中如果一个名称被一个包含模板参数的表达式限制,即被一个不确定的东西限制,那它的绑定将延迟到模板的实例化时,如果表示类型,要前加typename,如果表示成员模板,要在.和->后加template。比如一个模板类(或者叫类模板)中的成员函数中的this指针,实际上它的类型是不确定的,如:

template<typename T>
class V
{
};

的this是V<T>*类型的。

转到正题。成员指针实质上是成员数据的偏移。像这样定义:

int A::*p;

它不能直接指向一个数据,因为它必须要是一个受限的名称,它只能指向一个类的成员,它像这样赋值和初始化:

p=&A::a;

它不能单独使用,因为单独使用的时候是非受限的,要先定义一个A的对象,再限制使用:

A a(100);
cout<<a.*p<<endl;

它必须放在一个限制式的右边。用几个例子来说明一下:

A a(100);
A *p1=&a;
int A::*p2=&A::a;
cout<<p1->*p2<<endl; //实际访问了a.a

另外一个含内套类的复杂一些的例子:

struct A
{
    A(int _a,int _b): a(_a),b(_b)
    {
    }
    struct B
    {
        B(int _b): b(_b)
        {
        }
        int b;
    };
    int a;
    B b;
};

int main()
{
    A a(1,2);
    A *p1=&a;
    A::B A::*p2=&A::b;
    int A::B::*p3=&A::B::b;
    cout<<*p1.*p2.*p3<<endl;
    return 0;
}

4,指向成员函数的指针

如果(3)弄清楚了这个也应该很明白了,成员函数默认绑定this指针,即成员函数名也是一个受限的名称。它的定义和一般的函数定义类似,只是在指针前加上一个类名和::。

struct A
{
    A(int a)
    {
        this->a=a;
    }
    void foo(int)
   {
   }
    int a;
};

A a;
void (A::*pf)(int) = &A::foo;
(a.*pf)(100);// 相当于调用a.foo(100)

使用和(3)一样,完了再括起来传参调用函数,这个时候不能使用另外一种调用形式了,即不能这样调用:a.pf(100),即使pf是A的成员数据也不可以,例如:

struct A
{
    A(): pf(&A::foo1) {}
    A(int): pf(&A::foo2) {}
    void foo1(int)
    {
        cout<<"foo1 is called"<<endl;
    }
    void foo2(int)
    {
        cout<<"foo2 is called"<<endl;
    }
    void foo()
    {
        (this->*pf)(0);
    }
    void (A::*pf)(int);
};

int main()
{
    A a,b(0);
    a.foo();// 输出 foo1 is called
    b.foo();// 输出 foo2 is called
    return 0;
}

为什么不能默认使用pf呢?pf是A的成员,按理说会有隐含的this->在前面,如果foo()里换成:(*pf)(0);,会编译错误。原因是,pf是成员,但*pf不是,如果像后者那样调用,它相当于:(*(this->pf))(0)。直接引用了成员指针。

另外,static成员数据和成员函数不能用成员指针,它们不认为是对象的一部分,它们可以直接用一般指针访问,当然它们也是受限的名称,但是受一个类名限制和对象名无关。

阅读(5653) | 评论(1)


版权声明:编程爱好者网站为此博客服务提供商,如本文牵涉到版权问题,编程爱好者网站不承担相关责任,如有版权问题请直接与本文作者联系解决。谢谢!

评论

loading...
您需要登录后才能评论,请 登录 或者 注册