(C++)对象指针和对象引用

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

 

1、指向数据成员的指针格式如下:

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

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

<类型说明符>（<类名>：：*<指针名>）（<参数表>）

 

如下例：

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;

 

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

<a类型说明符>*<指向函数指针名>（<参数表>）；

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

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

 

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

（*<指向函数的指针名>）（<实参表>）

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

 

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

#include<iostream.h>

class A

{

 public:

    A(int i){ a = i;}

    int fun(int b){return a*b + c;}

    int c;

private:

    int a;

}

 

void main()

{

         A x(8);                    //定义类A的一个对象，并给其构造函数赋初值

         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->sexy(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;

 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);

}

 

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

 

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