浅谈对象指针和对象引用

转自：http://wujianyu.spaces.live.com/blog/cns!18E566CFC32EA114!164.entry

浅谈对象指针和对象引用

指向类的成员的指针

    在C++中，可以说明指向类的数据成员和成员函数的指针。

    指向数据成员的指针格式如下：

    <类型说明符><类名>::*<指针名>

    指向成员函数的指针格式如下：

    <类型说明符>(<类名>::*<指针名>)(<参数表>)

    例如，设有如下一个类A：

    class A
    {
    public:
        int fun (int b) { return a*c+b; }
        A(int i) { a=i; }
        int c;
    private:
         int a;
    };

    定义一个指向类A的数据成员c的指针pc，其格式如下：

    int A:: *pc = &A::c;

    再定义一个指向类A的成员函数fun的指针pfun，其格式如下：

    int (A:: *pfun)(int) = A::fun;

    由于类不是运行时存在的对象。因此，在使用这类指针时，需要首先指定A类的一个对象，然后，通过对象来引用指针所指向的成员。例如，给pc指针所指向的数据成员c赋值8，可以表示如下：

    A a;
    a.*pc = 8;

    其中，运算符.*是用来对指向类成员的指针来操作该类的对象的。

    如果使用指向对象的指针来对指向类成员的指针进行操作时，使用运算符->*。例如：

    A *p = &a;    //a是类A的一个对象，p是指向对象a的指针。
    p ->* pc = 8;

    让我们再看看指向一般函数的指针的定义格式：

    <类型说明符>*<指向函数指针名>(<参数表>)

    关于给指向函数的指针赋值的格式如下：

    <指向函数的指针名>=<函数名>

    关于在程序中，使用指向函数的指针调用函数的格式如下：

    (*<指向函数的指针名>)(<实参表>)

    如果是指向类的成员函数的指针还应加上相应的对象名和对象成员运算符。

    下面给出一个使用指向类成员指针的例子：

    #include <iostream.h>
    class A
    {
    public:
    A(int i) { a=i; }
    int fun(int b) { return a*c+b; }
    int c;
    private:
    int a;
    };

    void main()
    {
    A x(8);        //定义类A的一个对象x
    int A::*pc;    //定义一个指向类数据成员的指针pc
    pc=&A::c;    //给指针pc赋值
    x.*pc=3;    //用指针方式给类成员c赋值为3
    int (A::*pfun)(int);    //定义一个指向类成员函数的指针pfun
    pfun=A::fun;        //给指针pfun赋值
    A *p=&x;        //定义一个对象指针p，并赋初值为x
    cout<<(p->*pfun)(5)<<endl;    //用对象指针调用指向类成员函数指针pfun指向的函数
    }

    以上程序定义了好几个指针，虽然它们都是指针，但是所指向的对象是不同的。p是指向类的对象；pc是指向类的数据成员；pfun是指向类的成员函数。因此它们的值也是不相同的。

对象指针和对象引用作函数的参数

    1. 对象指针作函数的参数

    使用对象指针作为函数参数要经使用对象作函数参数更普遍一些。因为使用对象指针作函数参数有如下两点好处：

    (1) 实现传址调用。可在被调用函数中改变调用函数的参数对象的值，实现函数之间的信息传递。

    (2) 使用对象指针实参仅将对象的地址值传给形参，而不进行副本的拷贝，这样可以提高运行效率，减少时空开销。

    当形参是指向对象指针时，调用函数的对应实参应该是某个对象的地址值，一般使用&后加对象名。下面举一例子说明对象指针作函数参数。

    #include <iostream.h>
    class M
    {
    public:
        M() { x=y=0; }
        M(int i, int j) { x=i; y=j; }
        void copy(M *m);
        void setxy(int i, int j) { x=i; y=j; }
        void print() { cout<<x<<,<<y<<endl; }
    private:
        int x, y;
    };

    void M::copy(M *m)
    {
    x=m->x;
    y=m->y;
    }

    void fun(M m1, M *m2);
    void main()
    {
    M p(5, 7), q;
    q.copy(&p);
    fun(p, &q);
    p.print();
    q.print();
    }

    void fun(M m1, M *m2)
    {
    m1.setxy(12, 15);
    m2->setxy(22,25);
    }

    输出结果为：

    5,7
    22,25

    从输出结果可以看出，当在被调用函数fun中，改变了对象的数据成员值[m1.setxy(12, 15)]和指向对象指针的数据成员值[m2->setxy(22, 25)]以后，可以看到只有指向对象指针作参数所指向的对象被改变了，而另一个对象作参数，形参对象值改变了，可实参对象值并没有改变。因此输出上述结果。

    2. 对象引用作函数参数

    在实际中，使用对象引用作函数参数要比使用对象指针作函数更普遍，这是因为使用对象引用作函数参数具有用对象指针作函数参数的优点，而用对象引用作函数参数将更简单，更直接。所以，在C++编程中，人们喜欢用对象引用作函数参数。现举一例子说明对象引用作函数参数的格式。

    #include <iostream.h>
    class M
    {
    public:
    M() { x=y=0; }
    M(int i, int j) { x=i; y=j; }
    void copy(M &m);
    void setxy(int i, int j) { x=i; y=j; }
    void print() {cout<<x<<,<<y<<endl; }
    private:
    int x, y;
    };

    void M::copy(M &m)
    {
    x=m.x;
    x=m.y;
    }

    void fun(M m1, M &m2);

    void main()
    {
    M p(5, 7), q;
    q.copy(p);
    fun(p, q);
    p.print();
    q.print();
    }

    void fun(M m1, M &m2)
    {
    m1.setxy(12, 15);
    m2.setxy(22, 25);
    }

    该例子与上面的例子输出相同的结果，只是调用时的参数不一样。

this指针

    this指针是一个隐含于每一个成员函数中的特殊指针。它是一个指向正在被该成员函数操作的对象,也就是要操作该成员函数的对象。

    当对一个对象调用成员函数时，编译程序先将对象的地址赋给this指针，然后调用成员函数，每次成员函数存取数据成员时，由隐含作用this指针。而通常不去显式地使用this指针来引用数据成员。同样也可以使用*this来标识调用该成员函数的对象。下面举一例子说明this指针的应用。

    #include <iostream.h>
    class A
    {
    public:
    A() { a=b=0; }
    A(int i, int j) { a=i; b=j; }
    void copy(A &aa);    //对象引用作函数参数
    void print() {cout<<a<<,<<b<<endl; }
    private:
    int a, b;
    };

    void A::copy(A &aa)
    {
    if (this == &aa) return;    //这个this是操作该成员函数的对象的地址，在这里是对象a1的地址
    *this = aa;    //*this是操作该成员函数的对象，在这里是对象a1。
            //此语句是对象aa赋给a1，也就是aa具有的数据成员的值赋给a1的数据成员
    }

    void main()
    {
    A a1, a2(3, 4);
    a1.copy(a2);
    a1.print();
    }

    运行结果：

    3, 4

                                                            2001-7-6 23:56   阿青

 

------------------------------------------------------------------------------------------------------------

PS：形参和实参的关系

 

形参:全称为"形式参数"是在定义函数名和函数体的时候使用的参数,目的是用来接收调用该函数时传如的参数.
实参:全称为"实际参数"是在调用时传递个该函数的参数.

形参和实参的类型必须要一致,或者要符合隐含转换规则,
当形参和实参不是指针类型时,在该函数运行时,形参和实
参是不同的变量,他们在内存中位于不同的位置,形参将实
参的内容复制一份,在该函数运行结束的时候形参被释放,
而实参内容不会改变.

而如果函数的参数是指针类型变量,在调用该函数的过程
中,传个函数的是实参的地址,在函数体内部使用的也是
实参的地址,即使用的就是实参本身.所以在函数体内部
可以改变实参的值