/****************方法1************************/
Coordinate *p = NULL;
p = new Coordinate(3,5);   //或者：Coordinate *p = new coordinate(3,5);
    // 打印坐标
cout <<"("<<p->m_iX<<","<<p->m_iY<<")"<< endl;
    // 销毁对象指针
delete p;
p = NULL;
/****************方法2************************/
Coordinate p1(3,5);
Coordinate *p2 = &p1;
    // 打印坐标
cout <<"("<<p2->m_iX<<","<<p2->m_iY<<")"<< endl;
    // 销毁对象指针
delete p2;
p2 = NULL;

/******************coordinate.h文件*************************/
// stdafx.h : 标准系统包含文件的包含文件，
// 或是经常使用但不常更改的
// 特定于项目的包含文件
//
#pragma once
class coordinate
{
public:
coordinate();
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;
};
/******************Line.h文件*************************/
#pragma once
#include"coordinate.h"
class Line
{
public:
Line();
Line(int x1, int y1, int x2, int y2);
//Line(const Line& line);
~Line();
void setA(int x1, int y1);
void setB(int x2, int y2);
void printInfo();
private:
coordinate m_coorA;
coordinate m_coorB;
};
/******************coordinate.cpp文件*************************/
#include<iostream>
#include "coordinate.h"
using namespace std;
coordinate::coordinate()
{
cout << "coordinate()" << endl;
}
coordinate::coordinate(int x, int y):m_iX(x),m_iY(y)
{
cout << "coordinate(int x,int y);" << 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_iX = y;
}
int coordinate::getY() {
return m_iY;
}
/******************Line.cpp文件*************************/
// stdafx.cpp : 只包括标准包含文件的源文件
// test1.pch 将作为预编译头
// stdafx.obj 将包含预编译类型信息
#include<iostream>
#include<stdlib.h>
#include "Line.h"
using namespace std;
Line::Line()
{
cout << "Line()" << endl;
}
Line::Line(int x1,int y1,int x2,int y2):m_coorA(x1,y1),m_coorB(x2,y2)
{
cout << "Line(int x1,int y1,int x2,int y2)" << endl;
}
/*Line::Line(const Line& line) {
m_coorA = line.m_coorA;
m_coorB = line.m_coorB;
}
*/
Line::~Line()
{
cout << "~Line()" << endl;
}
void Line::setA(int x1, int y1) {
m_coorA.setX(x1);
m_coorA.setY(y1);
}
void Line::setB(int x2, int y2) {
m_coorB.setX(x2);
m_coorB.setY(y2);
}
void Line::printInfo() {
cout << "(" << m_coorA.getX() << "," << m_coorA.getY() << ")" << endl;
cout << "(" << m_coorB.getX() << "," << m_coorB.getY() << ")" << endl;
}
/******************main.cpp文件*************************/
// test1.cpp : 定义控制台应用程序的入口点。
//
#include<iostream>
#include<stdlib.h>
#include"Line.h"
using namespace std;
int main() {
Line *p = new Line(1,2,3,4);
p->printInfo();
//cout << coordinate::getX<< endl;
delete p;
p = NULL;
system("pause");
return 0;
}

/******************array.h文件*************************/
class Array{
public:
    Array(int _cout);
    ~Array();
    Array(const Array &arr);
    void setCount(int _cout);
    int getCount();
    void printAddr();
    void printArr();
private:
    int m_iCount;
    int *m_pArr;
};
/******************array.cpp文件*************************/
#include<iostream>
#include"array.h"
using namespace std;
Array::Array(int _count)
{
    m_iCount = _count;
    m_pArr = new int[m_iCount];
    for(int i = 0;i<m_iCount;i++){
        m_pArr[i] = i;
    }
    cout<<"Array"<<endl;
}
Array::~Array()
{
    delete []m_pArr;
    m_pArr = NULL;
    cout<<"~Array"<<endl;
}
Array::Array(const Array &arr)
{
    //m_iCount = arr.m_iCount;
    //m_pArr = arr.m_pArr;
    m_iCount = arr.m_iCount;
    m_pArr = new int[m_iCount];
    for(int i = 0;i<m_iCount;i++){
        m_pArr[i] = arr.m_pArr[i];
    }
    cout<<"Array&"<<endl;
}
void Array::setCount(int _count)
{
    m_iCount = _count;
}
int Array::getCount()
{
    return m_iCount;
}
void Array::printAddr(){
    cout<<"Address_value:"<<m_pArr<<endl;
}
void Array::printArr(){
    for(int i = 0;i<m_iCount;i++){
        cout<<m_pArr[i]<<endl;
    }
}
/******************demo.cpp文件*************************/
#include<iostream>
#include<stdlib.h>
#include"array.h"
using namespace std;
int main(void){
    Array arr1(5);
    //arr1.setCount(3);
    Array arr2(arr1);
    //cout<<"arr2.m_iCount "<<arr2.getCount()<<endl;
    //arr1.printAddr();
    //arr2.printAddr();
    arr1.printArr();
    arr2.printArr();
    system("pause");
    return 0;
}

走迷宫案例：

左手原则：想象自己在家左手扶着墙一直走。

右手原则：想象自己在家右手扶着墙一直走。

要建立两个类，迷宫类和人

成就感源于克服困难

码上大佬的代码，致敬！

#include <iostream>

#include <Windows.h>

#include <string>

#include <process.h>

#include <Windows.h>

using namespace std;

/* https://zhidao.baidu.com/question/1755742141667975828.html 

设定初始面向 East ( 如果是右手抹墙则是 West）

1如果当前格为第一排，则说明当前格为终点，结束。

2根据当前格的数据，找到下一步需要面向的方向， 方法是，如果当前方向上有墙，则顺时针（右手抹墙则逆时针）转身，重复这一步骤直到面向的方向上可以行走

3沿当前方向走一步

4逆时针（右手抹墙则顺时针）转身一次，使当前面对方向为第3步之后的左手（或右手）方向， 然后回到步骤1

*/

//墙体和路常量

#define WOLD  "■"

#define ROLD  "  "

//迷宫大小常量

const int X = 8;

const int Y = 8;

//计步器

int count = 0;

//方向枚举

enum direction{

N = 0,

S = 1,

W = 2,

E = 3

};

//地图类

class MazeMap {

public:

MazeMap() {}

void coutMap(string map[X][Y]) { //构造地图

for (int i = 0; i < X; i++) {

for (int j = 0; j < Y; j++) {

cout << map[i][j] ;

}

cout << endl;

}

}

};

//人类类

class Human {

public:

Human() :x(6), y(6), man("☆"), direction(W){} //默认人初始化为第一个位置

Human(string _man) :x(6), y(6), man(_man), direction(W){} //可以设置人的标识符

//横纵坐标

int x;

int y;

//人物标识

string man;

//方向

int direction;

// 移动方法

void humanMove(string map[X][Y], Human *man) {

MazeMap *mazeMap = new MazeMap;

map[man->x][man->y] = man->man;

mazeMap->coutMap(map);

cout << "READY?(Q:y/n)" << endl;

char flag = 'n';

cin >> flag;

//单向寻路原则  右手抹墙，初始朝向为W

if (flag == 'y') {

do

{

turnBack(map, man);

move(map, man);

Sleep(1000);

system("cls");

mazeMap->coutMap(map);

} while (finsh(man));

cout << "YOU WIN!!!" << endl;

}

else {

cout << "YOU ARE A LOSE!!!" << endl;

}

delete mazeMap;

mazeMap = NULL;

}

//确定方向 如果方向上有墙就逆时针转一下

void turnBack(string map[X][Y],Human *man) {

static int cache = 0;

if (man->direction == N) {

if (map[man->x - 1][man->y] == WOLD) {

man->direction = W;

cache++;

turnBack(map, man);

}

cache = 0;

return;

}

if (man->direction == S) {

if (map[man->x+1][man->y] == WOLD) {

man->direction = E;

cache++;

turnBack(map, man);

}

cache = 0;

return;

}

if (man->direction == W) {

if (map[man->x][man->y-1] == WOLD) {

man->direction = S;

cache++;

turnBack(map, man);

}

cache = 0;

return;

}

if (man->direction == E) {

if (map[man->x][man->y+1] == WOLD) {

man->direction = N;

cache++;

turnBack(map, man);

}

cache = 0;

return;

}

if (cache == 4) {

cache = 0;

return;

}

}

//移动一格  后顺时针调转方向

void move(string map[X][Y], Human *man) {

if (man->direction == N) {

man->direction = E;

map[man->x - 1][man->y] = man->man;

map[man->x][man->y] = ROLD;

man->x -= 1;

}else if (man->direction == S) {

man->direction = W;

map[man->x + 1][man->y] = man->man;

map[man->x][man->y] = ROLD;

man->x += 1;

}else if (man->direction == W) {

man->direction = N;

map[man->x][man->y - 1] = man->man;

map[man->x][man->y] = ROLD;

man->y -= 1;

}else if(man->direction == E) {

man->direction = S;

map[man->x][man->y + 1] = man->man;

map[man->x][man->y] = ROLD;

man->y += 1;

}

return;

}

//判断是否完成

bool finsh(Human *man) {

if (man->x == 0)

return false;

return true;

}

};

int main(void) {

string map[X][Y] = { {WOLD,ROLD,WOLD,WOLD,WOLD,WOLD,WOLD,WOLD},

{WOLD,ROLD,ROLD,ROLD,ROLD,ROLD,WOLD,WOLD},

{WOLD,WOLD,WOLD,WOLD,WOLD,ROLD,ROLD,WOLD},

{WOLD,ROLD,ROLD,ROLD,ROLD,ROLD,WOLD,WOLD},

{WOLD,WOLD,ROLD,WOLD,ROLD,ROLD,WOLD,WOLD},

{WOLD,WOLD,ROLD,ROLD,ROLD,WOLD,WOLD,WOLD},

{WOLD,WOLD,WOLD,WOLD,ROLD,ROLD,ROLD,WOLD},

{WOLD,WOLD,WOLD,WOLD,WOLD,WOLD,WOLD,WOLD} };

Human *man = new Human("⊙");

man->humanMove(map,man);

delete man;

man = NULL;

return 0;

}

Coordinate * const pCoor = &coor1 : 这种方式定义的常指针“只能指向coor1，但可以调用coor1的不同的函数”；（拥有读写权限） const Coordinate *pCoor = &coor1  : 只能调用coor1的“常成员函数”。（只拥有读权限）

常对象引用与常对象指针 

const Coordinate& coor2 ; const Coordinate *p; 只具有读权限，所以只能调用常成员函数。调用成员函数过程其实就是一个隐式的this指针，普通成员函数传递的是Coordinate *this指针，而常成员函数传递的是常指针const Coordinate *this(只具有读权限)。 注意，Coordinate * const p，该指针表明指针地址为常量，指针所指向的对象值是可以改变的，也就是说该指针具有读写权限

为什么需要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关键字限定的，也不能被常量对象调用。

用const修饰对象成员，对象成员就变成了常对象成员 用const修饰成员函数，成员函数就变成了常成员函数。const要放在函数的最后， 一旦初始化就不能再修改，const就是干这个的，长对象成员用初始化列表初始化 函数里看着没有参数，实际上隐藏着this指针。常成员函数中隐藏的是常this指针,常指针指向的数据不允许被修改 例如：void Coordinate::changeX(){m_iX = 10;}即为void Coordinate::changeX(Coordinate *this){this->m_iX = 10;} void Coordinate::changeX()const{m_iX = 10;}即为void Coordinate::changeX(const Coordinate *this){this->m_iX = 10;}这里的m_iX = 10;的写法是错误的，this已经是常指针,通过常指针是无法修改值的 void changeX();与void changeX() const互为重载 要调用const修饰的常成员函数，实例化对象时，必须用const来修饰对象，const写在最前面

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. 访问

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

This 表示对象的地址，可以访问到自身对象的数据成员 This 代表当前自身的对象，谁调用 Array 构造对象，然后 This 就代表那个对象取代那个对象，也就是  Array arr1； Array arr1；arr1.setLen（5）的时候，{this -> len = len}  中 this 就是代表了 arr1 对象，会取代 this ，而 this 其实是对象的地址，也就是指针，{this -> len = len} 就代表是 { arr1.len = len; },从而标记区别了数据成员和参数。

（1）32位的编译环境，一个指针占4个字节，1一个字节就是一个基本的内存单元，1Byte = 8 bit,即一个内存单元里可以存储2的8次方不同情况的高低电平。<br> （2）因为Line这个类中有，两个对象成员指针，所以占了8个字节。<br> （3）sizeof()函数返回的是整数，单位为“字节”. （4）64位的是32位的两倍

对象成员：一个对象作为另外一个类的数据成员<br><br><br> 对象成员指针：一个对象的指针作为另外一个类的数据成员<br><br> 1.对象成员指针的定义： 类名 * 指针名 是指针而不是对象<br> 2.指针在32位编译器下占4个基本内存单元<br><br> 3.若存在对象成员指针1，2……。sizeof（指针1，指针2……）只计算各指针所占内存的总和，不计算对象成员所占内存<br> 对象成员指针如果在构造函数用 new 的方式从堆中申请内存实例化2个 Coordinate 对象，那这2个对象都是在堆中，而不在 Line 对象中，因为每个指针占 4 个内存单元，因此 sizeof（Line） 只占 8 个内存单元，销毁 Line 的时候，先销毁队中的内存，在释放 Line 本身的内存

定义一个坐标类，在堆上实例化坐标对象，并给出坐标（3，5），然后打印坐标信息，销毁坐标对象。

结果如图：

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;

}