c++学习——（6）数组对象与对象成员

一.对象数组

1.对象数组的实例化

图中有两种实例化方法，前一个是在栈上，后一个是在堆上。

2.两种实例化方式的区别

在栈区实例化数组：在栈区实例化数组，由系统自动分配内存空间，并自动回收。

在堆上实例化数组：自行申请还得自行释放，这一点要注意。

3.代码实例

main函数代码：

#include<iostream>
#include<stdlib.h>
#include<string>
#include"Coordinate.h"
using namespace std;

/****************************************************************/
/*对象数组
要求：
	定义Coordinate类
	数据成员：m_iX和m_iY
	分别从栈和堆中实例化长度为3的对象数组
	给数组中的元素分别赋值
	遍历两个数组
*/
/****************************************************************/
int main(void)
{
	Coordinate coor[3];
	coor[0].m_iX = 3;
	coor[0].m_iY = 5;

	Coordinate *p = new Coordinate[3];
	p->m_iX = 7;
	p[0].m_iY = 9;

	p++;//p=p+1 p+=1
	p->m_iX = 11;
	p[0].m_iY = 13;

	p[1].m_iX = 15;
	p++;
	p->m_iY = 17;

	for (int i = 0; i < 3; i++)
	{
		cout << "coor_x" << coor[i].m_iX << endl;
		cout << "coor_y" << coor[i].m_iY << endl;
	}

	for (int j = 0; j < 3; j++)
	{
		cout << "p_x" << p->m_iX << endl;
		cout << "p_y" << p->m_iY << endl;
		p--;  //注意由于前面的赋值操作把指针p已经指向第三个元素，所有我们此次轮询是倒着打印的。
	}
	p++;    //前面的p--操作把指针已经指向p[0]更前面的未知区域，此处一定注意要加一否则会出现不可 
             //预料的问题
	delete []p;
	p = NULL;

	system("pause");
	return 0;

}




Coordinate.h代码：

#include<string>
using namespace std;

class Coordinate
{
public:
	Coordinate();
	~Coordinate();

public:
	int m_iX;
	int m_iY;
};




coordinate.cpp文件：

#include<iostream>
#include<stdlib.h>
#include<string>
#include "Coordinate.h"
using namespace std;


Coordinate::Coordinate()
{
	cout << "Coordinate" << endl;
}

 Coordinate::~Coordinate()
{
	cout << "~Coordinate" << endl;
}

结果展示：我们明显可以看到，前面栈中实例化的只初始化了一对数据，其他的则是系统随机给的，是顺序打印。堆中实例化的对象，是倒着打印出来的，原理可以看代码注释。我们从最后三行的结果可以看出调用了三次析构函数，原因在于delete []p;将我们实例化的三个对象都删除掉了，如果不加[]则只会删除一个，这一点要注意。

二.对象成员

1.对象成员的定义

     在c++中对象中含有其他对象的现象十分常见，举一个简单的例子。

如图所示我们要定义在直角坐标系中的一条线段，那么我们至少包含两个类。

2.对象成员的实例化以及销毁

   在这种对象最为数据成员的情况下，当实例化line对象时到底是先实例化Coordinate对象还是line对象呢？当销毁line对象时又先销毁哪一个呢？

结论是：当我们实例化一个line对象时先实例化A点在再实例化B点，最后再实例化line对象；销毁的时候是相反的，先销毁line对象再销毁B点再销毁A点。

3.代码展示

main函数文件：

#include<iostream>
#include<stdlib.h>
#include<string>
//#include"Coordinate.h"
#include"Line.h"
using namespace std;
/****************************************************************/
/*对象成员
要求：
	定义两个类：
	坐标类：Coordinate
	数据成员：横坐标m_iX、纵坐标m_iY
	成员函数：构造函数，析构函数，数据封装函数
	线段类：Line
	数据成员：点A m_coorA、点B m_coorB
	成员函数：构造函数，析构函数，数据封装函数，信息打印函数
*/
/****************************************************************/

int main(void)
{
	Line *p = new Line(1,2,3,4);
	p->printInfo();
	delete p;
	p = NULL;
	system("pause");
	return 0;

}




Line.h和Line.cpp文件：

#include<string>
#include"Coordinate.h"
using namespace std;

class Line
{
public:
	Line(int x1,int y1,int x2,int y2 );
	~Line();
	void setA(int x, int y);
	void setB(int x, int y);
	void printInfo();
private:
	Coordinate m_coorA;
	Coordinate m_coorB;
};




#include<iostream>
#include "Line.h"


Line::Line(int x1, int y1, int x2, int y2):m_coorA(x1,y1),m_coorB(x2,y2)
{
	cout << "Line()" << endl;
}

Line::~Line()
{
	cout << "~Line()" << endl;
}

void Line::setA(int x, int y)
{
	m_coorA.setX(x);
	m_coorA.setY(y);
}

void Line::setB(int x, int y)
{
	m_coorB.setX(x);
	m_coorB.setY(y);
}

void Line::printInfo()
{
	cout << "(" << m_coorA.getX() << "," << m_coorA.getY() << ")" << endl;
	cout << "(" << m_coorB.getX() << "," << m_coorB.getY() << ")" << endl;
}




Coordinate.h和Coordinate.cpp文件：

class Coordinate
{
public:
	Coordinate(int x,int y);
	~Coordinate();
	void setX(int x);
	int getX();
	void setY(int y);
	int getY();
private:
	int m_iX;
	int m_iY;
};


#include<iostream>
#include<stdlib.h>
#include<string>
#include "Coordinate.h"
using namespace std;


Coordinate::Coordinate(int x,int y)
{
	m_iX = x;
	m_iY = y;
	cout << "Coordinate" <<m_iX<<","<<m_iY<< endl;
}

 Coordinate::~Coordinate()
{
	cout << "~Coordinate" <<m_iX << "," << m_iY << endl;
}
 void Coordinate::setX(int x)
 {
	 m_iX = x;
 }

 int Coordinate::getX()
 {
	 return m_iX;
 }

 void Coordinate::setY(int y)
 {
	 m_iY = y;
 }

 int Coordinate::getY()
 {
	 return  m_iY;
 }

程序运行结果显示：先实例化的是A点然后实例化B点最后才是线段，先销毁的是线段然后再B点最后才是A点。（打印表示构造函数和析构函数的运行），也证实了前面的结论。

还有点需要注意的是：如果对象A中有对象成员B，对象B没有默认构造函数，那么对象A必须在初始化列表中初始化对象B。