C++对象数组&对象指针&对象指针数组

一、对象数组

对象数组中的每一个元素都是同类的对象；
例1 对象数组成员的初始化

1. #include<iostream>
2. using namespace std;
4. class Student
5. {
6. public:
7.     Student( ){ };
8.     Student(int n,string nam,char s):num(n),name(nam),sex(s){};
9.     void display()
10.     {
11.         cout<<"num:"<<num<<endl;
12.         cout<<"name:"<<name<<endl;
13.         cout<<"sex:"<<sex<<endl;
14.         cout<<"+++++++++++++++++"<<endl;
15.     }
16. private:
17.     int num;
18.     string name;
19.     char sex;
20. };
22. int main()
23. {
24.     Student Stud1;
25.     Stud1.display();//Stud1未初始化，打印的数据成员为内存脏数据
27.     Student Stud2(2078, "wang", 'm');
28.     Stud2.display();
30.     Student Stud3[20];
31.     Stud3[0].display();//Stud3[0]未初始化，打印的数据成员为内存脏数据
33.     Student Stud4[3]=            //对象数组的初始化
34.     {
35.         Student(1001,"He",'m'),    //对象数组成员的初始化
36.         Student(1002,"You",'f'),   //对象数组成员的初始化
37.         Student(1003,"She",'f')    //对象数组成员的初始化
38.     };
39.     Stud4[0].display();
40.     Stud4[1].display();
41.     Stud4[2].display();
42.     return 0;
43. }

复制代码

例2 对象数组应用

1. #include<iostream>
2. using namespace std;
4. class Box
5. {
6. public:
7.     Box(int h=10,int w=12,int len=15):height(h),width(w),length(len) {};//构造函数初始化
8.     int volume( );
9. private:
10.     int height;
11.     int width;
12.     int length;
13. };
15. int Box::volume( )
16. {
17. return(height*width*length);
18. }
20. int main( )
21. {
22.     Box a[3]=
23.     {
24.         Box(),         //10*12*15 = 1800
25.         Box(15,18),    //15*18*15 = 4050
26.         Box(16,20,26)  //16*20*26 = 8320
27.     };
28.     cout<<"volume of a[0] is "<<a[0].volume( )<<endl;
29.     cout<<"volume of a[1] is "<<a[1].volume( )<<endl;
30.     cout<<"volume of a[2] is "<<a[2].volume( )<<endl;
31.     return 0;
32. }

复制代码

二、对象指针

（一）指向对象的指针

在创建对象时，编译体系会为每一个对象分配一定的存储空间，以存放其成员。
可以定义一个指针变量，用来存放对象的指针。

1. class Time{……};
2. Time time1;
4. Time *pt; //格式  类名 *对象指针
5. pt = &time1; //格式  pt就是指向Time类对象的指针变量

复制代码

并且可以通过对象指针访问对象和对象的成员。

1. *pt
2. (*pt).hour或pt->hour //即t1.hour
3. (*pt).showtime()或pt->showtime() //即time1.showtime( )

复制代码

（二）指向对象数据成员的指针

对象中的成员也有地址，存放对象成员地址的指针变量就是指向对象成员的指针变量。
定义指向对象数据成员的指针变量的方法和定义指向平凡变量的指针变量方法相同。
通过指向对象数据成员的指针变量访问成员
   注：对象数据成员为私有时，则无法通过指针访问

1. int *p1;      //一般形式：数据类型名 *指针变量名；
2. p1=&time1.hour;
4. cout<<*p1<<endl;

复制代码

（三）指向对象成员函数的指针

指向一般函数的函数指针，如下：

1. int (*pf)();
2. p1=fun;
3. cout<<(*pf)();

复制代码

1 “定义”指向类成员函数的指针变量

   函数返回范例名 (类名∷*函数指针变量名)(参数表列);

1. void (Time∷*pf)( );

复制代码

2 “指向”一个成员函数的方法

   函数指针变量名 = &类名∷成员函数名;【注意：这里用类名，而非函数名】

1. pf = &Time∷showtime;

复制代码

3 通过指向对象中成员函数的指针，调用员函数

   （对象名.*函数指针变量名）();

1. (time.*pf)();

复制代码

例3 对象指针&对象数据成员指针&对象成员函数指针综合实例

1. #include <iostream>
2. using namespace std;
4. class Time
5. {
6. public:
7.     Time(int,int,int);
8.     void get_time( );
9.     void showtime();
10. //private:
11. public:                 //若为private，则不可通过指针访问（对象指针，对象数据指针均不可访问private）
12.     int hour,minute,sec;
13. };
14. Time::Time(int h,int m,int s):hour(h),minute(m),sec(s){};
16. void Time::showtime()
17. {
18.     cout<<"hour:"<<hour<<" minute:"<<minute<< " second:"<<sec<<endl;  
19.     cout<<"++++++++++++"<<endl;
20. }
22. void Time::get_time( )
23. {
24.     cout<<hour<<":"<<minute<<":" <<sec<<endl;
25. }
26. int main( )
27. {
28.     Time time1(10,11,12);
29.     Time *pt1;            //对象指针
30.     pt1 = &time1;
31.     pt1->showtime();
32.    
33.     pt1->hour = 9;
34.     pt1->minute = 10;
35.     (*pt1).sec = 11;
36.     (*pt1).showtime();
37.    
38.     int *p1,*p2,*p3;      //指向对象数据成员的指针
39.     p1 = &time1.hour;
40.     p2 = &time1.minute;
41.     p3 = &time1.sec;
42.     *p1 = 8;
43.     *p2 = 9;
44.     *p3 = 10;
45.     time1.showtime();
46.    
47.     Time time2(7,8,9);
48.     void(Time::*pf)();    //指向对象成员函数的指针
49.     pf = &Time::showtime; //注意，这里是类名，而非对象名 &time1.showtime
50.     (time2.*pf)();
51.    
52.     return 0;
53. }

复制代码

三、对象数组vs对象指针数组

为提高内存的使用率，内存须要被动态的创建和释放
   new运算符：动态分配内存；
  delete运算符：释放内存。
  用new运算符动态地分配内存后，将返回一个指向新对象的指针的值（内存地址，大小4字节），用户通过这个地址来访问对象。
   注：
  1）通过new创建的对象，由于未定义对象名，只能通过指针来访问；
2）创建对象时会主动执行构造函数；
3）体系内存不足，会出现异常。

1. Time *pt1=new Time;
3. Time *pt2;
4. pt2=new Time(8,29,59);
5. pt2->show_time();

复制代码

不再须要由new创建的对象时，用delete运算符释放

1. delete pt1;

复制代码

注：在释放内存空间之前，主动调用析构函数，完成有关善后清理工作。
例4  对象的申请和释放

1. #include<iostream>
2. using namespace std;
3. class Box
4. {
5. public:
6.     Box(int w,int l,int h);
7.     ~Box();
8.     int width;
9.     int length;
10.     int height;
11. };
13. Box::Box(int w,int l,int h)
14. {
15.     width=w;
16.     length=l;
17.     height=h;
18.     cout<<"========调用构造函数=======\n";
19. }
20. Box::~Box()
21. {
22.     cout<<"========调用析构函数=======\n";
23. }
25. int main()
26. {
27.     Box * pt = new Box(12,13,14);
28.     cout<<pt->width<<"\n";
29.     cout<<pt->length<<"\n";
30.     cout<<pt->height<<endl;
31.     delete pt;                //如果不delete pt,则不会执行析构函数
32.     return 0;
33. }

复制代码

（一）使用new创建动态对象数组成员

1. int n;
2. Time *pt;
3. cin>>n;
4. pt = new Time[n];
5. ……
6. delete []pt;

复制代码

（二）对象指针数组

一个指针只占用4个字节，因此相比于创建数组或对象数组，指针数组的方式更节流空间；
创建占用空间小的指针数组，灵活处理占用空间大的对象聚集。

1. const int N = 100;
2. Time *pt[N]={NULL};
3. int i;
4. ……
5. i=3;
6. if(pt[i]==NULL)
7. pt[i] = new Time(10, 10,10);
8. ……
9. if(pt[i]!=NULL)
10. delete pt[i];

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。