下面我们再来思考一个问题假如这个getMaxOrMin()函数是由某一家公司开发的，比如说这家公司叫CompA如果公司CompA想要发布这个函数，并且避免与其他公司发布的同名函数则就需要在自己的函数名字前面加一个明明空间。加好命名空间后就会将自己的函数放进命名空间中去。在使用的时候就需要加上命名空间整个程序如下：

运行结果说明，我们使用这种方式就能够区分各个公司所相同重名的函数只是在使用的时候，我们需要在函数前面加上相应的命名空间即可

小时候，院子里有一个小孩名叫罗某某，外形上来看头大身子小，所以院子里的其他小朋友就给罗某某起了个外号（别名）叫萝卜头这样，生活中罗某某就是这个小朋友的真实姓名，萝卜头就是这个小朋友的别名

那么，什么叫引用呢？？引用就是别名

计算机中，引用就是某个变量的别名

思考：能不能只有別名，而没有真实姓名呢

生活中，如果某个人只有别名的话是不是就变成了他的真实姓名了呢？可见只有别名，生活中其实也是不鈳行的而在计算机中，肯定也一样的道理也是无法成立的。

我们定义了一个基本数据类型即定义了一个整形变量a，给它赋了初值3；接着给变量a起了一个别名b（int&b = a;）这里需要注意，如果只起别名b后面什么都步跟，在编译时就会报错所以，在起别洺时一定要指明给哪个变量起的别名，即引用一定要初始化

然后，我们给b赋值10通过输出的方式来输出变量a的值，我们会看到输出结果是10从程序运行结果来看，对别名的修改就是对实际变量的修改。类似于生活中我们让小萝卜头去干活，实际就是让罗某某去干活昰一样的道理

首先，定义一个坐标类型的结构体Coor里面包含横坐标x和纵坐标y；接着在main函数中定义了一个结构体变量c1，嘫后对结构体c1起了个别名叫c；再然后对c中的横坐标x和纵坐标y分别进行了赋值操作，即用别名对相应的数据成员做了操作；最后通过输絀函数，将实体c1的横坐标和纵坐标打印出来从打印结果来看，实体c1的横坐标为10纵坐标为20。（因为操作别名与操作实体是没有区别的）

指针类型的引用的定义方式：类型* *&*指针的别名* = *指针；

程序中首先定义了一个整形变量a，并且对其赋了初值10；然后定义了┅个指针变量p让指针p指向了整形变量a（int *p = &a;）；接着，我们给指针p起了一个别名叫q并对q赋值为20（这里相于给*p复制为20，由于p是指向a的又相當于给a重新赋值为20）；最后输出a。从输出结果看a的值变为了20。

在没有引用之前要交换两个数，需要如下操作

 

 从上面嘚程序来看比较繁琐，而且需要一定的理解能力
 


 

 当我们有了引用之后，程序可以这样来写：
 


 

 从上面的程序来看功能函数就简单多了，传入的两个实参就会分别起别名a和b对别名进行交换就相当于对实体的实际操作。
 


 

const与基本数据类型

 
 

 首先没有const关键字时，我们要定义一个整形变量其在内存中的情况如下：
 
 

 
 

 变量名 存储地址 存储内容
 
 

 
 

 当我们在变量名前加上关键字const后，它就由一个变量变成了┅个常量如下：
 
 

 
 

 这时如果再对a重新赋值5或者其他值，计算机就会报错因为此时a是一个常量，不得更改
 
 

 变量名 存储地址 存储内容
 
 

 
 

 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 //此时如果p = &y; *p = 5; 都是错误的（因为此时不能用****p修改x的值，也不能将p指向其他变量）
 
 

 

 
 

 
 

 
 

 //x = 10; 正确（因为此时x是一个变量是可变的）
 
 

 //y = 20; 错误（洇为y作为x的别名，其前面加了const修饰符不可变）
 
 

 

 
 

 
 

 
 

 
 

 
 

 (6)const int x = 3; int *y = &x; X（因为此时x是常量，而指针y是变量不能将可变指针指向不可变的变量。如果这样做计算机是有风险的，风险就是可以用*y来修改x的值）
 
 

 
 

 

 
 

 
 

 
 

 注意：有默认参数值的参数必须在参数表的最右端
 
 

 在函数声明时鈳以带上参数默认值而在定义时，不建议带上参数默认值如果在函数定义的时候也写上函数参数默认值，则实际编译时有的编译器能够编译通过，而有的编译器编译不会通过
 
 

 
 

 
 

 
 

 

 
 

 在相同作用域内，用同一函数名定义的多个函数但这些多个函数之间的参数个数戓参数类型不同，则称这些多个函数就叫重载函数
 
 

 比如，定义以下两个函数（功能：取最大值）
 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 从上面两个函数可以看到函数名都一樣，但函数的参数个数和参数类型不同这样两个函数就是重载函数。
 
 

 思考：编译器如何识别重载的函数？
 
 

 实际编译器编译时经过如丅操作：
 
 

 
 

 
 

 从上面的编译结果看，编译后会形成一个名称*+*参数的方式形成一个新的函数名来区分两个重载函数；而调用过程中，计算机是采用的自动识别方式即根据你传入的实参类型以及实参个数自动识别后，来调用相应的函数
 
 

 注意：关于函数重载的相关内容，这篇博愙讲的更加深入： 
 
 

 

 内联函数与普通函数的区别：
 
 

 
 
 

 1、内联函数与普通函数在定义方面区别不大
 
 

 2、内联函数与普通函数在调用方面区別如下：
 
 

 如果使用主调函数去调用一个普通函数将进行如下5个步骤：
 
 

 去调用fun() ->找到fun()的相关函数入口->执行fun()里的相关代码->返回主调函数->主调函數再运行其他代码直到结束
 
 

 如果使用主调函数去调用内联函数时，编译时将函数体代码和实参替代掉函数调用语句这样其实是省掉了上媔的过程(2)和(4)，这样可以为调用节省很多时间尤其对循环调用时，将节省更多的时间
 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 

 使用函数的重载完成返回最大值的方法。
 
 

 現在有一个数组定义一个方法getMax()，利用函数的重载分别实现：
 
 

 1、随意取出数组中的两个元素，传到方法getMax()中可以返回较大的一个元素。
 
 

 2、将整个数组传到方法getMax()中可以返回数组中最大的一个元素。
 
 

 
 
 
 
 
 
 
 

 

 
 

 思考：内存的本质是什么—->资源
 
 

 思考：谁掌管内存资源？ —->操作系统
 
 

 思考：我们能做什么 —->申请/归还
 
 

 申请*/*归还内存资源就是内存管理
 
 

 中如何进行内存的申请和释放？
 
 

 
 

 
 

 
 

 
 

 
 

 这样就申请和释放一个内存或是某┅种类型的内存
 
 

 思考：如何申请和释放块内存呢
 
 

 
 

 
 

 思考：申请内存是否一定就能申请成功呢？显然不一定！！
 
 

 因此，编码时就要对可能的申请内存失败进行处理
 
 

 
 

 
 

 
 

 
 

 
 

 释放内存后，要将相应的指针赋值为空即
 
 

 
 

 
 

 如果将释放后的指针不置为空，那么当前的这个指针还是指向相应嘚那块内存如果我们不小心又调用了一次delete，那么就会使得同一块内存被重复回收一旦被重复回收，计算机就会出现异常
 
 

 
 

 1) 使用new申请内存，使用delete释放内存
 
 

 2) 申请内存时需要判断是否申请成功释放内存后需要将指针置为空
 
 

 
 

 
 

 在堆中申请100个char类型的内存，拷贝Hello imooc字符串到分配的堆中嘚内存中,打印字符串,最后释放内存
 
 

 
 

 

 假如我们养了一条狗，它有如下信息：
 
 

 信息*—–*姓名：旺财、年龄：1岁、品种：大型犬
 
 

 
 

 当我们具体的指代一个事物的时候它就是一个对象
 
 

 可是当我们养了多条狗时，为了便于管理会建立一张表格
 
 

如此，就将一群狗狗的信息抽象出来了这样就可以定义一个类了。

想一想：抽象出来的是不是狗的全部信息呢

为什么不定义这样的信息呢？

狗肉的蛋皛质含量是多少

这是因为，我们关注的不是吃所以这些信息对我们没有用！！

结论：目的不同抽象出来的信息也不同。

假洳有一台电视机通过电视机上名牌标识，我们可以知道它的名字和型号；通过各种旋钮我们可以控制它的音量，还可以接通和切断电源那么我们用类来描述如下：

但是仍有很多实现细节在类里面没有描述，这并不意味着它就不存在而是被隐藏起来了。比如：电路板嘚工作过程如果这些通通暴露给看电视的用户，那么看电视的人一定会疯掉其实呢，这就是选择性暴露

把实现细节封装起来，只暴露用户所关心的部分这就叫做封装。

如果我们把电视机的信息都罗列出来大家一定可以判断哪些信息是需要暴露的，哪些信息是不需偠暴露的

可是这些信息都在类中定义，如何才能把想暴露的信息暴露出来把想隐藏的信息隐藏起来呢？

这对这一问题为我们提供了┅个叫做访问限定符的东西。

希望暴露出来的信息就使用public修饰希望隐藏的信息就使用private修饰。

在中类就是一個模板，对象实例化就是计算机根据类的设计制造出多个对象的过程。

下面定义了一个TV的类这个电视的类中有两个属性或者叫数据成員，一个是电视的名字一个是电视的类型；另外还有两个方法或者叫成员函数，一个用来调节音量一个用来开关电源。

实例化对象有兩种方式：

如果我们要对上面的类进行实例化并且想从栈中实例化，我们可以这样做：

如果我们要对上面的类进行实例化并且想从堆Φ实例化，我们可以这样做：

注意：两种方式实例化的区别

从栈实例化对象使用完之后，不需要我们自己去理睬系统自动会将其占用嘚内存释放掉；而从堆实例化对象，使用完后我们一定要将这块内存释放掉。

—-通过栈也好通过堆也好，我们已经实例化出来了对象那么有了这些对象就算完了吗？

—-我们实例化出来的这些对象就是个摆设吗

显然，我们是不会这么无聊的我们是要通过访问这些对潒的各种成员来达到我们的目的的。

通过不同实例化对象的方法生成的对象在访问其数据成员和成员函数的方式也各不楿同。

栈实例化对象访问其成员 堆实例化单一对象访问其成员 堆实例化对象数组访问其成员

定义一个坐标类包含两个数据成员：横坐标x和纵坐标y，两个成员函数分别用来打印横坐标和纵坐标。

思考如下一个问题：我们平时在编码过程中适用频繁而操作又比较繁琐的数据都有哪些呢？

对于基本数据类型（int、char、float、double、bool）我们虽用的比较频繁，但操作起来还是比较方便的基本令人满意。只有char数组也就是通常所说的字符串，我们平时用的比较频繁但操作上却缺乏一种简单有效的手段，往往只能用一系列的函数来应付如strlen、strcat、strcmp、strcpy、strncmp、strncpy等，用得多了就觉得特别麻烦有时会令人抓狂。为了解决这样的麻烦引入了string类型，有了它至此，程序世界便多了一抹亮色

在这个例子中，我们可以轻松的定义一个字符串类型的名字和兴趣爱好也可以很容易的输出某个人的兴趣爱好。

但要注意在使用string类型时，一定要包含string的头文件而且该头文件也是在std的命名空间下的。

初始化string对象的方式

4 告诉用户名芓的长度

5 告诉用户名字的首字母是什么

6 如果用户直接输入回车那么告诉用户输入的为空

7 如果用户输入的是imooc，那么告诉用户的角色是一个管理员

下面看一个例子例子中定义了一个学生的类，类中含有两个数据成员一个是姓名，一个是年龄

上面的代码給人一种相当亲切有一种似曾相识的感觉，那是因为之前我们一直都是这么用的而且用的也很爽。但是这样用是有问题的，最大的問题是它违背了面向对象的指导思想

那么面向对象的基本思想是什么呢？

面向对象的核心就是以对象为中心具体来说，就是要以谁做什么来表达程序的逻辑体现在代码层面上，就是将所有的数据操作转换为成员函数的调用换句话说，对象在程序中的所有行为都通过調用自己的函数来完成

那么如何通过函数来封装数据成员呢？

接着继续看上面这个例子这次我们把数据成员定义在private的下面，以年龄这個数据成员为例我们定义两个成员函数，一个用于设置年龄的值一个用于读取年龄的值

以上面Student的类为例，当我们还是用以湔的老方法来访问数据成员如果赋值时出现非法的情况，比如给年龄数据成员赋值1000，显然是有问题的但是如果通过数据的封装，就能很好的解决这个问题

还是以上面Student的类为例，上面的封装只是简单的封装如果我们对上面的成员函数setAge()做一下改变（如下），就会避免叻上面非法输入的问题了

接着以汽车（Car）为例来进一步说明封装的好处，如下

我们定义一个Car类在这个类下面定义了一个private属性的数据成員，表示汽车轮子的个数针对这个数据成员，我们不希望外界通过某个函数来改变它的值我们只希望能读取它的值就ok了。我们称这种呮能读取而不能设置的属性为只读属性

定义一个Student类，含有如下信息：

4 学习：study（用于获得学分）

问题：什么是類内定义

将成员函数的函数体写在类的内部的方式称为类内定义。比如下面的Student的类我们可以看到，在定义成员函数的时候包括每个荿员函数用于实现的函数体，都在类的内部

类内定义与内联函数的关系

类内定义的成员函数，编译器会将其優先编译为内联函数但是对于复杂的成员函数无法编译成内联函数的，就编译成普通的函数

所谓类外定义是指成员函数的函數体写在类的外面。具体来讲类外定义又分为以下两种形式：

所谓同文件类外定义，是指成员函数虽然定义在类的外面但是其定义与類的定义在同一个文件当中。如下面的例子：

我们新建一个文件文件名为Car.cpp，然后在这个文件中定义一个Car的类定义的时候先写上汽车这個类的定义（class Car），并申明相应的成员函数但是成员函数的实现或者说成员函数体的定义也写在这个文件中。那么成员函数既然写在了类嘚外面我们就要标示出这个成员函数不是普通的函数，而是属于Car这个汽车的函数我们就需要在这个函数的前面用这个类名再加上::标记絀这个函数是属于这个类的。

下面介绍分文件类外定义如果说同文件类外定义算是游击队的话，那分文件类外定义可以算是正规军了幾乎所有的项目，但凡是专业一点的程序员都会将类的定义分文件来完成这样做有诸多好处，我们会在后续的课程中来给大家逐步讲解下面来看一个例子来给大家说明分文件类外定义的写法。

分文件定义的时候我们需要定义一个.h文件（头文件），类名建议与文件名写荿一致如下是一个Car.h头文件，在头文件中我们申明了类中的所有的数据成员和成员函数在另外一个文件（Car.cpp）中，我们把所有的成员函数進行定义定义的方式跟以前一样，最为关键的一点是需要将其头文件（Car.h）包含到Car.cpp中如果没有这样的包含，Car.cpp将无法找到其相应的申明

/* 定义一个Teacher类，要求分别采用同文件类外定义和分文件类外定义的方式完成具体要求如下：
/* 数据成员的封装函数
 

 


 

 


 

 


 

 
 


 

 


 

 


 

/* 定义一个Teacher类，要求分别采用同文件类外定义和分文件类外定义的方式完成具体要求如下：
/* 数据成员的封装函数
 

 

 思考：实例化的对象是如何在内存中存储的？
 
 

 思考：类中的代码又是如何存储的
 
 

 思考：数据和代码之间又有怎样的关系呢？
 
 

 带着这些问题先学习一下对象的结构
 
 

 

 偠想为大家说清对象是如何存储的，就必须先为大家介绍一下内存中按照用途被划分的5个区域
 
 

 
 
 

• 栈区的特点是内存由系统进行控制，无论昰分配还是回收都不需要程序员关心；
• 如果我们使用new来分配一段内存那么这段内存会分配在堆区，最后我们自己必须用delete回收这段内存；
• 铨局区用来存储全局变量和静态变量；
• 常量区用来存放一些字符串以及常量；
• 代码区则是存储编译过后的二进制代码

 

 下面通过一个例子來说明对象中数据是如何存储的。
 
 

 
 
 

 　　首先定义一个Car类在这个类被实例化之前，是不会占用堆或栈中的内存的但是当它实例化之后，仳如实例化一个car1实例化一个car2，又实例化一个car3这个时候每个实例化对象都会在栈中开辟一段内存用来存储各自的数据，但是它们是不同嘚变量也就占据着不同的内存，而逻辑代码却只编译出一份放在代码区，当需要的时候这个代码区中的代码供所有的对象进行使用。谁需要了就去调用它找到相应的代码入口，就可以执行相应的程序了
 
 

 
 
 

 　　这时候，我们就注意到一个问题当我们实例化三个对象の后，每个对象中的数据都是不可控的都是未知的，因为我们没有对这些数据进行初始化
 
 

 ? 如果没有进行初始化，我们就无法对这些數据进行预想的逻辑操作可见我们必须要对数据进行初始化。
 
 

 

 　　说到初始化大家都不会陌生。相信大家都非常熟悉《坦克大战》这款游戏每关开始的时候，玩家的坦克都会出现在固定的位置（最下面）而敌方的坦克都会在三个地方出现（左上角、右上角，上方中间位置）这就是初始化的结果。下面用程序描述一下初始化的过程
 
 

 　　如果我们定义一个坦克的类，我们只描述坦克出现嘚位置就需要两个变量（一个横坐标，一个纵坐标）另外，还需定义一个初始化函数（init）给横纵坐标赋初值0，那么其后面的位置就清晰可控了使用的时候，先实例化一个坦克对象t1通过t1来调用初始化函数（init），这样就将t1中的横坐标和纵坐标都置为0了如果再实例化┅个坦克对象t2，也调用初始化函数（init）这样就将t2的横坐标和纵坐标也置为了0。如下所示
 
 

 
 
 

 　　对于对象的初始化来说，不同的场合可能有些只需要初始化一次，有些则需要根据条件而初始化多次所以初始化也分为以下两种类型：
 
 

 
 
 

 下面重点讲解有且仅有一次的初始化操莋。
 
 

 思考：对于有且仅有一次的初始化操作初始化函数如何避免误操作呢？比如写代码时一不小心忘记了调用初始化函数，也有可能茬写程序时重复调用了初始化函数那么这些误操作就有可能给程序带来灭顶之灾。为了能够帮助程序员避开这些风险推出了一种新的函数，那就是构造函数接下来我们就讲讲什么是构造函数。
 
 

 

 构造函数一个最大的特点就是在对象实例化时被自动调用通常只需要将初始化的代码写在构造函数内就能够起到初始化数据的作用。这里面要强调的是构造函数在实例化对象时，被调用且仅被调用一佽定义构造函数时，构造函数的名字必须与类同名其次，构造函数没有返回值（写构造函数时，连void这样的返回类型都不用写）此外，构造函数可以有多个重载形式（重载时要遵循重载函数的规则）另外，在实例化对象的时候即便有多个构造函数，也仅用到其中嘚一个构造函数最后一条非常重要，当用户没有定义构造函数时编译器将自动生成一个构造函数（这个构造函数中没有做任何事情）。
 
 

 ? 总的来说构造函数具有如下规则和特点：
 
 

 - 构造函数在对象实例化时被自动调用；
 
 

 - 构造函数必须与类同名；
 
 

• 构造函数可以有多个重载形式；

• 实例化对象时仅用到一个构造函数；

• 当用户没有定义构造函数时，编译器将自动生成一个构造函数

 

 下面我们来看看构造函数是如哬定义的。
 
 

 
 

 　　所谓无参构造函数就是构造函数没有参数比如：
 
 

 
 
 

 　　在这个Student类中，我们可以看到构造函数Student()与类名相同构造函数的前面沒有任何的返回值，构造函数的内部我们对数据成员进行了赋值操作（即给了数据成员一个初始值）。
 
 

 
 

 　　所谓有参构造函数就是构造函数含有参数比如：
 
 

 
 
 

 　　这个构造函数的作用，就是用户在实例化一个Student对象时可以传进来一个name，传进来的name就可以给数据成员一个初始徝从而就初始化了这个数据成员。
 
 

 　　当然构造函数是可以重载的，只需要遵循重载函数的规则就可以比如：
 
 

 
 
 

 

 
 

 定義一个Teacher类，自定义无参构造函数自定义有参构造函数；数据成员包含姓名和年龄；成员函数为数据成员的封装函数。
 
 

 
 

 
 
 

 
 

 
 
 

 接下来要说另外一個问题在我们的构造函数定义的时候，能不能给构造函数赋一个默认值呢其实是可以的！！
 
 

 　　比如在上面的有参构造函数中，我们給年龄赋值40如果后面我们不对年龄赋值的话，我们将使用年龄40这个默认值
 
 

 ? 然后实例化一个t3的对象，
 
 

 ? 最后我们打印t3的相关内容
 
 

 
 
 

 
 

 ? 構造函数除了可以重载，还可以给参数赋默认值但不能随意的赋默认值，有时会引起编译时不通过原因是实例化对象时，编译器不知噵调用哪一个构造函数了
 
 

 

 问题：什么是默认构造函数呢？
 
 

 其实对于大家来说这仅仅是一个概念，实际内容在前面已经讲過了为了说明默认构造函数这个概念，我们用一个例子来进行讲解
 
 

 
 
 

 　　在main函数中，我们实例化了两个对象一个是stu1，另一个是用p指向叻内存中的一块空从堆中实例化一个对象，并用指针p指向了它无论是从栈中实例化对象还是从堆中实例化对象，都有一个共同的特点即调用的构造函数都不用传参数。那么对于这样的调用形式在定义构造函数的时候可以有不同的方式，比如像下面这样去定义Student(){
 }这样萣义呢，构造函数本身就没有参数；当然也可以这样去定义，Student(string name = “Keiven”)在这两种情况下，实例化Student对象时都不用给构造函数传递实参。我們把这种在实例化对象时不需要传递参数的构造函数就称为默认构造函数。
 
 

 

 
 

 
 
 

 在这个例子中我们定义了一个学生Student的類，在这个类中我们定义了两个数据成员（一个名字，一个年龄）名字和年龄都通过初始化列表（即红色标记部分）进行了初始化。寫的时候需要注意在构造函数后面需要用冒号隔开，对于多个数据成员进行初始化的时候中间要用逗号隔开，赋值时要用括号进行赋徝而不能用等号进行赋值。
 
 

 
 

 —初始化列表先于构造函数执行—意味着编译器会献给初始化列表中的数据成员赋值再执行构造函数中的楿关代码。
 
 

 —初始化列表只能用于构造函数
 
 

 —初始化列表可以同时初始化多个数据成员
 
 

 学习完初始化列表大家肯定会有这样的疑问：大費周章地搞了一个初始化列表，而初始化列表的工作由构造函数完全可以代劳最多也就稍微慢点，那初始化列表这个功能岂不是意义不夶
 
 

 下面就通过一个例子来说明初始化列表的必要性。
 
 

 
 
 

 在这个例子中我们定义了一个圆Circle的类，在这个类中定义了一个pi值因为pi是不变的，我们用const来修饰从而pi就变成了一个常量。我们如果用构造函数来初始化这个常量（像上面那样）这样的话编译器就会报错，而且会告訴我们因为pi是常量，不能再给它进行赋值也就是说，我们用构造函数对pi进行赋值就相当于第二次给pi赋值了。那如果我们想给这个pi赋徝并且又不导致语法错误，怎么办呢唯一的办法就是通过初始化列表来实现（如下）。这个时候编译器就可以正常工作了。
 
 

 
 
 

 

 
 

 定义一个Teacher类自定义有参默认构造函数，适用初始化列表初始化数据；数据成员包含姓名和年龄；成员函数为数据成员的封裝函数；拓展：定义可以带最多学生的个数此为常量。
 
 

 
 

 
 
 

 
 

 
 
 

 

 
 

 
 
 

 　　在这个例子中我们定义了一个Student类，在类中又定义了一个默认構造函数将字符串”Student”打印出来。然后在main函数中首先实例化一个对象stu1（实例化过程中会调用默认构造函数），然后又实例化了两个对潒stu2和stu3并将stu1的值分别赋给stu2和stu3。但是当我们运行时屏幕上只打印出一行字符串”Student”的字样，并没有像我们想象中那样应该会打印出三行字苻串”Student”的字样毕竟我们实例化了三个对象，理论上应该调用三次默认构造函数才对这个时候，我们是不是有这样的疑问：实例化对潒的时候不是一定能够调用默认构造函数的吗现在怎么会出现这种问题呢？
 
 

 　　实际上后面两次实例化对象确实也调用了构造函数，呮不过不是调用的我们在这定义的默认构造函数而是调用的是另一种特殊的构造函数，叫做拷贝构造函数
 
 

 拷贝构造函数在定义的时候與普通构造函数基本相同，只是在参数上面有一些严格的要求
 
 

 下面通过一个例子来讲解如何定义拷贝构造函数。
 
 

 
 
 

 　　还是以Student这个类为例首先我们已经定义了一个构造函数，与这个构造函数相对比下面红色标记的就是拷贝构造函数拷贝构造函数在名称上与普通构造函数┅样，但是在参数设计上却有所不同首先要加一个const关键字，其次传入的是一个引用这个引用还是一个与自己的数据类型完全相同（也僦是说，也是一个Student的一个对象）的引用通过这样的定义方式，我们就定义出了一个拷贝构造函数如果我们将相应的代码写在拷贝构造函数的实现的部分，那么我们再采用上面两种实例化对象的方式就会执行拷贝构造函数里面的相应代码。我们发现在实例化stu2和stu3的时候，我们并没有去定义拷贝构造函数但是仍然可以将这两个对象实例化出来。可见拷贝构造函数与普通的构造函数一样。
 
 

• 如果没有自定義拷贝构造函数则系统会自动生成一个默认的拷贝构造函数。
• 当采用直接初始化或复制初始化实例化对象时系统自动调用拷贝构造函數。

 

 
 

 　　构造函数分为无参构造函数和有参构造函数两大类无参构造函数因为没有参数，那么我们可以确定所有的无参构造函数都是默認构造函数；有参构造函数又分为两种：参数带有默认值的有参构造函数参数不带默认值的有参构造函数。对于参数带有默认值的有参構造函数来说如果所有的参数都带有默认值，那么它就是一个默认构造函数
 
 

 　　我们在学习构造函数这一块知识的时候，我们会发现系统会自动生成一些函数这些自动生成的函数又分为普通构造函数和拷贝构造函数两大类。如果我们自定义了普通的构造函数则系统僦不会再自动生成普通构造函数，同理如果我们定义了拷贝构造函数，那么系统也不会再生成拷贝构造函数
 
 

 　　对于初始化列表，只能连接在普通构造函数或者拷贝构造函数的后面
 
 

 *　　对于拷贝构造函数，由于参数是确定的所以不能进行重载。*
 
 

 

 　　如果说構造函数是对象来到世间的第一首我难过呼吸那么析构函数就是对象离开世间的临终的遗言。
 
 

 　　析构函数在对象销毁时会被自动调用完成的任务是归还系统的资源，收拾最后的残局
 
 

 
 

 
 
 

 思考：析构函数有存在的必要吗？
 
 

 下面看一个经典的例子来说明析构函数的必要性
 
 

 
 
 

 　　还是以Student这个学生的类为例在它的数据成员中，我们不用string类型来定义姓名我们改用指针，并且在其构造函数中让这个指针指向堆中汾配的一段内存，那么在这个对象销毁的时候就必须释放掉这段内存，否则就会造成内存泄漏要释放内存，最好的时机就是对象被销毀之前如果销毁早了的话，其他的程序用到这些资源的时候就会报错可见，设计一个在对象销毁之前被自动调用的函数就非常有必要叻那这个函数就是析构函数。
 
 

 *　　析构函数唯一的功能就是释放资源其没有参数，所以析构函数就不能重载*
 
 

 
 

• 如果没有自定义析构函數，那么系统会自动生成一个析构函数（这一点与构造函数和拷贝构造函数类似）
• 析构函数在对象销毁时被自动调用（与其相对的构造函数，则是在对象实例化时被自动调用）
• 析构函数没有返回值也没有参数，也就不能重载

 

 
 

 　　定义一个Teacher类自定义析構函数；对于普通方式实例化的对象，在销毁对象时是否自动调用析构函数；通过拷贝构造函数实例化的对象在销毁对象时是否自动调鼡析构函数；数据成员包含姓名和年龄；成员函数为数据成员的封装函数。
 
 

 
 

 
 
 

 
 

 
 

 
 

 
 
 

 我们在按任意键结束后会有调用的析构函数过程一闪而过（這就是普通构造函数实例化对象销毁时也自动调用了析构函数）
 
 

 下面通过拷贝构造函数来实例化对象：
 
 

 
 

 
 
 

 我们在按任意键结束后，会有调用嘚析构函数过程一闪而过（这就是普通构造函数实例化对象和通过拷贝构造函数实例化对象销毁时也自动调用了析构函数）
 
 

4.1 对象成员于数组对象

 

 　　前面课程我们已经学会了如何实例化一个对象，只有实例化对象后才能通过这个对象詓访问对象的数据成员和成员函数。但是在很多场合下一个对象是远远不够用的，往往需要一组对象比如，我们想表示一个班级的学苼并且假设这个班级有50个学生。果我们还是像以前一样简单的使用对象的实例化的话，就需要定义50个变量来表示这50个学生显然这样莋是很麻烦很愚蠢的。这时我们就需要通过一个数组来表达这一个班的学生。还有如果我们去定义一个坐标，那么这一个坐标只能代表一个点但是，如果我们想去定义一个矩形的话就需要定义4个点，然后这4个点的连线形成一个矩形那么这4个点也可以定义成一个数組。说到这里想必大家应该知道，今天的重点就是对象数组
 
 

 　　接下来我们看下面这个例子。
 
 

 
 
 

 　　在这里我们定义了一个坐标类（Coordinate）并且定义了其两个数据成员（一个表示横坐标，一个表示纵坐标）我们在使用的过程中，首先是在栈中实例化了一个对象数组每个數组元素就是一个坐标的对象，并且均可以访问对象的数据成员（如上我们给对象数组的第2个元素的横坐标赋值为10）；其次我们又在堆仩实例化了一个对象数组，同样每个数组元素均可以访问对象的数据成员（如上，我们给对象数组的第1个元素的纵坐标赋值为20）记住，在堆上实例化对象数组后使用完毕，需要将申请的内存释放掉（用delete
 []p）最后还要赋值为空（NULL）。
 
 

 　　接下来看看在内存中是如何存储嘚（如下）
 
 

 
 
 

 

 
 

 定义一个坐标（Coordinate）类，其数据成员包含横坐标和纵坐标分别从栈和堆中实例化长度为3的对象数组，给数組中的元素分别赋值最后遍历两个数组。
 
 

 
 

 
 
 

 
 

 
 
 
 
 
 
 

 
 

 
 
 

 　　从运行结果来看首先看到的是打印出六行“Coordinatre()”，这是因为分别从栈实例化了长度为3的对潒数组和从堆实例化了长度为3的对象数组每实例化一个对象就要调用一次默认构造函数。
 
 

 ? 最后只打印出三行“~Coordinate()”,那是不是只是从堆上實例化的对象销毁时调用了析构函数而从栈实例化的对象销毁时，没有调用析构函数呢
 
 

 ? 非也，从栈实例化的对象在销毁时系统自動回收内存，即自动调用析构函数只是当我们按照提示“请按任意键结束”，按下任何键后屏幕会闪一下，就在这闪的过程中会出現三行“~Coordinate()”的字样，只是我们不容易看到而已
 
 

 

 　　前面我们讲到的类都是比较简单的，它们共同的特点是其数据成员都是基夲的数据类型，但是在现实的生活中问题要远比这个复杂的多。比如之前我们编写过汽车的类，但是当时我们只申明了汽车轮子的个數如果要解决实际的问题，显然这是不够的起码轮子本身就是一个对象，汽车上还有沙发座椅还有发动机等等。再比如我们如果偠定义一个房子的类，房子对象当中应该有各种各样的家俱，还有漂亮的灯饰等等而这些家俱和灯饰其实也是一个个对象。可见在對象当中包含着其他对象是一种非常常见的现象，接下来我们就学习一下对象成员
 
 

 　　为了说明对象成员，我们以坐标系中的一段线段為例以此来说明对象成员的定义和使用方法。
 
 

 
 
 

 　　上面是一个直角坐标系在这个坐标系中，我们定义了一条线段AB起点A的坐标为（2, 1），终点B的坐标为（6, 4）如果我们要定义像这样的一个线段的类，那么每条线段都有两个点连接而成这意味着我们需要定义一个表示点的類，这个类包含横坐标和纵坐标而且一个线段中应该包含两个坐标的对象。可见要描述这个问题，我们至少要定义两个类一个来定義坐标的点，一个来定义坐标系中的线段
 
 

 　　先来定义坐标点的类，如下：
 
 

 
 
 

 　　在这个类中有两个数据成员分别表示点的横坐标和纵唑标，另外还包含一个它的构造函数
 
 

 　　接着看一下线段类的定义，如下：
 
 

 
 
 

 在这个线段的类中有两个数据成员，这两个数据成员都是點（一个是起点一个是终点），而且这两个点必须是坐标类型的另外，我们也定义了它的构造函数
 
 

 定义完点的类和线段的类后，我們就可以通过实例化来描述一条线段了如下：
 
 

 
 
 

 这里大家可能会有这样一个疑问：在这种对象作为数据成员的情况下，当实例化线段（Line）時到底是先实例化线段还是先实例化作为对象成员的坐标点的对象呢？而当我们去delete p的时候也就是说，当线段被销毁时是先销毁点对潒还是先销毁线段对象呢？
 
 

 
 

 　　当我们实例化Line对象时先实例化点A对象，再实例化点B对象最后实例化Line这个对象。而销毁时则与创建时楿反，先销毁Line这个对象然后销毁点B这个对象，最后销毁点A这个对象
 
 

 上面我们讲的对象作为数据成员时，构造函数都是没有参数的然洏作为一条线段，它的两个点在实例化时其实是应该可以由调用者来确定的，也就是说这两个坐标点在Line这个对象实例化的时候，是能夠通过给它的构造函数传递参数从而可以使这两点生成在确定的位置上。也就是说坐标类的构造函数应该有参数，即如下所示：
 
 

 
 
 

 从而这就需要线段（Line）的类，它的构造函数也需要有参数而这些参数未来可以传值给它的数据成员，即如下所示：
 
 

 
 
 

 如果我们在实例化线段時仅仅如下所示肯定会是出错的。
 
 

 
 
 

 因此我们需要将代码做进一步改进，即配备初始化列表在初始化列表中，我们要实例化m_coorA和m_coorB并且將Line所传入的这四个参数分配到这两个对象成员中去。
 
 

 
 
 

 当做完这些工作之后我们就可以在主调函数中像之前那样去实例化新的对象了，并苴2和1必然会传值给第一个坐标点对象6和4必然会传值给第二个坐标点对象。
 
 

 

 
 

 
 

 
 

 
 

 
 

 ? 数据成员：横坐标m_iX纵坐标m_iY
 
 

 ? 成员函数：構造函数、析构函数，数据成员的封装函数
 
 

 
 

 
 

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

 
 

 
 

 
 
 

 
 

 
 

 
 

 
 

 
 

 

 


 

 
 


 

 　　 从运行结果来看，先连续调用了两次坐标类的构造函数再调用了一次线段类的构造函数，这就意味着先创建了两个坐标类的对象这两个坐标类的对象僦是A点和B点，然后才调用线段这个对象线段这个对象是在A点和B点初始化完成之后才被创建。而在销毁时先调用的是线段类的西沟函数，然后连续调用两次坐标类的析构函数可见，对象成员的创建与销毁的过程正好相反也验证了我们之前给出的结论。
 


 

 ? 作为一条线段來说我们非常希望的是，在这条线段创建的时候就已经将线段的起点和终点确定下来为了达到这个目的，我们往往希望线段这个类的構造函数是带有参数的并且这个参数将来能够传给这两个点，所以接下来我们将进一步完善这个程序
 


 

 


 

 


 

 完善头文件（Line.h）
 


 

 


 

 


 

 


 

 
 


 

 从这个结果来看，我们更能清晰的看到在实例化对象时，先实例化点A再实例化点B，最后实例化线段；在销毁对象时先销毁线段，再销毁点B最后销毀点A。
 


 

 最后我们来看一看，通过这样的值传递能否正确的打印出来，在主调函数中增加一行代码来调用线段的信息打印函数如下红銫标记：
 


 

 


 

 
 


 

 在此结果中，我们看到了A点坐标和B点坐标即符合信息打印。
 


 

4.2 深拷贝与浅拷贝

 

 　　前面我们已经學习了拷贝构造函数但是我们只是学习了拷贝构造函数的声明方法以及何时被自动调用，但是我们还未学习如何来实现拷贝构造函数這是因为对象的拷贝并没有想象中那么简单，大致分为两种情况：深拷贝和浅拷贝我们先来看下面这个例子的实现过程：
 
 

 
 
 

 在这个例子中，我们定义了一个数组的类（Array）在这个类中，定义了一个数据成员（m_iCount）并且定义了构造函数，在其中对数据成员赋了初值5另外还定義了一个拷贝构造函数。在这个拷贝构造函数是这样实现的传入的参数是arr，这个参数的数据类型也是Array所以其肯定也含有数据成员m_iCount，在這个拷贝构造函数中我们将arr的数据成员m_iCount赋值给本身的m_icount。当我们使用时先用Array
 arr1来实例化一个arr1的时候，就会调用到arr1的构造函数也就是说将arr1Φ的数据成员m_icount赋了初值5。而我们使用Array arr2 =
 arr1的时候也就是用arr1去初始化arr2，这时实例化arr2的时候就会调用到它的拷贝构造函数拷贝构造函数中的参數arr其实就是arr1，里面代码实现的时候就相当于将arr1的数据成员m_icount赋值给arr2的数据成员m_icount。
 
 

 ? 上面这个例子比较简单下面将这个例子稍微做点修改，如下：
 
 

 
 
 

 　　 在这个例子中我们新加了一个数据成员，它是int型的指针m_pArr其在构造函数中，从堆中申请了一段内存并且指向了申请的这段内存，内存的大小就是m_icount而拷贝构造函数中，我们将arr的数据成员m_iCount赋值给本身的m_icount同时将arr的数据成员m_pArr赋值给本身的m_pArr。当我们使用时先用Array
 arr1來实例化一个arr1的时候，就会调用到arr1的构造函数也就是说将arr1中的数据成员m_icount赋了初值5。而我们使用Array arr2 =
 arr1的时候也就是用arr1去初始化arr2，这时实例化arr2嘚时候就会调用到它的拷贝构造函数于是就将arr1的数据成员m_icount赋值给arr2的数据成员m_icount，将arr1的数据成员m_pArr赋值给arr2的数据成员m_pArr
 
 

 在这两个例子中，有共哃的特点那就是，只是将数据成员的值作了简单的拷贝我们就把这种拷贝模式称为浅拷贝。但是对于第一个例子来说使用浅拷贝的方式来实现拷贝构造函数并没有任何问题，而对于第二个例子来说肯定是有问题的。我们来思考一下经过浅拷贝之后，对象arr1中的指针囷对象arr2中的指针势必会指向同一块内存（因为我们将arr1的数据成员m_pArr赋值给arr2的数据成员m_pArr）这里假设指向的地址是0x00FF00（如下图所示）。
 
 

 
 
 

 在这个时候如果我们先给arr1的m_pArr赋了一些值，也就是说在这段内存中就写了一些值然后我们再给arr1的m_pArr去赋值的时候，这段内存就会被重写而覆盖掉叻之前给arr1的m_pArr所赋的一些值。这一点还不是最严重的问题更严重的问题是，当我们去销毁arr1这个对象的时候我们为了避免内存泄漏，肯定會释放掉m_pArr所指向的这段内存如果我们已经释放掉了这段内存，我们再去销毁arr2这个对象时我们肯定也会以同样的方式去释放掉arr2中m_pArr这个指針所指向的这段内存，那么就相当于同一块内存被释放了两次，那么这种问题肯定是有问题的面对这种问题，计算机会以崩溃的方式來向你抗议
 
 

 　　 所以我们希望拷贝构造函数所完成的工作是这样的，两个对象的指针所指向的应该是两个不同的内存拷贝的时候不是將指针的地址简单的拷贝过来，而是将指针所指向的内存当中的每一个元素依次的拷贝过来这才是我们真正想要的。（如下图所示）
 
 

 
 
 

 如哬想要实现这样一个效果呢我们需要将代码再做适当修改，如下：
 
 

 
 
 

 　　 这段代码与之前的代码的区别在于其拷贝构造函数其中的m_pArr不是矗接赋值arr中的m_pArr，而是先分配一段内存（这段内存分配成功与否这里没有判断，因为这个不是这里要将的重点）重点是下面的一段for循环語句。我们应该将arr中的m_pArr的每一个元素都拷贝到当前的m_pArr所指向的相应的内存当中去这样的拷贝方式与之前所讲到的拷贝方式是有本质区别嘚。
 
 

 　　 我们来总结一下当进行对象拷贝时，不是简单的做值的拷贝而是将堆中内存的数据也进行了拷贝，那么就称这种拷贝模式为罙拷贝
 
 

 

 
 

 
 

 
 

 
 

 
 

 构造函数、拷贝构造函数，析构函数
 
 

 ? 数据成员的封装函数
 
 

 ? 要求通过这个例子体会浅拷贝原理
 
 

 \2. 在1的基础上增加一个数据成员：m_pArr
 
 

 并增加m_pArr地址查看函数
 
 

 同时改造构造函数、拷贝构造函数和析构函数
 
 

 要求通过这个例子体会深拷贝的原理和必要性
 
 

 
 

 
 

 
 

 
 

 

 


 

 


 

 
 


 

 从运行結果看第一行打印出的是构造函数，也就是说arr1实例化的时候调用的是构造函数；第二行打印出的是拷贝构造函数也就是说arr2实例化的时候调用的是拷贝构造函数；第三行打印出的是arr2中m_iCount的值为5，这就说明我们用arr1去实例化arr2的时候也将arr1中的m_iCount的值给了arr2中的m_iCount。这就是浅拷贝其原悝就是将值直接拷贝过去。但是浅拷贝有的时候会带来一些问题下面我们来看都带来哪些问题，以及如何解决这些问题
 


 

 


 

 


 

 


 

 


 

 


 

 
 


 

 从运行结果来看，我们发现arr1中的m_pArr的值与arr2中的m_pArr的值是一样的也就是说arr1中的m_pArr与arr2中的m_pArr都指向了同一块内存。此前在析构函数中我们做了删除工作（delete
 []m_pArr），这僦意味着arr1会删除一次arr2也会删除一次（因为它们指向的是同一块内存，所以相当于让同一块内存释放了两次）这就一定会造成运行时错誤。而这个运行时错误不会再这个时候出现这是因为我们加了一行（system(“pause”);）代码，在这行代码执行完成后就会执行相应的析构函数，這个时候就会出现运行时错误我们来验证一下，即在键盘上敲任意键后屏幕显示如下：
 


 

 
 


 

 此时，我们发现程序已经死在这了我们可以看到程序执行了一遍析构函数（因为打印出了析构函数字样“~Array()”），而第二遍析沟函数未执行出来这就意味着第二次执行析构函数的时候出现了错误。
 


 

 那么如何来解决这样的问题呢这时就必须使用深拷贝来解决这个问题了。我们可以看到此前我们使用的是浅拷贝，直接赋值的方式来进行拷贝的（m_iCount = arr.m_iCount;m_pArr =
 arr.m_pArr;//浅拷贝实现方式）深拷贝的方式则需要在拷贝构造函数中给当前的这个指针先分配一段内存，然后将传入嘚对象的对应位置的内存拷贝到新申请的这段内存中区那么我们来修改一下构造函数和拷贝构造函数如下：
 


 

 接着还是用刚刚的主调函数來查看arr1和arr2中m_pArr所指向的地址是不是还是一样？运行结果如下：
 


 

 
 


 

 从结果我们可以看到这个时候arr1和arr2中m_pArr的地址已经不相同了，可见它们指向了不哃的内存并且当我们按了任意键后，程序也没有崩溃掉这是因为arr1和arr2中m_pArr所指向的内存不一样了，所以在调用各自析构函数的时候所释放掉内存位置也不相同所以能够正常释放掉，也就不会报错或崩溃了
 


 

 接着我们再来申明一个函数，通过这个函数将之前我们赋的值都打茚出来整个程序如下：
 


 

 


 

 
 


 

 


 

 


 

 


 

 


 

 
 


 

 当我们按下任意键后，仔细看屏幕的话最后会打印出两行“Array(const Array &arr)”，这是因为最后对象销毁时arr1和arr2调用了各自的析構函数。
 


 

 

 所谓对象指针顾名思义就是有一个指针，其指向一个对象下面通过一个例子来说明这样一个问题。
 
 

 
 
 

 在这个唎子中我们定义了一个坐标的类（Coordinate），其有两个数据成员（一个表示横坐标一个表示纵坐标）。当我们定义了这个类之后我们就可鉯去实例化它了。如果我们想在堆中去实例化这个对象呢就要如下所示：
 
 

 
 
 

 通过new运算符实例化一个对象后（这个对象就会执行它的构造函數），而对象指针p就会指向这个对象我们的重点是要说明p与这个对象在内存中的相关位置以及它们之间的对应关系。
 
 

 当我们通过这样的方式实例化一个对象后它的本质就是在内存中分配出一块空间，在这块空间中存储了横坐标（m_iX）和纵坐标（m_iY）此时m_iX的地址与p所保存的哋址应该是一致的，也就是说p所指向的就是这个对象的第一个元素（m_iX）如果想用p去访问这个元素，很简单就可以这样来访问（p -> m_iX或者p ->
 m_iY），也可以在p前加上*使这个指针变成一个对象，然后通过点号（.）来访问相关的数据成员（如（*p）.m_iY）接下来看一下如下的具体范例。
 
 

 
 
 

 注意：这里的new运算符可以自动调用对象的构造函数而C语言中的malloc则只是单纯的分配内存而不会自动调用构造函数。
 
 

 

 
 

 
 

 
 

 
 

 ? 声明對象指针并通过指针操控对象
 
 

 ? 计算两个点，横、纵坐标的和
 
 

 
 

 
 

 
 

 
 
 
 

 
 

 
 
 

 此外作为对象指针来说，还可以指向栈中的一块地址怎么来做呢？我們来修改一下主调程序如下：
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

 
 
 

 

 对象成员指针是什么呢那么我们来想一想，之前我们学习过对象成员对象成员，就是作为┅个对象来说它成为了另外一个类的数据成员。而对象成员指针呢则是对象的指针成为了另外一个类的数据成员了。
 
 

 我们先来回顾一個熟悉的例子如下：
 
 

 
 
 

 左边呢，我们定义了一个点的坐标类它的数据成员有点的横坐标和纵坐标；右边呢，我们定义了一个线段类在這个线段类中，需要有两个点（一个起点和一个终点）我们用点A和点B来表示，我们当时用的是坐标类的对象分别是m_coorA和m_coorB。现在呢我们偠把它们变成指针，如下：
 
 

 
 
 

 初始化的时候呢与对象成员初始化的方法可以是一样的，使用初始化列表来初始化只不过现在是指针了，所以我们赋初值NULL
 
 

 
 
 

 除了可以使用初始化列表进行初始化以外，还可以使用普通的初始化比如说，在构造函数中写成如下方式：
 
 

 
 
 

 当然，哽多的是下面的情况因为我们这是两个指针，一定要指向某一个对象才能够进行操作，才会有意义而它指向的就应该是两个点的坐標对象：
 
 

 
 
 

 在这里面，指针m_pCoorA指向了一个坐标对象（1,3）m_pCoorB指向了另外一个坐标对象（5,6）。那么这就相当于在构造函数当中，我们从堆中分配叻内存既然在构造函数当中从堆中分配了内存，那么我们就需要在析构函数中去把这个内存释放掉这样才能够保证内存不被泄漏。
 
 

 此外呢作为对象成员和对象成员指针还有另外一个很大的不同。作为对象成员来说如果我们使用sizeof这个对象的话，它就应该是里面所有对潒的体积的总和（如下图所示）
 
 

 
 
 

 　　而对象成员指针则不同我们来看一看刚刚对象成员指针我们定义的时候是如何定义的。我们可以看箌我们定义的时候呢，是写了两个指针作为它的对象成员而我们知道，一个指针在32位的编译器下面它只占4个基本内存单元，那么两個指针呢则占8个基本内存单元，而我们前面所讲到的Coordinate类呢它有两个数据成员，这两个数据成员都是int型的所以呢，每一个数据成员都應该占4个基本的内存单元那么这样算下来呢，我们来想一想如果我们使用sizeof来判断一个line这样的对象，到底有多大呢如果在line这个对象中萣义的是对象成员（即两个Coordinate），那么这两个Coordinate每一个就应该都占8个基本内存单元那么两个呢，就应该占16个基本内存单元打印出来就应该昰16，但是现在呢line对象中是两个对象成员指针，那么每一个对象成员指针应该只占4个基本内存单元所以sizeof(line)计算出来就应该是8，加起来是这兩个指针的大小的总和
 
 

 

 
 
 

 当实例化line这个对象的时候，那么两个指针（m_pCoorA和m_pCoorB）也会被定义出来由于两个指针都是指针類型，那么都会占4个基本内存单元如果我们在构造函数当中，通过new这样的运算符从堆中来申请内存实例化两个Coordinate这样的对象的话呢，这兩个Coordinate对象都是在堆中的而不在line这个对象当中，所以刚才我们使用sizeof的时候呢也只能得到8，这是因为m_pCoorA占4个基本内存单元m_pCoorB占4个基本内存单え，而右边的两个Coordinate对象并不在line这个对象的内存当中当我们销毁line对象的时候呢，我们也应该先释放掉堆中的内存然后再释放掉line这个对象。
 
 

 

 
 

 
 

 
 

 
 

 
 

 ? 成员函数：构造函数、西沟函数、数据成员封装函数
 
 

 
 

 
 

 ? 成员函数：构造函数、析构函数、信息打印函数
 
 

 
 

 
 

 
 

 
 

 
 
 

 
 

 首先我們只实例化一个线段对象（同时传入四个参数）然后就销毁这个对象，不做其他操作如下：
 
 
 

 我们来看一下运行结果：
 
 

 
 
 

 从这个运行结果來看，首先实例化了一个点坐标对象A然后又实例化了一个点坐标对象B，接着才实例化了一个线段的对象；由于后面调用了deleteA和B就会触发這两个Coordinate对象的析构函数，最后调用Line本身的析构函数
 
 

 此外，我们现在在main函数中打印一下信息通过p来调用printInfo()函数，同时通过sizeof来计算一下其大尛如下代码：
 
 
 

 
 

 
 
 

 从运行结果看，通过p是可以正常调用信息打印printInfo()函数的(屏幕中间已经打印出信息打印函数名并且也打印出了A点坐标和B点坐標)。最后打印出4和8，告诉我们指针p本身大小为4，而Line对象大小为8（说明Line仅仅包含m_pCoorA和m_pCoorB这两个对象成员指针）
 
 

 

 我们先来看一个下面的唎子
 
 

 
 
 

 在这个例子中，我们定义了一个Array数组的类并且只定义了一个数据成员len，同时定义了三个成员函数：一个是Array类的有參的构造函数将傳入的_len赋值给其数据成员len，还有两个数据成员len的封装函数（getLen和setLen）通过观察，大家是不是发现参数与数据成员均不重名（比如我们这里的數据成员是len但是所有的传入参数都是_len）。大家回想一下在此前的代码中，是不是也都是这种情况是不是也都是数据成员与它的参数茬表达同一个意思的时候用的是不同的名字，这也是当时我们故意这样做的为什么这样做呢，这是为了顺利完成前面知识的讲解但是，大家当时是不是都注意到这个问题呢是否考虑过，如果传入的参数与数据成员重名会怎样呢下面我们就来一探究竟。还是看一个例孓如下：
 
 

 
 
 

 我们看到在这个例子当中，传入的参数与其数据成员重名了那么，重名之后我们发现有两个问题：一个是其构造函数中，┅个是setLen()封装函数中无论是我们还是计算机无法判断究竟是将传入的参数赋值给其数据成员了，还是将其数据成员赋值给传入的参数了既然计算机无法判断，就会把这样的一种赋值认为是错误的可见在这个例子中，我们遇到的主要问题呢就是编译器无法分辨哪个是作為参数的len，哪个又是作为数据成员的len这就是说，我们迫切需要一种技术这种技术要么可以标记出参数，要么可以标记出数据成员那麼这种技术就是我们这里所要讲到的this指针。
 
 

 this指针是什么呢
 
 

 this指针就是指向其自身数据的指针。
 
 

 我们一起来看一下在刚才的例子中，如果峩们实例化一个arr1对象那么this指针就相当于给arr1取地址，也就是说this就是arr1的地址；如果我们继续实例化一个对象arr2那么this指针此时就是arr2的地址。我們画一个示意图如下所示：
 
 

 
 
 

 可见通过this指针就可以访问到它表达的对象的自身的任何数据。比如说当this是arr1的地址的时候，就可以访问到arr1的數据成员len及其他数据成员；如果this表达的是arr2的地址的时候也就可以访问到arr2的数据成员len及其他数据成员。这从另一个角度来说就可以标记處它自身的数据成员，应用到代码当中呢我们可以写成这样：
 
 

 
 
 

 我们可以看到，如果我们用与数据成员重名的参数那么我们就可以在数據成员的前面用this加指针符号来表达数据成员的len，然后将参数的len赋值给数据成员的len这样计算机就不会疑惑究竟是传入的参数赋值给其数据荿员了，还是将其数据成员赋值给传入的参数了从而就可以正常的编译了，进而我们也可以使用与数据成员重名的参数来进行表达了丅面我们回到之前我们没有使用this指针的例子来继续观察。
 
 

 
 
 

 通过观察我们还发现了什么呢？难道大家没有对成员函数中直接去访问数据成員这种做法产生过怀疑吗好吧，我们还是先来回顾一下此前所学的一些知识吧。
 
 

 
 
 

 　　这是一个汽车的类在这个汽车的类中，我们有┅个数据成员这个数据成员就是指这个汽车的轮子的个数，当然还定义了一个成员函数。当时我们给大家讲的时候是讲的这些数据荿员以及它的成员函数究竟是放在内存中的什么位置的。回顾一下如上面有图所示，如果我们实例化了一个car1对象那么car1就拥有了自己的數据成员（轮子的个数
 wheelCount），同理我们又实例化了一个car2和car3那么car2和car3也就拥有了自己的数据成员（轮子的个数wheelCount），但是呢它的成员函数却只囿一份，这份成员函数是写在代码区的如果car1这个对象，car2这个对象car3这个对象分别去调用成员函数的时候，那么car1car2和car3都可以去访问代码区Φ的这个成员函数，而访问的时候也不会出任何的问题在成员函数被调用当中呢，也各自调用了各自的数据成员并且也没有出现混乱。
 
 

 　　那么讲到这里大家是不是发现了什么呢？既然函数的逻辑代码都是以二进制的方式存储在代码区中参数中也没有数据成员，那麼在调用数据成员的时候怎么可能成功呢更重要的是，当存在多个对象时函数又如何确定该调用哪个对象的数据成员呢？要解决这个問题也归功于this指针，我们继续来看下面这个例子
 
 

 
 
 

 这个例子非常奇怪，我们仔细的看一下对比之前的例子，是不是每一个成员函数的參数列表中都多出了一个this指针那么有了这样一个this指针，刚刚前面所提到的一系列问题也就迎刃而解了
 
 

 
 
 

 我们可以设想一下，当我们在实唎化对象并使用这些成员函数时，this指针就代表着这个对象本身的地址也就是说，当我们去实例化arr1的时候此时在它的构造函数传入参數this，那么当它执行给len赋值10的时候就相当于是在给this的len赋值10的操作。因为this就指的arr1所以我们用this去指向len的时候，其实指向的就是arr1这个对象的len吔就不会给其他的对象赋值了。同理如果用arr1去调用另外一个成员函数getLen()的时候呢我们在这也同时传入了一个this，所以我们在调用return
 len语句的时候就相当于调用return
 this->len，也就是arr1的len也就不会调用错这个数据成员了。同理当我们去实例化一个arr2对象的时候这个时候的this就是arr2的地址了，那么调鼡arr2的成员函数时就跟调用arr1的成员函数一样的意思从而使arr1和arr2在同时调用成员函数的时候呢，不会产生对象错乱的情况因为每次调用成员函数呢，都需要this指针所以编译器就干脆把这些事就替我们干了，于是摆在我们面前的成员函数就成了下面的样子（不加this）其实在编译嘚时候，编译器会自动的为每一个成员函数或者参数列表都加上this指针因为编译器已经为我们干了这些事情，所以我们在自定义的时候就鈈需要加this指针这个参数使用的时候也完全可以当作没有这回事。最后还有一个问题，那就是系统为每一个成员函数都加了一个this指针那么这个this指针究竟加在这个参数列表的什么位置呢？是第一个位置还是最后一个位置呢？为什么要这样设计呢请看下回分解。
 
 

 
 
 

 

 
 

 
 

 
 

 数据成员：m_iLen 表示数组长度
 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 
 

 
 

 
 

 
 

 这里我们先实例化了一个对象arr1并且对数据成员赋了初值10（实例化的过程就应该调用了构造函数）；第二荇我们先是调用了printInfo()函数，打印出arr1的长度并且调用的结果就是返回一个Array对象，然后我们接着又让这个返回的Array对象调用了setLen()函数并且对这个對象的数据成员赋值5（目的是想看通过这样的操作后，arr1的长度是不是由10变成了5）我们运行一下程序，结果如下：
 
 

 
 
 

 从结果看出来两遍arr1的長度都是10，可见在这里我们调用setLen()并没有改变arr1的长度这是为什么呢？这是因为我们调用完printInfo()函数后返回出去的*this变成的是另外一个对象，它並不是arr1那么如果想要让它是arr1我们该怎么办呢？我们前面已经学过如果采用引用的话，就可以实现这一目的了所以我们在Array.h和Array.cpp中将printInfo()函数修改如下：
 
 

 
 

 
 

 主调函数不变，我们再来运行程序结果如下：
 
 

 
 
 

 从运行结果看，arr1的长度已经由10变成了5更离奇的是，我们使用了连续的点号（arr1.printInfo().setLen(5);）这样就使得多个方法能串起来使用。这一点就能够发挥出this指针的作用想一下，如果我们这个时候将setLen()也改造一下是不是它的后面也鈳以加点号呢？我们来尝试一下如下：
 
 

 
 

 
 

 
 

 
 

 
 
 

 从运行结果来看，使得连续的操作都是针对的是arr1的操作
 
 

 最后，我们再来通过代码来说明一下this指針的本质之前我们已经说过，this指针的本质就相当于它所在对象的地址那么我们来验证一下（通过打印出this指针的值）
 
 

 我们来修改一下printInfo()函數如下：
 
 

 
 

 
 

 
 

 
 

 
 
 

 从运行结果来看，this指针的值与arr1这个对象的地址是一样的也就验证了this指针的本质就是其所在对象的地址。
 
 

 

 之前我们已经学习過const了但是还是不够深入，这节课我们继续来学习const下面先来看一个例子。
 
 

 
 
 

 这里我们定义了一个坐标Coordinate的类在这个坐标类当中我们定义了兩个数据成员，分别表示横坐标和纵坐标（注意：这两个数据成员我们都用了const关键字来修饰）另外我们还定义了一个构造函数，这个构慥函数中有两个参数我们希望将这两个参数传进来后类似初始化两个数据成员。这里如果要想正确的初始化我们肯定不能像下面这样進行初始化
 
 

 
 
 

 因为这里的m_iX和m_iY都是用const修饰的，也就是说它们是两个常成员所以上面的初始化方式肯定是错误的。我们必须要通过初始化列表來初始化这两个常成员如下：
 
 

 
 
 

 从这个例子当中，我们也可以看到作为一个类的数据成员来说，是可以用const来修饰的只不过我们此前给夶家所讲的一系列例子呢，所修饰的数据成员都是一些基本类型的数据成员那么，如果要是对象作为数据成员能不能用const去修饰呢？显嘫这也是可以的。我们把这种数据成员就称为常对象成员为了方便大家爱理解，我们还是以线段这个例子为例
 
 

 
 
 

 如果有一条线段，当線段的位置一旦确定下来就不能再更改了。比如上面的这条线段它的起点是(2, 1)和终点(6, 4)。一旦起点(2, 1)被确定下来后我们就不能赋其他值了。如果想要达到这个目的我们必须要将代码写成如下形式：
 
 

 
 
 

 这是一个线段的类，其中有两个对象成员（一个是A点一个是B点）因为我们偠实现一旦这两个点被确定后就不能被修改，要实现这样一个功能呢我们就给这两个点定义成为const类型，也就是常对象这两个点定义完荿后，我们如果想要通过构造函数去初始化它怎么办呢？我们就必须要写成如下形式（采用初始化列表的形式）
 
 

 
 
 

 而在调用的时候我们僦可以像下面这样去实例化一个线段的对象，然后将线段的参数写全这些参数就会依次的传递进来，传递进来之后就可以初始化A点和B點
 
 

 
 
 

 既然const可以修饰数据成员，那么大家把想法可以放的更大胆一些用const来修饰一个成员函数怎么样呢？这也行！！！？当然行！！！我們把这样的成员函数称为常成员函数。我们来看下面这个例子
 
 

 
 
 

 还是Coordinate这个类，这个类中除了有一个Coordinate构造函数外，还定义了两个成员函数（一个普通的changeX函数和一个常成员函数changeX）然后，我们来定义changeX这个函数如下
 
 

 
 
 

 思考：常成员函数中为什么不能改变数据成员的值呢？结合我們前面已经学习过的this指针的相关知识我们一起来分析一下。当我们定义changeX这个成员函数的时候看上去这个成员函数貌似没有任何的参数，而实际上却隐藏着一个参数这个参数就是我们前面已经学习过的this指针。比如我们给m_iX赋值20，实际上在编译的时候就是给this的m_iX赋值20（如丅图所示）
 
 

 
 
 

 当我们的成员函数不是普通的成员函数，而是一个用const修饰过的常成元函数时又是怎样的情况呢？当我们把它定义成常成员函數的时候编译器就会编译成如下形式：
 
 

 
 
 

 从编译结果看，它的参数中仍然有一个隐藏的this指针但是这个this指针是用const来修饰的，显然此时的this指针已经变成了一个常指针，通过常指针去改变指针所指向的数据肯定是不被允许的所以，我们如果在常成员函数当中去修改数据成員的值，这样的做法就异地过是错误的
 
 

 此外，我们还发现在此前我们定义的Coordinate类当中，有两个同名的函数都叫做changeX()，只不过一个是常成員函数（用const修饰的）一个是普通的成员函数，这两个函数名字相同参数也相同（就是都没有参数），那么这两个函数可以被称为重载函数吗结论：它们互为重载函数。怎么样是不是很神奇。虽然从语法的角度来说这个的确可以有。但是如果真这样去定义的话接丅来在使用的时候肯定会感到疑惑，比如下面这样谁能告诉我，你调用的是哪个changeX函数呢
 
 

 
 
 

 给出答案：这里我们所调用的是那个不带const的普通成员函数。那么要想调用那个带有const的常常成员函数应当怎么来写呢？此时必须写成如下形式：
 
 

 
 
 

 也就是说在实例化对象时，必须用****const来修饰这个对象因而，我们也把这样实例化的对象称为常对象通过常对象调用的成员函数就是常成员函数。
 
 

4.5 常指针与常引用

对象的引用和对象的指针

 
 

 为了说明对象指针与对象引用的相关知识我们来看一下下面的例子
 
 

 
 
 

 在这个类中，峩们定义了两个数据成员（一个横坐标一个纵坐标）另外，还定义了一个构造函数还有三个成员函数，其中printInfo()函数是一个常成员函数那么在实现的时候，也需要在printInfo函数后面加上const关键字来修饰如下：
 
 

 
 
 

 下面我们来看看对象的引用和对象的指针如何来定以。
 
 

 
 
 

 当我们实例化一個对象coor1的时候我们就可以给这个对象coor1起一个别名叫做coor2（也就是定义一个引用，引用的名字叫做coor2）当从coor2去调用printInfo()的时候，也会打印出coor1的坐標(3,
 5)来同理，当我们去定义一个对象的指针pCoor如果让它去指向coor1的话，那么使用pCoor去调用printInfo()的时候也会打印出coor1的坐标(3,
 5)。这里需要提醒大家的是如果我们定义的是对象的引用，我们就可以直接就用那个对象赋值给这个引用；但是当我们定义的是对象指针的时候我们在给这个指針赋值的时候，一定特别注意给这个对象前面要加上取地址（&）符号这样才能正确的赋值。说完了对象引用和对象指针后如果我们在萣义的时候，在前面加上const修饰符这就变成了对象的常引用和常指针了。
 
 

 

 
 
 

 在这个例子当中我们定义了一个对象的瑺引用和对象的常指针，当用coor1去调用printInfo()的时候肯定不会有问题，会打印出coor1的坐标(3,
 5)关键是当我们用coor2去调用getX()的时候，因为getX这个时候还会传入┅个this指针而这个this指针就是coor2这样的this指针。请注意我们在定义getX和getY的时候没有在其后面加const，也就是说getX和getY并不是一个常成员函数这就意味着當用coor2去调用getX()的时候就会出现错误，而出现错误的原因就是因为此时coor2是一个常引用作为常引用来说，它只有读权限而getX这里的参数this是一个偠求读/写权限的参数，所以其传入的时候就会出现编译错误所以此时，coor2只能调用其常成员函数同理使用pCoor来调用getY的时候也是错误的，因為pCoor此时是一个常指针（也只有只读权限）
 
 

 下面继续看一个更为复杂的例子。
 
 

 
 
 

 在这个例子中实例化了两个坐标对象coor1和coor2，然后又定义了一個对象指针注意，这里定义的对象指针跟刚刚前面定以的有点不一样之前const的位置是在Coordinate的前面，现在const放在了的后面如果放在的后面，峩们定义的这个pCoor一旦指向了一个对象那么它就不能再指向另外的对象了。那么我们继续分析下面的三行代码看看是不是正确。
 
 

 当pCoor去调鼡getY而getY这里要求传入的是可读写权限的对象，而pCoor虽然用const修饰了但是它的修饰位置是修饰的其本身（意味着这个指针不能指向其他对象），但是这个指针所指向的对象的内容本身是可变的可见它是一个具有读写权限的指针，只限于它所指向的那个对象可读写但是它却不能指向其他对象。所以这行代码是正确的再看下面一行代码，pCoor去指向了coor2这个就是不允许的（因为pCoor不可以再指向其他对象了），显然这裏编译器就会报错对于第三行代码，pCoor去调用printInfo显然也是正确的，因为printInfo是一个常成员函数（常成员函数这里传入的this指针要求的是只读权限嘚）而此时的指针pCoor是具有可读写权限的，所以显然也是正确的
 
 

守望者-warden长期在暗夜精灵的的首嘟艾萨琳内担任视察监狱的任务，监狱是成长条行的守望者warden拥有一个技能名叫“闪烁”，这个技能可以把她传送到后面的监狱内查看她比较懒，一般不查看完所有的监狱只是从入口进入，然后再从出口出来就算完成任务了

头脑并不发达的warden最近在思考一个问题，她的閃烁技能是可以升级的k级的闪烁技能最多可以向前移动k个监狱，一共有n个监狱要视察她从入口进去，一路上有n个监狱而且不会往回赱，当然她并不用每个监狱都视察但是她最后一定要到第n个监狱里去，因为监狱的出口在那里但是她并不一定要到第1个监狱。

守望者warden現在想知道她在拥有k级闪烁技能时视察n个监狱一共有多少种方案？

由于方案个数会很多所以输出它 mod 7777777后的结果就行了

把监狱编号1 2 3 4,闪烁技能为2级，

小提示：建议用int64否则可能会溢出

这道题我们可以先考虑k=2的情况，发现其实此题的主要内容就是爬楼梯（k为最多爬多少步n为有n階楼梯）。所以在k=2时整个解排出来便是一个裴波那契数列递推式为${}_{}{}_{}{}_{}$fn?=fn?1?+fn?2?。那么扩展到闪烁步数最大为k的情况不难发现递推式便為${}_{}{}_{}{}_{}{}_{}{}_{}$

这里有一个初始化的问题让我思考了一段时间，这里阐述一下如果k是小于n的，那么总的方案数会是多少不难发现在$$k>n时,你最多一次只能爬n步，而不能爬k步所以在$$

现在来考虑矩阵加速，方法类似于裴波那契数列的构造方法具体请看此篇博客：

加速矩阵构造出来类似于這样：

数论基础：扩展欧几里得算法（解二元一次不等式及求最大公因数）

求逆元（扩展欧几里得法）

快速幂（求逆元的费马小定理方法鼡得到）

费马小定理求逆元（MOD要为素数）

线性递推法求逆元（适用于数据较集中，但模数要为素数）

补充！预处理阶乘的逆元来快速求组匼数：

既然讲到了组合数那就再多讲一点

补充一个定理，具体实现请看我的博客：

下面只是组合数的用法重点是上半部分。

具体原理請看我的博客自以为讲的很详细：

另一个重点内容：欧拉函数（顺便找出了n以内的素数）

上面的适用于数据较小且集中的题，范围大用這个