C++动态组类，一个类中含有另一个类的对象,对象指针等

详情看每句的注释！！

#include <iostream>
using namespace std;
class Point {
public:
	Point() :x(0), y(0) { cout << "调用无参默认构造函数" << endl; }
	Point(int x1, int y1) :x(x1), y(y1) { cout << "调用含参构造函数"<<endl; }
	Point(const Point &point)
	{
		x = point.x;
		y = point.y;
		cout << "调用point复制构造函数" << endl;
	}
	~Point() { cout << "调用析构函数" << endl; }
	int getX() { return x; }
	int getY(){ return y; }
	void setX(int x1) { x = x1; }
	void setY(int y1) { y = y1; }
private:
	int x, y;
};
class AofPoint {
public:
	AofPoint(int size):size(size)
	{
		p = new Point[size];
		cout << "调用afp构造函数" << endl;
	}
	~AofPoint()//把释放空间delete[] p;放在析构函数体，利用return之前会自动调用析构函数，实现自动释放
	{
		delete[] p;
		cout << "调用afp析构函数" << endl;
	}
	AofPoint(const AofPoint &afp)
	{
		cout << "调用afp复制构造函数" << endl;
		size = afp.size;
		p = new Point[size] ;
		for(i=0;i<size;i++)
		{
		   p[i]=afp.p[i];
		}
	}//深层复制
	Point& visit_point(int index)//采取引用&，返回的是对象别名，实现数据双向变化，若不加&，得到的是副本
	{
		return p[index];
	}
	Point* fpvisit_point(int index)//返回的是对象指针，实现数据双向变化
	{
		return  &p[index];
	}
private:
	Point *p;
	int size;
};
int main()
{
	AofPoint afp(4);//创建afp对象时，也设置了动态对象数组的大小
	cout << "使用返回值是对象的引用的函数，返回的是对象的引用(别名)，用对象.成员，调用对象的函数成员" << endl;
	for (int i = 0; i < 4; i++)
	{
		afp.visit_point(i).setX(i);
		afp.visit_point(i).setY(i);
	}
	for (int i = 0; i < 4; i++)
	{
		cout << "p["<<i<<"].x="<< afp.visit_point(i).getX();
		cout << "p[" << i << "].y=" <<afp.visit_point(i).getY() << endl;;
	}
	cout << "使用返回值是对象指针的函数，返回的是对象指针，用—>调用对象的函数成员" << endl;
	for (int i = 0; i < 4; i++)
	{
		afp.fpvisit_point(i)->setX(i+1);
		afp.fpvisit_point(i)->setY(i+1);
	}
	for (int i = 0; i < 4; i++)
	{
		cout << "p[" << i << "].x=" << afp.fpvisit_point(i)->getX();
		cout << "p[" << i << "].y=" << afp.fpvisit_point(i)->getY() << endl;;
	}
}

运行结果：

调用无参默认构造函数
调用无参默认构造函数
调用无参默认构造函数
调用无参默认构造函数
调用afp构造函数
使用返回值是对象的引用的函数，返回的是对象的引用(别名)，用对象.成员，调用对象的函数成员
p[0].x=0p[0].y=0
p[1].x=1p[1].y=1
p[2].x=2p[2].y=2
p[3].x=3p[3].y=3
使用返回值是对象指针的函数，返回的是对象指针，用—>调用对象的函数成员
p[0].x=1p[0].y=1
p[1].x=2p[1].y=2
p[2].x=3p[2].y=3
p[3].x=4p[3].y=4
调用析构函数
调用析构函数
调用析构函数
调用析构函数
调用afp析构函数
请按任意键继续. . .

结论：

Point visit_point(int index)//返回的是对象，得到的是对象副本
	{
		return p[index];
	}
Point& visit_point(int index)//返回的是对象别名，采取引用&，实现数据双向变化，若不加&，得到的是副本
	{
		return p[index];
	}
Point* fpvisit_point(int index)//返回的是对象指针，实现数据双向变化
	{
		return  &p[index];
	}

1，以前见过这中语句：afp.visit_point(i).setX(i);不知其意
现在懂了：组合类的对象调用组合类的函数，该函数返回的是部件类的对象Point visit_point(int index)或者对象的引用(别名)Point& visit_point(int index)，然后再通过 部件类的对象.成员 调用部件对象的函数成员。
2，类似afp.fpvisit_point(i)->setX(i+1);
解释：组合类的对象调用组合类的函数，该函数返回的是指向部件类的对象的指针，即组合类的该函数是指针函数，部件类的对象的指针通过“—>”调用部件类的成员，afp.fpvisit_point(i)->setX(i+1);
3，如果是对象，就对象.成员
如果是对象指针，就指针名—>.成员
不要混淆写成 ： 指针名.成员
对象—>.成员
返回对象： return 对象名; 对应函数类型写为 类名 函数名
返回对象指针： return &对象名; 对应函数类型 写为 类名* 函数名