const 怎么还有你的出场。

深拷贝即是先申请一段内存，再在这段内存里进行复制操作把上一个对象数组的成员全部拷贝过来；

浅拷贝则直接把指针的地址复制给一个对象数组的第一个成员。

在释放内存时，浅拷贝就可能出问题。

动画控制函数封装

1. 常对象只能调用常成员函数，不能调用普通成员函数

2. //指向常对象的指针 = 常指针 = Coordinate const *pCoor;

3. //指向对象的常指针 = 指针常量 = Coordinate *const pCoor;

4. 普通对象能够调用常成员函数，也能够调用普通成员函数

5. 常指针和常引用都只能调用对象的常成员函数

6. 一个对象可以有多个对象常引用
   

指向常对象的指针 = 常指针 = Coordinate const *pCoor;

指向对象的常指针 = 指针常量  = Cooridnate *const pCoor; 

拷贝函数~

/*

常对象成员，常函数，常对象

要求：

     定义两个类：

Coordinate：数据成员：m_iX，m_iY

             成员函数：构造函数，析构函数，封装函数

Line：数据成员：点A,点B

       成员函数：构造函数，析构函数，封装函数，信息打印函数

*/

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

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

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

const 对象不能修改其成员变量，也就是说只能读不能写

为什么需要const成员函数？ 我们定义的类的成员函数中，常常有一些成员函数不改变类的数据成员，也就是说，这些函数是"只读"函数，而有一些函数要修改类数据成员的值。如果把不改变数据成员的函数都加上const关键字进行标识，显然，可提高程序的可读性。其实，它还能提高程序的可靠性，已定义成const的成员函数，一旦企图修改数据成员的值，则编译器按错误处理。 const成员函数和const对象 实际上，const成员函数还有另外一项作用，即常量对象相关。对于内置的数据类型，我们可以定义它们的常量，用户自定义的类也一样，可以定义它们的常量对象。例如，定义一个整型常量的方法为： const int i=1 ； 同样，也可以定义常量对象，假定有一个类classA，定义该类的常量对象的方法为： const classA a(2)； 这里，a是类classA的一个const对象，"2"传给它的构造函数参数。const对象的数据成员在对象生存期内不能改变。但是，如何保证该类的数据成员不被改变呢？ 为了确保const对象的数据成员不会被改变，在C++中，const对象只能调用const成员函数。如果一个成员函数实际上没有对数据成员作任何形式的修改，但是它没有被const关键字限定的，也不能被常量对象调用。

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;

}

Array.cpp

#include"Array.h"

#include<iostream>

using namespace std;

Array::Array()//构造函数

{

cout << "Array" << endl;

}

Array::Array(const Array& arr)//拷贝函数

{

m_iCount = arr.m_iCount;//拷贝

cout << "Array&" << endl;//加上&与前面的Array相区别

}

Array::~Array()//析构函数

{

cout << "~Array" << endl;

}

void Array::setCount(int count)//数据的封装

{

m_iCount = count;

}

int Array::getCount()

{

return m_icount;

}

主函数

int main(void)

{

Array arr1;

arr1.setCount(5);

Array arr2(arr1);

    cout << "arr2.m_iCount"<< arr2.getCount() << endl;

system("pause");

return 0;

}

输出如图

浅拷贝实践题目

生成A--生成B--生成线段——销毁线段——销毁B——销毁A

主要是证明了这个观点

Line *p = new Line(1,2,3,4);

Line::Line(int x1, int y1, int x2, int y2) :m_coorA(x1, y1), m_coorB(x2,y2)

Line(int x1,int y1,int x2,int y2);

Coordinate::Coordinate(int x,int y)

Coordinate(int x,int y);

在这些构造函数和析构函数中添加了参数，以便于证明这一观点。

对象指针先有指针然后指向数据，销毁先销毁数据。

demo.cpp

#include<iostream>

#include<stdlib.h>

#include<string>

#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();

delete p;

p = NULL;

system("pause");

return 0;

}

Line.cpp

#include"Line.h"

#include<iostream>

using namespace std;

Line::Line()

{

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;

}

Line.h

#include"Coordinate.h"

class Line

{

public:

Line();

~Line();

void setA(int x,int y);

void setB(int x,int y);

void printInfo();

private:

Coordinate m_coorA;

Coordinate m_coorB;

};

Coordinate.cpp

#include"Coordinate.h"

#include<iostream>

using namespace std;

Coordinate::Coordinate()

{

cout << "Coordinate()" << endl;

}

Coordinate::~Coordinate()

{

cout << "~Coordinate()" << 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;

}

Coordinate.h

class Coordinate

{

public:

Coordinate();

~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类

数据成员：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;

}

执行顺序！