第八讲：对象数组与指针

第八讲：对象数组与指针

本讲基本要求

    * 掌握：对象数组和对象指针的定义及引用。
    * 理解：this指针的使用；对象数组的定义、使用方法；指向对象成员的指针。
    * 了解：构造函数有多个参数对象数组和构造函数有单个参数对象数组的实参的传递方式。
重点、难点
    * 对象数组和对象指针的定义及引用。

一、对象数组

   数组不仅可以由简单变量组成(例如整型数组的每一个元素都是整型变量)，也可以由对象组成(对象数组的每一个元素都是同类的对象)。

      定义对象数组的一般格式：类名 数组名[数组个数]

说明：
   1、有许多实体的属性是共同的，只是属性的具体内容不同时我们可对立对象数组。
   2、定义数组，有多少个元素在建立数组时，同样要调用多少次构造函数。如果有50个元素，需要凋用50次构造函数。
   3、如果构造函数只有一个参数，在定义数组时可以直接在等号后面的花括号内提供实参。如
Student stud[3]={60，70，78}； //合法．3个实参分别传递给3个数组元素的构造函数。
   4、构造函数有多个参数，则不能用在定义数组时直接提供所有实参的方法，因为一个数组有多个元素，对每个元素要提供多个实参，如果再考虑到构造函数有默认参数的情况，很容易造成实参与形参的对应关系不清晰，出现歧义性。
   5、构造函数有多个参数，在建立对象数组时，分别调用构造函数，对每个元素初始化。每一个元素的实参分别用括号包起来，对应构造函数的一组形参，不会混淆。

例6 对象数组的使用方法。
#include <iostream>
using namespace std;

class Box
   { public:
      Box(int h=10,int w=12,int len=15):height(h),width(w),length(len){ }
//声明有默认参数的构造函数，用参数初始化表对数据成员初始化
      int volume();
     private:
      int height;
      int width;
      int length; };

int Box::volume()
 { return(height*width*length); }

int main()
 { Box a[3]={    //定义对象数组
   Box(10,12,15), //调用构造函数Box，提供第1个元素的实参
   Box(15,18,20), //调用构造函数Box，提供第2个元素的实参
   Box(16,20,26) //调用构造函数Box，提供第3个元素的实参
  };
cout<<"volume of a[0] is "<<a[0].volume()<<endl;//调用a[O]的volume函数
cout<<"volume of a[0] is "<<a[1].volume()<<endl;//调用a[1]的volume函数
cout<<"volume of a[0] is "<<a[2].volume()<<endl;//调用a[2]的volume函数
return 0; }

运行结果如下：
   volume Of a[0] is 1800
   volume Of a[l] is 5400
   volume Of a[2] is 8320

 

二、 对象指针

指针可以用来指向一般的变量，也可以指向对象。

1、 指向对象的指针

   在建立对象时，编译系统会为每一个对象分配一定的存储空间，以存放其成员。对象空间的起始地址就是对象的指针。可以定义一个指针变量，用来存放对象的指针。

定义指向类对象的指针变量的一般形式为：类名 *对象指针名；

例如：以下对象指针的定义、赋值语句：
      Time *pt； //定义Pt为指向Time类刈象的指针变量
      Time tl；  //定义tl为Time类对象
      pt=&tl；   //将t1的起始地址赋给pt

如果 有—个类：
   class Time
      { public：
         int hour：
         int minute：
         int sec；
         void get_time()；
      }；
   void Time::get_time()
     { cout<<hour<<":" <<minute <<":"<<sec<<endl；}

   这样，Pt就是指向Time类对象的指针变量，它指向对象t1。 可以通过对象指针访问对象和对象的成员。如:
   *pt           pt所指向的对象，即t1
   (*pt).hour     pt所指向的对象中的hour成员，即t1.hour
   pt->hour       pt所指向的对象中的hour成员，即t1.hour
   (*pt).get_time()调用pt所指向的对象中的get_time函数，即t1.get_time
   pt->get_time()  调用pt所指向的对象中的get_time函数，即t1.get_time

2、 指向对象成员的指针

   对象有地址，存放对象初始地址的指针变量就是指向对象的指针变量。对象中的成员也有地址，存放对象成员地址的指针变量就是指向对象成员的指针变量。

(1)指向对象数据成员的指针
   定义指向对象数据成员的指针变量的方法和定义指向普通变量的指针变量方法相同。

   定义指向对象数据成员的指针变量的一般形式为:
   数据类型名 *指针变量名；

例如：int *p1； //定义指向整型数据的指针变量
   如果Time类的数据成员hour为公用的整型数据，则可以在类外通过指向对象数据成员的指针变量访问对象数据成员hour。
   pl=&t1.hour；    //将对象tL的数据成员hour的地址赋绐p1，P1指向t1.hour
   cout <<*p1<<endl；//输出t1.hour的值

(2)指向对象成员函数的指针

   需要注意：定义指向对象成员函数的指针变量的方法和定义指向普通函数的指针变量方法有所不同。这里重温一下指向普通函数的指针变量的定义方法：

   数据类型名 (*指针变量名)(参数表列)；

   如: void (*P)()； //p是指向void型函数的指针变量

可以使它指向一个函数，并通过指针变量调用该函数：
   p=fun；  //将fun函数的入门地址赋抬指针变量P。P就指向了函数fun
   (*P)()： //调用fun函数
   而定义一个指向对象成员函数的指针变量则比较复杂一些。如果模仿上面的方法将对象成员函数名赋给指针变量P： p=t1.get_time；//  则会出现编译错误。

指向成员函数的指针变量的定义的一般形式为:

      数据类型名 (类名::*指针变量名)(参数表列)；

指针变量指向一个公用成员函数的一般形式为:

       指针变量名=&类名::成员函数名；

例： void (Time::*p2)()； //定义p2为第向Time类中公用成员函数的指针变量
    p2=&Time::get_time;  //将Time类中公用成员函数get_time的地址赋给指针变量P2

注意：(Time::*p2)两侧的括号不能省略，因为()的优先级高于*。如果无此括号，就相当于：
      void Time::*(P2())； //这是返回值为void型指引的函数定义指向公用成员函数的

在系统中，也可以不写&，以和C语言的用法一致，但建议在写程序时不要省略&。

例7 有关对象指针的使用方法。
#include <iostream>
using namespace std;
class Time
   { public:
      Time(int,int,int);
      Int hour;
      int minute;
      int sec;
      void get_time(); //声明公有成员函数
    };
Time::Time(int h,int m,int s) //定义构造函数
   { hour=h;
     minute=m;
     sec=s; }
void Time::get_time()    //定义公有成员函数
  { cout<<hour<<":"<<minute<<":"<<sec<<endl;}

int main()
 { Time t1(10,13,56); //定义Time类对象t1
   int *p1=&t1.hour; //定义指向整数数据的指引变量p1，并使P1.hour
   cout<<*p1<<endl;  //输出pl所指的数据成员t1.hour
   t1.get_time();   //调用对象t1的成员函数get_time
   Time *p2=&t1;    //定义指向Time类对象的指引变量P2，并使P2指向t1
   p2->get_time();  //调用p2所向对象(即t1)的get_time函数
   (*p2). get_time();
   void (Time::*p3)();//定义指向Time类公用成员函数的指针变量p3
   p3=&Time::get_time;//使p3指向Time类公用成员函数ge_time
   (t1.*p3)();       //调用对象t1中P3所指的成员函数(即t1.get_time())
   return 0; }

程序运行结果为：

10 (main函数第4行的输出)
10：13：56 (main函数第5行的输出)
10：13：56 (main函数第7行的输出)
10：13：56 (main函数第8行的输出)
10：13：56 (main函数第11行的输出)

说明：
   (1)从main函数第9行可以看出：成员函数的入口地址的正确写法是：&类名::成员函数名。不应写成：       p3=&t1.gel_time；    //t1为对象名
   成员函数不是存放在对象的空间中的，而是存放在对象外的空间中的，如果有多个同类的对象，它们共用同一个函数代码段。因此赋给指针变量p3的应是这个公用的函数代码段的入口地址。
   (2)main函数第8、9两行可以合写为一行：
      void(Time::*p3)()=&Time::get_time； //定义指针变量时指定其指向

3、 this 指针

   每个对象中的数据成员都分别占有存储空间，如果对同一个类定义了n个对象，则有n组同样大小的空间以存放n个对象中的数据成员。但是，不同的对象都调用同一个函数代码段。那么，当不同对象的成员函数引用数据成员时，怎么能保证引用的是所指定的对象的数据成员呢?

   在每一个成员函数中都包含一个特殊的指针，这个指针的名字是固定的，称为this。它是指向本类对象的指针，它的值是当前被调用的成员函数所在的对象的起始地址。

需要说明：
   1、这些都是编译系统自动实现的，编程序者不必人为地在形参中增加this指针，也不必将对象a的地址传给this指针。这里写出以上过程，只是为了使读者者理解this指针的作用和实现的机理。
   2、 在需要时也可以显式地使用this指针。例如在Box类的volume函数中，下面两种表示方法都是合法的、相互等价的。
      return(height*width*length)； //隐含使用this指针
      return(this->height*this->width t this->length)； //显式使用this指针
   3、this两侧的括号不能省略，不能写成*this.height。因为成员运算符“．”的优先级别高于指针运算符“*”，因此，*this.height就相当于*(this.height)，而this.height是不合法的，编译出错。
   4、例6程序中定义的Box类，volume函数要计算height*width*length的值，实际上是执行：
      (this->height)*(this->width)：(this->length)
由于当前this指向对象a，因此相当于执行：
      (a.height)*(a.width)*(a.length)

 

 

 

转自：http://210.44.195.12/cgyy/text/HTML/text/08.htm