对象数组与对象指针
1. 对象数组
所谓对象数组是指每一数组元素都是对象的数组， 也就是说，若一个类有若干个对象，则把这一系列的对象用一个数组来存放。ios
对象数组的元素是对象， 不只具备数据成员，并且还有函数成员数组
定义一个一维数组的格式以下: 类名 数组名[下标表达式];函数
exam ob[4]; //定义了类exam的对象数组ob.
与基本数据类型的数组同样,在使用对象数组时也只能访问单个数组元素,也就是一个对象,经过这个对象,也能够访问到它的公有成员spa
使用的通常形式是: 数组名[下标].成员名设计
例3.4 对象数组的应用
#include<iostream.h>
class exam{
public:
void set_x(int n){ x=n; }
int get_x(){ return x; }
private:
int x;
};
main()
{
exam ob[4];
int i;
for (i=0;i<4;i++)
ob[i].set_x(i);
for (i=0;i<4;i++)
cout<<ob[i].get_x()<<′ ′;
cout<<endl;
return 0;
}
0 1 2 3
若是须要创建某个类的对象数组，在设计类的构造函数时就要充分考虑到数组元素初始化的须要；指针
- 当各个元素的初值要求为相同的值时，应该在类中定义出不带参数的构造函数或带缺省参数值的构造函数；
- 当各元素对象的初值要求为不一样的值时须要定义带形参(完好省值)的构造函数。
- 定义对象数组时，可经过初始化表进行赋值。定义对象数组时，可经过初始化表进行赋值
【例3.5】 经过初始化表给对象数组赋值
#include<iostream.h>
class exam{
public:
exam()
{ x=123;}
exam(int n)
{ x=n;}
int get_x()
{ return x; }
private:
int x;
};
main()
{
exam ob1[4]={11,22,33,44};
exam ob2[4]={55,66};
exam ob3[4]={exam(11),exam(22),exam(33),exam(44)};
exam ob4[4]={exam(55),exam(66)};
ob4[2]=exam(77);
ob4[3]=exam(88);
int i;
for (i=0;i<4;i++)
cout<<ob1[i].get_x()<<' ';
cout<<endl;
for (i=0;i<4;i++)
cout<<ob2[i].get_x()<<' ';
cout<<endl;
for (i=0;i<4;i++)
cout<<ob3[i].get_x()<<' ';
cout<<endl;
for (i=0;i<4;i++)
cout<<ob4[i].get_x()<<' ';
cout<<endl;
return 0;
}
11 22 33 44 55 66 123 123 11 22 33 44 55 66 77 88
【例3.6】 本例说明当构造函数具备一个以上的参数时，如何对二维数组对象进行初始化
#include <iostream.h>
class example{
public:
example(int n, int m)
{
x = n;
y = m;
}
~example()
{ cout<<"Destructor called.\n"; }
int get_x()
{ return x;}
int get_y()
{ return y;}
private:
int x, y;
};
main()
{
example op[3][2]={
example(1,2),example(3,4),
example(5,6),example(7,8),
example(9,10),example(11,12) };
int i;
for (i=0;i<3;i++)
{
cout<<op[i][0].get_x()<<' ';
cout<<op[i][0].get_y()<<"\n";
cout<<op[i][1].get_x()<<' ';
cout<<op[i][1].get_y()<<"\n";
}
cout<<"\n";
return 0;
}
1 2 3 4 5 6 7 8 9 10 11 l2 Destructor called. Destructor called. Destructor called. Destructor called. Destructor called. Destructor called.
2. 对象指针
每个对象在初始化后都会在内存中占有必定的空间。所以，便可以经过对象名访问一个对象，也能够经过对象地址来访问一个对象。code
对象指针就是用于存放对象地址的变量。声明对象指针的通常语法形式为：类名* 对象指针名;对象
（1）用指针访问单个对象成员
- 定义指针变量：
Date *p,date1; - 初始化：指向一个已建立的对象
p=&date1; - 访问：用“->”操做符,只能访问该对象的公有成员。
p->setdate(2007,10,18);内存
例3.7 对象指针的使用
#include<iostream.h>
class exe{
public:
void set_a(int a){ x=a; }
void show_a(){ cout<<x<<endl; }
private:
int x;
};
main()
{
exe ob,*p; // 声明类exe的对象ob和类exe的对象指针p
ob.set_a(2);
ob.show_a(); // 利用对象名访问对象的成员
p=&ob; // 将对象ob的地址赋给对象指针p
p->show_a(); // 利用对象指针访问对象的成员
return 0;
}
2 2
（2）用对象指针访问对象数组
对象指针不只能访问单个对象,也能访问对象数组.get
exe *p; //声明对象指针p exe ob[2]; //声明对象数组ob[2] p=ob; //将对象数组的首地址赋给对象指针
main()
{
exe ob[2],*p;
ob[0].set_a(10);
ob[1].set_a(20);
p=ob;
p->show_a();
p++;
p->show_a();
return 0;
}
结果：
10 20
通常而言,当指针加1或减1时,它老是指向其基本类型中相邻的一个元素,对象指针也是如此. 本例中指针对象p加1时,指向下一个数组对象元素.
【例3.8】 本例说明如何经过对象指针来访问对象数组，使程序以相反的顺序显示对象数组的内容
#include <iostream.h>
class example{
public:
example(int n, int m)
{
x=n;
y=m;
}
int get_x()
{ return x;}
int get_y()
{ return y;}
private:
int x,y;
};
main()
{
example op[4]={
example(1,2),
example(3,4),
example(5,6),
example(7,8)
};
int i;
example *p;
p=&op[3]; // 取出最后一个数组元素的地址
for (i=0;i<4;i++)
{
cout<<p->get_x()<<‘ ‘;
cout<<p->get_y()<<"\n";
p--; // 指向前一个数组元素
}
cout<<"\n";
return 0;
}
7 8 5 6 3 4 1 2
指向类的成员的指针
类的成员自身也是一些变量、函数或者对象等。所以，也能够直接将它们的地址存放到一个指针变量中，这样就可使指针直接指向对象的成员，进而能够经过指针访问对象的成员。
可在类外定义指向类的成员的指针来控制对象的成员。
注意：
- 指向成员的指针只能访问公有数据成员和成员函数。
- 使用要先声明，再赋值，而后访问。
（1）指向数据成员的指针
- 声明： 类型说明符 类名:: *数据成员指针名
- 赋值： 数据成员指针名＝&类名:: 数据成员名
- 使用
- 对象名. *数据成员指针名
- 对象指针名->*数据成员指针名
【例3.9】 访问对象的公有数据成员的几种方式
#include<iostream.h>
class A{
public:
A(int i) { z=i; }
int z;
};
void main()
{
A ob(5);
A *pc1; // 声明一个对象指针pc1
pc1=&ob; // 给对象指针pc1赋值
int A∷*pc2; // 声明一个数据成员指针pc2 // ①
pc2=&A∷z; // 给数据成员指针pc2赋值 // ②
cout<<ob.*pc2<<endl; // 用成员指针pc2访问数据成员z
cout<<pc1->*pc2<<endl; // 用成员指针pc2访问数据成员z
cout<<ob.z<<endl; // 使用对象名访问数据成员z
}
（2）指向成员函数的指针
- 声明： 类型说明符 (类名∷ *指针名)(参数表);
- 赋值： 成员函数指针名 = 类名∷成员函数名;
- 使用
- (对象名.*成员函数指针名)(参数表);
- (对象指针名 -> *成员函数指针名) (参数表);
【例3.10】 访问对象的公有成员函数的几种方式
#include<iostream.h>
class Coord {
public:
Coord(int a=0,int b=0) { x=a; y=b; }
int getx() { return x; }
int gety() { return y; }
private:
int x,y;
};
void main()
{
Coord op(5,6);
Coord *pc1=&op;
int (Coord∷*pc_getx)();
pc_getx=Coord∷getx;
cout<<pc1->getx()<<endl;
cout<<op.getx()<<endl;
cout<<(op.*pc_getx)()<<endl;
cout<<(pc1->*pc_getx)()<<endl;
}