7- C++远征之封装篇（下）-学习笔记
C++远征之封装篇（下）
c++封装概述
下半篇依然围绕类 & 对象进行展开ios
将本来学过的简单元素融合成复杂的新知识点。c++
- 对象 + 数据成员 = 对象成员(对象做为数据成员)
- 对象 + 数组 = 对象数组(一个数组中的每一个元素都是对象)
- 深拷贝 & 浅拷贝 (对象之间彼此赋值，彼此拷贝)
- 对象指针(操做对象) & 对象指针成员
- this指针
- const + 对象 -> 常对象
- const + 函数 -> 常成员函数
- const + 对象成员 -> 常对象成员
设计了一个精巧的案例，走迷宫。
c++ 对象数组
如何实例化一个对象？实例化对象对于程序是很重要的，只有实例化了对象才能访问成员函数和数据成员。算法
某些状况下咱们每每须要实例化一组对象。好比:咱们想实例化出一个50人的班的学生。数组
一个坐标只能表明一个点，若是咱们要想定义一个矩形。定义四个点，四个点的连线造成矩形。
这四个点能够定义为一个数组，每一个点就是一个对象。架构
对象数组: 坐标类函数
class Coordinate
{
public:
int m_iX; // x坐标
int m_iY; // y坐标
}
int main()
{
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;
return 0;
}
栈区实例化对象数组，会分配相应的内存，系统会自动管理。每个内存中保存着x,y
堆区分配相应内存，p 与 p[0] 是等价的。
C++对象数组实践代码
2-2-InstanceArray动画
Coordinate.hthis
class Coordinate
{
public:
Coordinate();
~Coordinate();
public:
int m_iX;
int m_iY;
};
coordinate.cpp编码
#include <iostream>
#include "Coordinate.h"
using namespace std;
Coordinate::Coordinate()
{
cout << "Coordinate" << endl;
}
Coordinate::~Coordinate()
{
cout << "~Coordinate" << endl;
}
main.cppspa
#include <stdlib.h>
#include <iostream>
#include <string>
#include "Coordinate.h"
using namespace std;
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->m_iX = 11;
p[0].m_iY = 13;//此时由于上面p++。p已经指向第二个地址了
p[1].m_iX = 15;//此时p指向第三个元素
p++;
p->m_iY = 17;//此时p指向第三个元素
for (int i = 0; i < 3; i++)
{
cout << coor[i].m_iX << " coor x&y " << coor[i].m_iY << endl;
}
for (int j = 0; j < 3; j++)
{
//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++;//由于上面p=-1时才退出了循环。所以释放时已经不是原来那段内存了。
delete []p;
p = NULL;
system("pause");
return 0;
}
遍历就是打印出数组中每一个元素的信息。
delete 销毁堆中对象数组，显示了三次的析构函数调用。 系统自动管理的栈中销毁，在咱们敲回车时能够看到，也一样调用了三次。
注意让p归位本来位置以后，再执行删除。
c++数组对象实践(二)
以前咱们讲使用了new，就要配套的使用delete。
若是new的是一个数组，那么delete时就要加中括号。
但是，为何数组对应的delete就要加中括号呢?
- 当实例化一个数组时其实数组中的每个对象都执行了它的构造函数。
- 在销毁的时候，咱们也但愿他们(每一个对象)都执行本身的析构函数
- 若是不加中括号，则只销毁第一个元素。
delete p;//将中括号去掉以后，则只销毁当前指针指向的内存,只执行一次析构函数
能够看到只执行了一次析构函数。
对象成员
前面讲的都是比较简单的对象，数据成员都是基本的数据类型。
- 对象中包含其余对象(对象成员)
- 笛卡尔坐标系
以坐标系中的一个线段为例，起点A(2,1),终点B(6,4).
定义一个线段类，每一个线段都有一个起点，一个终点。
点坐标的定义:
class Coordinate
{
public:
Coordinate();
private:
int m_iX;
int m_iY;
}
线段的定义:
class Line
{
public:
Line();
private:
Coordinate m_coorA;
Coordinate m_coorB;
}
实例化描述线段
int main(void)
{
Line *p = new Line();
delete p;
p = NULL;
return 0;
}
结论：
当咱们实例化一个line对象时，会先实例化a坐标点，再实例化b坐标点，当这两个对象实例化完成以后再实例化line对象当销毁时正好与建立相反，先销毁line再销毁b，最后销毁a
好比造汽车->零件->图纸; 拆汽车->图纸->零件
以上状况构造函数都没有参数,坐标类的构造函数实际上是须要有参数的。
class Coordinate
{
public:
Coordinate(int x, int y);
private:
int m_iX;
int m_iY;
}
class Line{
public:
Line(int x1,int y1, int x2,int y2);
private:
Coordinate m_coorA;
Coordinate m_coorB;
}
若是直接写成以下会出问题
int main(void)
{
Line *p = new Line(2,1,6,4);
delete p;
p = NULL;
return 0;
}
由于传进去，并无赋值给里面的对象成员。
要对代码进一步改造：为line的构造函数配备初始化列表
Line(int x1,int y1, int x2,int y2):m_coorA(x1,y1),m_coorB(x2,y2)
{
cout << "Line" << endl;
}
c++对象成员实践(一)
2-6-ObjectMember
Coordinate.h ：
class Coordinate
{
public:
Coordinate();
~Coordinate();
public:
int getX();
void setX(int x);
int getY();
void setY(int y);
private:
int m_iX;
int m_iY;
};
Coordinate.cpp ：
#include <iostream>
#include "Coordinate.h"
using namespace std;
Coordinate::Coordinate()
{
cout << "Coordinate" << endl;
}
Coordinate::~Coordinate()
{
cout << "~Coordinate" << endl;
}
int Coordinate::getX() {
return m_iX;
}
void Coordinate::setX(int x) {
m_iX = x;
}
int Coordinate::getY(){
return m_iY;
}
void Coordinate::setY(int y) {
m_iY = y;
}
Line.h :
#include "Coordinate.h"
class Line {
public:
Line();
~Line();
void setCoorA(int x, int y);
void setCoorB(int x, int y);
void printInfo();
private:
Coordinate m_coorA;
Coordinate m_coorB;
};
Line.cpp :
#include <iostream>
#include "Line.h"
using namespace std;
Line::Line() {
cout << "Line()" << endl;
}
Line::~Line() {
cout << "~Line()" << endl;
}
void Line::setCoorA(int x, int y) {
m_coorA.setX(x);
m_coorA.setX(y);
}
void Line::setCoorB(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;
}
main.cpp
#include <stdlib.h>
#include <iostream>
#include <string>
#include "Line.h"
using namespace std;
int main(void)
{
Line *p = new Line();
delete p;
p = NULL;
system("pause");
return 0;
}
上图中咱们能够看到类在建立和销毁时对于对象成员的前后处理顺序。
C++对象成员实践(二)[类往对象成员传参]：
做为线段这个类，咱们但愿在他建立的时候将里面的两个点肯定下来。线段类构造函数带参数，而且传给点。
Coordinate(int x, int y);
Line::Line(int x1,int y1,int x2,int y2):m_coorA(x1,y1),m_coorB(x2,y2)
{
cout << "Line()" << endl;
}
重点在于：
- Coordinate有两个参数
- Line的构造函数使用初始化列表
2-6-2-ObjectMemberParameter
Coordinate.h:
class Coordinate
{
public:
Coordinate(int x, int y);
~Coordinate();
public:
int getX();
void setX(int x);
int getY();
void setY(int y);
private:
int m_iX;
int m_iY;
};
Coordinate.cpp :
#include <iostream>
#include "Coordinate.h"
using namespace std;
Coordinate::Coordinate(int x,int y)
{
m_iX = x;
m_iY = y;
cout << "Coordinate()"<< m_iX << "," << m_iY << endl;
}
Coordinate::~Coordinate()
{
cout << "~Coordinate()" << m_iX << "," << m_iY << endl;
}
int Coordinate::getX() {
return m_iX;
}
void Coordinate::setX(int x) {
m_iX = x;
}
int Coordinate::getY(){
return m_iY;
}
void Coordinate::setY(int y) {
m_iY = y;
}
Line.h：
#include "Coordinate.h"
class Line {
public:
Line(int x1,int y1,int x2,int y2);
~Line();
void setCoorA(int x, int y);
void setCoorB(int x, int y);
void printInfo();
private:
Coordinate m_coorA;
Coordinate m_coorB;
};
Line.cpp:
#include <iostream>
#include "Line.h"
using namespace std;
Line::Line(int x1,int y1,int x2,int y2):m_coorA(x1,y1),m_coorB(x2,y2)
{
cout << "Line()" << endl;
}
Line::~Line() {
cout << "~Line()" << endl;
}
void Line::setCoorA(int x, int y) {
m_coorA.setX(x);
m_coorA.setX(y);
}
void Line::setCoorB(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;
}
main.cpp:
#include <stdlib.h>
#include <iostream>
#include <string>
#include "Line.h"
using namespace std;
int main(void)
{
Line *p = new Line(1,2,3,4);
p->printInfo();
delete p;
p = NULL;
system("pause");
return 0;
}
注意：
若是对象A中有对象成员B，对象B没有默认构造函数，那么对象A必须在初始化列表中初始化对象B。
若是对象成员B有默认的构造函数，那么就能够不用在对象A中使用初始化列表初始化B。
单元巩固
定义具备2个对象的Coordinate数组，遍历对象数组，打印对象信息
#include <iostream>
using namespace std;
class Coordinate
{
public:
Coordinate()
{
}
// 打印坐标的函数
void printInfo()
{
cout << "("<<m_iX<<","<<m_iY<<")"<<endl;
}
public:
int m_iX;
int m_iY;
};
int main(void)
{
//定义对象数组
Coordinate coorArr[2];
coorArr[0].m_iX = 1;
coorArr[0].m_iY = 2;
coorArr[1].m_iX = 3;
coorArr[1].m_iY = 4;
//遍历数组，打印对象信息
for(int i = 0; i < 2; i++)
{
coorArr[i].printInfo();
}
return 0;
}
深拷贝和浅拷贝
讲解拷贝构造函数的时候只讲解了拷贝构造函数的声明方法以及什么时候会被自动调用。
但没有讲解如何来实现拷贝构造函数，由于对象间的拷贝不简单。
有两种: 深拷贝和浅拷贝
class Array
{
public:
Array() { m_iCount = 5;}
Array(const Array& arr)
{ m_iCount = arr.m_iCount;}
private:
int m_iCount;
};
int main(void)
{
Array arr1;
Array arr2 = arr1;
return 0;
}
实例化arr1时就会调用构造函数Array(), 而后m_iCount = 5。arr2时会调用拷贝构造函数，
Array(const Array& arr) 将arr1做为参数经过arr传入。
加强版
class Array
{
public:
Array(){
m_iCount = 5;
m_pArr = new int[m_iCount];
}
Array(const Array& arr){
m_iCount = arr.m_iCount;
m_pArr = arr.m_pArr;
}
private:
int m_iCount;
int *m_pArr;
}
int main(void)
{
Array arr1;
Array arr2 = arr1;
return 0;
}
- 共同的特色，普通版和加强版都只是将数据成员的值进行了简单的拷贝。咱们也把这种拷贝模式称之为浅拷贝。对于第一个例子来讲使用浅拷贝是没有问题的。
将arr1中的指针拷贝到arr2中，两个指针此时就会指向同一个内存地址。
- 可是加强版会出现问题就是只简单地把指针拷贝过去的话（对象arr1和arr2的指针会指向同一个地址），一旦修改拷贝对象的数据，被拷贝对象里面的数据也会随之发生改变。（销毁了arr1，指针不存在了, 销毁arr2时会出现空指针回收）
所以，咱们想要的是指向两块不一样的内存，而后内存中的值(元素)对应相等
class Array
{
public:
Array(){
m_iCount = 5;
m_pArr = new int[m_iCount];
}
Array(const Array& arr){
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];
}
}
private:
int m_iCount;
int *m_pArr;
}
int main(void)
{
Array arr1;
Array arr2 = arr1;
return 0;
}
深拷贝：新建一个堆，而后就经过循环的方法把堆中的一个一个的数据拷过去。这样就能够避免在修改拷贝对象的数据时，同时改变了被拷贝对象的数据.
浅拷贝代码实践
要求：
说明一下某些场合深拷贝的实用性。
3-2-ShallowCopy
浅拷贝代码：
Array.h
class Array
{
public:
Array();
Array(const Array& arr);
~ Array();
int getCount();
void setCount(int val);
private:
int m_iCount;
};
Array.cpp:
#include <iostream>
#include "Array.h"
using namespace std;
Array::Array()
{
cout << "Array()" << endl;
}
Array::Array(const Array& arr) {
m_iCount = arr.m_iCount;
cout << "Array(&)" << endl;
}
Array::~Array() {
cout << "~Array()" << endl;
}
void Array::setCount(int c) {
m_iCount = c;
}
int Array::getCount() {
return m_iCount;
}
main.cpp:
#include <iostream>
#include <stdlib.h>
#include "Array.h"
using namespace std;
int main(void)
{
Array arr1;
arr1.setCount(5);
Array arr2 = arr1;
cout << "arr2,count:" <<arr2.getCount() << endl;
system("pause");
return 0;
}
深拷贝代码实践
浅拷贝代码:
Array::Array(const Array& arr) {
m_pArr = arr.m_pArr; //使用浅拷贝
m_iCount = arr.m_iCount;
cout << "Array(&)" << endl;
}
注意由于这样使得两个arr指向同一块内存。在销毁时同一块内存被销毁两次，会产生错误停止。
3-3-DeepCopy
Array.h:
class Array
{
public:
Array(int count);
Array(const Array& arr);
~ Array();
int getCount();
void setCount(int val);
void printAddr();
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];
cout << "Array()" << endl;
}
Array::Array(const Array& arr) {
m_pArr = arr.m_pArr;//使用浅拷贝
m_iCount = arr.m_iCount;
cout << "Array(&)" << endl;
}
Array::~Array() {
delete[]m_pArr;
m_pArr = NULL;
cout << "~Array()" << endl;
}
void Array::setCount(int c) {
m_iCount = c;
}
int Array::getCount() {
return m_iCount;
}
void Array::printAddr() {
cout << "m_pArr:" << m_pArr << endl;
};
main.cpp
#include <iostream>
#include <stdlib.h>
#include "Array.h"
using namespace std;
int main(void)
{
Array arr1(5);
Array arr2(arr1);
arr1.printAddr();
arr2.printAddr();
system("pause");
return 0;
}
能够看到浅拷贝中，两个指向同一块内存。释放内存时会出现问题。
改造为深拷贝
修改Array.cpp的拷贝函数
Array::Array(const Array &arr) {
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;
}
深拷贝：1.申请一段内存。再将源对象的内存中数值拷贝到对应位置一份。
为了看起来更加清晰，在构造函数为arr1的每个元素赋值
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.h中添加void printArr();
在Array.cpp增长打印数组函数：
void Array::printArr() {
for (int i=0;i<m_iCount;i++)
{
cout << m_pArr[i] << endl;
}
}
此时main.cpp添加:
arr1.printArr(); arr2.printArr();
完整深拷贝代码：
3-3-DeepCopy
Array.h:
class Array
{
public:
Array(int count);
Array(const Array& arr);
~Array();
int getCount();
void setCount(int val);
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(const Array& arr) {
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;
}
Array::~Array() {
delete[]m_pArr;
m_pArr = NULL;
cout << "~Array()" << endl;
}
void Array::setCount(int c) {
m_iCount = c;
}
int Array::getCount() {
return m_iCount;
}
void Array::printAddr() {
cout << "m_pArr:" << m_pArr << endl;
};
void Array::printArr() {
for (int i = 0; i < m_iCount; i++)
{
cout << m_pArr[i] << endl;
}
}
main.cpp：
#include <iostream>
#include <stdlib.h>
#include "Array.h"
using namespace std;
int main(void)
{
Array arr1(5);
Array arr2(arr1);
arr1.printAddr();
arr2.printAddr();
arr1.printArr();
arr2.printArr();
system("pause");
return 0;
}
能够看到深拷贝时指向两个不一样的地址，其中内容保持一致。
C++对象指针
有一个指针用来指向一个对象。
demo：
class Coordinate{
public:
int m_iX;
int m_iY;
}
将咱们的坐标类，在堆中实例化：
Coordinate *p = new Coordinate; //执行构造函数
p指向m_iX,访问方式为p->m_iX;
*p变成一个对象,采用.访问其中元素。
具体示例代码：
int main(void)
{
Coordinate *p = new Coordinate;
p -> m_iX = 10; //(*p).m_iX =10;
p -> m_iY = 20; //(*p).m_iY =20;
delete p;
p = NULL;
return 0;
}
- new 会自动调用对象的构造函数；
- C语言中的 malloc 则不会调用相关对象的构造函数，只是分配内存。
C++对象指针实践：
4-2-ObjectPointer
Coordinate.h
class Coordinate
{
public:
Coordinate();
~Coordinate();
int m_iX;
int m_iY;
};
Coordinate.cpp
#include <iostream>
#include "Coordinate.h"
using namespace std;
Coordinate::Coordinate()
{
cout << "Coordinate()" << endl;
}
Coordinate::~Coordinate()
{
cout << "~Coordinate()" << endl;
}
main.cpp:
#include <iostream>
#include "Coordinate.h"
#include <stdlib.h>
using namespace std;
int main()
{
// 使用对象指针指向内存，两种方法
// 堆中实例化
Coordinate *p1 = NULL;
p1 = new Coordinate; //由于有默认构造函数，括号可写可不写
Coordinate *p2 = new Coordinate(); //方法2
p1->m_iX = 10;
p1->m_iY = 20; // 指针方式
(*p2).m_iX = 30; //*p2使p2变成了一个对象
(*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;
system("pause");
return 0;
}
VS中 先ctrl+k再ctrl+c能够注释一段代码
//栈中实例化
Coordinate p1;
Coordinate *p2 = &p1;//让p2指向p1的地址，p2可操做p1
p2->m_iX = 10; // (*p2).m_ix =10;
p2->m_iY = 20;
cout << p1.m_iX << "," << (*p2).m_iY << endl;
能够看到p2指向p1的地址,修改p2，p1也会修改。
编码练习
定义一个坐标类，在堆上实例化坐标对象，并给出坐标（3，5），而后打印坐标信息，销毁坐标对象。
#include <iostream>
using namespace std;
class Coordinate
{
public:
Coordinate(int x, int y)
{
// 设置X,Y的坐标
m_iX = x;
m_iY = y;
}
public:
int m_iX;
int m_iY;
};
int main(void)
{
// 在堆上建立对象指针
Coordinate *p = new Coordinate(3,5);
// 打印坐标
cout <<"("<<(*p).m_iX<<","<<(*p).m_iY<<")"<< endl;
// 销毁对象指针
delete p;
p = NULL;
return 0;
}
C++对象成员指针
- 对象成员： 一个对象成为另一个类的数据成员
- 对象成员指针： 对象的指针成为另一个类的数据成员
坐标类：
class Coordinate
{
public:
Coordinate(int x, int y);
public:
int m_iX;
int m_iY;
};
线段类：
class Line {
public:
Line();
~Line();
private:
Coordinate m_coorA; //起点
Coordinate m_coorB; //终点
};
将线段类代码中的对象成员变成对象成员指针：
class Line {
public:
Line();
~Line();
private:
Coordinate *m_pCoorA;
Coordinate *m_pCoorB;
};
初始化时仍可使用初始化列表进行初始化：
Line::line():m_pCoorA(NULL),m_pCoorB(NULL){
}
也能够在构造函数中使用普通初始化：
Line::line()
{
m_pCoorB = NULL;
m_pCoorA = NULL;
}
通常的普通初始化状况：
Line::line()
{
m_pCoorB = new Coordinate(1,3);
m_pCoorA = new Coordinate(5,6);
}
Line::~line()
{
delete m_pCoorA;
delete m_pCoorB;
}
int main(void)
{
Line line();
cout << sizeof(line) <<endl; //8
return 0;
}
对象成员与对象成员指针的不一样：
对于对象成员来讲，sizeof是里面全部对象的总和。
指针在32位编译器下占4个基本内存单元,两个指针占8个内存单元。
- 对象成员指针的定义:
类名 *指针名; - 若存在对象成员指针1,2。sizeof(对象),只计算各指针所占内存的总和。
建立时line对象中只有两个占4字节的指针。
而实例化出的两个对象在堆中;销毁时，先销毁堆中的，再释放line对象。
对象成员指针实践
4-5-ObjectMemberPointer
Coordinate.h
class Coordinate
{
public:
Coordinate(int x, int y);
~Coordinate();
public:
int getX();
int getY();
private:
int m_iX;
int m_iY;
};
Coordinate.cpp
#include <iostream>
#include "Coordinate.h"
using namespace std;
Coordinate::Coordinate(int x,int y)
{
m_iX = x;
m_iY = y;
cout << "Coordinate()"<<m_iX<<","<<m_iY << endl;
}
Coordinate::~Coordinate()
{
cout << "~Coordinate()" << m_iX << "," << m_iY << endl;
}
int Coordinate::getX() {
return m_iX;
}
int Coordinate::getY(){
return m_iY;
}
Line.h:
#include "Coordinate.h"
class Line {
public:
Line(int x1,int y1,int x2,int y2);
~Line();
void setCoorA(int x, int y);
void setCoorB(int x, int y);
void printInfo();
private:
Coordinate *m_pCoorA;
Coordinate *m_pCoorB; //这是一个坐标类的对象指针。它只是一个指针。
};
Line.cpp:
#include "Line.h"
#include <iostream>
using namespace std;
Line::Line(int x1,int y1,int x2,int y2){
m_pCoorA = new Coordinate(x1, y1);
m_pCoorB = new Coordinate(x2, y2);
cout << "Line()" << endl;
}
Line::~Line() {
delete m_pCoorA;
m_pCoorA = NULL;
delete m_pCoorB;
m_pCoorB = NULL;
cout << "~Line()" << endl;
}
void Line::printInfo() {
cout << "("<<(*m_pCoorA).getX()<<","<< (*m_pCoorA).getY()<< ")" << endl;
cout << "(" << m_pCoorB->getX() << "," << m_pCoorB->getY() << ")" << endl;
}
main.cpp:
#include <stdlib.h>
#include <iostream>
#include <string>
#include "Line.h"
using namespace std;
int main(void)
{
Line *p = new Line(1,2,3,4);
p->printInfo();
delete p;
p = NULL;
cout << sizeof(p) << endl;
cout << sizeof(Line) << endl;
system("pause");
return 0;
}
运行结果：
- 能够看出在类包含指针对象时，先实例化指针对象a,b。再去调用父对象的构造函数。
- 在销毁时也是先按照顺序销毁指针对象a,b；最后销毁父对象。
- 指针p占用四个内存空间，对象Line中包含两个对象成员指针，也就是包含两个指针，大小为8.
这里咱们使用的是32位编译，状况是如上图所示。
能够看到，在64位编译状况下，一个指针占8个字节。
这种状况下对象的销毁与建立顺序一致。
这里咱们须要注意对象成员与对象成员指针在建立与销毁时的不一样
this指针
- 对象指针
- 对象成员指针
- this指针
例子：
class Array
{
public:
Array(int _len){len = _len;}
int getLen(){return len;}
void setLen(int _len){len = _len;}
private:
int len;
}
参数与数据成员，并不一样名。
数据成员与参数在表达同一个意思的时候取类似的名字。
问题: 当参数和数据成员同名会怎么样呢？
class Array
{
public:
Array(int len){len = len;} //错
int getLen(){return len;}
void setLen(int len){len = len;}//错
private:
int len;
}
计算机和人类都没法判断是把参数赋值给成员了，仍是成员赋值给参数。没法分辨两个len了。
this指针: 指向对象自身数据的指针
Array arr1; //this <-> &arr1 Array arr2; //this <-> &arr2
this表达什么地址,取决于当前所在做用域。这样就能够标记出自身的成员，与参数能够分清哪一个是哪一个了。
class Array
{
public:
Array(int len){this->len = len;}//对
int getLen(){return len;}
void setLen(int len){this->len = len;}//对
private:
int len;
}
对象结构：
- 存在多个对象，成员函数只有代码区内的一份。
又没有传递参数，成员函数如何肯定该调用哪一个对象的数据成员？
- 成员函数如何访问到对应对象的数据成员？
class Array
{
public:
Array(T *this,int len){this->len = len;}//对
int getLen(T *this){return this->len;}
void setLen(T *this,int len){this->len = len;}//对
private:
int len;
}
- 经过this来实现分辨不一样的arr。
- 编译器自动的为每个成员函数的参数列表都自动加上了this指针。
this指针在参数列表中的位置（代码实践）
要求：
正常版本1:
4-7-ThisPointerPosition
Array.h
class Array
{
public:
Array(int len);
~ Array();
void printAddr();
void printArr();
int getLen();
void setLen(int val);
void printInfo();
private:
int m_iLen;
};
Array.cpp:
#include <iostream>
#include "Array.h"
using namespace std;
Array::Array(int len)
{
m_iLen = len;
cout << "Array()" << endl;
}
Array::~Array() {
cout << "~Array()" << endl;
}
void Array::setLen(int len) {
m_iLen = len;
}
int Array::getLen() {
return m_iLen;
}
void Array::printInfo() {
}
main.cpp:
#include <iostream>
#include <stdlib.h>
#include "Array.h"
using namespace std;
int main(void)
{
Array arr1(10);
system("pause");
return 0;
}
改动: 将全部m_iLen都改成与参数名相同的len,此时已经人眼分辨不出哪一个是数据成员，哪一个是参数
为了程序更好看(能够分辨出哪一个是哪一个)，咱们引入this。
改动Array.h中数据成员:
private:
int len;
改动过的Array.cpp:
#include <iostream>
#include "Array.h"
using namespace std;
Array::Array(int len)
{
this->len = len;
cout << "Array()" << endl;
}
Array::~Array() {
cout << "~Array()" << endl;
}
void Array::setLen(int len) {
this->len = len;
}
int Array::getLen() {
return len;
}
void Array::printInfo() {
}
main.cpp添加调用arr1的打印函数。
#include <iostream>
#include <stdlib.h>
#include "Array.h"
using namespace std;
int main(void)
{
Array arr1(10);
cout << arr1.getLen() << endl;
system("pause");
return 0;
}
this指针实践(二)
4-8-ThisPointerPositionLinkCall
将Array.h中的printInfo()改成:
Array printInfo();
Array.cpp中的printInfo()改成:
Array Array::printInfo() {
cout << "len:" << len << endl;
return *this; //this自己是一个指针，而加上*之后变成一个对象。
}
main.cpp:
#include <iostream>
#include <stdlib.h>
#include "Array.h"
using namespace std;
int main(void)
{
Array arr1(10);
arr1.printInfo();
system("pause");
return 0;
}
这里的printInfo被正常的调用了，可是没有体现出返回this指针的价值。
由于printInfo()是有返回值this指针的，能够进行链式的调用。
arr1.printInfo().setLen(5); cout << "len_after_set:" << arr1.getLen() << endl;
打印出来的结果能够看出，咱们并无成功的改变掉arr1的值。由于咱们返回的
*this出来以后又变成了另一个临时的对象。这是一个临时的对象，并非arr1。
若是想让它就是arr1，那么引用就能够实现。
Array.h
Array& printInfo();
Array& Array::printInfo() {
cout << "len:" << len << endl;
return *this; //this自己是一个指针，而加上*之后变成一个对象。
}
main.cpp:
#include <iostream>
#include <stdlib.h>
#include "Array.h"
using namespace std;
int main(void)
{
Array arr1(10);
arr1.printInfo().setLen(5);
cout << "len_after_set:" << arr1.getLen() << endl;
system("pause");
return 0;
}
能够看到由于是引用，arr1都没有被销毁，而是被赋上新值。
咱们若是想让链式调用变得更长，只须要给setLen方法，让其也返回this指针的引用。
4-8-ThisPointerPositionLinkCallTwo
Array.h
class Array
{
public:
Array(int len);
~ Array();
void printAddr();
void printArr();
int getLen();
Array& setLen(int val);
Array& printInfo();
private:
int len;
};
Array.cpp:
#include <iostream>
#include "Array.h"
using namespace std;
Array::Array(int len )
{
this->len = len;
cout << "Array()" << endl;
}
Array::~Array() {
cout << "~Array()" << endl;
}
Array& Array::setLen(int len) {
this->len = len;
return *this;
}
int Array::getLen() {
return len;
}
//添加引用以后才是arr1
Array& Array::printInfo() {
cout << "len:" << len << endl;
return *this;//this自己是一个指针，而加上*之后变成一个对象。
}
main.cpp:
#include <iostream>
#include <stdlib.h>
#include "Array.h"
using namespace std;
int main(void)
{
Array arr1(10);
//由于此时this返回了当前对象。因此可使用"."
arr1.printInfo().setLen(5).printInfo();
system("pause");
return 0;
}
运行结果：
指针实现版本:
若是咱们不是返回一个引用，而是返回一个指针，那又是什么状况？
- 将返回类型
Array &改成Array * - 将
return *this改成return this - 将对象的使用符
.改成指针操做符->
完整代码以下：
4-8-ThisPointerPositionLinkCallTwoByPointer
Array.h:
class Array
{
public:
Array(int len);
~ Array();
void printAddr();
void printArr();
int getLen();
Array* setLen(int val);
Array* printInfo();
private:
int len;
};
Array.cpp:
#include <iostream>
#include "Array.h"
using namespace std;
Array::Array(int len )
{
this->len = len;
cout << "Array()" << endl;
}
Array::~Array() {
cout << "~Array()" << endl;
}
Array* Array::setLen(int len) {
this->len = len;
return this;
}
int Array::getLen() {
return len;
}
Array* Array::printInfo() {
cout << "len:" << len << endl;
return this;//this自己是一个指针.
}
main.cpp:
#include <iostream>
#include <stdlib.h>
#include "Array.h"
using namespace std;
int main(void)
{
Array arr1(10);
//由于此时this返回了arr1的指针，因此要使用"->"
arr1.printInfo()->setLen(5)->printInfo();
system("pause");
return 0;
}
最终结果与刚才一致。说明不论是引用仍是指针均可以实现改变实际的值。
this指针的本质: 至关于所在对象的地址
在printInfo中打印出this指针的值
Array.cpp:
Array* Array::printInfo() {
cout << this << endl;
return this;//this自己是一个指针,而加上*之后变成一个对象。
}
main.cpp:
int main(void)
{
Array arr1(10);
arr1.printInfo();
cout << &arr1 << endl;
system("pause");
return 0;
}
运行结果：
this指针无需用户定义，是编译器自动产生的。
常对象成员和常成员函数
const重出江湖
例子：
class Coordinate
{
public:
Coordinate(int x,int y);
private:
const int m_iX;
const int m_iY;
}
//错误作法:
Coordinate::Coordinate(int x,int y)
{
m_iY =y;
m_iX =x;
}
//正确作法：使用初始化列表
Coordinate::Coordinate(int x,int y):m_iX(x),m_iY(y)
{
}
做为一个类的数据成员是能够用const来修饰的，只不过之前讲的都是一些基本数据类型的数据成员。
常对象成员: 对象成员经过const修饰
线段: 一旦起点和终点被肯定就不容许修改了。
class Line
{
public:
Line(int x1,int y1,int x2 ,int y2)
private:
const Coordinate m_coorA;
const Coordinate m_coorB;
}
//初始化两个对象使用初始化列表
Line::Line(int x1,int y1,int x2 ,int y2):m_coorA(x1,y1),m_coorB(x2,y2)
{
cout<< "Line" << endl;
}
//调用：
int main(void)
{
Line *p = new Line(2,1,6,4);
delete p;
p = NULL;
return 0;
}
const修饰成员函数（常成员函数）
例子：
class Coordinate
{
public:
Coordinate(int x,int y);
void changeX() const; // 常成员函数
void changeX();
private:
int m_iX;
int m_iY;
}
//定义常成员函数
void Coordinate::changeX() const
{
m_iX = 10;//错误
};
//普通函数
void Coordinate::changeX()
{
m_iX = 20;
};
思考: 为何常成员函数中不能改变数据成员的值？
实际成员函数有一个隐藏的参数，this指针。
this指针变成了一个常指针，经过常指针改变数据，显然是不被容许的。
互为重载：
void changeX() const;
void changeX(); //互为重载
Q：当直接调用：coordinate.changeX()到底调用的是哪个呢？
A：调用的是普通的不带const的。
Q: 那么想调用那个带const的如何写？
A:代码以下
int main(void)
{
// 实例化对象时用const修饰这个对象
const Coordinate coordinate(3,5);//常对象
coordinate.changeX(); // 调用的是常成员函数
return 0;
}
常对象调用的是常成员函数。
普通对象调用的是普通成员函数。
常对象成员与常成员函数代码实践
5-2-ConstantMemberFunction
Coordinate.h :
class Coordinate
{
public:
Coordinate(int x, int y);
~Coordinate();
public:
int getX() const;//此处声明该成员函数为常成员函数
void setX(int x); // 至关于setX(Coordinate *this, int x)
int getY() const;//同上
void setY(int y);
private:
int m_iX;
int m_iY;
};
Coordinate.cpp
#include <iostream>
#include "Coordinate.h"
using namespace std;
Coordinate::Coordinate(int x, int y)
{
m_iX = x;
m_iY = y;
cout << "Coordinate()" << m_iX << "," << m_iY << endl;
}
Coordinate::~Coordinate()
{
cout << "~Coordinate()" << m_iX << "," << m_iY << endl;
}
int Coordinate::getX() const{
return m_iX;
}
void Coordinate::setX(int x) {
m_iX = x;
}
int Coordinate::getY() const{
return m_iY;
}
void Coordinate::setY(int y) {
m_iY = y;
}
Line.h:
#include "Coordinate.h"
class Line {
public:
Line(int x1, int y1, int x2, int y2);
~Line();
void setCoorA(int x, int y);
void setCoorB(int x, int y);
void printInfo();
void printInfo() const;//互为重载
private:
const Coordinate m_coorA; // Coordinate const m_coorA;
Coordinate m_coorB;
};
Line.cpp:
#include "Line.h"
#include <iostream>
using namespace std;
Line::Line(int x1, int y1, int x2, int y2) :m_coorA(x1, y1), m_coorB(x2, y2) {
cout << "Line()" << endl;
}
Line::~Line() {
cout << "~Line()" << endl;
}
void Line::setCoorA(int x, int y) {
//m_coorA.setX(x); // 出现问题: 此时至关于在setX中传递了一个this指针
//m_coorA.setX(y);
}
void Line::setCoorB(int x, int y) {
m_coorB.setX(x);
m_coorB.setY(y);
}
void Line::printInfo() {
cout << "printInfo()" << endl;
cout << "(" << m_coorA.getX() << "," << m_coorA.getY() << ")" << endl;
cout << "(" << m_coorB.getX() << "," << m_coorB.getY() << ")" << endl;
}
void Line::printInfo() const{
cout << "printInfo() const" << endl;
cout << "(" << m_coorA.getX() << "," << m_coorA.getY() << ")" << endl;
cout << "(" << m_coorB.getX() << "," << m_coorB.getY() << ")" << endl;
}
main.cpp
#include <stdlib.h>
#include <iostream>
#include <string>
#include "Line.h"
using namespace std;
int main(void)
{
Line line(1, 2, 3, 4);
line.printInfo();//调用的是普通的
const Line line2(1, 2, 3, 4);
line2.printInfo();//调用的是常成员函数
system("pause");
return 0;
}
void setX(int x); // 至关于setX(Coordinate *this, int x)
咱们在定义的时候，
Coordinate *this要求的是一个既有写权限又有读权限的指针。
而咱们在调用的时候，咱们传入的m_coorA是一个只有读权限的对象。
若是咱们想让函数能用，加const就能够了。setX是不能加的，否则就不能修改x,y的值了
可是getX 和 getY是能够加的。
int getX() const;//此处声明该成员函数为常成员函数
int getY() const;// const应写在函数声明的后面
而后将const也要同步到定义上去。此处略去自行完成。将setX和setY注释掉。
int getX(const Coordinate *this) const;
这就要求咱们传入的是常对象。
- 常对象只能调用常成员函数。
- 普通对象能够调用所有成员函数(很是成员函数)。
思考:为何须要const成员函数?
咱们定义的类的成员函数中，经常有一些成员函数不改变类的数据成员，也就是说，这些函数是"只读"函数，而有一些函数要修改类数据成员的值。若是把不改变数据成员的函数都加上const关键字进行标识，显然，可提升程序的可读性。其实，它还能提升程序的可靠性，已定义成const的成员函数，一旦企图修改数据成员的值，则编译器按错误处理。
常指针与常引用
对象指针与对象引用
class Coordinate
{
public:
Coordinate(int x, int y);
public:
int getX();
int getY();
void printInfo() const; // 常成员函数
private:
int m_iX;
int m_iY;
};
定义：
int Coordinate::getX(){
return m_iX;
}
int Coordinate::getY() const{
return m_iY;
}
void Coordinate::printInfo() const
{
cout << "(" <<m_iX <<","<<m_iY <<")"<<endl;
}
对象的引用 & 对象的指针
int main(void)
{
Coordinate coor1(3,5);
Coordinate &coor2 = coor1; //对象的引用,起别名
Coordinate *pCoor = &coor1;//对象的指针，注意取地址符。
coor1.printInfo();
coor2.printInfo(); //也将打印出coor1的坐标(3,5)
pCoor -> printInfo();
return 0;
}
对象的常指针与对象的常引用
int main(void)
{
Coordinate coor1(3,5);
const Coordinate &coor2 = coor1; //常：对象的引用
const Coordinate *pCoor = &coor1; //常：对象的指针，注意取地址符。
coor1.printInfo(); //普通对象正常使用
coor2.getX(); //错误，常引用（只具备读权限的this指针）
// 定义getX的时候没有加const，所以它内部隐藏传入的this是要求一个读写权限都有的。
// 只能调用常成员函数
coor2.printInfo();
pCoor -> getY(); //错误。常指针（只有只读权限）。
//getY的隐藏参数要求传入的是读写权限的this
// 只能调用常成员函数
pCoor -> printInfo();
return 0;
}
更复杂的例子：
int main()
{
Coordinate coor1(3,5);
Coordinate coor2(7,9);
//定义一个对象指针
Coordinate *const pCoor = &coor1;
// 注意，const在*的后面。
// pCoor一旦指向一个对象就不能指向其余的对象
//指针不能够指向其余对象，可是指针自己指向的对象内容可变。
//这是一个具备读写权限的指针。只限于当前指向的对象。
pCoor ->getY(); //正确
//pCoor已经被const修饰了，不容许修改
pCoor = &coor2;
//printInfo是一个常成员函数（要求读权限的指针），而pCoor具备读写权限,大权限能够调用小权限的。
pCoor -> printInfo();
return 0;
}
常指针容易混淆的：
-
const *p->*p不能够再赋值 -
*const p->p不能够再赋值 -
const * const p->*p和p都不能够再赋值
不能把小权限的指向大权限的，可是能够把大权限的指向小权限的。
- 常对象只能调用常成员函数，不能调用普通成员函数
- 普通对象可以调用常成员函数，也可以调用普通成员函数(权限大调用权限小)
- 常指针和常引用都只能调用对象的常成员函数。(小权限调小权限)
- 一个对象能够有多个对象常引用 (小名自身不能够改，可是能够有多个别名)
单元巩固
定义一个坐标类，在栈上实例化坐标类常对象，并给出坐标（3，5），而后定义常引用、常指针，最后使用对象、引用、指针分别经过调用信息打印函数打印坐标信息。
#include <iostream>
using namespace std;
class Coordinate
{
public:
Coordinate(int x, int y)
{
// 设置X,Y的坐标
m_iX = x;
m_iY = y;
}
// 实现常成员函数
void printInfo() const
{
cout << "("<<m_iX<<","<<m_iY<<")"<<endl;
}
public:
int m_iX;
int m_iY;
};
int main(void)
{
const Coordinate coor(3, 5);
// 建立常指针p
const Coordinate *p = &coor;
// 建立常引用c
const Coordinate &c = coor;
coor.printInfo();
p->printInfo();
c.printInfo();
return 0;
}
迷宫程序(走出迷宫)
走出规则(算法)：
- 左手规则 & 右手规则
- 原则：保证手始终触墙(黑暗中在家扶墙走)
- 结果：走出迷宫
状况1(建议设计成这样)：有入有出。
状况2:出入口是一个）
架构描述
涉及两个类: 迷宫类（MazeMap）& 走迷宫的人(Person)
二维数组：
1表明墙，0表明路,本身决定。
迷宫类(MazeMap)
数据成员：
- 墙壁字符 - 通路字符 - 迷宫数组
成员函数：
- 构造函数 - 数据封装函数 - 迷宫回执函数 - 迷宫边界检查函数
人类(MazePerson)
数据成员:
- 人的字符 - 人的朝向 - 人当前位置(设置在入口) - 人前一个位置 (人走动，前位置抹掉，后一个位置绘制） - 人的速度
成员函数：
- 构造函数 - 数据封装函数 - 向不一样方向前进的函数(上下左右) - 转弯函数 - 开始函数
控制台动画控制：
/*
* 函数名称：gotoxy
* 函数功能：肯定控制台中字符的输出位置
* 函数列表：
* x：横坐标
* y：纵坐标
*/
void MazePerson::gotoxy(int x, int y)
{
COORD cd;
cd.X = x;
cd.Y = y;
HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleCursorPosition(handle,cd); // 把光标定位到相应位置上
};
首先须要定义一个迷宫，迷宫是一个二维数组，WaLL是墙，Road是路。
绘制迷宫cout就能够了。有了迷宫的二维数组，先实例化一个迷宫对象，经过setMazeMap函数将
二维数组设置进去，SetMazeWall告诉计算机墙用什么表示。设置好以后绘制迷宫。
走迷宫的人，设置人的位置位于入口。设置人的速度，设置人的字符形状。
人开始运动。
注意事项:
- 枚举类型：方向(上下左右)
- 常量定义：宏定义 & const
成就感源于克服困难
迷宫代码实现
未完待续, 以后补充。
相关文章
- 1. C++远征之封装篇（下）-学习笔记
- 2. 6-C++远征之封装篇[上]-学习笔记
- 3. c++学习笔记之封装篇(上)
- 4. C++远征离港篇-学习笔记
- 5. 8-C++远征之继承篇-学习笔记
- 6. 10-C++远征之模板篇-学习笔记
- 7. 9-C++远征之多态篇-学习笔记
- 8. C++远征之起航篇
- 9. C++笔记（2）：封装篇（上）
- 10. C#学习笔记（7）
- 更多相关文章...
- • C# 封装 - C#教程
- • 您已经学习了 XML Schema，下一步学习什么呢？ - XML Schema 教程
- • Tomcat学习笔记（史上最全tomcat学习笔记）
- • 适用于PHP初学者的学习线路和建议
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. Duang!超快Wi-Fi来袭
- 2. 机器学习-补充03 神经网络之**函数(Activation Function)
- 3. git上开源maven项目部署 多module maven项目（多module maven+redis+tomcat+mysql）后台部署流程学习记录
- 4. ecliple-tomcat部署maven项目方式之一
- 5. eclipse新导入的项目经常可以看到“XX cannot be resolved to a type”的报错信息
- 6. Spark RDD的依赖于DAG的工作原理
- 7. VMware安装CentOS-8教程详解
- 8. YDOOK：Java 项目 Spring 项目导入基本四大 jar 包 导入依赖，怎样在 IDEA 的项目结构中导入 jar 包 导入依赖
- 9. 简单方法使得putty（windows10上）可以免密登录树莓派
- 10. idea怎么用本地maven
欢迎关注本站公众号,获取更多信息
相关文章
- 1. C++远征之封装篇（下）-学习笔记
- 2. 6-C++远征之封装篇[上]-学习笔记
- 3. c++学习笔记之封装篇(上)
- 4. C++远征离港篇-学习笔记
- 5. 8-C++远征之继承篇-学习笔记
- 6. 10-C++远征之模板篇-学习笔记
- 7. 9-C++远征之多态篇-学习笔记
- 8. C++远征之起航篇
- 9. C++笔记（2）：封装篇（上）
- 10. C#学习笔记（7）