int main(void)

{

//Coordinate *p1 = NULL;//第一个点，指向NULL

//p1 = new Coordinate;//因为Coordinate是一个默认的构造函数所以可以没有参数

//Coordinate *p2 = new Coordinate();

//p1->m_iX = 10;//两种不同的赋值方法

//p1->m_iY = 20;

//(*p2).m_iX = 30;

//(*p2).m_iY = 40;

//cout << p1->m_iX + (*p2).m_iX << endl;//输出

//cout << p1->m_iY + (*p2).m_iY << endl;

//

//delete p1;

 //   p1 = NULL;

//delete p2;

//p2 = NULL;

/*************************************************************/

Coordinate p1;//从栈中实例化一个对象

Coordinate *p2 = &p1;//让p2指向p1，运用了取地址的符号

//然后就可以用p2来操作p1的数据成员和成员函数了

p2->m_iX = 10;

p2->m_iY = 20;

cout << p1.m_iX << endl;

cout << p1.m_iY << endl;

system("pause");

return 0;

}

#include<iostream>

#include<stdlib.h>

#include<string>

#include"Coordinate.h"

using namespace std;

/*对象数组

要求：

     定义Coordinate类

数据成员：m_iX和m_iY

分别从栈和堆中实例化长度为三的对象数组

给数组中的元素分别赋值

遍历（把数组中的所有元素访问一遍）两个数组*/

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; 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++)

{

//如果p没做++，则可以直接写成

//cout<<"p_x"<<p[j].m_iX<<endl;

//cout<<"p_y"<<p[j].m_iY<<endl;

cout << "p_x" << p->m_iX << endl;

cout << "p_y" << p->m_iY << endl;

p--;

}

p++;//使指针指向最初的那一段内存

delete []p;//在销毁他的时候我们希望他的每一个对象都执行他的析构函数

//如果不加中括号，销毁的时候只销毁第一个元素

p = NULL;

system("pause");

return 0;

}

1、为什么需要const成员函数？ 我们定义的类的成员函数中，常常有一些成员函数不改变类的数据成员，也就是说，这些函数是"只读"函数，而有一些函数要修改类数据成员的值。如果把不改变数据成员的函数都加上const关键字进行标识，显然，可提高程序的可读性。其实，它还能提高程序的可靠性，已定义成const的成员函数，一旦企图修改数据成员的值，则编译器按错误处理。 const成员函数和const对象

2、1. 常对象只能调用常成员函数。 2. 普通对象可以调用全部成员函数。 3. 当对一个对象调用成员函数时，编译程序先将对象的地址赋给this指针，然后调用成员函数，每次成员函数存取数据成员时，由隐含使用this指针。 4. 当一个成员函数被调用时，自动向它传递一个隐含的参数，该参数是一个指向这个成员函数所在的对象的指针。

this指针的作用就是：解决了参数和数据成员重名的问题，让计算机清楚是参数传给了数据成员； this指针一般都是系统默认调用，以防止在实例化对象调用成员函数的时候出现错误，保证一一对应，当数据成员和构造函数中的形参名字相同是，计算机会分不清楚谁给谁赋值，这是需要人工加上this指针，用来区别。

对象成员：一个对象作为另外一个类的数据成员

对象成员指针：一个对象的指针作为另外一个类的数据成员

1.对象成员指针的定义： 类名 * 指针名 是指针而不是对象

2.若存在对象成员指针1，2……。sizeof（指针1，指针2……）只计算各指针所

占内存的总和，不计算对象成员所占内存

对象成员指针如果在构造函数用 new 的方式从堆中申请内存实例化2个

Coordinate 对象，那这2个对象都是在堆中，而不在 Line 对象中，因为每个指

针占 4 个内存单元，因此 sizeof（Line） 只占 8 个内存单元，销毁 Line 的时

候，先销毁队中的内存，在释放 Line 本身的内存

常对象只能调用常成员函数。

普通对象既可以调用普通成员函数，也可以调用常成员函数。

常成员函数不能改变成员的值（因为不传入this指针）

对象成员指针：一个类的对象指针作为另外一个类的成员 在构造函数中从堆中该分配了内存，就需要在析构函数中释放掉内存 对象成员指针初始化时和对象成员方法相同，可以通过初始化列表进行初始化也可以普通刑事初始化 对象成员：Line 有两个Coor对象 一个Coor对象有2个int坐标成员 一个int类型在32位上占4字节 所以Coor占8个内存 Line占16个内存(32位) 对象成员指针:Line有两个Coor对象指针 一个Coor对象指针 指向Coor(含int 坐标成员)的内存 一个指针在32位上占4字节 64位占8字节 所以Line占8字节(32位) 释放顺序: 1、对象成员 因为Line包含Coor的内存 所以先释放Line 再释放Coor 2、对象成员指针 由于Line包含的只是Coor的指针 Coor的内存本身不再Line内 所以先释放Coor 再释放Line

对象成员在初始化的时候，它的调用顺序以及被销毁的时候它的相关调用顺序（例）如果坐标类有一个默认构造函数（不带参数），那么它就可以在实例化对象的时候不使用初始化列表，如果坐标类必须有参数传入，那么在实例化线段类的时候就必须要使用初始化列表的方式将相应的值传递给坐标类

用new实例化对象数组，在释放内存时如果不加中括号[]，销毁的只是第一个元素

1、this指针无需用户定义，是编译器自动产生的。 2、同一个类的两个对象的this指针指向不同位置的内存：对象各自的this指针指向各自对象的首地址，所以不同对象的this指针一定指向不同的内存地址 3、当成员函数的参数或临时变量与数据成员同名时，可以使用this指针区分同名的数据成员。 4、this指针也是指针类型，所以在32位编译器下也占用4个基本的内存单元，即sizeof(this)的结果为4。

this的值是对象本身地址；*this 就是对象arr1 1、 Array ... return *this 相当于： Array arrX = arr1; arrX是一个新的对象。即返回的this指针为另一个临时对象 2、 Array& ... return *this 相当于： Array & arrX = arr1; 此时arrX是arr1的别名。 3、 Array* ... return this 相当于： Array* arrX = this; 此时arrX的值 是地址，且是指向arr1的。用->访问或者*p. 访问

选中代码，按Ctrl+c+k=注释掉

demon.cpp中有include"Line.h"就包含了include"Coordinate.h"了，再写会出现类的重定义

默认构造函数：无参构造函数，有参构造函数切所有参数均进行默认这样的两种函数叫做默认构造函数。（切记，如果函数的参数没有全部进行默认则不叫默认构造函数。） 对象成员如果没有默认构造函数那么外部对象必须对对象成员进行初始化！

在对象内做数据成员的对象做叫做对象成员，而且在实例化对象时先执行对象成员的构造函数，然后执行外部对象的构造函数，在销毁时，先执行外部对象的析构函数，最后执行对象成员的析构函数，两个函数的执行顺序相反！