【对象的常指针和常引用】

Coordinate coor1(1,2);
Coordinate coor0(3,4);
const Coordinate &coor2=coor1;//常引用
const Coordinate *pCoor1=&coor1;//常指针
Coodinate *const pCoor2=&coor1;  //pCoor2指针不能指向其他对象，但是所指向对象的内容是可变的

常对象成员，用初始化列表初始化

private：
    const Coordinate m_CoorA;
Line::Line(int x,int y):m_CoorA(x,y){...};

常成员函数

public:
    Coordinate(int x,int y);
    void changeX() const; //在常成员函数中，不能修改数据成员的值
    void changeX();   //这两个函数互为重载

【调用常成员函数】实例化时

const Coordinate coor1(3,5);//常对象
coor1.changeX();  //此处调用的是常成员函数changeX() const;

Coordinate coor2(2,4);//普通
coor2.changeX();  //此处调用的是普通成员函数changeX();

Array Array::printInfo(){   //要求返回值为一个对象
    return *this;     //this是一个指针，*this代表一个对象
}

*this返回的对象是另外的一个对象（不是Array实例化的arr1），一个临时对象，要想让返回的对象就是arr1，需要加【引用】的符号【&】

Array& Array::printInfo(){
    return *this;
}

在main中，如果用了Array&，则可以通过以下方法改变len的值

Array arr1(10);
arr1.printInfo().setLen(5); //两个点连用，可以把两个方法串起来

或者用同样的Array&方法改造setLen()，则可以：

Array arr1(10);
arr1.printInfo().setLen(5).printInfo();//第一个printInfo打印出10，第二个打印出5

【还可以通过指针来声明】：

Array* Array::printInfo(){
    return this;  //类型已经是指针，此处用this，不加星号
}

【用Array* 时，在main中应该：】

Array arr1(10);
arr1.printInfo()->setLen(5)->printInfo();//指针用“->”符号而不用“.”

【this指针的地址=实例化后的arr1的地址：】

cout<<this<<" "<<&arr1<<endl;  //打印出来的这两个值完全相同

【this指针】指向对象自身数据的指针

Array arr1实例化一个对象，则this代表&arr1【arr1的地址】

public：
    Array(int len){this->len=len;}
private:
    int len;

编译器编译时，其实给每个参数列表都加了this指针，为了方便访问数据

对象成员指针：初始化

1、初始化列表，可以赋值为null

Line::Line():m_pCoorA(NULL),m_pCoorB(NULL){
...
}

2、普通初始化

Line::Line(){
    m_pCoorA=NULL;
    m_pCoorB=NULL;
}

3、指向某个对象

Line::Line(){    
    m_pCoorA=new Coordinate(1,3);
    m_pCoorB=new Coordinate(2,4);
}
Line::~Line(){
    delete m_pCoorA;
    delete m_pCoorB;
}

【与对象成员的不同】

sizeof（line）

若line中是两个对象成员，则占8x2=16个内存单元

若line中是两个对象成员指针，则占4x2=8个【*m_pCoorA和B各占4个，而A和B申请到的m_iX和Y（共4个）并不在line的内存中，而在堆中，因此释放内存的时候要先释放堆中的内存，再释放line的内存】

Coordinate p1;  //在栈中实例化一个对象p1
Coordinate *p2=&p1;  //p2指针指向p1的地址
p2->m_iX=19;
(*p2).m_iY=22;
cout << p1.m_iX <<" "<<p1.m_iY<<endl; //可以通过p2操纵p1的相关内存

Coordinate *p=new Coodinate;
p->m_iX=20;  //(*p).m_iX=20;
p->m_iY=45;  //(*p).m_iY=45;

浅拷贝只是简单的值拷贝，在拷贝堆上对象时，只是将引用拷贝过去，在销毁时，同一块堆上内存被释放两次报错。 

深拷贝会将堆上对象的值也进行拷贝，在销毁时，是不同的堆上内存分别进行销毁。

public:
    Coordinate();
private:
    int m_iX;
    int m_iY;
int main(){
    Coordinate coorArr[2];
    coorArr[1].m_iX=1;
    coorArr[1].m_iY=3;
}

当构造函数有参数时

public:
    Coordinate(int x,int y):m_iX(x),m_iY(y);
private:
    int m_iX;
    int m_iY;
int main(){
    Coordinate coorArr[2]{
        Coordinate(1,2),Coordinate(3,4)
    };
}

Line.h

public:
    void setA(int x,int y);
    void setB(int x,int y);
private:
    Coordinate m_coorA;
    Coordinate m_coorB;

Line.cpp

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

Coordinate.h

public:
    void setX(int x);
    int getX();
    void setY(int y);
    int getY();
private:
    int m_iX;
    int m_iY;

Coordinate.cpp

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;
}

【对象成员】对象作为数据成员。

先创建小的（对象成员），再创建大的（对象）；销毁时相反

实例化一个数组时，数组中每一个对象都执行了构造函数，因此销毁时每个对象都要执行析构函数：delete []p

如果没有"[]"，则只销毁第一个对象（只执行一次析构函数）

实例化数组：

Coordinate coord[3];  //在栈中
coord[1].m_iX = 10;
Coordinate *p = new Coordinate[3]; //在堆中
p[0].m_iY = 20;    //也可以通过指针 p->m_iY = 20; 
delete []p;
p=NULL;