斯坦福-CS106A-B-L-X-编程入门笔记-九-
斯坦福 CS106A/B/L/X 编程入门笔记（九）
【编程抽象方法 cs106x 2017】斯坦福—中英字幕 - P13：Lecture 13 - Pointers and Nodes - 加加zero - BV1By411h75g
很高兴再次见到大家，嗨，现在是第五周，我们快完成一半了，本周我们将学习一个叫做指针的新概念，我们还将学习如何实现链表，所以我们将从一个跨越几周的材料单元开始，在那里我们将了解许多收藏是如何建立在内部的。
主要是，我们将通过自己动手来学习如何做到这一点，通过重新实施，比如哈希集是如何工作的，地图是如何工作的，矢量是如何工作的，所有这些不同的事情，我们将详细了解这一点，并自己实施其中的一些，原来如此。
原来如此，下一个我们就这么做，一个，两个，两三个星期，至少是这样，是啊，是啊，就上周五的大局而言，作业四上了，它是关于回溯，下周初到期，你的期中考试下周就要迟到了。
练习考试材料将在未来一两天内上线期中考试，好啦，这就是我们现在的处境。
所以让我打开我的幻灯片，看看指针，我想说今天的主题主要是关于这个概念指针，你知道的，以我的经验，无论我教什么，学生们有一堆关于指针的问题，有点像第一周，有很多关于C++语法之类的有趣问题，嗯，那太好了。
但实际上，这个功能是我想使用的一种工具，以便我们学习如何实现链表，所以指针很棒，但我没有，你知道的，这堂课的重点不是喜欢，深入研究指针的一切，对呀，事实上，如果你想这么做，CS一一零七。
做了一大堆指针和记忆，你会得到比你想要的更多的指示，如果你拿七个中的一个，所以我们要看看你们有没有朋友拿了107，他们就像在哭泣，尝试实现内存分配器之类的，反正，是啊，是啊，就像我说的。
指针作为实现链表的工具，来自书的第十一章和第十二章，我很久以前简短地说过一个链表，对它基本上和矢量是一样的，只不过不是存储某种数组，一个大的内存块来处理所有的元素，相反，它有这些小盒子，我称之为节点。
每个节点取一个元素值，然后它有一个链接到另一个节点，它们就像链条一样，呃，许多教师使用视觉辅助工具，就像火车车厢，或者你把玩具带进来，一桶猴子，你把小猴子拉出来，它们看起来像这些小节点，手牵手什么的。
所以链表是一种，像这样的结构的第一个例子，但是还有其他结构使用这种小节点的概念，这些小节点指向彼此，事实上，我们在我们的，在我们的图书馆中使用类似的概念，所以我们很快就会知道的，但无论如何。
这种结构相对于数组有一些好处，我们讨论过如果你想在列表的前面插入一些东西，你不必把元素转移到你身上，就像做一个新的盒子，你用箭头指着东西，然后新元素就在你要移动的列表的前面，当然，这也有一些缺点。
所以对于一些赞成和反对的人来说，不管怎样，如何很好地实现这件事，这些箭头使一个盒子有一个连接，如果你想要这种结构，你必须学习一种叫做指针的东西，现在呢，你知道吗，我一直认为思考上下文是很好的，就像。
如果我们不是用c+来做这门课呢，如果是Java呢，如果是蟒蛇，随便啦，大多数语言没有指针，取而代之的是，他们有一种叫做参考文献的东西，哪里，存储对象时，你实际上将这些访问对象的能力存储在内存中。
大多数语言都有一个概念，有点像这样，但不管怎样，让我们谈谈指针，嗯，在我进入指针之前，我想谈谈我将用什么来实现这些小盒子，这些被称为结构或结构，他们就像小物件，所以我想先谈谈这个。
所以结构或结构是一个非常轻量级的类，我之前给你们看过一两个，但我只想确保我们在同一战线上，所以结构是新数据类型的定义，您写单词struct，然后写它的名字，然后在括号中写出该类型的每个元素的数字。
只是想说清楚，这很像上课，你的意思是，我想创建一个名为date和every date元素的新类型，每个日期实例或值存储一个月，它储存了一天，所以你可以说我要做一个新的变量，叫做today类型的date。
然后我可以设定这个月，今天是圆点日期，所以它就像一个小的单一变量，在里面存储了两个，这就是结构，再一次，我想有些学生的问题是，也许你们很擅长这个，但有些学生纠结的是，他们看到了这个。
他们认为你在这里声明了某个单一变量，这个变量有一个月，有一天在里面，但不完全是这样，这就像模板的声明，就像你说的，我希望能够制作日期对象，在里面他们有一个月的时间，他们会有个约会。
所以这个东西本身不会产生任何日期，这些行创建了日期，我想创造多少就创造多少，所以这是一个重要的区别，所以无论如何，这就是结构或结构，是呀，所以在底线上，状态x错过了，什么，如果今天就像。
在一个中说字符串，你可以说是的，你可以说12个逗号引号，哈喽，你会猜你可以做两种不同的，啊，我去了哪里，我去了哪里，好啦，别碰它，是啊，是啊，因此，您可以创建一个结构并初始化该结构的新元素，所以好吧。
这就是结构，可以使用，比如他们的方法，比如如果你想说一个月中的几天，取决于月份，它是，你回来，还有多少天，您可以编写一个返回内容的双字符串方法，这些方法可以参考这些变量。
所以如果你做一个变量叫做today，然后你说今天一个月中的几天，它使用今日对象月，创建另一个名为XMAS的数据对象，你叫月相，它将使用该对象一个月，所以这些方法，我是说，这是你可能会在。
就像一个零六一个类型的课程或AP课程，具有与类中的数据交互的方法的like类的相同概念，这里的想法是一样的，是呀，我们的压力，不同的阶级对吧，所以呢，这怎么不只是一堂课，然后右边，嗯，在某种程度上。
这只是惯例，如果你说在C++中有一个类，当你做一门课的时候，你的期望是你在做一些大的事情，使用类似的构造函数和方法，然后呢，当你做一个结构时的期望，在那里有一些小裂缝，只是一对夫妇，可能是一种方法。
但它不应该像一个大的，但它只是一个小家伙，所以让我们从战术上看看他们能做什么，他们其实是势均力敌的，结构和类之间唯一的行为区别是默认情况下，结构中的所有内容都是公共的，所以你可以进入它。
看看它的变量的值，而对于一个类，默认情况下事情是私人的，所以如果你试图从变量的角度，它会说你没有权限，为什么他们都有这两种东西，它们之间几乎没有区别，用同样的语言，它主要与这样一个事实有关。
即这种C语言，c加加的前身，只支持这些结构，和c+加上增加的类，然后他们回去增强结构，基本上是类，反正，管他呢是啊，排序结构基本上是一个类，基本上是一个物体，事实上，所有这些代码都是。
如果您只写class而不是struct这个词，所有的代码都非常相似，好啦，所以有一个打击，其中有一些方法，有人举手，你也有同样的问题吗，好吧那么好，我给你看结构的原因，我希望能够把这些节点的小链接。
把他们联系在一起，所以如果你要为这些节点创建一个类型，你会说，嗯，它们存储某种数据，然后它们存储某种方法来到达下一个节点，数据可能就像一个int，因为他们把数字分类，你知道的，如果是Java。
也许你想要更一般的东西，像物体，你可以储存任何东西，但也许现在它只是存储数据的末尾，但是下一件事是什么，你可能会说，嗯，我看到一个节点，那是下一个。
那不太对，因为如果你试着画一个节点的内存图，就像一个小正方形，我的天啊，我不会画画，好啦，在那里等着，就像如果是的，谢谢你，如果这东西有两个小隔间，就像数据是一点点，这里的小int可以存储4-2。
如果下一个是节点，就像如果我在这里写节点，这就意味着就像这个小隔间储存了另一个节点，然后那个节点有某种末端，它有一个下一个，所以它就像这个无限自递归结构。
或者一些不太对劲的事情，几乎就像，你知道的，如果你说像一个人有一个名字和一组朋友，啊，他们的朋友是什么，他们是人吗，但你不会把你的朋友塞进你的身体里，你明白我的意思吗，我是说，我不知道，呃。
我不知道你们中的一些人周末做什么，但是呃，是呀，反正，呃，有时候你所做的，如果你，如果你说，哎呦，这些是我的朋友，你真正储存的是指他们或接触他们的某种方式，你储存他们的名字，或者你把他们的电话号码。
或者你把他们的地址，你可以去他们家，或者他们的宿舍，或者你储存的任何东西，所以如果我说，下一个节点，这在这里是不正确的，所以我们最终要做的，就像下一个节点不起作用一样。
我们真正需要的是一种叫做指针的东西，这将说明我如何到达另一个节点，在电脑的内存里，这个特性将允许我们将这些东西链接在一起，所以我要跳到一边一秒钟，谈谈指针，他们是什么，这样我就可以回到这里。
用指针构建链表，好啦，所以指针，啊，快速快速问题，你们中有多少人以前已经用指针编程了，为什么用C或者为什么用指针，是呀，C加加上你怎么了，人，好啦，不管我想你有什么，所以说，如果你不举手，没关系的。
我在跟你说话，所以在C或C++中有一个运算符，与号算子，这是接线员的地址，如果在变量前面使用address of，它将计算并告诉您存储该变量的内存地址，大多数时候你不必去想这些事情。
电脑只是为你做这件事，但如果你想知道记忆中的东西在哪里，你可以自讨苦吃，像这样使用这个运算符，我不常画记忆的图画，而且这些照片不是很好，但就像你声明索引4 2，它留出一些记忆作为某种地址。
内存地址通常用这种有趣的语法编写，零x7f8，这是十六进制，这只是一个数字，但它是以十六进制写的，每个数字从0到9，然后a到f a是10，f是15，所以每一个数字的位置都是从0到15。
我们这样写是因为你可以用更少的字符写更大的数字，它可以让你以某种方式写出这些密集的小内存地址，也因为计算机的思维能力是二的很多，而16的能力是二的，所以我们写这样的内存地址，X不代表什么。
这就像说这将是一个十六进制的数字，就像你做一个变量，然后一些内存地址，你的能力被存储，好啦，如果你写了与号x，它将求值以产生该内存地址的整数，存储x的地方，好吧，你可以打印内存地址，然后打印出来。
你知道我申报了一个INT Y，我打印了，如果你仔细看，内存地址彼此相差四个，因为那样就需要三个，二位或四字节，所以很多时候，如果声明两个变量，他们会碰巧在连续的内存地址，我宣布了一个日期叫d。
它有一个内存地址，日期有月有日，还有一些方法和东西，所以祝福你，日期的各个组成部分就像存储在那里的内存中，这不完全是它看起来的样子，已经够近了，所以如果你试着打印当天月份的地址，或当天的地址。
或者别的什么，你可以在记忆中看到这些不同的东西，使用这个和运算符，所以内存地址，我能拿他怎么办，是啊，是啊，继续并决定打印出，最后三个点其中一个最后打印出来，D代表D个月代表点头日，不是，哦，好吧。
为什么是的，为什么d和d一样，我想我想说的是因为，决定成为记忆中的第一个，就像如果你做一个结构，它有两个东西在里面，然后真的需要把这两件事的记忆加起来，第一个在那里，然后第二个就像现在一样。
我不知道这是不是字面上的记忆，有时取决于编译器或编译器，或者有些事情会随着系统的变化而变化，有时它实际上会走另一条路，就像内存地址下降，你做的变量越多，有点奇怪，但是去拿七个中的一个吧但是不管怎样。
是啊，是啊，结构的各个部分都只是连续地放置在存储器中，就在彼此旁边，所以好吧，罚款，你能做到的，你可以问东西的地址，可以将内存地址存储在变量中，从技术上讲，内存地址只是一个数字，您可以将其存储为int。
但我们认为这被认为是一种不好的形式，因此，我们创建了一种新的数据类型，称为指针，指针是用星号声明的变量，我阅读的方式，这就像int星p或int指针p等于x的地址，所以我要做的就是把这个数字。
零x 7f不管我把它作为p中的变量存储，该变量的类型是和的内存地址或指针，从技术上来说，这是正确的号码，这个数字的值是零x七，管他呢管他呢管他呢，但是我们写这个小星星是为了说它是一个int的内存地址。
它是一个int问题的指针，是啊，是啊，有多少内存，指针占用多少内存，取决于您的系统，但如果你有一台64位的电脑通常会接受64个出价，如果你有一台三位数的电脑，这是一个三二位，其实呢。
当他们谈论这些区别时，你要么是在说CPU指令的大小，或者你说的是内存地址，侧面或两者兼而有之，所以是的，我是说，现在大多数计算机实际上是64位指针，我想在我的例子中，它们都是32位指针。
但我教的东西都不依赖于这一点，所以我可以把主要的基因，就像，提出一个观点是，它总是一个优秀的数字，它总是一个出口小数，嗯，我是说在电脑上几乎有数字，想着他们。
因为十六进制只是为了帮助我们弱小的大脑正确地理解事物，好像他们都只是，都是数字，所以有没有可能只是说，就像没有你可以说int p等于x的地址，除了我想编译器有点不高兴，说很好，你不应该把它当作指针。
编译器希望您这样做的原因是，因为，对指针所做的操作类型是不同的，比你会做的任何其他，所以他想帮你检查，型式检查和安全检查某些操作，所以你可以把p等于x的地址，但编译器会说嘿，你在做什么。
也许应该是一个点，所以无论如何，好啦，所以我把它储存起来，我想说的是p指向x，p存储x的地址，如果我画一幅记忆的图画，就像x存在于内存的某个地方，p存在于内存的某个地方，但P商店是什么。
其中x存在于内存中，好啦，所以我想我马上要做的是，您可以使用p的值转到这里来找出，我们把它画在图画里，通常用这些箭头，当然，这只是我想教你，就像，没有箭，对呀，就像它没有任何字面上的联系。
它实际上只是一个存储在那里的数字，但这个数字是一个地方，我可以进入记忆，如果我想正确，好啦，这就是指针，我会告诉你，学生们都搞混了，你什么时候在，你什么时候把一颗星星，我什么时候把他们两个，然后呢。
不幸的是，语法有时很难记住，但是哦，好吧，所以如果你想跟随指针，如果您想去指针指向的地方，看看那里的记忆，你可以通过在Poin的名字前面写一颗星来做到这一点，所以它被称为哦，尊重不，应该是院长的推荐信。
遵从运算符否，你。
嗯。
当然你只是看错了幻灯片，因为上面写得很清楚，反正，如果你在指针的名字前面放一颗星，它的意思是指针指向的东西，它的意思是转到存储在指针中的内存，就像，如果我说星号p等于x的地址，然后我说打印P。
它会打印出X的地址，也就是x78，如果我说打印星P，这意味着打印，P指的是什么，p所指向的是，或者是在记忆中发现的东西，就是四十二，如此锐利的印花，坚韧，我想什么来着，什么，什么让人困惑，有的同学就像。
当你申报的时候，你在这里写上星p，但接下来就像等待，我写星星吗，当我用还是不用的时候，就像如果你想跟着指针走，你确实写了一颗星，一些学生感到困惑，他们写与号和p，你认为与号p是e的内存地址。
就像那个数字，你知道我的意思，但那不是有用的东西，我不管他在哪里，不管怎样，但你不能，这就是为什么它令人困惑，就是，你可以问P的地址，那不值钱，你想跟着，呃，你推动文化，是啊，南，如果把价值的9%。
如果你把1-2-3-4-5和1-2-3-4-5放在一起，因为要提供的是一个字面值，它不存储在内存中，也不只存储在变量中，数组，像这样的事情，是啊，是啊，你必须写一个变量或一些占用内存的东西。
就像如果你有一个数组，您可以询问该数组的地址，毕业四，它会指出，但你不能问你好的地址，或者一二的地址，三个，如果您有一个指向某物和异常的指针，如果你喜欢指，中间的指针，或者末尾的相似整数，是啊，是啊。
嗯，你可以有一个指针指向一个指针，你得用星星写，明星，P2或任何等于，P地址，你能做到的，如果你做一个明星，它跟随一次，所以说，如果指向指针的指针，指向指向指针的指针，你得放一个嗯。
就像七种东西中的一种，我们不会那么做的，我不认为，但你可以，如果你在B的地方做，它告诉你x的值，它告诉你四到二，如果我说p星等于99，意思是去他指的地方把99放进去，所以我只是从，所以这是相关的。
然后如果我打印x，我说九十九，所以这就像你不能用Java做这种事情一样，它在Java中没有指针，你真的做不到，所以说，好啦，那是取消指针的引用，这里有一个指针，神秘问题，呃，我不想这么做。
我只是我建议你以后再看这个例子，我不认为我们需要这个，我今天想用链表做什么，但是看看你是否可以通过这段代码来跟踪并计算出输出是什么，谨记，我在这里也有一英寸的参考，记住参考文献。
这就是愚蠢的符号的另一种用法，有同学会问，你很清楚，指针和引用有什么区别，好像有点相似，这就像一个参考，让我和一些主要的人谈谈，他们似乎分享了相同的记忆，某些内存中的指针感觉非常相似，嗯。
指针是引用的前身，指针以前就在身边，指针很强大，但他们更容易搞砸，它们更容易制造虫子，他们可以做比推荐人更多的事情，但做错更容易，所以很多人都有很多bug和代码，因为指针。
所以他们发明了更简单的参考文献，更难，我打赌你们偶尔会因为引用而有bug，但是您所遇到的bug的数量和种类可能更简单，比那些写糟糕指针代码的人少，后面有问题吗，A是。
如果你引用指针是你的程序可以做的东西，当您尝试重新分配值时，这是要重新分配一些东西吗，哦耶，如果你指向一些随机的东西，我想我有一张幻灯片，是关于一个垃圾指针，基本上你可以指向任何东西，包括随机数。
可能与你的程序无关的地方，你可以去那里，你可以试着乱搞东西，让我，我想我马上就到了，基本上坏事可能会发生，让我看看能不能到那儿，让我先谈谈空指针，然后我想下一个会是垃圾指针，所以你们可能听说过null。
大多数语言都有null的概念，空的意思是没有对象，或者它不是指任何东西，这和这里的想法是一样的，在指针方面，空是啊，指向零的指针，是内存地址零，所以如果你储存，他们称之为无页脚，嗯，以前叫不。
你得大声说不，在um之前加上c，这两种方法都有效，这两种方法都有效，推荐用这个，因为出于某种原因，编译器更擅长查找检查和错误，如果你用那个，我想这只是数字零的别名，我认为这就像一个很好的零指针什么的。
我不知道，我不太记得为什么，但没有页脚是说，不要指着任何东西，所以有插入，指向无，如果我打印P，它打印零，如果我试着打印星P，这意味着转到内存地址零，把里面的东西拿出来打印出来，内存地址零没有任何东西。
只是个假地址，如果你的记忆，如果你的电脑试图进入那里，试图进入那里并获取内容，它导致了所谓的分段错误分段错误，意思就是你的程序试图，不允许看，每个程序都有一定的内存，允许看一定数量的，它不应该这样看。
如果你试图进入虚假的内存地址，您可能会使程序崩溃，所以当我说砰的一声，这意味着程序停止，红色错误消息文本弹出，所以现在您仍然可以将某些内容设置为零点，或者你可以测试，如果某物为空，还有。
我不知道你能不能在幻灯片上读到这么远，但是C++有这样的语法，你称之为真实性语法，如果你说像，如果喜欢的话，您执行一个if语句，测试只是一个指针名称，你要问的是p是不是空的，或者如果你说如果不是P。
你在问p是不是空的，所以你可以用它来速记，而不是写一个相等的小指针，或者它不等于空指针，是呀，很清楚我们可以访问程序的内存的哪一部分，像整数，是啊，是啊，比如你怎么知道内存地址是什么，好吧好好看看。
我是说我一会儿就给你看，但是在语法上你可以请求内存，你可以说我想要足够的内存来存储一个int，我需要足够的内存来存储矢量，还有电脑，的，你知道的，编译器会给你这么多内存，你保证你可以用那么多。
大家可以看一下，所以我认为这个想法就像，如果你想要记忆，你想玩记忆，你应该自讨苦吃，一旦你得到了，你拥有它，你控制它，你可以做任何事，你想用那段记忆，如果你要求一兆字节，只是一百万字节或其他什么。
他们会给你一百万个中的第一个，现在从那里到那里，加九九九九九九，您可以使用所有这些字节，但任何你从未要求过的记忆都是不可预测的，不管你是否被允许乱来，如果你搞砸了，坏事可能会发生。
它可能会导致您的程序崩溃，可能会引起奇怪的行为，基本上，你只是随意地伸手摆弄一些东西，谁知道它会做什么，是啊，是啊，问题，有一个程序像我的人已经要求一些东西，哦好吧，当你启动一个程序时。
它为Main和类似的东西加载了一些内存，所以你有一些记忆在没有你的情况下被使用，另外，cplus标准库为自己使用一些内存，就像，即使你的程序只是说你好世界，然后退出，你会得到一些内存。
但我的意思是我一会儿会给你看更多，如何喜欢，请求记忆，但基本上我想说的是，有时您想声明指针，但出于某种原因，你还没有准备好把它指向任何事情，如果是这样的话，您应该这样将其设置为空指针，是啊，是啊。
我想空指针的好处是，很容易检查，这是一个明确的，就像，不要指着任何有价值的东西，而不是编造一些随机数，那将是数字的，但在那边的第二个盒子里，内存地址为零，P本身仍然不在位置是由那里的文本给出的。
所以基本上它仍然存在于记忆中对吧，所以我想有一件事，对于刚学这个的学生来说，有一件事可能很棘手，那就是，就因为我说p等于空，指针，这并不意味着p在地址0，P是存在的指针，p存储在某个合法的内存地址中。
只是他储存的东西是空的，他储存零，他指向零，它是一支选择不指向任何东西的箭，但是这个p并不意味着p在地址零上是关闭的，或者P不存在，或者类似的东西，好啦，这就是空指针现在与之相关的内容，这就是空。
是宇宙的黑暗，我想我不知道，然后有一个垃圾指针，我想刚才那位先生的问题是关于这个的，垃圾指针是指向内存中某个随机位置的指针，您有垃圾指针的最有可能的原因是，你没有初始化它，在C设计的无限智慧中，另外。
他们这样做是为了如果你不初始化指针，它存储任何数字，它只是存储一些随机数，所以这个随机数可能指向记忆中某个可怕的地方，你不应该去惹，所以如果你试着遵循这一点，谁知道那里有什么。
有时候如果你写了这个并运行它，它只会打印一些数字，比如12，你就像，啊，我想有一个12，那里，你知道吗，有时候很好，但你知道这很有趣，就像有时候你去回忆，你把它设成四二什么的，但是哎呀。
这是函数的返回地址，然后函数返回到四，两个什么的，它会做奇怪的事情，就像有时你是你的垃圾指针，如果你搞砸了，在那个位置的记忆，你破坏了整个程序，把一切都搞砸了，最阴险的是什么，有时我是说我写了卡布。
但有时它不去卡博，有时它只是默默地去调整一些东西，从不告诉你，现在你的程序员有一些奇怪的任意更改值，在剩下的运行时，这很难调试，所以我的建议是永远不要声明指针而不等于，即使您只是将其设置为空指针。
追踪起来容易多了，把虫子放下来，有人举手，是啊，是啊，你能去修改你系统上运行的其他程序的内存吗，是啊，是啊，问得好，其他节目呢，就像我不会花很多时间谈论这个，只是因为我觉得这更像是一个零七的话题。
但就像以前一样，所有程序共享内存，所以如果你跳到了错误的内存地址，你实际上是在扰乱另一个程序的内存，所以浏览器可能会因为运行错误的内存地址而扰乱你的聊天程序，现在他们使用一种叫做虚拟地址的东西。
每个程序都有自己的假映射，哪些内存地址对应于，不管我做什么，我不能碰其他节目，记忆，所有的内存地址，伪造我的地址，但实际上它将它们映射到我的一些实际内存块上，所以操作系统将每个程序与其他程序隔离开来。
有了这个假的记忆抽象层，但尽管如此，仍然有大块的内存，我不该惹的，或者其他与我的程序对话的东西，或者只是程序中我无法控制的部分，所以是的，你不必担心破坏其他程序，但你破坏了你的程序，是啊，是啊。
我们能恢复被程序修改的数据吗，另一个类似的程序发生在现实世界中，但他们会恢复照片之类的东西，我是说，有可能把它编码成，喜欢编辑、还原或修改另一个程序的数据，一个程序出错并结束，我们想看看数据。
而最后一部分被修改得很好的内存，是啊，是啊，我是说，我不想跑题，所以我认为对你问题的简短回答是，当程序运行时，它使用一些内存，它在内存中存储一些数据，一些价值观，然后当程序退出时，通常情况下。
操作系统会将所有内存标记为可用，所以技术上来说，如果其他程序出现，抓住内存并查看它，里面可能还有一些敏感的东西，所以一些程序在退出之前会在不同的地方清零它们的内存，或者别的什么。
程序会做不同的事情来避免这类事情，我们今天甚至不会接近那种魔法，但有些棘手的事情，现在的一些操作系统在内存上有这些保护机制，试图阻止程序查看内存，他们不应该看，或者别的什么。
因为你的记忆中有一些非常敏感的数据，反正，不管怎样，小心不要用指针，小心垃圾指针，空比垃圾好，因为您可以更好地调试它，所以我画了指针指向一些小精灵，我以为我真的很有趣，因为我让指针指向死亡，你死定了。
所以好吧，很明显你和我一样喜欢，您可以创建指向结构的指针，日期的地址基本上是一样的，所以如果你想的话，这个指针指向这个门，你想把数据的月份，你不得不说，你不能只说P点月那是不对的，你得说去他指的记忆。
去找他指的那个日期，让那个日期明白，所以说，这就是你如何按照指针到达印钞的日期，因为这个语法太挑剔了，你会经常这么做，理论上，他们添加了一个简短的语法，你说p箭头，一种语法与此语法完全相同。
它的意思是像星星一样跟着p，当你到了那里，在那上面做一个月，这个语法是我本周会经常使用的语法，所以我想让你明白箭头的意思是跟着指针走，例如，如果他是空的，我试着说P箭头月，它会说，转到空。
那里会有个约会等着你，听起来像很多爱情生活，我会说，嗯，然后当你到了那里，打印出那个东西的月份，它会崩溃，如果你有一个空指针，他说，去箭一个月那就撞车了，好啦，但是嗯，如果你想在上面调用一个方法。
你可以说p箭头二弦，好啦，所以p是一个指针，这说明了这一点，所有的东西都在里面，到目前为止我们很好，是呀，好啦，好吧，现在让我们来谈谈东西在内存中的位置，我不想多谈这件事，因为它更像是一个零七的东西。
但我想让你觉得，有点感觉到底发生了什么，所以我会试着给你们一个快速的版本，当你运行一个程序，当每个功能启动时，它为该函数分配一块内存，所有这些内存块的集合，我们称之为调用堆栈或堆栈，我把它画为上升。
就像一个函数调用另一个函数一样，它堆叠在另一块内存上，那块内存里有什么，嗯，很明显，如果他们的函数有任何局部变量，就像A和B，他们会进去，实际上如果你做递归，你有五个深入的调用，每个调用都有局部变量。
它们中的每一个都有对每一个副本调用局部变量的内存，对吗，这里不是我画的，但在内存中也存储了一些东西，比如函数完成时，我应该回到哪里，我应该从G回到F什么的，它也在内存中的这个地方存储了一些类似的东西。
我真的不想画所有的细节，但那有点，这里也是这样，所以所有这些记忆的收集，它里面的东西叫做堆栈，关于堆栈要知道的一件重要的事情，我想你从编程中就知道了，不是在记忆中，但是当一个函数完成时。
它所有的局部变量都超出了作用域，所以它们都被扔掉了，我们明白这一点，但它真正做的是，它获取这个内存并清除它，然后回到以前的函数，所以从技术上讲，当这些变量消失时，发生什么事了，它向下推这个调用栈。
所有这些变量的内存都被回收，是啊，是啊，这个成本因素也是，这就像一个特别的东西，那就像那样，我想只有程序本身，有什么特别的吗，嗯，我是说这只是记忆，就像，如果我碰巧有一个指针指向那里。
我可以跟着它改变电源变量，即使我是很高的调用堆栈，如果我有一个指针来存储那个内存地址，我可以跟着它把它调到12，现在的意思是A是12，所以说，但是有一个月的时间，所以说，是啊，是啊。
我是说你可以做这些奇怪可怕的黑客，我认为我今天不会做的事情，就像你可以要求的那样，有点像，如果你在工作，G，您可以询问d的内存地址，哪个是你的局部变量，然后你可以四处走走，我在哪里这附近有什么。
你知道的，就像你可以看到周围是否有其他变量之类的，所以你可以在你喜欢的地方做一些可怕的事情，故意向下移动，用变量惹下面的家伙，这叫做粉碎统计数据，你可以，你可以做一些奇怪的很酷的黑客事情。
我真的不想那样谈论黑魔法，但是你知道，你可以做一些这样的事情，你可以利用，事实上，这大部分是毗连的，大多数情况下，一个函数存储在另一个函数旁边，这也是c+e，因为就像在Java中，有一堆，而这正在发生。
但你不能伸手去摸它，你不能在Java中获得指向它的指针，他们觉得这太危险了，他们不再让人们这么做，但是我们在c+，所以我们可以，嗯很好，所以这是一堆，好啦，酷现在我想谈谈另一段记忆，它被称为堆，堆。
堆是与调用堆栈分开的另一块内存，技术上又像了，我真的不想谈这件事，但内存只是一个很长的数组，就像从地址0到大数n的地址，从技术上讲，它的一部分是堆栈，另一部分是热量，但这只是记忆，从技术上讲。
但从概念上讲，这些是程序与之对话的内存中非常独立的区域，现在堆是一种，一个内存空间，人们可以请求大块的，所以你请求堆的大块的方式，记忆是通过写新这个词，你在Java中看到了新的，可能是蟒蛇什么的。
我想蟒蛇不会说新的，但他们中的许多人只是说新的建造东西，但是如果你是C+，你可以做一个新的打击，我们可以做一个新的替身，你可以做一个新的弦，你可以做任何新的东西，如果你说新的。
您编写要为其分配内存的类型，然后括号或者花括号，或者无论你写什么，应该用什么值初始化，它返回的是一个指针，指向分配给它的内存中的位置，所以你可以说，指针A等于新的，所以它的作用是在这个前夜，我正在画。
在这里和记忆中的某个地方是一片看起来很糟糕的云，它留出一块薄荷糖大小的大块，它把4-2的值存储在里面，它发送回或返回内存地址，存放它的地方，所以我把它保存为指针，所以在工作人员中，我有一个。
它存储的价值，上面有地址，所以如果我说星A，一共是四二，所以现在这里的主要区别是，我是说，你说新去去去做关键上的事，这是这里的一个区别，另一个很重要也很酷的区别，堆与堆栈完全无关，就事物的诞生而言。
东西都死了，就像在我的尽头，或者任何创建的函数，这个东西这个变量不是，或者这个，这个被指向的东西不会被清理和扔掉，在函数f中，我创建了一个指针c，它指向一个新的int 49。
所以它指出了这大约是99家商店的新产品，当函数f完成时，它返回堆内存没有被清理，它是左边的，指针C也是如此，这些记忆被清理和扔掉，所以有点奇怪，因为当f返回时，你还有这九十九，但再也没有指向它的指针了。
所以它是一种丢失的孤立数据，我们称之为内存泄漏，但这是一个仍然存在的数据，所以无论如何，这个堆小发明是一种分配内存的方式，不会被收回的，当函数返回时，那很重要，我们马上就需要，再一次。
单词new是如何指定这两个中的哪一个，如果你不说新的，您将使用堆栈，如果你说新的，你会指着上面的东西，当你说热量就像消失了，或者像没有指针的漂浮，它只给了一堆球体权利，但如果你能找到那个地址。
不会再出现了，对呀，就像这个指针在f返回时消失了，但不知何故，如果我把那个地址保存在其他地方，或者我知道那个地址，不知何故，我跟着它，这仍然在等着我，是啊，是啊，所以这真的只是，你知道的。
你忘了写去派对的指示，但派对仍在进行，对呀，如果可以的话，你只要听一听，或许你能找到回去的路，差不多吧，是啊，是啊，好啦，现在又来了，就像，我想你不必想那么多，日复一日，你不必太担心这个。
但它会派上用场的，当我们谈论这些链表之类的东西时，我保证我们这样做是为了一个链表，这一切都是有原因的，好啦，所以新这个词又来了，语法是，您编写要分配的类型，你在做一个指向它的指针。
您将其设置为存储该类型的新版本，并使用参数，现在呢，我在上一张幻灯片上展示了一个示例，其中我创建了一个新的int，你不常这样，因为如果你想要一个在你的功能完成后仍然存在的提示，只需返回int。
你知道或有一个推荐人，你可以，如果你有尽头，你想从函数中得到它的值，没有这种新东西也有办法做到这一点，但当涉及到物体时，更常见的是使用这种语法，所以你要做的就是，你可以说日期指针，D等于新日期。
您设置字段，你开始使用它，随便啦，所以现在在堆栈的主中，你有一个指针，它指向堆日期对象，对呀，那个约会对象有什么酷的，他可以活得比他现在宣布的功能更长，您可以返回一个对象，你可以这么做。
但是物体开始变得越来越大，就像归还笨重的东西，他们必须复制他们和东西，所以这家伙有很多好处，他的寿命不被任意限制在，他被宣布，实际上这里的语法，这种看起来像什么，有点像Java。
就像你在Java中创建对象一样，所以如果你想让你的大脑稍微弯曲一点，基本上，在Java中存储对象的每个变量基本上都是一个指针，就像每个变量基本上都在堆中存储内存地址一样，在Java创建该对象的地方。
所以哎呀，哦好吧，这就是为什么当您有null并尝试调用它的方法时，您得到了一个空指针异常，即使Java没有指针，您可以获得空指针异常，似乎他们保留了最糟糕的指针部分，但是哦，好吧，干得好Java。
所以是的，这就是如何在堆上创建一个新对象，现在又来了，指向对象的指针在集合上，但物体本身就在堆上，所以这些是不同的事情，好啦，所以回到这个链接列表，我们试图建立啊哈时刻。
这里是每个节点不应该存储另一个节点，因为那根本说不通，就像如果你是人类，你的父母是人类，你不储存它们，你只是有一种方式来称呼他们，所以它存储另一个节点的内存地址，所以如果我在第一个音符里。
我的数据是这个四二，下一个是这个节点的内存地址，这家伙储存了负3，他的下一个是这个节点的内存地址，如果你一直跟着明星明星，因为接下来的指针，你可以通过这种方式访问每个节点。
直到您最终到达列表中的最后一个节点，之后就没有数据了，所以我们通常通过让下一个指针为空来表示这一点，没有人追我，我的下一个是无名小卒，所以你才知道，当你到达列表的末尾，这就是这里的大意，你的手在后面。
你刚才想说什么，你好吗，这怎么比参考文献好呢，我是说，我想关于推荐人的问题是，你指的仍然是堆栈上的东西，所以我画的小书堆，您可以从一个函数引用到另一个函数，但你真的有点在堆栈里上上下下。
从一个堆栈块到另一个堆栈块，每当创建的原始函数，你提到的东西消失了，那个被引用的东西也消失了，这个机制你可以指向这堆东西，我有点跳出了函数，调用堆栈世界，因此，没有特定的函数终止会导致节点的破坏。
我在建造，所以如果我建立这个漂亮的链表，你想把它交给你程序的许多不同部分，没有一个部分有能力喜欢，爆炸链表，并通过意外返回或其他方式将其全部扔掉，所以是脱钩，自动回收我们想要使用的东西的内存。
这就是它的要点，我猜，嗯好吧，这就是创建列表节点结构的方法。
我来教你怎么做，其实喜欢，如果你想列一个小清单，我有一个小小的可爱的创作者项目，我们今天不会写很多代码，如果我想存储42的值呢，负3，十七九，所以如果我想这么做，我是说，当然，我可以做一个矢量或数组。
我可以把0加起来等于4 2，括号1等于负3，当然当然，但如果我想把它表示为一个链表，我能做的就是，我可以说列表节点指针，节点一等于一个新的列表节点，我怎么才能很好地说列表节点，我有一个列表节点点h。
在这个项目中，它有一个数据和一个下一个之类的东西，所以我可以，只是滑梯上的东西，我只有那个，这样我就可以做一个新的列表节点，我可以把他的数据设为4 2，好啦，所以像这个小盒子是第一条数据。
然后我可以说列表节点星，节点二是一个新的列表节点，负3，链接在链表中的什么位置，我可以说，所以节点一的下一个箭头，我想指向节点二的盒子。
就像节点一一样，这个家伙是指向这个家伙的指针，节点2是指向这个家伙的指针，所以我说嘿，你向他表明你的下一个观点，所以现在前两个盒子看起来像我的照片，基本上。
就像我认为当你初始化对象时，呃，你只要用那些，用花括号，所以有可能，哎呦，就像花括号语法，是啊，是啊，我想我可以我是说人们通常会做的事情，减少行数或其他什么，他们会编写一个小构造函数，您可以在下一个。
可选地，所以我可以说这里的数据是42，这里的数据是负3，然后如果我想说，节点1下一个等于节点2，你可以做的是，你可能会说，节点1下一个等于一个新列表，存储负3的节点，所以我只有一个变量。
但在他指着另一个之后，在这种情况下，两个都喜欢10%不是这样，为什么我没有符号或权利，这是个好问题，因为通常当你说指针等于，你得说某物的符号和地址，或者当你说新的新的去，并在堆上做一个列表注释。
它以指针的形式隐式地返回该列表节点的地址，新运算符已经返回指针，所以当我说等于，我没必要说那些含蓄的话，是啊，是啊，所以如果我想储存那17个，我可以说你知道节点一，这就是真正有趣的地方。
你可以说节点1下一个等于17，你明白吗，因为它就像节点1是一个节点，然后他有一个指针，所以让它指向另一个节点，所以现在是另一个节点，让他有下一个点，指向其他节点的其他点，所以你可以。
你可以让这整件事下一个下一个等于9，然后呢，哦等等等等等等，这个会说下一个，下一个，下一个，然后再来一个，放在这儿的是什么？完全正确，所以这就是那组线条存储数据的东西，这在概念上意味着，我做不到。
我不能只说流苏就把它打印出来，但我以某种方式存储了所有这些值，如果我想，我可以全部看完然后打印出来，如果我想打印值，我可以像，看出去，所以说四十二个，我没说符号什么的，当我在节点1上写箭头的时候。
这意味着跟随指针，当你到了那里，你会在一个小节点盒，把盒子里的数据拿出来给我看，所以我做了一个小链表，所以我的意思是，你可能想问自己一件事，如何在此列表中进行各种操作，我如何打印清单，我如何修改列表。
这里有一个快速的例子，如果我想删除这四个呢，名单上有两个，我希望只有这三个，我该怎么做呢，你有个建议，是呀，节点一所在的地方可能没有人，所以现在，在这里的一个点，每一个都指向下一个，下一个，下一个。
好吧如果我想摆脱这家伙，我所要做的就是说嘿，节点一不再指向4-2，指向四二后的那一个，那么四二之后的那一个是什么呢？是下一个，所以如果我说节点一等于下一个节点一，然后如果我打印节点一数据，然后打印负3。
我基本上已经从链表前面删除了那个节点，你可以看到，也许现在我们为什么要从链表中移动是一个很大的原因，我基本上只是把那个人从指针链中剔除，我不再指他们了，我不需要转移任何人，每个人都呆在原地。
我只是指着别的地方，我的记忆在继续，我马上就停在这里，但在那之前我还要再回答一个问题，我们如何预置，是啊，是啊，这是个好问题，如果你指着这42，我不再有任何变数，指向那个，我把那条信息弄丢了。
您必须使用一个名为delete的命令来释放和回收内存，我星期三就开始，当我们继续，祝你下午愉快。
我们从这里开始，星期三。
【编程抽象方法 cs106x 2017】斯坦福—中英字幕 - P14：Lecture 14 - Linked Lists - 加加zero - BV1By411h75g
好啦，我们何不现在就开始呢？嗯，在我开始今天的讲座之前，我想介绍科林，他是我们的组长之一，他要讲几分钟关于，我们的部门领导计划，所以拿着吧，谢谢马丁，哎呀等一下，您不打算在这里给出我的链表演示文稿。
没关系，那里，你先走吧，好啦，嗨，就像马蒂提到的，我叫科林，我是部门领导计划的协调员之一，今天来到这里我真的很兴奋，和你们谈谈部门领导的事情，鼓励你们申请，因为作为六个X学生中的一个。
你们现在都有资格申请部门领导，这看起来真的很势不可挡，如果你在斯坦福上第一堂课，你已经准备好教书了，但你是如此，我们只是想提醒你，区长的样子没有标准的形象，不管你的专业是什么，你的专业或任何其他身份。
如果你有兴趣申请，我们很想看看你的申请，所以我将略过部门领导所做的后勤和要求，因为你们班至少有一个组长，但有几个快速的观点，这是一份有报酬的工作，它至少是两个季度的承诺，你有任何其他问题都可以在。
可能在这些幻灯片里，但是在讲座结束后看着他们，嗯，所以真正领导的理由，作为一个对教育事业有潜在兴趣的人，在工作经验方面真的没有比这更好的了，我可以想象比在斯坦福大学领导和教学生。
你还可以学到很多关于计算机科学的知识，当部门领导，真是难以置信，我从学生那里学到的东西，从复习话题，当我以后去教他们的时候，嗯，即使在斯坦福助教职位中，这样的职位也是不可思议的。
因为你可以和学生一起工作，就像一对一在区段，在IGS和轨道上，人的进步，看他们如何成长，这真是不可思议，我们有很多活动，我稍后会讲到，部门领导是一群非常棒的人，我从部门领导那里有很多非常非常亲密的朋友。
他们不仅是善良的人，但也非常非常聪明，我在所有的CS课上都和他们一起工作，对我来说太酷了，最后，就遗产而言，当我回想过去的四年，我在斯坦福待了四年多，就像对我来说，我介绍的都是计算机科学的人吗。
对我非常关心的事情感到兴奋，所以就我个人而言，这真的很棒，嗯活动我们有，所以我们有很多愚蠢的传统，包括一个层形式，在季度末，我们有点喜欢打扮和风暴层，帮助很多人，还要吃零食闲逛，而且超级好玩。
也与谷歌等公司举办活动，我们有个铁厨师活动，我们实际上只是去谷歌校园，为他们做一个小时的食物，一起吃饭，而且真的很有趣，我们有很多这样的活动，包括微软，小船，巡航，但也包括与不是超级大科技公司的事件。
所以如果你对可汗学院或IXL学习和教育方面感兴趣，我们也在那里掩护你，最后，你们将加入这个由优秀的部门领导组成的团队，包括所有这些技术主管，还有像米安萨米这样的教授、医生和作家，就像很多很棒的人一样。
他们很高兴能在你的角落里，申请开放，离现在还有一个多星期，如果你对申请过程有疑问，或任何评论或任何东西，欢迎您通过这个电子邮件地址给我们发电子邮件，我想这些都会在幻灯片里，除此之外，感谢大家的收听。
我们可能有时间问一两个问题，你们有什么关于性项目的问题吗，所以你们，是啊，是啊，嗯，我实际上做在春天，但不一定冬天还是那样，好啦，我现在喜欢的，我觉得你应该以后再申请，如果你认为有任何机会。
你会喜欢在冬天做这件事，你现在应该申请，因为人们在第一次尝试时没有得到它是很常见的，我没有得到我的第一次尝试，但一旦你被录取了，就像我们希望你做的那样，从那个季度开始，同样地，如果你想等到明年。
你会想在春天申请的，或者任何一个季度，比如你想开始的前一个季度，好啦，谢谢，谢谢，太棒了，太感谢你让我失望了，我想尽快加两分钱，你知道我自己是一个部门的领导很久以前，不是在斯坦福，我没被斯坦福录取。
但是好吧，嗯不，我在另一所大学是这样的领导者，我真的很喜欢它，和学生一起工作真的很有趣，是我是，我喜欢那样，我要去帮助别人，我必须使用他们的代码并帮助其他学生，我认识了一些很酷的人就像她说的。
他们付钱给我，我就像真的，你愿意付钱给我，这很有趣，感觉不像是工作，是啊，是啊，你得到报酬，你知道你得到了什么，我知道，我知道大学校园里对本科生来说工资最高的工作，只是把它放在那里，这是个不错的交易。
我要说的是这不仅很有趣，但我不认为我会站在这里，如果我没有那样做，我是说，我想这就是让我对教育和教学感到兴奋的原因，它带领我一路晋升，然后我是一个研究生，我暑假要去上课。
接下来我知道的是我在申请一份教练的工作，现在你们都和我在一起，所以这真的对我的生活产生了影响，所以我当然希望看到你们中的很多人申请，前几天有人在我办公室问我这件事，他说，你们可能不会像我这么早雇人。
对呀，因为我只是在一个零六个X，你可能需要大三或大四的人，我的意思是不，我们雇了很多和你一样的人，所以是的，你有机会被选中，如果你想等，不管是什么原因，因为这是你的时间表，或者因为不管怎样，那很好。
但刚出1 0 6 x，我是说如果你在这门课上表现好，你了解这些材料，这就是我们希望你帮助人们的，所以说，如果你能做好这个，对我们来说已经足够了，所以再加上一些良好的人际交往技巧，也许过了这个季度。
你就会成为一个很好的部门领导，所以我鼓励你考虑一下，你还有别的问题吗？每周多少小时，你说，是啊，是啊，每周工作时间变化很大，哪个班级领先的季度，我想你通常可以期待你的第一季度。
每周工作15到20小时，这改变了很多，基于，比如本季度的招生规模，或者截面大小是多少，嗯，有多少课程经验，你有很多因素，但我们总是希望把我的工作量减少几个小时。
但你也可以通过图层时间或其他方式来增加时间，好像真的是，你呀，喜欢很多，是啊，是啊，好啦，嗯嗯，如果你还有其他问题，请埃隆和CS的其他协调员，在CS斯坦福的一个九八或访问他们的网站了解更多。
关于引导部分的信息再次正确，谢谢科林，感谢你的时间，现在我们来谈谈链表。
上次我跟你说指针的时候，什么是指针，这是现在开始的组长面试，什么是指针，走呀，走呀，你先举手的，是啊，是啊，去吧，有效的和呃，呃那只是，呃只是，只是，储存一个地方来纪念其他东西，不管那是一个物体。
另一头，这是正确的，它存储其他东西的内存地址，有些东西可能是，就像你说的，它可以是任何东西，也可以是一个int，它可能是一个物体，可能是一个数组，向量，对呀，存储指针，存储其他值的内存地址，好的很好。
指针与构建链表有何关联，为什么我需要知道，创建链表的指针，就在后院，在链表中，列表的每个元素都有一个指针，是啊，是啊，这是正确的，节点，清单的要素，它们存储从一个元素到下一个元素的小指针。
我们用这些指针把它们联系在一起，这就是我们的名单，对呀，是啊，是啊，你们记得你们的想法是对的，让我们从那里开始，所以你知道，你说“新”这个词来在这堆上做一个对象，还记得我们说过这个堆栈吗，而这堆。
我真的想强调一下，每做一个节点，链表，存储某些数据的节点，您总是要使用这种新语法，你从来不只是说，列表节点n分号，你总是说列表节点星号n等于新列表节点，你总是把这些东西当作指针，不仅仅是作为指针。
但是作为堆指针，当你说这个新的关键字，你知道我会理解的，如果周一讲座的那部分是最模糊的，但我只是我真的想让你记住，我们需要以这种方式构建所有的节点，如果你不，内存不会持续足够长的时间在我们的程序中使用。
它会导致bug或崩溃，它不会以正确的方式工作，所以当你创建列表节点时，用这种语法来制作它们，所以我们制作了这些列表节点结构，它们具有从一个节点到下一个节点的指针，在列表的末尾，我们有一个值为零的空指针。
表示在那之后没有其他节点，是啊，是啊，为什么你一定要，尤其是如果你使用你喜欢的关键字，什么是我相信，为什么你必须使用关键字新井，我是说，New关键字是一个导致几件事发生的单词，当你说新。
C+Plus系统得到了一大块热内存，它得到的那一大块，是那种类型的物体的大小和地雷，就这样进去了，它留出它分配了一个大小的内存块，然后如果你有某种带有参数的构造函数，它在这么大的物体上运行。
然后返回它的起始内存地址，所以所有这些事情都发生在你说新的时候，如果你不说新的，它不会去堆上制造内存，在堆上存储内存，这个对象对于这些示例非常重要，所以这就是为什么我们在这里说新，这就是我的意思。
但那是在想，为什么储存是至关重要的，哦，为什么把它储存在堆上很重要，嗯，我想我想给一个简短的答案，就像你知道的那样，你会使这些节点链，像这样，我们编写了代码，就像这个星期一讲座结束的时候。
就像你总是有一些东西在堆栈上，就像我调用的main或函数中的任何局部变量一样，那些在堆栈上，通常您要做的是在堆栈上保留一个指针，它指向堆上的东西列表的前面，所以当我画这些画的时候，我画了一堆。
像一朵云什么的，我不想每次都画云，我画了一个链表，我只是希望它是含蓄的，它在堆上，所以总的来说，当我画这些画的时候，我只是不打算画云，或者真的画堆栈，我要画一个指向这个的指针。
只是隐含地说这部分在堆栈上，所有这些高温下的磨砂膏，为什么这一定要在，是因为如果主调用函数a和a调用，函数b和b调用，函数c和函数c使链表链，函数c返回的瞬间，整个内存链就被释放了，被赶出去。
这就是堆栈的行为方式，我可能不想那样，我可能需要函数c使链表，在运行完c之后，列表将继续存在，所以你得把这些东西放在暖气上，为了让它们活得足够长，我想令人困惑的是，就像嗯，等一下等一下。
我用向量之类的东西，我用弦之类的东西，我不必说新的和堆的，所以我为什么要在这里做得很好，不同的原因是在矢量内部，如果你看了向量的代码，它使用单词new分配内存数组，把它放在，当你返回矢量时。
它有点像指针的手，它做了一些事情，所以它做了正确的事情，但就像你归还的任何东西一样，那很复杂，它可能是在内部做堆积的事情，以活得比你的功能更长，所以我们以前从来没有处理过，因为这些图书馆和收藏。
我们一直在使用的东西有这些内部的东西为我们做到了这一点，所以这就是为什么，突然间我们不得不做一件我们以前从来没有做过的事情，我们突然要担心这个从来没有讨论过的堆东西，直到今天这周的讲座，是啊，是啊。
所以说，如果函数c做了一个链表，使用新的，上的堆，如果它把所有的钱都放在堆栈上，就像上面说的，不带列表的列表节点前分号，二号节点，不听第三，列出节点4，它可以把它们联系在一起。
但它们都会在堆栈中连接在一起，指上指下，在堆栈里的某个地方，当函数c返回时，所有的静态记忆都会崩溃，所以所有这些节点基本上都会被抹去，所以他们已经走了，你可以回来，但是你返回的可能是前面的节点。
但你会回来，就像一个被擦洗的记忆指针，所以这就像写下你朋友的家庭住址，明天他们就会推平他们的房子，嗯，你还留着他们的地址，但如果你去那里，只有一堆瓦砾在等着你，你知道房子不在那里，所以不是说，哈哈哈。
我把房子从拆迁中拯救出来，因为我把房子的地址写下来了，它不完全是这样工作的，这更像是在云端盖房子，然后推土机就打不到它了什么的，我不知道这里有什么类比，但我想我的混合隐喻偏离了我什么的。
但就像那电影什么的，我不知道，我觉得，是啊，是啊，好啦，所以这就是我们现在的处境，我会我会理解，如果这些东西有点模糊，像什么窥视，这都是什么，我会说，我想你不需要知道细节，那些东西到底是关于什么的。
我觉得最主要的是，你要记住，当你在做这些节点的时候，你创建节点，您必须使用这种语法，我所有的例子都会做到这一点，你应该经常这样做，你知道堆积如山的东西，我告诉你这件事，因为我想你们是前男友。
你可能关心这个，但这更像是一个零七域，如果你拿一零七，你做了一大堆关于记忆看起来如何的事情，如果我分配这个，那是去哪里的，如果我去这个指针，再向前移动十个字节，会发生什么，你知道你会做很多那样的事情。
我不想做很多那样的事，因为他们会为你这么做，你要去教书，他们会教你的，所以无论如何，这就是你如何制造一个节点链，好吧，我想指出一件事，我已经说过了，但通常你所做的是只保留一个指向列表前面的指针。
你可以在这里保留前面的点，在这里保留第二个节点点，在这里保留第三个节点点，所以Main有所有这些局部变量，指向每个节点，那就太好了，因为您可以非常快速地使用任何指针与任何节点对话。
但实际上我们所做的是我们很好地计算，前面已经够好了，因为从前面你可以沿着指针到达所有其他节点，所以只要有一个指向前面的指针就足够了，现在只走一个方向，如果你在看这个节点，你不能倒着走。
因为从这里找不到内存地址的指针，跳回他们的，你知道这是单向的，但那是可以到达的，一切皆有可能，所以现在如果你想把整个名单交给某人，这是这个链表，我让你把这个指针，这个前面的指针。
你给他们这张纸条的内存地址，现在他们可以看到这一切，当然缺点是它们必须跳跃，跳，从一个节点跳到下一个节点，如果他们想查看所有的节点，不过没关系，这就够了，所以通常我们只谈论前面或开始。
或者是以名单前面的名字命名的头，所以我想谈谈当你在代码中有赋值语句时，涉及指针的相等语句，代码是做什么的，我认为你必须对此建立直觉，而且画画真的很有帮助，你这周肯定想去你的部门。
因为你要练习一大堆链表的东西，你画一些节点之类的东西，所以当你说左边等于右边的时候，如果你说的是指针，我会区分变量和存储在变量中的值，所以我有下面的图片，我有这个，这个链子在这里我有一个指针，一种叫做。
它指向一个节点，那个节点有一个下一个指针指向另一个节点，那个节点有一个下一个指针，它存储NULL，所以它不指向任何节点，这就是我现在在这个节目中所拥有的，如果我写了一个箭头，x等于p。
我想让你明白这句话现在意味着什么，什么P P不是东西，他什么都不是，但这意味着什么呢，当我说斧头等于好的时候，A是这个，下一个是箭头，记住箭头运算符的意思，箭头表示跟随指向该事物的指针。
它指向取消引用运算符，所以接下来的箭头表示，跟着箭头走，下一个等于，意思是把这个东西指向某个地方，下一个箭头等于p，意思是让这个东西指向p是这样的，如果我有一个像这样的节点b，我说下一个箭头等于b。
下一个会指向这里的b，反过来说，如果我把这个翻过来，如果我翻转赋值语句，然后我说p等于一个箭头，你可以想象他们会在这个问题上提出p点，因为右手边有一个箭头，你不会真的指着指针。
如果接下来你说p等于一个箭头，意思是指向下一个点的同一个地方，如果下一个是这个，它指向那个，然后做任何p也是点，指向我图表中的第二个，所以我认为对一些学生来说，那有点令人困惑。
指针似乎做了两件不同的事情，如果你把它们放在等号的两边，我想如果你真的想对这件事字面上说，像这样下一个，其实不是箭，它存储了一个数字，它存储了一个内存地址，所以存储在这里的内存地址。
如果我设置了与之相等的其他东西，我说什么都行，另一件事是在另一件事中放入相同的内存地址，从概念上讲，这意味着它们都有指向相同另一个地方的箭头，但是没有箭，箭是给我们人类的小大脑的。
这有点像第二个人的直觉，当我说下一个箭头的时候，我的意思是，转到这个变量并更改数字，将其排序为等于其他数字，从概念上来说意味着让它指向其他东西，不管怎样，我只想让你有一个普遍的直觉，意味着什么。
当您用指针编写这些赋值语句时，你需要有这种直觉，因为构建链表的整个想法就像操纵箭头，指向不同的东西，而不是他们过去指向，因此，您必须能够使用这些语句来正确地构建链表，所以让我们来试试，让我们练习一下。
哦，对不起，这里有一个例子，如果我，如果我有这张照片，我想说清楚，当我有这个东西，说a是一个列表节点星，它是一个列表节点指针，指向这个东西的是一个列表节点对象，好啦，所以当我说下一个箭头等于下一个箭头。
我的意思是，提出这一点，哎呀哎呀，动画在我的Linux上不太好用，但这就是那句话的作用，那么你如何让这张照片变成那样，其中列表是指针，列表节点指针，看一下，谁勇敢，谁有答案，为什么要举手，你说呢，我说。
C c，因为列表和第一个列表之间的箭头，下一个是在这一点上有十个的箭头之间的箭头，除非下一个下一个会创造，所以我想你可能会差一个，让我追踪她，看看列表在这里列表箭头表示跟随这个，所以现在我在这里。
我说下一个，那现在就在这里，我说箭头，现在跟着，我说下一个，现在在这里，我有箭头，跟着那个，所以我想这一行代码会设置，但没有那个，我们只有这个权利，所以我想我要改变的指针是下一个列表。
我想改变他指向一个新的节点，所以我觉得，但看起来我不会感觉太糟糕，被一个人带走，就像这是人们最常见的事情，他们下一个加了一个额外的箭头，他们有一到Q的误差限制，就像这正是，人们需要大量的链表练习。
被一个人甩了真的很容易，我觉得你只需要画图然后数数，好几次才能变好，是呀，那么什么是最确切的，是它是它，第一个元素，这是一个指针，这些彩色盒子是真正的，所以这个指针指向第一个对象。
那个对象有一个下一个指针，指向第二个物体，所以第一个对象只是下一个列表，你知道就像，如果我想打印十个，我说列出箭头数据，我不知道，我不说下一个，我想这是很多学生做的另一件事，当他们第一次这么做的时候。
他们就像，哦，名单在这里，所以如果我想去第一个真正的音符，接下来我要说的是列表箭头，因为接下来是推动你前进的东西，我是说，有点是的，但实际上向前移动的是负大于运算符，箭头操作符实际上是引导你前进的东西。
所以如果你现在说列表箭头，我在看这个，然后如果我说数据是这样的，如果我想去20，我说名单，向前箭头，看下一个，跟着那个箭头，这个箭头下一个箭头数据是再练习练习练习，我们再来一次。
我怎么把这张照片变成这个，所以最后一个，上一张幻灯片是，我在后面加了点东西，这张幻灯片，我之前加了点东西，其他元素，所以我在这里所做的是对初学者来说，我创建了一个名为temp的新节点。
它存储了一个带有30的新节点，我写什么是为了什么对语句，水平地将三十节点连接在正确的位置，你说呢，所以我喜欢画画。
所以如果我有临时工，我就写，T temp是一个变量，它指向一个新的盒子，里面有一个30，右边看起来不错，现在你说的是，所以你是说临时工下一个应该指向列表点，所以这里的下一个应该指向与列表点相同的地方。
我想我正在做幻灯片的上半部分，所以下一个应该指向列表点的同一个地方，像这样对吧，好啦，顺便说一下，注意一件事，可能看起来像是嘿，三十而立，三十到十，二十到二十，我受够了，我造了30到10个，二十还不够。
因为我也是当你说名单的时候，名单也应该从30岁开始，所以你明白吗，就像你有时可以在同一个链中有多个入口点，哪里，就像这家伙和这两个有联系，但是如果你说列出箭头数据，你拿不到三十，你得10分。
因为列表仍然指向节点，它之前指出，所以是的，下一个会说，那里有温度点，所以不要再让它指向那里了，让它指向那里，所以现在我知道我的图表有点乱，但喜欢名单，如果你顺着这个点，你就到了这里，你得到第三个。
然后如果你跟着他的下一个指针，你得到它的十个，所以这就是工作，有道理，如果我用另一个顺序做这些呢，如果我在这里写了试图抹去呢，所以首先我做列表等于临时，其次，我做临时工。
Next equals list，如果我那么做了，然后我会说列表等于临时，所以我会让这家伙像那样指出来，然后我说临时下一个等于列表，所以临时工来了，接下来是这个东西，让它指向，其中列表点，那是哪里哇。
我指着自己，喔喔，你看到了吗，如果我翻转两个命令的顺序，我真的会打破一切，我会，我将用一个元素替换列表，向自身报告重复循环的列表，你知道的，我会失去可能指向这些其他元素，他们将无法联系到，我就没有指针。
会让我得到这些东西，你看到了吗，我们称之为内存泄漏，因为我失去了记忆，我再也拿不回来了，当我还是个小男孩的时候，我学习链表，我的组长杰米，他很讨人喜欢，她让我想想他们，好像他们身上绑着小气球，指针就像。
你紧紧抓住的细线，就像，你知道的，名单就像我，那个小男孩拿着绳子什么的，她是个比我更好的艺术家，但是一个小男孩有一根绳子什么的，还有一个，这家伙身上绑着一个气球，他有一根小绳子。
他身上绑着一个小气球什么的，然后小男孩说，哦哇哦，你看这个盒子，哇塞，那个盒子太酷了，里面有三十块钱，哇塞，整洁，也许我会松开绳子，伸手过去，我要把绳子系在他身上，哦不，我的绳子掉了，然后他扬帆而去。
所以我的意思是，这里发生了类似的事情，嗯，我不知道什么心理图景或类比最适合你，但是如果您没有保留任何指向给定节点的指针，或者一系列指针，将您带到给定的节点，然后它就不见了，你再也找不到了。
你泄露了不好的记忆，所以陈述的顺序很重要，你是对的。
答案A是正确的，我们再来一次，所以我想把这张照片变成这张照片，所以我现在做了更多的操作，所以这是我想做的，嗯。
我要打开一个文本编辑器，我要把它缩小，这样它就不会覆盖整个。
我要试着打字，我要你告诉我，然后我会画，我把代码写下来，你告诉我，然后我也会试着画这幅画，所以谁来告诉我，这将有助于在把这个变成那个方面取得进展，列表1下一个等于列表2，名单一在这里，名单一。
下一个在这里，你想让他指出，列出两点，所以你想让我这么做，好啦，但后来我失去了我的小气球要飘走了，这家伙，对呀，我想我们需要这么做，在我做对之前，我可能需要做一些事情，所以也许哎呀，我做了什么，帮我。
也许在这一行代码之前我该怎么做，如果你想做临时工，我想那很好，做临时工，如果您想要列表节点温度等于，现在有一件有趣的事情，几分钟前我告诉过你，每次声明节点时，你说星结，你说它等于一个新节点。
所以让我们记住新的含义，这意味着进入堆，留出内存，实际上创建一个完整的节点，这与指向节点的指针不同，您可以有许多指向同一节点的指针，这意味着所有这些小指针都在堆栈上，一个节点在堆上，他们都指向他。
如果你说列表节点星型温度等于，让我们列出一个，好啦，如果你写那就意味着，你做了一个小指针叫做，你知道临时工，我就写一个T，他指出了名单上的一个点，这就是那行代码的意思，但它不会复制节点对象的整个副本。
只是这两个指针指向同一个对象，所以现在如果我继续说列表一等于，你知道不管是什么空指针，就会切断这根绳子，但气球不会飞走，因为我在剪断第一根弦之前先接了第二根弦，所以你可以做这样的事情。
如果你认为这能帮你解决这个问题，我只想强调，就像我没说知道什么，因为这样会使图片上出现第五个盒子，五年级箱式，我不需要五年级的书，所以考虑到这一点，我是说，我只是这几行代码不一定能帮助我们，到目前为止。
你会在后面的代码中添加什么，对不起什么，你想让我怎么做，清单二，好啦，让它坚持住，让我来，我以为这会很好，不确定这里是不是这样，好的，你想让我把这个等价于下面的列表2，所以你想让临时工。
其中列出两个下一个点，所以你想让临时工看起来像，嘿嘿，我有个小窍门给你，如果你没有一个红色的标记在你的屏幕上画满，你可以做的一件事是在每一行，你可以写一点评论，就像四十个节点的临时点，你知道吗。
你人真好，如果你那样做，当你在考试的时候，你不需要对测试发表评论，但如果你这么做了，这会帮助部门领导理解你到底想做什么，因为你可能搞砸了，所以评论可能会有所帮助，好啦，所以温度是40。
我知道我的字体有点小，我要说的是列表节点温度，然后我要像那样打破界限，所以你可以看到更大字体上的行，好啦，温度到40，现在呢，你要那个干什么，你想在那之后再给我一句台词吗，是啊，是啊，然后你要做什么。
对X说这个现在得到，列出两个下一个等式，下一个列表1，所以下一个列表2，下一个是这个指针，就在这里，你说你希望它不再指向那个，但你想让它指向，列出一个下一个要点，在那里列出一个点。
在那里列出一个下一个点，所以你想这样，三十归二十，所以再一次，我可能会在这里写一点评论，三十支箭二十支，把这些排成一行，所以他们很容易读到这样的东西，好啦，那很好，再给我几行代码，我们有。
我们这里有一个列表一，下一个等于列表二，现在可以吗，所以如果我下一次这么做，下一个等于列表二，所以现在，我不想再让这家伙在这里指指点点，我要他指出两点，所以在这一点上，所以那是在十个之后做的。
我想指出三十个，像这样，是这样吗，好啦，我们在后面还需要做什么，是啊，是啊，我觉得你，所以我没有说下一个，你不必总是说下一个，我是说我想把这份名单放在前面的箭头上，不要再指着三十岁了，但要指出四十个。
所以把这个剪掉，像那样点，你说我们结束了，让我看看，是啊，是啊，我的意思是，如果你真的想清理，你可以说夯实等于空指针，会切断这根绳子，但你不必这么做，那很好，所以现在让我来看看我们是否做对了。
所以如果你按照列表一，我得先去十楼，我就是这么做的，然后如果我去下一个，我应该到30岁，我做到了，然后如果我去下一个，我需要得到20，我做的，然后如果我试着从下一个，那应该是空的。
所以整个链条看起来是对的，我知道这都是对角线，到处都是东西，但这些照片只是为我们愚蠢的大脑制作的，对呀，所以是的，这些是正确的跳转序列，以获得正确的节点序列，然后列表二应该会让我得到40，没有别的。
它只带我到四十岁，你也知道，在我们这么做之后，它祝福你，所以是的，这些命令序列将把顶部的图片变成底部的图片，这不是唯一的命令序列，如果你有不同的解决方案，可能有很多不同的方法，你可以。
你可以改变这些指针，然后去试试，如果你想看，是啊，是啊，你能把开头写完吗，所以就在这两点，两个嗯，你不用尝试就能做到，你只需要小心不要切分，你可能会失去你的气球，就像你说的清单直接到40。
你会失去那三十块钱的，好啦，所以你可以做一些把戏，就像你知道的，也许暂时成为四十个中的下一个，一个三十，然后做四十个中的这个，我基本上可以翻转这两个，现在更容易在不丢失任何东西的情况下删除30。
你可以做这样的事情，您可以把这里的这些结尾空指南看作是临时的，在某种程度上，所以如果你的目标是喜欢，不使用临时变量，你可以完成那个目标，但我不知道，你知道的，偶尔我会问你这样的问题。
我会说不要临时指点什么的，这意味着你可能会做一些把戏，但总的来说，我会让你做一个临时指针，如有需要，你觉得这样做有什么意义，你对这里的这些线条有问题吗，很快，你要做一个家庭作业，你基本上要做这个。
但这是行不通的，因为你已经写好了，这是你第一次尝试，也不会是对的，所以这很难，因为你会运行程序，你的程序会崩溃，会出现分割错误，因为有些指针会掉进深渊，你要跟着指针走，您的程序将崩溃。
所以你要做的就是写一张图片，所以你有你写的代码行，画一张图，然后沿着每一条线，如果它看起来应该做正确的事情，但事实并非如此，然后呢，坦率地说，你可能画错了图，就像你对代码的解释可能是错误的。
所以你给你的部门领导看代码，你给区长看图层里的图片，他们和你一起走过，或许他们能帮你看清，哦不不不，实际上，这改变了指针，不是那个指针，所以，这就是区长如何真正帮助您调试这类代码，但你需要照片。
没有照片真的很难做到这一点，就连我也喜欢今天，你知道的，当我想到涉及指针的试题时，我画这些愚蠢的画，我画小箭头，我把它们弯弯曲曲地写出来，所以这样做是可以的。
好啦，所以好吧，有趣的是，就像我拍的那些小照片，但那很好，但是链表可能是这个长长的节点链，我们要操纵它什么的，那么当它是一条很长的链子时，你会怎么做，你可能连链条有多长都不知道，你可能会说很好。
它在哪里存储列表的大小或长度，并没有把它储存在任何地方，我是说，我想我们可以保留一个整数什么的，但我们甚至不一定知道有多少节点，如果我们有一张纸条，有人给了我们一个指向链子前面的指针。
这就是我们所拥有的，我们不知道确切的长度，我们想打印所有的值，好吧，想打印所有的值，所以我的意思是，我有我有一个可爱的创作者项目。
在那里我们做了一系列的价值观，哎呀这里，所以我把这个链子，如果我想绕过它们，如果是数组或向量，我要说的是，我从零到大小，或者我对每个循环做一个，那些在这里不起作用，因为我没有尺码。
对于每个不明白指针的人来说，那么我该怎么做呢，这样我就可以打印所有这些值，我是说如果我想打印一个值，我可以这样做，我可以说打印节点一的数据，然后如果我想打印下一个值。
我可以说打印像空间加节点一个下一个数据，然后我可以说打印一个空格加节点，接下来你知道我可以这样做吗，但这似乎很傻，我想在这里做一个循环，我只是不知道有多少这样的，我需要做任何建议，是啊，是啊。
所以建立一个什么，把它循环起来，只要下一个数据值不存在，不想，是啊，是啊，我想你的想法是对的，就像做一个循环穿过指针，直到我击中零，打印每一个，就像用指针访问节点一样，所以我要稍微歪曲一下你说的话。
让它变得不那么好，因为我想先说明它的一个常见bug，然后我会照你说的做，如果你允许的话，嗯那么好吧，如果我只是这样做，而某事，我马上回来做循环测试，我会打印节点数据加上空格什么的。
然后我想前进到下一个节点，所以如果我在这里有这些值，我的节点1有点像一个指针指向这里，所以这个声明将打印四个二，然后如果我想去下一个节点，我可以说。
就像让他等于他的下一个变量点。
所以说，换句话说，打印完四个两个，它将把节点1提前到这里，然后在它打印一个负3之后，它将节点指针前移到那里，以此类推，好啦，所以现在我们回到这里，你说就像你不再做的地方，这是当您最终看到一个零的时候。
对呀，所以我会说，当节点一不是空的时候，推杆，做那个，一旦它变成空停止，所以让我们来试试，然后在最后我会做c out end l，也许只是为了说清楚，我出去看看，所以我编译它并运行它，我想这是另一回事。
等一下等一下，这五十是什么，这只是一些其他的东西，对不起，对不起，就像撞车一样，不是我们送的，忽略这些其他指纹，那是一些我们还没有写的代码，我的单子是四二负三，好啦，所以嘿，就像工作一样，印对了。
如果我想把列表打印两次呢，我将复制并粘贴所有这些代码，只需在列表上循环两次，没关系的，一切都会好起来的，我的清单是它打印了所有的元素，我的清单是它不按任何打印，任何元素，这个零号的东西，我把它关了。
那是哪里，那么为什么它第一次打印列表，然后第二次就什么也没打印出来，是呀，气球飞走了，所有的气球都飞走了，是呀，这是一种说法，是啊嗯所以再次。
图片很有帮助，所以我列出了指向第一个音符或前面或其他什么的列表，你知道吗，我不知道我的职业叫什么，但我打印十个，然后我说让他等于，下一个点是什么，所以现在他指着这个，但我弄丢了巴林B，然后我打印这个。
我说指向下一个，但我失去了指向这些原始节点的指针，因为我把前面向前移动，你明白吗，就像我有这个，在那里列出要点，然后当我说列表等于列表下一个，它改变列表指向那里，然后在我打印20之后。
它将列表更改为指向那里的任何地方，但我要开门见山了，所有这些节点都坐在这里，他们仍然存在，他们仍然有数据存储在里面，他们仍然互相指指点点，它们最终连接到我所指的部分，但没人指出他们，你明白吗。
就像你在推特上知道的那样，你知道你可以跟着名人或很酷的人，或者随便你怎么指着他们，就像你在看他们一样，但好像他们没在监视你，就像单向的关系，你知道这就像，是啊，是啊，我和思嘉，Johansson。
就像约翰·德普，我们都很亲密，我们在推特上都是朋友，就像不不，你跟着他们，他们不跟着你，你不会被邀请参加他们的派对什么的，所以我想现在的情况是，这些家伙可能看起来还和链条有联系。
但他们只是他们不是因为没有人能接触到他们，他们指着链条上仍然可以到达的部分，但他们自己是无法联系到的，所以这是一个重要的区别，你能不能，您可以通过内存本身手动将列表的值编辑为双向，好好找回来的路。
你说过，是啊，是啊，我怎么解决这个问题，我怎么才能把名单找回来什么的，我想秘密就在一分钟前，我们学会了制造一个临时变量，我想这就是你要我做的，但我假装你没这么说，所以与其这样做。
让我们把它做成某种TAM或当前指针，并将其设置为列表的前面，或者我们的前指针的变量名是什么，因此，它将被创建为另一个箭头，指向开始，如果我跟着它打印它的数据，同样的十个也会出来。
如果我接下来设置电流等于电流，电流会哎呀，现在电流将指向20，如果我再说一次，当前等于下一个当前，然后电流会指向三十，以此类推，所以我可以用这个指针遍历节点，但我不会把我的气球串丢到名单的前面。
这样我就不会损坏任何东西。
不管怎样，回到这个程序，与其这么说，我要做的是，我说列出节点电流曲线或电流或等于节点一的东西，前面一个，然后我会说，当当前节点不是空指针时，打印它的数据并转到下一个，然后如果我想再做一次。
我将再次复制粘贴相同的代码，除了我不重新声明类型，我只说当前，所以现在如果我编译，我管理它，我得到了整个名单两次，我没有弄丢，所以很多时候你想把这些操作写成函数，所以你可以把这段代码，你可以把它拔出来。
你可以称之为印刷品，如果你给我一份名单，节点前端，我帮你把名单打印出来，所以我写了一张清单，节点，链表函数，你能看到，比如我们如何在这里建立一个收藏，我会写一个添加函数和删除函数，和打印功能。
和一个什么功能，他们都会走着一连串的东西，总的来说，我们将建立向量所具有的操作，或者链表有，或者别的什么，是啊，是啊，这么说的问题，如何在不引起内存的情况下删除其中一个，好吧好吧，让我们现在就谈谈那个。
我不认为我今天会删除，所以让我们做加法，我想我们可以做到这一点，让我们谈谈在列表的末尾添加一些东西，所以，嗯，在这里，我想说我的清单是，然后我会写打印节点一，我把第一个节点当作前面。
我想在列表的末尾添加一些东西，所以我有一个节点链。
我的幻灯片里有这个的照片吗，它在哪里，这里，好啦，所以我有一个节点链，我想在最后添加一个新节点，这就是add方法在向量或链表上的作用，所以让我们把它写下来，所以基本的想法是，我得去名单的末尾。
然后在那里贴一个新的盒子，对呀。
所以如果我如果我想做一个新的盒子，也许列出节点指针，新节点是新列表节点，也许我想加上八八的值，八八到名单末尾，所以有了新的节点，把它贴在末端，所以我认为你需要做的是你需要喜欢，走到列表的末尾。
这样我就可以把它放在那里，因为我没有直接的指针，指向列表的末尾，你可以有一个，但我不知道，那么你如何走到列表的末尾，这有点像打印一个列表，所以你说前面的节点电流等于节点一，当电流为零时。
我可以说电流等于电流，就像我想要的是。
我想做，所以我就在这里等着，然后我可以把他绑在这里，现在让我们仔细考虑一下循环条件，我希望电流是这个节点，这样我就可以在他之后安排一个新的下一个人，如果电流指向此节点，则为右，我想让循环停止。
什么会是真的，当我指向这个节点时，我的下一个将是不，并不是说电流将为零，电流不为空，电流指向这个，但我前面的下一个是空的，如果是这样的话，我想让这个循环停止。
你明白的，所以重要的是要指出，像这样，直到电流为零，这个循环才应该循环，它应该循环到电流不，所以向前走，直到电流没有下一个，一旦我到了那里，在新节点处设置当前点，在新音符上做当前的下一个点。
所以在我构造的新节点上设置当前的下一个点，是啊，是啊，列表为空，是啊，是啊，如果列表为空怎么办，所以我刚才写的代码走了一个现有的列表，但它可能不适用于空列表。
那么我该怎么处理呢，所以我只需要一些喜欢，如果为空，就像我知道我的主这里的这个列表不是空的，但让我们概括地说，所以如果它是空的，我想干点别的，但如果不是空的，我想这么做，所以如果列表为空，你怎么知道。
如果列表为空，空列表的含义是什么，你认为第一个前面的指针没有指向任何东西吗，那里没有节点，所以如果节点一，前面是零推杆。
如果是这样的话，我想我有一张照片，我意识到我快没时间了，如果列表为空，那么前面是空的，我想做，所以后来就这样了，对呀，那么我该怎么做呢，我想在一个新的节点上做前端。
所以我应该说节点一个点在一个新的节点上，像这样，现在我要告诉你的最后一件事，我没时间了，但我还有一句话，我想在这里说，我最后要告诉你的是，如果你拿着这个，你想把它变成一个函数，所以你把这个。
然后你把它贴在，你下去喜欢，我有一个，我有一个加法，在某个地方加上就在这里，所以如果我把这个，不是八八八八，我写价值，所有这些代码仍然是正确的，但如果我运行这个，然后我把它打印出来，不会总是奏效的。
我给你一句话，原因为什么，然后我们会解释为什么在星期五，一句话，原因是我必须传递这个指针，我必须将此称为传递对指向列表前面的指针的引用，现在，狗屎变得真实，所以你看。
我们将解释为什么我们将在星期五更多地讨论这个问题，但时间长了，所以去你的部门，星期五见，我们在那里继续。
【编程抽象方法 cs106x 2017】斯坦福—中英字幕 - P15：Lecture 15 - Linked Lists 2 - 加加zero - BV1By411h75g
嘿嘿，最近怎么样？今天是星期五，嗯，这是一个星期的结束，本周是什么，五是这样吗，是呀，哇塞，它飞驰而过，在我开始之前，我们今天要做一些更多的链表的东西，我想提醒大家，你知道你有期中考试，下周四晚上。
我在班级网站上贴了一些学习材料，所以有一个链接说考试，你看，如果你点击它，它显示了将附加到测试的语法参考文档，因此，关于该文件的信息将在你的考试中，你可以使用，我想我可以，我可以把它弹出来。
看起来是这样的，它有所有的方法，所有的收藏品和东西，所以它没有所有的c+和语法，它主要是一系列的方法和东西，所以如果你不记得，向向量添加某物的方法是什么，你可以看看里面，它还有大O，因为我很好。
每种方法的大O，所以你去嗯，又来了，这已经会打印出来，附在周四的考试中，所以你不需要打印这个，你会得到这个，但我想让你记住在考试中，我不允许你把你的任何纸质资源，你可以带上你的书和你的大大脑。
但仅此而已，原因是我想给你带来问题，这很像练习测试中的问题，所以我不希望你把练习题，和你一起练习测试的解决方案，好啦，但我会让你拥有这个，我把课本给你，如果你有一个，如果你没有，教室前面会有一些教科书。
每个人都可以分享，在某种嬉皮士，卡米，反正我也不知道，在那里练习考试，问题是，问题有答案钥匙，还有一个拉链，你可以下载一个可爱的创建者项目，所以你可以输入，如果你有解决办法，您可以输入它。
看看您的解决方案是否正确，或者你可以检查答案键，这些答案键的工作方式是我有我写的一个解决方案，您的解决方案可能不同，但它可能仍然有效，你知道解决问题的方法不只一种，所以你可以试试看。
你也可以在逐步网站中尝试所有这些问题，他们都贴在那里，你可以试试，嗯，所以是的，这里应该有很多材料，我想说的是，就我对你如何学习的建议而言，嗯，我想说熟能生巧，就像你做的练习题越多，你准备得越充分。
所以只要留出一些时间来学习和练习，当我说练习的时候，我不是说，看问题再看答案，然后说是，这就是答案，那不是他妈的学习，不是那样的，学习就像什么，我的建议是看看这个问题，然后认真地试图解决这个问题。
只有在你的过程的最后才能看到答案，我见过很多学生一眼就能看出来答案，他们走了，是啊，是啊，这并不难，就像嗯，为什么不那么难，为什么你要偷看答案，所以试着自己解决问题，有些人还发现。
如果他们所有的学习都在电脑上，那就感觉不到真正测试的感觉了，因为它是为了真正的测试而写在纸上的，所以也许你应该去学校把它打印出来，找张白纸试着写下来，感觉真的很奇怪，就像在纸上写代码。
但这是你星期四必须做的，所以练习一下，在没有编译器的地方，而且没有任何东西在语法错误下划线，去试试吧，一旦你完成了测试，一旦你想交卷，然后你可以去输入，看看它是否正确，或者看看答案键，看看它是否正确。
这是一个建议，嗯，你也知道我没有无限的练习问题，但我有很多练习问题，这里有两个假的期中考试，或者如果你把这些都用完了，去看看你们的讲义，我知道你没有做所有的问题，我给你额外的钱是为了让你在考试时学习。
嗯，我想这里还有其他的东西，比如如果你想看看什么主题，或者不太可能参加测试，你可以看这里，从本质上讲，这就是我们今天要讲的一切，除了你知道，几个细节，一些小细节被剪掉了。
就像我不会让你用G窗口画任何图形一样，今天之后我什么都不问了，所以如果你在这里看到一个主题，你就像，我都不知道那是什么好东西，考试上没有，所以不用担心，嗯，这些是我要测试你的东西。
从第一周开始的C++语言基础知识，第二周的所有数据结构，大O与算法分析，我可能会给你看一些代码，这有什么大不了的，或者我可能会说我想让你写一个这个问题的解决方案。
但我希望你的全学分解决方案不比什么大O差，我想让你写递归代码，我可能会让你写代码，它在回溯，我可能会让你用指针做一些事情，可能是小列表节点，我想让你重新排列的小链接节点，像我们一直在做的一些指针，好啦。
嗯，这就是我给你准备的考试，你们对考试有什么问题吗？因为这是现在讨论的话题，就像，根据我的语法评分，所以如果你忘了喜欢，如果您犯了任何语法错误，你没有信用，我可能是认真的，啊对，我这个季度太刻薄了。
也许我的意思是不，我开玩笑的，我当然不是这个意思，嗯，更多的是关于你的算法，如果你有语法错误，就像你忘了一个卷曲的支架，你忘了一个分号，我们实际上让一小部分没有扣除，如果你有很多这样的东西。
你开始得到一个小的扣除额，但你仍然可以，如果问题值20分，你仍然可以得到大约1819个，即使你有几个这样的小语法错误，现在分号和你完全错误的算法是有区别的，这些都不是语法错误，你知道我的意思。
但是就像一点点或者像，如果你，如果你写，矢量点删除，你是说矢量点删除，但很明显，这就是你的意思，就像一个小小的语法错误，但就像一些大的东西，哎呦，你忘了检查空表箱什么的，那不是语法错误。
那是算法上的缺陷，那不一样，所以我们更多的是根据你的算法给你打分，我们意识到您无法访问编译器，我们也意识到把代码写出来真的很奇怪，用铅笔，所以我们试图解释这一点，在评分中，我们也有很多部分信用。
所以我们不仅有一桶桶的积分，就像你看到了问题的一部分，对这部分对这部分，所以即使你只能想如何解决前半部分的问题，你一定要写下来，因为你会得到那些分数，但也。
我们有像你这样的人在解决这部分问题上做了很好的尝试，相反，你实际上解决了这部分问题，所以如果你能尝试一下，这取得了一些进展，你可能会得到一些分数，即使不成功，即使它不编译。
即使你给它的每一个输入都会崩溃，如果里面有好东西，呃，我们会试着给你的好东西加分，所以无论如何，是啊，是啊，很多学生，我觉得，如果他们想不出一个完美的解决方案，他们锁起来了，就像嘿，把你的一半给我。
好解决问题，你可能会得到一半或三分之二的分数，代码样式多少，哦，风格几乎完全不分级，唯一的例外是，有时我会说在这个问题上不允许使用矢量，所以现在你的风格很重要，因为我这么说，或者您必须递归地执行此操作。
我要问你一个递归问题，如果您使用for循环而不是递归，这不是我想测试你的，所以这是你风格中很重要的一部分，但总的来说，就像你绝对不需要注释你的代码一样，不过，如果你愿意。
这可能会帮助更多的人理解你到底在做什么，您不需要有好的缩进和好的变量名，而这些事情，虽然再一次，这样做可能会使我们更容易理解您的代码并对您的代码进行评分，但是是的，就像你不用担心风格，一般来说。
在这一页的底部有一份文件叫做考试策略，我的同事朱莉泽伦斯基给她的学生们写了一些建议，我喜欢它，所以我也把它贴了出来，你可能也想看看，一些学生和一些部门领导谈论的一件事是伪代码，比如。
如果你不能很好地想象如何解决这个问题，你能用英语写吗？像井这样的段落，我可能会这么做，然后我会把它分类，然后我想补充一点，如果你愿意，你可以，但它不太可能得到很多分，我想如果你想要信用。
您应该尝试编写C++代码，即使你的C++代码有点错误，或者语法有一点错误，这对我们来说比伪代码好，因为很多时候伪代码太模糊了，这就像，我会从列表中找到正确的元素，然后删除它，这就像，哦好吧，你会怎么做。
爱因斯坦，你知道这就像，太模糊了，你知道你知道你必须给我喜欢，基本上是那种你必须编写才能获得信用的伪代码，本质上必须将一对一映射到C++代码，所以你为什么不直接写C++代码，所以是的。
有些sls会给你这个建议，就像如果你想不通，编写伪代码，然后再像，我通常会说，试着用C+和我说话，我想这样你会得到更多的分数，好啦，但正如我所说，即使你的C加+不完美或缺失，一些仍然得到部分荣誉的东西。
还有别的吗？我希望你对这个测试有中等程度的恐惧，我不想让你害怕，如果你去看看学习问题，你就能解决它们，你觉得你理解这些话题，真正的考验，我保证会和这些测试非常相似，问题的类型，问题的一般难度。
接下来我会尽量不给你惊喜，星期四，你会说，哦耶，递归问题，开始了，或者别的什么，我不想吓到你，我不是夜施米兰，我不是想在这里有一个曲折的结局，但我希望你，所以我希望你有信心，如果你去学习和准备。
你可能会做得很好，但我也想让你有一点恐惧，如果你不准备，我会努力想出具有挑战性的问题，所以就像你知道的，你应该好好读书，喜欢中怕不，好啦，嗯，反正，如果你对考试还有其他问题，给我发电子邮件。
在广场上问我，到办公时间来，我很乐意回答他们，把作业做完，所以你可以留出时间学习。
话虽如此，让我们回到过去，进一步讨论链表，好啦，所以我们开始编写函数，对链表进行操作。
首先，你知道我们有一个可爱的创作者项目，我把这个打开，链表客户端，好啦，所以我们写了一些代码，可以创建一个像这样的链表，把一些节点放在一起，把它们连起来，把它们连接起来，然后我们想做一些事情。
比如打印列表或在列表中添加一些东西，所以现在我们开始写这些函数，像打印或添加或其他什么，所以让我们来谈谈一些简单的，很快的，比如什么，如果我们想知道链表的大小，所以你可以知道链表的大小。
通过保持一个int数，知道大小是什么样的，我想在这里，每次我添加一个节点，我可以做一些加号加号，我可以记住大小，但实际上，如果你所拥有的只是名单的前面，你可以用这个来计算尺寸，你是怎么做到的。
一直跳下去，找到中间的赢家，然后你计算，你呀，只要从列表的前面开始，跳过，数数我跳的次数，然后当我打零，我停下来，我数对了音符的数量，所以，让我们写的真正快作为一种热身，所以如果你要写一个大小函数。
再次，我没有太多时间来完成所有的工作，我想谈谈上次，但是很多时候，当你写这些链表函数时，你必须考虑列表可能处于的不同状态，如果你没有充分考虑到这些州，在某些情况下，您的代码可能会失败。
所以你需要考虑的一个非常常见的事情是，如果列表是空的怎么办，与列表非空的情况相反，你怎么知道，如果这是空的，是的，所以如果前面是空指针，那是个空名单，所以这就是零的大小，对呀，返回零，否则非空列表。
我想你不必说别的了，但我有点喜欢这里的if和else的si树，所以如果它不是空的，我们照他说的做，从前面开始数啤酒花，现在呢，记住诀窍，您制作一个临时指针，类列表节点，我输入情欲节点，那是什么？
它是一个节点，好色地指向你，我指的是你，我们不要，我们不要列出节点，电流等于正面，然后你说继续直到我看到空指针，所以可能像计数等于零或其他什么，然后当电流不是空指针时，我会做计数加加。
我会做电流等于电流，下一步移动到下一个节点，然后当我做完，哎呀会的，然后当我做完，我说还数，好啦，是呀，问题是我们需要声明吗，然后返回零，如果，是啊，是啊，其实会的，所以说，我是说这段特殊的代码。
我认为是安全的，嗯，我们写的大多数其他作品都需要这种分离，你可以判断的方法是，如果你说的是，下一个会崩溃的空的东西，因此，您希望确保您的代码永远不会陷入，其中指针为空，然后你在中间的指针上有一个箭头。
因为我们没有听到，我想你是对的，我们可以删除，如果，所以我们就这么做吧，好啦，这就是列表的大小，让我们快速测试一下，在缅因州，当我打印时，我在这里等，我的名单是，然后我会说再见，尺寸是，节点1的大小。
我们得到了什么，尺寸是四个，我想这是对的，因为在我们添加的代码中有四个节点，所以看起来还不错，事实上，我今天不打算花时间在这上面，但上帝保佑你，其实有一种乐趣，您可以再次使用递归来实现其中的一些内容。
我今天不打算那么做，这怎么会是递归的，就像，如何查找列表的大小，类似于查找另一个列表的大小，你说呢，你要不要，等于零，回零，然后在那之后返回一个，加，完全正确，是呀，如果我清空，我的大小为零。
如果我不是空的，我的尺码比下一个家伙的尺码多一个，所以是的，完全正确，我认为这是一种非常酷的方式来编写这些函数，我不打算那样做，因为我认为递归开销，如果名单很大，它进行了很多函数调用，所以我不会那么做。
但是在算法上有一个很好的自相似性，好啦，这就是尺寸，那很容易，怎么样我想谈谈，得到得到，会像，我有一长串名单，我想把数据，位于索引处的元素值，什么指数什么指数，好啦，所以如果它是一个矢量，如果是数组。
你只要用括号，你会说跳到索引处，从那里抓住东西，但是这里不能用括号，因为节点是连接在一起的，索引四的权利，我们必须喜欢，往前走到那里，你明白我的意思吗，所以让我们考虑一下如何快速地编写代码。
那个代码是什么样子的，我会说使用从零到更少的支持，好的循环，我等于零，我比索引少，我加加，我叫它，我称之为，等一下，让我重新命名，移位控制r重命名任意变量，然后归还什么，是呀，有人说回卷。
但当然复发本身就是节点，我不太想要节点，我想要数据，节点内的小int，我听过很多类比，链表，节点是糖果包装纸，我不想吃包装纸，真恶心，我想把糖拿出来，我什么都不知道，所以从节点中获取数据并返回数据，嗯。
这段代码假定您传递的索引是正确的，我可以很容易地检查阴性病例，if语句，比你的体型大，笼大于等尺寸，我不知道尺寸是否合适，除非我走路，所以说，我可以做一些事情，比如如果我打了空，我还没有到达索引。
我想在错误检查上下注，我想代码就是代码，我们都可以想出以后如何添加，我们有很多事要做，但就像我一样，我就当你没把坏索引传给我，但我认为一个更好的实现会检查这一点，如果语句，你知道我的意思。
抛出一个错误异常或某种，如果他们通过了好吧，到目前为止，一切都好，对吧，这些方法并不难理解，我们在列表中走来走去，对列表做一些事情，对呀，所以我们一起写了一个方法，我们开始一起写一个函数。
叫Add是因为我想你很了解这里的代码，下一个下一个下一个，那很好，几乎是真的，人们不是这样建立收藏的，他们说我想要一个空的收藏，然后他们说加上，添加或插入，插入，好像有某种功能，如果我们做对了。
我不想太多考虑节点，当我们做完的时候，我们将完全调用函数来完成所有的事情，我们不会直接在主，弄乱这些指针，那有点，数据结构的客户端和数据结构的实现之间的区别，缅因州应该用这个东西，也不用想太多。
方法本身应该担心所有的小箭头和指针，和东西，是啊，是啊，我想，get方法的，就像，我想上一堂课你提到的，当你这么做的时候，是啊，是啊，你在问，我只是重复你的问题，所以它被拍到了视频上。
你说我们写的一些方法，我在这里写符号，到目前为止，我在这些例子中没有这样做，那么我什么时候做，我什么时候不这么做，我有点导致了这一点，所以我的意思是，到目前为止，我们编写的代码都很好，它的写作方式。
我将得到这个在第二，但关键是，您是否要修改列表，我刚刚写的所有方法都是大小和获取这些只是看列表，我没有改变名单上的任何内容，如果我真的要开始把箭头指向新的地方，并改变列表中的结构。
然后我需要这个与与符号不同的语法，所以让我们去吧，所以我们想写一个名为add的函数，所以我想你会做的是你通过前面的指针，以及要添加的值，它会把新值放在列表的末尾，就像我白手起家，我有四个两个。
然后它就会变成四二，后面什么也没有，然后做了一个三，它会把它挂起来并理解，添加到列表末尾右，我们基本上在周三写了代码来做到这一点，我有点没时间了，所以如果你跳转到那个方法的代码，这是可以理解的。
您用其中的值创建一个新节点，如果列表为空，所以现在我们需要空箱子，与大小不同，如果列表为空，把这个新音符放在前面，前面指向这个新节点，如果你听一个空的，然后走到尽头，然后把这个东西。
这段代码是相当不言自明的，关于这段代码，您想知道的主要事情是循环测试是，我想循环直到下一个为空，直到电流为空，原因是，我想我有一张幻灯片，上面有一张小照片。
我去找找，坚持住，我跳过这里，所以我听说这被描述为詹姆斯·邦德的类比，喜欢啊，回到1999年，当我在学这些东西的时候，当然，一切都回到了白纸黑字的背上，然后大多数人都戴着圆顶礼帽和车把。
胡子和单片眼镜之类的，我们看起来都像大富翁，基本上嗯，但我们当时确实有链接列表，我听到这个类比，我不知道你们是否听说过詹姆斯邦德，但好像他是个间谍，他叫杰森伯恩，你听说过杰森·伯恩吗，可能是他，就像他。
但是年纪大了，所以他就像在火车上，你知道吗，火车上有个炸弹，他得把车拆下来，这就是炸弹，我把那辆车和火车的其他部分分开了，但就像如果他要这么做，他会想上前一辆车，所以他可以把这个，然后坏车就开走了。
如果詹姆斯邦德在这里，他切的，他就死定了，因为他站在右下角，所以这有点像链表，很多手术，这是，这就是重点，你知道的，如果你不想记住詹姆斯，重点是修改链表的操作，插入新内容或删除现有内容的，做这些手术。
您需要在要更改的地方落后一个节点一步，所以如果你想在这里加上某人，你应该站在这里或看着这里设置下一个这个家伙，如果你想删除这个人，你不会特别想指着他吧，你想指着他前面的人，这样你就可以告诉他前面的人。
别再让那个家伙成为你的下一个，不要让任何人成为你的下一个，不要让别人成为你的下一个，所以这里的关键思想是由一个，通常在代码中显示的方式。
代码测试说我要去，直到下一个有一些我感兴趣的财产，直到当前有一个属性，如果我不走，直到电流是我想要的方式，然后我站在炸弹车上，或者像我想站在后面，下一个是，这就是循环，直到我唱到最后一个音符。
最后一个音符是下一个为空的音符，然后一旦我到了那里，附上一个新的通知是下一个，好啦，现在我还没有完全解决这个问题，就像是，和号的事呢？那是什么，我为什么要做得那么好，好啦，让我试着画一幅画，让我看看。
如果我有一张有图片的幻灯片，我忘了，我忘了我今天有什么照片。
让我看看，让我看看，嗯，詹姆斯邦德在哪儿，好啦，我可以回到詹姆斯·邦德身边，他在哪儿。
这里，好啦，这里，他是如此，这是詹姆斯邦德对吧，如果没问题呢，如果我说加上前二十呢，好啦，好吧，所以我做了当前的指针，所以我说我说它等于前面，所以它指向那里，然后我循环下一个下一个下一个。
然后我到了这里，现在它是空的，但我说你想加20，所以好吧，然后我把它指向这里，所以在幻灯片上的这个例子中，与号的东西是不必要的，就像传递列表前面的指针，我跟着指针走到尽头，我附加了一个新的节点。
一切都很好，好啦，所以是与号，在这一点上，你不必担心与号的事情，好啦，但是列表为空的情况呢，所以我只是删除了我的链接列表，再见詹姆斯邦德就像啊，然后他掉进了。
我该怎么做，她掉进了下面的火焰里，哦不不不，Linux，男人，我得摆脱。
我得，我要把这堆火点燃，如果你安装了Ubuntu，你也可以把你的电脑点着，好啦，等等，我想看看如果列表为空，这段代码会做什么，你说你想加点东西。
我想告诉你为什么它不起作用，好啦，所以你在这里要小心地跟着，所以我要试着把它放在屏幕上。
和我的照片同时，好啦，好啦，所以我现在基本上有了图片中的代码，所以想象一下我说，加上前面二十，但是前面是空的，它没有指向任何正确的东西，让我们追溯一下代码的作用，我先做这个，我说新节点等于新列表节点。
所以我做了一个节点，我存储了它是多少，在那里是20，它有一个空用于下一个，我把这个新节点叫做，我只是要写新的，因为我不能，用鼠标写信很难，然后我说如果前面是空的，指针，现在就是这样，其实等一下。
让我们记住一秒钟，让我们假装我没有这个符号，主有一个指针，哎呀哎呀，我就像把我的应用程序拖出被告席，Main有一个指针叫做前置，前面的主指针是空的，离开这里，然后主呼叫增加前20右。
所以现在在add函数中的add方法中，我有一个名为list node的参数，所以list node front是一个变量，它是一个空指针，所以好吧，罚款，如果前面为空，它是什么，然后我说让前面相等。
新节点，这意味着在新的节点点的地方做前点，所以不是空的正面会像那样指向右边，所以看起来不错，前方是新节点。
但那是广告方法，正面版本，这不是缅因州版的正面，这就像如果main有一个int x，并将x传递给其他函数，这个函数调用它作为参数索引，这个函数改变了x的值，不会变的，缅因州版本的X值右。
因为你是按价值传递的，这是个复制品什么的，所以这里的想法是一样的，现在你可能会说等等，等等，等等，我以为指点的重点是，你指的都是一样的东西，对，没错，如果你按照指针，你到了同一个地方。
但是如果你做一个指针，然后你再做一个指针，你再做一个指针，就像如果你，如果你不遵循这些指示，如果你换了其中一个，它不会改变其他的，就像如果你，如果你在这里有一个指针，在这里有两个指针。
然后你说提出一两个观点，为空，你知道这对指针1没有影响，所以如果你做两个指针，指向同一个地方，然后你把其中一个变成空的，或者把其中一个变成其他东西，它不影响第一个，点在你明白，所以像这里的关键想法是。
像，如果我可能需要改变，不仅仅是跟在前面的东西，但如果我可能需要换前面，那我就得做点不同的事，因为此代码将更改前面的副本，这是局部的，这个函数不起作用，我的意思是看，如果你对演讲的这一方面有困难。
这里的简单版本是，如果要编写一个更改链表的函数，您应该用与号传递指向列表的指针作为引用，因此，与其复制指针，它们将共享相同的指针，因此当您更改指针时，维修时也会更换，是啊，是啊。
因为在其他地方你可能会调用前面的指针，你会打电话给主要的，因此它没有被修改过，因为如果这是两个小时的讲座，我会做什么我的意思是，在漫长的演讲时间里，我们都会感到悲伤和痛苦，但我可能会用额外的时间做的是。
我会加载调试，否则我会挑小虫子，我真的会运行我，在调试器中，它会显示所有变量的值，我看得出来，对朋友来说，维护价值是这个还是什么，然后我跳转到Add函数，我想说，如果你对朋友的价值是如此，我真的会看着。
做这件事花的时间太长了，在很短的时间内，但它是一个独立的前置变量，他们同名，但它们有不同的范围，主要的是重要的，因为当手段说，把这个加给我，这是我的正面，他不想听这些，你设置一些其他的战线。
要做到这一点，我只想说，名字并不意味着，分享一切，这就是为什么我对我和我女儿泰勒·斯威夫特的计划从未实现，我想也许我会得到她所有的钱，但事实并非如此，嗯反正，这里的解决方案有很多方法可以解决这个问题。
我向你展示的方式，我想最简单的方法就是通过这个，不仅仅是一个指针，但是作为对指针的引用，现在呢，我想有些学生会对此感到困惑，什么明星安珀索，哎呦，这是怎么回事？你看，这只是一个，这是一个参考。
就像一个int引用，记住引用的作用，意思是分享而不是复制，如果通过引用传递int，我们共享一个int，如果你在没有符号的情况下，它复制了，我们每个人都有一份独特的副本，同样的想法在这里，当缅因州超过我。
他们的前指针，他们直接允许我修改指针，如果我将指针设置为其他东西，缅因州将看到这种变化，这就是一切，这就是我在任何方法上都要做的，任何更改链表的函数，我将通过引用传递指针，有个问题，去吧。
你能传递指针引用吗。
就像，你能把星星和其他单词的平均值。
啊，你能给它传递一个指针吗，所以我们开始了，你能用c+加上空格吗？几乎每个问题的答案都是肯定的，但几乎每一个问题的答案，你应该质疑的往往是没有的，所以嗯，如果你过了一个点，而不是对指针的引用。
您想传递指向引用的指针，是啊，是啊，指向引用的指针只是指向事物的指针，就像你不把指针传递给int，引用将指针传递给int，您也可以引用相同的int，也像参考，你不能指着推荐人，你指着东西。
引用是事物的别名，所以你只要指着那个东西，不是参考文献，你知道的事情，我不知道，如果这有任何意义的话，你不会这么说的，您只需将其声明为指针，还可以将指针传递给指针，我本可以给你一份名单，节点星。
我觉得这样比较好，因为嗯，如果你把它作为列表传递，节点星，你基本上要做一堆取消引用，它使这里的代码，你不会想那么做的，所以无论如何，这就是解决办法，如果要更改函数中的列表，通过引用传递列表。
这就是我们的add函数所做的，所以现在，让我们做一些其他的事情，让我们做其他方法做的事，我这里有，让我们先做一个叫做加法的，所以首先实际上，我想我没有出现，让我注释掉之前的所有代码，所以现在我所拥有的。
我正试图使用Add建立一个列表，然后我想把名单打印出来，好啦，所以其实只是为了好玩，我要去加，我要拿走这个符号，我要到这里来我必须在原型中匹配它，我要把符号去掉，所以我要编译它，现在在Main中。
我试着列出四个，让我们看看它是否真的有效，所以我运行它，上面写着测试添加功能，它没有，我不认为它做了什么，它只是说完成了程序运行，它试图打印，但什么也没有出来，所以不是，其实呢。
也许如果我想说得更清楚一点，我可以做一些事情，比如如果前面是空的，指针，我可以做C出来空和其他一切，我可以你明白我的意思，所以至少它会打印一些东西，如果没有名单，所以没有，那里什么都没有，所有那些广告。
我做了四个广告，他们都没有在我身上成就什么，所以现在如果我回去添加，我又把它改为指针引用，我们看到了什么，我的意思是，它应该工作扰流板，对呀，现在起作用了，它添加了所有的元素，好啦。
所以让我们用这个想法来实现一些更多的链表代码，现在让我们先写一个叫做add的，意思是把它放在前面，而不是把它放在后面，相似的想法，好啦，现在看，我没有把这些和符号放在一起，但他们需要符号。
所以让我们继续在上面加上一个符号，然后一开始，我们只拿前面和新的值，所以说，那么我该怎么做呢，谁来帮帮我，是呀，在后面，你会怎么做，你在举手吗，好啦，新节点等于新列表，存储现在值cool的节点。
我现在希望那个节点是列表中的第一个，所有其他元素都应该是在那个元素之后的元素，对呀，我还做什么，是啊，是啊，我用前面做了一个新的节点，然后前面，节点等于前面像这样，是啊，是啊，点，很接近了。
我觉得不太好，是你先开始的，去吧，你一定要做吗，你还有更多的想法来完成这件事或修复它，是呀，新节点等于前下井，所以如果你这么做，你要吃的是，如果我有，如果我有一二，哦伙计，这些不是三级的。
然后我想加上一个四，我想要的是四个人在这里，哇塞，那太糟糕了，我想要四个那样的对吗，我想如果我在前面，如果我使新节点等于前面，所以等待，让我们，让我们真的把这个新节点指向这个，这么新。
然后如果我说下一个新节点等于前面，记住这意味着什么，这意味着做一个新的节点点，前面的下一个点，如果前面在那里，然后前面的下一个点，所以这意味着新节点不再指向这个新节点，但指出这一点。
所以我认为这是不太对的，图片有帮助，虽然，什么，我怎么解决这个问题，所以四得到真的排在名单的前面，是啊，是啊，去吧，是啊，是啊，反过来，我想很接近，只是有点倒退，下一个新节点应该是后一个新节点。
新节点之后的下一个应该是前面当前的位置，所以4后面跟着1，然后如果我说前面等于新节点，意思是前面不要指向这个，但要指出这一点，这东西是对的，所以现在我们有了前面的新人，紧随其后的是之前的新人。
和许多这些方法一样，这些陈述的顺序很重要，我想如果你把这一行的顺序翻过来，我觉得没用，你得小心点，对呀，因为我觉得很多学生他们所做的就是画这幅画，然后他们写出他们需要做的所有改变。
然后他们这样做有点无序，然后他们把它们都写下来，但这不起作用，即使他们的照片大部分是对的，2。他们那样做是不对的，所以想想秩序，好啦，现在有意义了吗，等等怎么样，通常，当我们有这些链表函数时。
我们得考虑不同的情况，比如空名单，非空列表，如果列表为空，这段代码会做坏事吗，如果列表为空又如何，我们做一个新的节点，那很好，我们使它的下一个为空，因为前面是空的，这是个空单子。
所以接下来新来的人就空了，那就对了，然后我向他们提出前面的观点，而不是空，所以这个代码前面都工作得很好是不是，你看，所以有时你必须有，如果md不是空的，你得把那些案子分开，但关键是。
如果我在做前箭什么的，在我做正确的箭头之前，我需要确保前面不是空的，好啦，所以我没有在这里这么做，所以我不需要把这些案子分开，如果你真的想这么做，您实际上可以将所有这些混合到一行代码中。
也许我会把我们写的东西留在那里，但我会把它揉成一团，所以你能做的就是，你可以说你可以通过下一个也在这里，这样我就可以从前面通过，后面的应该是前面，所以我去掉了这一行，现在前面等于新节点，嗯。
为什么我不直接说前面等于，所以前面等于一个新节点，存储这个值，后面跟着前面，它做右边的部分，在它做赋值部分之前，所以这就是为什么，那两大块哥打，同样的权利，我很清楚，所以这是在列表的前面添加了一些东西。
有什么问题吗，好啦，嗯，让我们再做一些，下一步是什么，他在哪里做的，好啦，我想做一些移除的事情，我们来谈谈移除，我认为删除的简单情况是从列表中删除第一个元素，因为那个很容易得到，因此，如果您要修改链表。
你要通过引用来传递这件事，所以我还没那么做，所以让我在这里加一个与号，让我们先下去做一个移除，好啦，从列表中删除第一个元素，如果列表为空，它什么都不做，那么我该怎么办，帮帮我，检查这是否为空。
如果我不检查，我想这将是一个代码崩溃的情况，因为我可能会看到某人的下一个，你不能要求下一个人谁是空的，所以我同意你，所以说，如果是空的，所以如果前面是空推杆，那我什么都不想做，所以如果是空的。
如果所有的动作都在别人身上，那也许我们想，如果不是空的，我们会做些事情，好啦，然后呢，我的意思是，如果前面指向一个，指向两个，分数哇，这表明有三个，我要前面到那里，就像，我该怎么办，你在后面，是的。
前面应该指向它自己的下一个箭头指向右边的地方，因此，与其指向一个点，不如指向两个点，这很好，代码有个小问题，还记得我对气球之类的东西的类比吗，好吧，所以这个人再也没有人指着他了。
所以他的小气球会让他飘走，男孩，这是一个可怕的气球，等等，等等，好啦，那是一个稍微不那么可怕的气球，链表下面是不是有什么燃烧的火什么的，我不知道为什么，嗯好吧，所以那家伙飘走了，我上次简短地提到过。
如果你有一个节点，你失去了它的跟踪，您不再有任何指向C Plus功能的指针，在这种情况下，记忆只是坐在那里被占用，就像声称的那样，不能用于其他任何事情，在程序的余生中，这叫内存泄漏。
因为如果你这么做很多次，您的程序会有所有这些垃圾内存，它无法清理，最终你的电脑甚至会耗尽内存，现在呢，我想说清楚，我想有些学生对此有错误的本能，你又不是要在这里买一台新电脑，重新启动操作系统。
不管是什么感觉，当您的程序退出时，当程序进程退出时，操作系统抛出所有内存，包括这个泄漏的内存，所以从某种意义上说，对于我们今天玩的小程序来说，这没什么关系，因为我们没有主菜然后主菜就完成了。
一切都会烟消云散，但是如果你有一个运行很长时间的程序，就像网站上的服务器或你正在玩的游戏，那个，你要为，你在玩超级马里奥，《奥德赛》刚刚上映，我的天啊，所以你当然要为，就像连续17个小时的马拉松。
如果你经常让马里奥丢失他代码中的链表节点，程序最终会崩溃，你会生气的，所以你不想那样，所以你不想让你的记忆现在泄漏，我想告诉你，嗯，大多数编程语言都没有这个问题，像Java这样的语言，Python。
JavaScript，红宝石，C尖，它们都做所谓的自动内存管理，当一个对象不再有任何指向它的指针时，或任何使用它的代码，它能够自动计算出这一点，并为您回收内存，你不必做任何大多数人更喜欢的事情。
就像文明的处事方式，但是C++是在1983年制造的，那时他们没有文明的东西，所以它不会这样做，好啦，所以如果你想确保内存不会泄漏，您必须明确地告诉语言释放内存，你这样做的方法是写删除这个词。
后面是指向要回收的内存的指针，所以就像问题一样，虽然，一旦我们这么做，整个想法是，我们再也没有指向那个内存的指针了，所以我们必须调整这个代码，一点来解释这个问题，你做什么模式，我喜欢这样。
我将在我的很多例子中向你们展示，我做了一个特殊的指针，我把它指向我想摆脱的东西，像垃圾一样，Tr i指向前面指向的是哪个盒子，然后我说前面等于前面，意思是扔掉那个指针，把前面的两个点。
所以现在唯一指着它的人是垃圾，然后我写删除，我想它更像一个回收站，但不管怎样，我们不必一直是自由主义者，所以它是一种堆肥，有点像，嗯，删除垃圾会使其消失，现在呢。
我听到的关于删除free up的最常见的问题，记忆是我认为人们误解的，就像，指针和指针指向的东西是有区别的，就像列表节点对象与指针，就像我说删除垃圾一样，我不会删除这个指针，我在删除指针指向的东西。
这就是我要失去的东西，现在呢，你说得好，要清理和删除指针的指针呢，嗯，在这周之前你从来没有说过删除，对呀，因为你声明的每一件事，在堆栈上分配的将自动删除，当函数完成时，所以在堆栈上声明的东西。
你在这周之前做过的所有变量，向量和弦，所有这些东西都在堆栈上，你永远不必说删除那些，因为函数会清理它们，指针位于函数的堆栈上，他们指的是外面那堆云，所以当你说删除，它进入堆云并释放内存。
指针本身位于此函数的局部变量堆栈中，它被清理干净了，函数返回时，你不必担心清理指针，你把点上的东西清理干净，是啊，是啊，如果列表节点由于某种原因在堆栈上声明，叫delete就不好了。
Delete是为了释放堆分配的内存，如果对堆栈上的内容调用delete，它经常会使程序崩溃，就像，如果你做了像，你知道列表节点LOL，然后你说删除，你不能说删除法，你得传递一个指针。
所以你得通过法律地址，这可能会使程序崩溃，因为，就像它会去看它的内存表，就像我不知道的，那不是我分配给任何人的记忆，它可能会我不记得它是否会立即崩溃，或者如果它非常想声称记忆用于。
现在您的函数堆栈被分配到，我不记得有什么用，但你不会想这么做的，像在那里这样的参数，啊，这是个好问题，是啊，是啊，就像我怎么知道我应该释放这个，我想这就像是这个代码的一个隐含的先决条件。
就像我没有写在这里，但这就像，我假设，此空间中涉及的所有列表节点都是堆分配的，如果不是，删除它就太糟糕了，我不认为有测试，就像这个堆内存是真的还是假的，嗯，我不知道有什么测试。
尽管有时如果您查看实际的指针内存地址，数字范围不同，但你不会想担心这个的，我想你宁愿只写代码，对这类事情有很好的假设，实际上，这确实导致了某些类别的C Plus在大型系统中的bug，就像。
谁的工作是解放，这段记忆，是我的工作吗，您的工作是堆栈内存，是热记忆，在本课程中，我们将通过使用heap来解决这个问题，当我们做链表或二叉树的节点时，或者类似的事情，是啊，是啊，所以就像你说的第二。
因为当你写删除，你得给它一个指针，列表节点不是指针，列表节点星号或列表节点的地址是指针，所以指针，是呀，它删除了指向的内容，它，转到堆上的内存块，他说这块内存现在应该可以供其他人使用，但你从不写信。
删除与号，因为这是邪恶的代码，反正，所以好吧，去掉第一个元素，这很有效，让我们在列表中的一个一般位置写删除，所以让我们写删除，我想我这里有一些例子，在索引零处移除或在索引处移除，让我们删除列表中的内容。
在这一点上，我们有五六个东西在这里，所以就像我想的那样，在移除第一条战线后，我们删除这个类似的东西，我想这就是我们所拥有的，因此，让我们尝试将元素索引移除到，然后打印列表。
所以我想在那之后应该是这样的对吧，我只是想估计一下你的期望如果我再来一次，让我们用，类元素，你知道的，又是两个，哪个应该是九个，所以应该是这样的，然后让我们用元素零来做，让我们确保它对零元素有效。
想把这里清理一下，所以这应该去掉四个二，好的知道了，让我们去掉一些东西，所以让我们写删除，我想我得上去，我没时间了，但我想我得上去把符号再放在这里，所以这有点像添加，记住当你添加，你得走到正确的地方。
对呀，所以我们在Add函数中为它写了一些代码，我是说你看，我想复制广告代码一秒钟可能会很有说明性，让我们复制添加代码，然后说什么这是不对的，嗯，我的意思是，事实上，它添加的东西是错的，但如果你要把你。
不要创建新节点，因为你不是，你知道移除不是创建新节点，对呀，我们有一个空名单，非空列表的东西，我不知道这样划分是否正确，但我们为什么不把注意力集中在这个案子上，找到它，把它移到这里的一般情况下。
从前面开始，这走到最后，我不知道这样对不对，如果我想删除索引五处的元素，我应该走到什么索引，我应该移动到我站在索引4詹姆斯邦德对吧，所以我应该做的是，我应该说对于int，我等于零，我小于指数减一。
你可以画个图自己验证一下，但你想在一个小时前回来，现在前进，事情的状态是我站在一个节点上，我是詹姆斯邦德，我有一个节点，我想摆脱就在这里，我希望链接列表像这样，就在他们上方，我想跳过它们。
我想剪掉目前在那里的和弦，那我怎么跳过这个家伙，我怎么把他带回来，是啊，是啊，当前下一个应该指向当前下一个点的位置，所以实际上清理，你说的对，我有一个内存泄漏，所以同样的模式列表，节点垃圾等于现在的人。
下一个调用当前，就是那个有X的家伙，然后我把指针向前移动，我会删除我的垃圾权利，这是正确的代码，我们失踪了，有点，有一点点，如果这里还有别的事，我有个问题，去吧，所以它会坠毁吗。
如果您传递一个超界的索引，这将崩溃，所以现在的代码依赖于用户不这样做，索引就像，接下来就没有意义了，所以现在下一个下一个，好的好的，所以如果我想删除最后一个节点，那情况就是这样，詹姆斯·邦德的事，对呀。
所以电流在这里，当前下一个在这里，当前下一个下一个在这里，所以如果我说当前下一个应该等于当前下一个，它的下一个点将把这个设置为那个的值，所以它会把这个设置为空，所以它会，一切都会好的，我想你是担心。
如果詹姆斯邦德在这里，这违背了我对用户将传递什么的假设，如果他们站在这里，这意味着他们让我去掉尺寸，元素的大小，是啊，是啊，对此的问题，我是说，所以这样有可能，哎呦，你在说废话，嗯。
我想问题是你得把你的垃圾指针，因为，啊，你在说废话，否，我想这是你想说的方式，因为你真的需要进入列表中的下一个指针，如果你把垃圾换成，您正在修改一个名为trash的局部变量，你不能修改，它不指向指针。
它指向一个物体，如果你说符号和垃圾，那是箭头之类的地址，你知道的，我知道你在问什么，但我认为那不太对，我不得不让你走，但我会说，如果我们需要，不是关于前面，为空指针，这对所有情况都有效，除了一个，做。
你知道那个案子是什么，我知道该走了，但在我们离开之前，让我回答这个问题，有一种情况下，此代码在，名单的末尾，因为我想我们刚刚追踪到，这是列表末尾的内容，我觉得那个还可以，这是名单的最前面。
让我解释为什么这个代码，不可避免地说，旁边有人指出了不同的东西，不能更改链表的第一个音符，通过设置某人的下一个指针，让我们考虑一下，如果，如果第二天过了零点，你需要从前面跳到下一个节点。
而不是将当前设置为下一个，好啦，我就到此为止，因为我得让你把代码贴在网站上，祝你周末愉快，祝你学习顺利。
星期一见。
【编程抽象方法 cs106x 2017】斯坦福—中英字幕 - P16：Lecture 16 - Classes - 加加zero - BV1By411h75g
大家都好吗都一周了，星期一，我们基本上完成了一半，不过，这周晚些时候我们有个小事情要处理，如你所知，我们星期四晚上有期中考试，所以我希望你们开始考虑，期待那两个练习考试的研究。
我可能会在周四前再发一次练习考试，还有很多其他的问题，虽然，即使你完成了练习考试，去你的部分讲义，如果你想要更多的问题，转到代码，逐步网站，感觉到更多的问题，看完课本中的章节，有很多问题。
你甚至可以谷歌寻找旧的宿舍，一零六X或B的网站，他们有，他们有时会遇到其他示例问题，外面有很多问题，希望你不会出问题，用练习来练习是好的练习，尽你所能，从现在到周四晚上，嗯，我要给你们发些信息。
可能今晚或者明天早上我们就分头行动，因为我们要在几个不同的房间里做测试，我们不会在这里，那么我们要去哪里进行实际的考试呢？周四晚上将按字母表分开，就像姓，我要把你要去的地方发给每个人。
我也会把它发布在班级网页上，我会把它贴在广场上，我会寄的，我会发邮件给你，所以希望每个人都知道他们需要去哪里，我们还没有完全弄清楚，不过，明天就知道了，我想是的，好啦，那是考试。
你们还有其他考试相关的问题吗，我是说，2。我今天不准备复习，但我只是想看看是否有人对此有疑问，好啦，嗯，你知道怎么找到我，如果你以后有这样的问题，是啊，是啊，这就是例子，像链表一样的封面。
考试包括链表吗，是啊，是啊，我是说，我认为上周末是范围，我可能会更有可能给你点赞，在链表方面，我可能更有可能问你一个问题，这是之前的节点，这是笔记，在我想让你把这张照片变成那张照片之后。
与上周晚些时候的部分问题相反，在链表上写入方法，所以这是我在真正的考试中更有可能做的，实际上，从今天开始，我本周要讲的是，不会出现在期中考试上，所以说，当然你们今天都不会注意我，对呀。
但你的家庭作业需要它，你期末考试需要它，仍然需要知道，但不是周四对吧，之前还有什么关于考试的问题吗，我开始我今天的内容，是啊，是啊，那有什么用，第五份家庭作业什么时候交？它的到期日是一个星期后的星期三。
所以我的意图，我打算今晚或明天早上把新作业交上去，我的意图是你根本不会去想这件事，直到考试结束，就像这个即将到来的周末，这里会是，当你开始看它的时候，希望它还有足够的时间，有些人在订单中间发现。
不是因为我就是因为你其他的责任，是一个烂摊子，而且很忙，这可能是一个时候，你想利用今天晚些时候等到这个星期五，或者下周一交作业，那由你决定，嗯是的，反正，那是我们的总时间表。
所以好吧，我们来谈谈今天的内容，我有点转换档位了，我们上周一直在讨论链表，今天我想谈谈如何用C++构建类和对象，我也不知道，也许这似乎是一个奇怪的话题变化，你知道就像一家人。
Esque跳转到与之前的内容无关的东西，或者类似的东西，但我确实认为这和我们报道的内容有关，因为如果你看看我们上周写的代码。
我在可爱的创造者里有代码，我们编写了所有这些函数来对链表进行操作，你必须传递的所有功能，基本上是名单的前面，你必须传递一些你想做什么的其他参数，添加此值或搜索此值，或者把它移除，或者任何权利，这样很好。
我是说我们有很多这样的方法来使用这种风格，但这不是你真正做对的方式，像斯坦福图书馆的所有藏书一样，他们不是这样工作的，它们被写成对象的类，就像矢量是一个物体，哈希映射是一个对象，你创建一个，你申报一个。
然后在这个物体内部，它有一堆函数，执行该集合的所有有用行为的一组方法，对呀，所以我想学习如何教你们，如何在C++中做到这一点，所以我们可以把这个功能变成一个链表，上课。
好啦，在C++中就是这样做的，这就是联系，看，所以这与上周的内容并非完全无关，我认为任何实现数据结构的人都会把它作为一个类来实现，这就是我们要学的，我因为这是x，你知道的。
我想我会假设你们中的一些人以前已经实现了类，用另一种语言，请你举手好吗？如果您以前实现过对象类，是啊，是啊，你们大多数人都有，好啦，很多时候，你知道我告诉你，不管我假设你以前的知识是这样还是那样。
我要试着做手术，假设您以前见过类和对象，因为这就像是，我要复习一下，但我会尽量把重点放在，C++类，在语法和行为上，好的，好的，所以我们开始了，如果你想了解，它们来自第六章，所以这里的目标是。
我想写一个名为链表的类，实际上，我将调用我们的链接int列表，因为它储存int，也因为我不想与实际链表的名称发生冲突，来自斯坦福图书馆的类，但不管怎样，我们要写一个链表类，我们的类将包含所有这些方法。
列表本身将是一个对象，存储指向前面的指针，前面是一系列节点，所以它会管理，我是说，我想你可以这样想，我们写的所有这些函数。
你经过的地方前面前面前面前面，对象将存储前面，然后所有这些方法，我再也不用把它作为参数传递了。
因为它存储在对象内部，计划是这样的，所以好吧，首先，我要倒回去学习一般的课程，所以再一次，什么是课堂，我想你们知道有一类是一种对象，一种对象类型的模板，它指定该类型中的内容，它存储了什么数据。
它存储了什么行为，如果您不太熟悉类和对象，我建议去读这本书的第六章，因为我不打算详细介绍什么是类，等等，去看看第六章，好好读读，嗯，就像有很多C++的类，你已经可以做新的了，取决于您的程序是什么。
你在写什么，如果你在做日历或活动计划，可以运行日期类，如果你在做学生注册系统，你可以写一个学生类、课程类或教师类，你在做一个金融系统，您可以创建一个银行帐户类，等等，对呀，魔兽世界游戏，你在执行。
你可能有一个兽人职业和一个人类职业，或者我不知道所有的熊猫熊类和潘多拉，我的魔兽有点落后了，我不知道所有的种族都是什么第三原型的东西，我不知道，嗯，什么是，我知道那是一类，那么什么是物体呢。
对象是存储数据并具有行为的实体，数据和行为的混合，好的，数据基本上是用变量来表示的，行为被表示为方法或函数，这个物体把这些东西放在一起，所以这很重要，你想把所有这些都放在一起，我想总的来说。
面向对象编程的思想是，大多数代码都涉及到确实工作的对象，并与其他对象交谈以帮助他们在主C++中不是对象，它不是面向对象的，但是如果Main创建了一个对象来做很多花哨的事情，就像G窗口或向量。
如果G窗口产生了一个G椭圆形，g o创造了一个g矩形什么的，那么大部分代码实际上是由对象完成的，所以你可以说这是一个面向对象的程序，我们喜欢拥有类和对象的最大原因之一，是因为它提供了一个叫做抽象的概念。
也许你以前听过这个词，当然这个想法是，你不必总是知道某件事是如何工作的所有细节，为了使用它，很多现实世界的例子，我不知道我的这个小玩意里面发生了什么，但它很好用，我知道怎么用，我不用打开它。
了解电路板和所有的东西，你知道生活中各种各样的例子，一堂课是一样的，如果我告诉你一个类有什么方法，您实际上不需要阅读代码来查看类是如何实现的，只要你明白它会做什么，有什么功能可用，你可以用对它。
所以这是件好事，它为程序提供了一个抽象层，当然我不需要说服你，你一直在利用它，所有季度，您还不知道哈希映射是如何工作的，可能是，但你一直在用它，所以你去那里，嗯好吧，所以我们存储为变量的类中的内容。
我们称它们为成员变量，你可能听说过另一个术语，比如实例变量或字段，或者基本上每种编程语言都为这个东西起了另一个名字，你所说的，存储在对象内部的变量，从技术上讲，在C++中应该调用的名称是成员变量。
我听说很多人喜欢，我想大多数部门领导都称它们为实例变量，所以不管我挑什么你最喜欢的，将函数，存在于物体内部的行为，我们称之为成员函数，很多人把这些方法简称为，我说过我想在过去很多次。
语言会给同样的东西想出新的名字，我想在上课的第一天或第二天，或者我说的任何东西，比如Java调用函数，方法，你知道功能和方法是一样的，但函数是C++对它的称呼，方法是Java对它的称呼，那多半是真的。
但我认为技术上来说如果你想对你的术语吹毛求疵，函数应该是与任何特定对象无关的东西，而方法应该是存在于对象内部的东西，所以我认为从技术上来说，调用对象内部的函数是可以的，语言标准中的C++术语是成员函数。
好啦，这些成员函数的一个重要之处在于，你可能已经知道了，对象的成员函数可以与该对象的数据交互，比如如果一个银行账户里有一个平衡变量，你写一个存款方法，存款可以与银行账户的余额相互作用，对其调用方法。
所以这是一个重要的想法，我们会好好谈谈的，然后通常在一个类中，你也有一个构造函数，您可以在创建对象时初始化对象的状态，当它诞生的时候，您可以传入一些参数或设置一些设置，然后对象就可以使用了。
所以我的假设是这对你来说是新的或不新的，除了术语，这些概念并不新鲜，我希望到目前为止大部分是对的，这么好，到目前为止有任何问题评论，说我的麦克风，我不知道，嗯好吧，所以让我们。
让我们试着谈谈所有这些东西的C+版本，在C加加中，当你写一个类时，您通常编写两个文件，编写一个点h文件和一个点cpp文件，还记得一开始上课的时候，我们学习了如何用分号声明函数的原型，然后。
您可以用花括号编写函数体，这基本上就是这种分离，您可以声明您的类的名称是什么，它的所有功能是什么，它的所有内容都用分号放在点H文件中，然后您可以编写这些函数是如何实现的主体，在cpp文件中使用花括号。
从技术上讲，您可以将所有代码放入一个文件中，把它们分开被认为是更好的风格，原因之一是因为你知道，程序中的其他文件将希望包括您的类磅包括，所以他们可以用它，一般来说，您希望它们包括这个标题。
如果您将标题和CPP混合在一起，我想这里的想法是，使用你的类的人可以看看这个，H文件的标题，他们不知道所有的方法是如何实现的，他们只会看到他们的名字，或者参数是什么，他们只需要知道这些，所以它把。
你的类的用户不应该在Java中查看，没有这种分离，事实上，大多数语言只是将这两个概念混合在一起，如果你有课，你只要做一个点Java文件，你把所有的代码都放进去，那没有错。
我认为这是大多数语言决定去的方向，但是C++认为把这两件事分开可能会很好，所以不管，所以是的，这是代码的主要分离，我马上就给你看，比如你在每个文件中都写了什么样的语法，但你我们会在我们所有的例子中。
我们每次上课都会有这双，下面是一个类的样子，这张幻灯片上有很多废话和语法，但我觉得这样更容易，如果我把所有的东西都放在屏幕上，一个h文件以几行开始以一行结束，前面有这些哈希符号的行称为预处理器指令。
它们有点像包含声明，你在哪里，将一个文件链接到另一个文件，你知道这些线条的作用基本上是，这样您就可以避免多重定义问题，因此，如果您的项目中有两个文件都希望使用您的类，他们都会说他们想把这个班包括在内。
包括该类的点h，但问题是，如果您理解该命令是如何工作的，包括，从字面上获取该文件的内容，并将其粘贴在那里，所以如果你不小心，发生的事情是，它们都粘贴在类的声明中，所以现在类在整个文件中定义了两次。
在您的整个编译项目中，然后编译器不喜欢这样，它说了，不管是什么课，它基本上尝试两次构造一个类，所以我们把这个说唱歌手放在文件的顶部和底部，这基本上是说，如果我以前从来没有包括过这个文件。
然后我想把这个定义为那个，然后结束，否则什么都没有，所以基本上这里的顶部和底部的东西会让它，这样您就不会意外地包含了您的类的多个副本，你必须做一件愚蠢的事，因为c+是愚蠢的，我关于这个语言特写的社论。
但你必须这么做，如果你不做，你在那里会有麻烦的，这个有一个更短的版本，在那里你可以说像庞德·普拉格马一次，但这并不像某些编译器那样兼容，所以我不打算先用那个，所以无论如何，你说，如果if和def定义。
如果只是为了向你展示。
我们要写一堂课，作为第一个例子，我们要写一门叫做银行账户的课，银行账户点H等在这里，我要说像，你知道的，类别银行帐户，如果你去一个程序，就像使用银行帐户类，你知道的，也许你们已经知道了。
一堂课通常不是一个完整的程序，类就是模块，可被其他文件用来帮助解决问题的库，所以如果你在这里有一个银行账户类，你可能有一些叫做Wells Fargo的客户端程序，或者是想用银行账户的东西。
所以你可能会说包括银行账户点h，现在你做到了，您可以说该类中的银行帐户B分号现在存在于此文件中，因为我把银行账户H，但如果我说包括银行账户点H两三次，它应该说重新定义类银行账户，好像你有两份。
如果两个不同的cpp文件各包含一次，也会产生类似的错误，所以解决方案又是，幻灯片上写的，那就是我在顶部有这个愚蠢的东西，我说的地方，如果不是定义的银行帐户h，然后我想把银行帐户h定义为这个类。
然后我说如果部分结束到结束，这个下划线是什么，它是一个预处理器变量符号，从技术上讲，这可能是任何东西，我可以写沃尔马蒂的死，你好，这里，只要这个在一个字上和这个匹配。
约定是使用与您的类名或昵称完全匹配的名称，所以如果是食物h，你说下划线食物下划线h或类似的东西，为什么下划线，因为那样你就不会把它和，就像你程序中的一些变量，或者类似的东西，好吧。
现在我把如果和def的东西，我重新编译了它，至少现在编译成功了，尽管我把它包括了很多次，基本上接下来的两个包括，什么都没做，因为如果从来没有进入顶部，好啦，这就是类的外壳。
现在呢，类里面的内容，是构造函数、方法和变量，这可能看起来很像Java，除了一些不同，一个是在Java中，类的每个成员，你通常在它的前面写一个说明符，你说的地方，不管是公共的还是私人的，右C加+。
您可以有一个类的公共部分和一个类的私人部分，是同一个概念，同样的想法，完全一样的意思，只是你说公众的，你写的都是公开的东西，然后你说私人的，你写了所有私人的东西，你实际上可以来回切换。
你可以想一些私人的事情，一些但你可以的东西，你想换多少次就换多少次，但它更传统，他们有一个公共的东西和一堆私人的东西，是啊，是啊，所以你有一个公共冒号语法，或者像你们一样，我想说和Vo一起公开。
你得用冒号这样做，是啊，是啊，我是说，如果你想假装是Java，你可以在这些东西前面写一个冒号，它看起来有点像Java，但它还得有结肠，那不是很传统，虽然我认为这是人们通常做的方式，然而。
这不像是一个主要的大会，就像Python中的自然键，你有两个联合国，那是二等兵，但这是不对的，有一些语言使用约定来表示事物，但从技术上来说，它们并不是强制执行的，就像你说的，Python语言。
如果你用某种方式命名事物，你在向别人暗示这是公开的或私人的什么的，尽管语言实际上并不限制或强制该约束，这确实加强了这一点，必须是公共这个词，不是随便不是别的词，就像，必须是公共冒号，我马上就来。
如果你有什么私事，然后其他文件试图触摸它，它会给出编译器错误，所以是的，这是现在一个重要的区别，否则，我认为这个语法的大部分将与Java语法相同，如果你想用Java写一个构造函数，你说公开课。
你要在一部经典的戏剧里写一个方法，你说公共空虚，不管公众是什么，都一样，你说过你只是不对公众说同样的话，实例变量的变量数，田野，你只是通常会，你会说私有int x什么的，相反，你说私有冒号。
然后把所有的变量都写出来，语法的一个小问题是在类声明的末尾，你绝对要写一个分号，否则就没用了，我年轻的时候，我会说我失去了一两个小时的生命，寻找我在课程结束时忘了放的丢失的分号，有一件事很酷。
虽然实际上，我不知道你有没有注意到，但当我开始输入可爱的创造者时。
我实际上打了一堂课，好像里面什么都没有，但我只是键入类银行帐户括号输入，它把模拟冒号给我，所以这就像，哦感谢上帝，对不起，也许你们没有和我一样的情绪反应，但就像我刚刚失去了一天寻找一个愚蠢的分号。
在一节课后，我忘了把。
但不管怎样，你必须有一个分号，但总的来说，我会说，除了语法差异，这些命令做你认为它们会做的事情，但你也会注意到这里有半列，所以它非常类似于函数原型，你们一直在用的，我只是看看课堂上会有什么。
然后在另一个文件中的CPP文件中，我要用花括号和，尸体什么的，你能有私人构造函数吗，你是单身，是啊，是啊，你可以有一个私人的，因为你可以，我是说，基本上你从Java中看到的任何小东西。
您可以使用静态方法，你可以有私人方法，您可以拥有私有构造函数，你可以有各种很酷的东西，你知道吗，几乎所有的事情都是一样的，有几个重要的区别，我要试着给你看，但坦率地说，大多数喜欢的答案，你能做到吗。
或者你能像这样，这可能是你能做的事情的一个超集，在Java或Python中，因为c加上，他们不知道什么时候该退出，所以他们，他们增加了每一个功能，即使它是邪恶的，就像你看《星际迷航下一代》。
你就会知道有一个安卓数据，然后是邪恶的安卓传说，他是个坏人，你知道的，不同的是，知识是首先建立的，他有更多的特征，好像他有感情，但后来他学会了嫉妒、恶毒和刻薄，所以他们在数据上做了一个新的没有情感的。
他更简单，但后来他是好人，他是个更好的人，你知道的，他们从错误中吸取了教训，我是劳拉，这种语言里的东西太多了，它是邪恶的，嗯，和意见和赠款，所以这就是点，H，所以就像一个快速的例子，会在这里，银行账户。
每个物体都有名字和平衡，所以也许有那么一秒钟，一个快速的黑客就像你可以把变量放在你的公共中，那不被认为是好的风格，但也许这可以让我玩一秒钟。
所以如果我回到可爱的造物主那里，如果我说公开啊，字符串名称，双重平衡，所以这就像那个人的名字，谁有银行账户，双倍就是他们有多少钱，我不知道你可以有一个INT ID，就像一个帐号，或者类似的东西。
你可以有各种各样的字段，我想指出的一件事是，就像任何其他文件一样，你知道如果我在这里用绳子，那么实际上我应该说，字符串，如果我想叫它字符串而不是STD字符串，我应该说使用名称空间，所以就像所有的一样。
还是c++右，所有的规则都适用于这里，嗯，所以现在只是，你会注意到我没有，我是说文件是分号，然后CPP文件就像尸体一样，但我实际上还没有任何功能，我没有任何构造函数或方法。
所以我实际上在技术上还不需要CPP文件，所以就这样，我可以去找客户，使用这个的东西，所以我可以像银行账户B一样，然后我可以说B一个点名等于马蒂，余额等于，你知道我有五块钱。
或者任何银行账户B一个两个B一个两个点的名字等于Meron Homi，两个余额，他赚的钱比我多一点，不管你知道什么，所以我的意思是我显示我显示银行账户在一到六A，当我教这门课的时候，所以如果你把我的A。
你可能看起来有点眼熟，但就像我认为一个非常重要的概念，我想你已经知道了，但我只想确保每个人都在想这件事，这里重要的概念是当你做一个类，您正在启用一种新类型，一种新型变量，一种新型对象。
程序可以使主要的用户能够创建和使用权利，真正重要的是，如果我做两个，每一个里面都有一个名字，每一个里面都有一个平衡，这不像我说的银行账户有名字，有一个字符串叫做name，在程序的某个地方不。
这是一个模板，每次我做一个我就会得到一个名字，每次我做这个，我得到了平衡，所以这真的很重要，这就是我所说的实例概念，您创建的每个对象都是该模板的另一个实例，你在银行账户里申报的那些东西的另一个复制品。
H文件，好啦，我想你已经知道了，但重要的是要记住，因为如果我改了这个人的名字，它不会改变那个人的名字，他们是分开的，他们彼此不同，对呀，重要的概念，好啦，所以即使只是这样，嗯，我有点课。
它内部有很小的变量，对呀，但这显然是不完整的，所以让我们再走远一点。
所以哦，这里有一个，这里有一张照片，我想如果你想拍张照，就像在小堆栈上，银行帐户对象基本上是一小块内存，有足够的空间放绳子，也有足够的空间放双倍，或者别的什么，所有的成员变量都是对的，好啦。
就像我们已经学会了结构，基本上是一样的，只是几个变量合二为一对吧，好吧好吧，现在让我们来谈谈成员函数，所以如果你想写成员函数，您现在突然必须编写一个cpp文件，成员函数的语法与常规函数完全相同。
除了在函数或方法名称前面，你写的类，两个冒号，所以这有点奇怪，我想他们可能在这个语法上搞砸了一点，我只是要告诉你一个小秘密。
所以你看，我给你看看银行账户，如果你说你知道你有一个名字和一个平衡，就像，我觉得应该有一个叫无效存款的功能，你可以把钱存入银行账户，所以让我们看看，它回来了吗，它有很好的参数吗，可能是双倍。
你存入一定数量的钱，当然，这个想法是，但是，你在这里花了很多钱，我来调整平衡，这就像增加了平衡，基本上是对的，这并不意味着很复杂，但是当你想实现函数体的时候，带着花括号，你去银行账户CPP文件。
所以现在银行账户CPP现在完全是空的，通常CPP和H是相同的，除了用分号代替，你有大括号，对呀，所以你，你可能会想象你会做这样的事情，您知道在CPP中，您将粘贴类，但你会那样做的，你知道的，但没有。
那不是你该做的，取而代之的是，你拿着这个，所以你要做的第一件事就是你的CPP文件，你需要猛击，包括您自己的H文件，因为您的cpp需要知道类的声明，它要把谁的身体，所以这是你要做的第一件事。
接下来你要做的就是写出所有函数的所有主体，这样你就不会复制到类标题上，您只需像这样复制方法头，哎呀像这样，现在你用大括号写，但你得把它和普通的存款功能区别开来。
你必须区分这不仅仅是一个叫做存款的全局函数，这是一个类的方法，称为存款的银行帐户类，你区分它的方法就在你写的函数名之前，我个人认为这看起来很完整，我不喜欢这种句法，你就是这么做的，如果你要写十个函数体。
你必须把银行账户Colin放在十个中的每一个前面，这就是这些身体的语法，关于这些成员函数，最重要的是，你可能会从一个，或者你以前的编程经验，这些功能，这些成员函数，它们在任何物体内部运作，你叫他们。
好啦，就像一般，我想要存款功能来增加银行账户的余额，所以如果我来到这里，我说加等于量，这是一件非常重要的事情，我的意思是你所谓的“零钱押金”，那个物体平衡了那么多，所以这里有一个概念。
我称之为对象上下文，你得明白，每当此代码运行时，此时您在一个银行帐户对象中，你可以在那一刻引用那个对象的数据，它会修改它，或者使用来自该对象的数据，这不同于常规的全局函数，对他们来说没有这个概念，就像。
例如，如果我来到这里这个客户代码，你知道这个使用银行帐户的代码，如果我说B一个点存款，你知道十二个，当存款代码运行时，理解这一点非常重要，它在这个对象上运行，所以它将把这个平衡修改12，就在这下面。
如果我说B A 2点存款1美元或其他什么，也许他得到了，他有九个，九十九八，他上升到九什么的，在那一刻，存款正在这个物体上运行，所以它改变了这个物体的平衡，所以如果你输入存款密码，我只是说平衡。
我不说b a 1余额或b a 2点余额，不管我是谁，我的余额应该改变对吧，代码是对象真正重要概念的一部分的概念，关于这门课的前提概念，是啊，是啊，你需要通过推荐信，虽然，因为一份好的，对呀。
所以我想问题是，如果你没听到，1。这个帐你是按人头算的吗？或者我想说的是，思考这些事情会让你误入歧途，因为你不喜欢，传递银行账户作为参数，非参照，不是指针，不是像你叫存款那样。
隐含地知道这是感兴趣的对象，所以它就像通过自己，所以它知道自己是谁，不知何故，我们可以谈谈它是如何知道的，如果你真的想，但就像你不喜欢，传递对象，任何方式的银行账户，您的代码不能做到这一点。
这个用这个的名字，你不能那么做，在这里嗯，你知道你不必提到你自己，必要的，我是谁，AM是什么参数，我是我指针的引用，我是常量吗，我是什么，你只是，你只是存在，您在此代码中隐式存在。
您作为对象的身份隐式地包含在此代码中，事实上，我们有时称之为，隐式参数，因为代码中没有任何地方说明它，但就是在那里，你知道这种存款在我身上的想法，因为我是银行账户，有一种方法可以在目标代码中引用您自己。
如果你用了Java或Python或其他通常会说，如果你想把自己称为一个对象，它在Python中被称为，你有时说自己，但那只是个惯例，你可以叫它这个，如果你想用Java这么想。
你可以用C++来表示这个点平衡，你可以说这个箭头平衡，同样的想法，如果你熟悉这个概念，所以这意味着无论你在什么对象上调用这个函数，但是，你可以说平衡而不是平衡，你的意思很含蓄，这个物体的平衡。
因为这里有一个箭头，你对此了解多少，是个指针，它的类型是银行账户明星，所以从技术上来说，这里的机制是，当你说b a 1点存款时，它将这个点设置为1，然后它运行这个代码，这就像c+所做的。
调用对象上的方法时，但一般来说，你不需要经常写这个，因为它暗示了，如果你真的想看奇迹发生，您可以设置一个小断点并在调试器中运行，我忘了它会显示什么，我觉得会有好东西，所以呢，我的代码在这里暂停。
我有两个银行账户，另一个里面有垃圾，因为我还没有真正达到，然而，你可能会说等等，为什么这个会在这里，我还没到这一行呢，为什么会在那里，从技术上讲，c plus提升了这些定义，并将它们作为垃圾留下。
直到您到达初始化它们的行，但我们别再提那件事了，如果你想仔细观察，就像第一个物体是Eoe，第二个是一个很像，如果有帮助的话，内存地址可能有助于您了解这些对象中的哪一个是，哪个。
所以我从来没有设置ID外观，它怎么会有一个随机的垃圾号，因为我从来没有设置过，所以它只是耶，垃圾C加未初始化变量，嗯所以当我说存款，如果我现在接那个电话，我在里面看，这就是那个物体，你看，所以。
如果我说余额加金额五应该是加十二，所以我得到17个，现在我击中了支架，所以我回去，现在再看看缅因州，马蒂有十七个，但如果我能成为一个二，我声明我把名字设置为Maron，我把余额定在很多钱，我叫定金。
如果我跳进去，还记得伊伊为马蒂，梅隆一人，如果我跳进去，嘿嘿，这是一个，我是梅龙，对呀，所以我余额加上金额，它的转速是998，再加一块钱，他到了那里，我退出，所以我的意思是。
我想我想你们已经从以前的经验中得到了，但我只是我真的想确保这很清楚，你以前也见过，如果你对这些东西是如何工作的感到好奇，我是说你可以穿过它们看，看着它发生，你知道在调试器里，任何。
到目前为止有什么问题吗。
好啦，好酷啊，我是说，主要是新东西，下面是语法，我希望，这些概念你大多熟悉。
嗯，好啦，所以就像其中一个原因，你知道的，学生们总是问的经典问题是，为什么我要存款方式，我可以说1余额加等于12对吧，这就是它的作用，有存款方式有什么意义，如果只是把几个数字加起来，你对此有何反应？
是啊，是啊，假期封装，好啦，你什么意思，比如什么，为什么这样做更好，通过方法修改变量，通过成员函数和值，您可以创建安全检查以确保您没有执行该值，或者是的，我想你已经捕捉到了我想谈的很多东西，你说的是。
如果我强迫客户像这个主要的人总是和对象说话，通过调用它的方法，而不是直接接触它的变量，这将允许我有一些支票和一些保护，和物体上的一些东西，是啊，是啊，我认为那是正确的想法。
我可能想要的银行账户支票的例子是什么，非否定喜欢喜欢，也许我们有一个撤回，就像一个很简单的例子就可以了，我有存款，我们也撤退吧，我会从CPP去H并退出，撤回和撤回是减去金额很大，所以这似乎很简单，好吧。
现在我回到那个人身边，使用它的客户，我说实际上我想提取12美元，哎呀哎呀，马蒂没有12美元，我现在不想让他那样做，如果允许我说负等于十二，我无法阻止双倍变成负7对吧，但如果我强迫他们使用撤回。
然后我可以说嘿之类的话，嗯，等一下，你知道的，如果你的余额足够大，可以提取这笔钱，那我就这么做，但除此之外我不知道，我可以打印一条错误信息，我可以抛出一个异常，或者我可以默默地不执行这个动作。
现在我可以保护这个变量不被滥用，你可以做的另一个检查是，你可能会说很好，我不想让他们，你知道的，提款负一美元，偷偷存一块钱，或者任何你能做的，你可以把任何支票，你认为你的课程需要，那是啊。
那正是正确的想法，除了，当然，到目前为止的问题是，现在我，即使这个方法有那些检查，我可以避开这些检查，说啊，余额等于负七对，所以它仍然不能阻止我，所以你用封装这个词。
这就是如何完全阻止恶意客户端做坏事的方法，对呀，那么如何获得封装，是啊，是啊，您必须使对象的变量是私有的，这应该是您的审查，对吗，所以在这里你把你的方法公之于众，你把你的变量变成私有的。
现在它不允许他们做，当然，这意味着它也不允许他们这样做，我们希望那是我们就像初始化对象一样，哎呀，看来我们需要一个例外，的特例，就像我希望能够设定这些值，当我初始化新创建的对象时。
您通常如何实现正确编写构造函数，那么如何用C++编写构造函数，另外你回来说，银行账户，把你名字的绳子和余额的双倍递给我，或者你只是把名字传给，我不知道你不用给我余额，也许你从没有钱开始，差不多吧。
所以现在在H文件中，然后在CPP中，我会写银行账户冒号冒号，银行帐户字符串名称，再说一次，这看起来有点奇怪，但这就像你只是把它在h文件中的样子，但是你用银行账户冒号作为名字的前缀，所以银行账户冒号冒号。
银行账户，是啊，是啊，所以你就会说，如果我把一个名字作为参数传递进来，我想将帐户设置为以它为名称，我想把它设置为零美元作为余额，所以实际上你可以做的是，如果这叫名字，你可能想叫它不同的东西。
所以你可能会说也许n所以如果这是n，您可以说，将我的名字设置为n，将我的余额设置为零，这个构造函数类似于存款或取款的方法，从某种意义上说，它是在一个对象的上下文中操作的，该对象隐式参数，在这种情况下。
对象是在那一刻诞生的对象，所以如果你回到富国银行，你会说Java中的银行账户，你会说银行账户b a等于一个新的银行账户，然后你会超过马蒂，差不多就是这样，这是C++中的Java语法。
您只需删除等于新类型部分，你说银行账户B一个马蒂，调用构造器传递马蒂，然后存储在该变量中创建的对象，一个银行账户B一个语法看起来有点奇怪的账户，但你就是这么做的，假设我想要中的功能。
就像我的银行帐户对象，它有一个构造函数，名称只有一个参数，或者使用一个可以包括银行和起始余额的，我做了一个构造函数，它与，就像默认值，就像你处理函数一样，当然，你可以说都等于零。
所有常见的函数都应该适用于这里，我可以通过一个可选的余额，或者如果你没有通过一个，你得了零分，那么在CPP中，你说双弓平衡等于肠道，对呀，当然有用，那我想我能做的就是，我可以过来有几个方法。
我可以初始化一个银行账户，我可以说银行账户马蒂，然后我可以说是一个存款，五美元就能让我达到五美元，或者在这里我可以说银行账户B两个马龙萨米逗号这么多钱，所以现在他会开始，我不必做两行，好啦。
所以现在我编译所有编译，但在这里，我得到了一个平衡错误，等于负七，它不让我做，二等兵的规则是你的阶级，你的档案可以看到这个东西，以及其他文件，任何其他代码都不那么私密，指银行账户方法。
银行账户建设者可以看到它，改变它，看看它，没有其他人，你能在一行上声明一个变量吗，然后你可以在另一条线上指导，你能申报吗，啊，你能申报一个银行帐户吗，但直到另一条线，是啊，是啊，在Java中。
你有时可以做银行账户B分号，然后你可以说B等于一个新的银行账户，没有嗯C加加上喜欢，那是一种更多，如果你想这么做，你得做一个指针，银行帐户指针，是分号，然后你会说B等于一个新的银行账户，马蒂·乌姆。
所以申报银行账户的概念，但您还没有初始化它，然而，你不能在C++中真正做到这一点，而且你必须初始化它，当你宣布的时候，或者如果您不想初始化它，这就是指针的作用，您将创建一个空指针。
然后你会把它指向一个新的，你不能像有一个如果声明，它以一种基于条件的方式或另一种基于另一种条件的方式初始化它，因为我是说总会有办法的，但就像，是啊，是啊，我是说你想的风格更像是Java，ISM。
就像c+不是那样做的，是啊，是啊，所以这条线就像你声明的那样，你初始化它，准备好出发了，你可能会说，啊，我不喜欢那样，但我会说，你会有更少的bug关于未初始化的空对象，因为这个模式。
所以我不知道做的每件事都有利弊，我只是补充，C加加脏，把它从我身上弄下来很好，我喜欢它，不会再发生了，我答应你，好啦，好啦，所以你不能，你不能设定平衡，那太好了，当然问题有时也会出现。
你可能会喜欢打印的地方，就像，看你怎么知道，我的余额是一个余额结束，就像，啊，我印得不好，但我不想改变它，你不需要保护我，我只想把它打印出来，那么你通常怎么解决这个问题呢，你就像个讨厌鬼，一种访问方法。
让您看到余额，但不会让你如此频繁地改变平衡，你这样做的方式是你来到这里，你说双倍获得平衡，所以它再次返回余额，所以在这里我只是字母表，我喜欢按字母顺序，因为我就是那样，所以你说银行账户有余额。
你说回报平衡，所以不管是什么东西，我返回我的余额变量的值，但我要按价值退货，在它成为复制品之前，所以你不能惹我，我是说这就像，类比，在这里，这个银行账户的余额就像，当你去银行存钱的时候，他们去做。
你要一份有余额的收据，你答应了，那个副本是得到平衡，如果你把它撕了，你不会输光你的钱，对呀，或者如果你在那个东西上加一个额外的零，你拿不到十倍的钱，因为它是复制品，这是一个，这是一个，它是那个值的表示。
就像在富国银行，我可以说B一个点得到平衡，现在它编译并工作，还有我的老板，上面说五个，因为它没有在那里提取，所以我想说清楚，就像如果你说b a 1得到平衡，减等于七，它不让你这么做。
因为你基本上是想说5减等于7，它没有到达，它不工作，这不是参考，所以它不让你这么做，好啦，Private实际上保护内存中的数据吗，还是它只是隐藏了它，就像如果我把指针返回到天平，你能进去把它弄乱吗。
是啊，是啊，这是个好问题，不幸的事实是，私人的东西只在访问点保护，就像你知道天平的内存地址，你可以伸手进去摆弄它，它会让你这么做，事实上，其实不难弄清楚它的内存地址是什么，因为你要的是1的和号。
在它前面有一些字节数，你知道吗，也许第一块地就在上面，下一个字段在它前面四到八个字节，所以你实际上，这是一个在C++中不存在的问题，甚至是常量，不一定意味着绝对没有办法修改那个东西。
但我要说的是它能保护你免受，就像这是你真正想要的东西，我不能直接去改变变量，一切都会好的，我是说，如果我们不给用户一个指向余额的指针，我们会没事的，如果他们只是访问随机的内存地址。
那我不知道他们已经很邪恶了，他们罪有应得，所以是的，私人功能有什么用例吗，当然当然，我的意思是，我想这个例子应该很简单，这样我们就可以像上课一样交谈了，大多数时候你写得更大，更复杂。
比如去看看作业的启动代码，我要写一个大文件，这就像一个贵，我会有一堆功能在那里，动画之类的，我不希望你们调用所有这些函数，所以我会做一些像拼字游戏的GUI，家庭作业四，规格上有一张桌子，列出了五个功能。
剧透警报，在boggle gui中有五个以上的函数，但我让你接触到了他们的另一个，因为我不希望你们乱来，我不想让你打电话，所以是的，我保护我的代码不受你的代码的影响。
基本上，私有函数肯定有一个用例，不，不是真的在这里，但在其他例子中，所以再一次，主要是对概念的回顾，但是C的语法，再加上它是新的东西，好啦，那么我们在哪里，我们在哪里构造函数构造函数，是呀，是呀。
我跳过了一些幻灯片，不过，好吧，让我们看看有时在课堂上，如果客户不好，抛出异常，就像我们写的构造函数，我们把平衡参数，嗯，他们可以在那里通过负10，我们所有的存款提取，他们试图防止负数。
但如果我们从负数开始，这只会让我们处于一个糟糕的状态，所以有时候如果你得到不好的参数，你你扔，因为我无法初始化，我想我可以把余额设为零，如果是阴性，但很多时候这意味着这是衣领上的虫子。
所以我想告诉他们他们有一个bug通过扔弹跳，就在他们后面，比如你去银行你有一张负7美元的钞票，你转向存款，就像把它扔向你一样，你的脸还是怎么的。
我不知道，我不知道这是什么类比，但你知道你去上银行账户课，你说你知道如果val小于零。
扔弓，你只要把它扔向它，好啦，好啦，先决条件，那还有什么，私人数据，让我们谈谈康斯特，所以您可以在类中使用const这个词，常量的含义变得更加重要和复杂，当你处理一个类，我想你已经知道缺点是什么意思了。
你不能改变这件事，但是在C++中至少有三种不同的方法可以使用const，您可以声明一个变量，这意味着在你设置了它的值之后，你可以重新设置，那是可以理解的，很简单，您还可以传递参数，那是缺点。
尤其是常量引用，就像这里，这是我的矢量，大家可以看一下，但请不要改变元素，我在问我的推荐人，所以我和你分享我的矢量，但我不会让你改变的，好啦，罚款，这就像你把你的手机给你的小侄女什么的，但你把它锁起来。
这样她就可以把脸打开了，向奶奶问好，但她不能删除你所有的联系人，或者别的什么，你知道的，就像上锁了一样，但你可以拿着它看一分钟，然后还有第三条路，如果你在写一门课，您可以编写一个常量方法。
语法是你只写一个词，方法标题末尾的常量，意思就是你，由于本课程的作者都承诺该方法，如果调用该方法，它不会改变物体的状态。
所以如果你看看我们班，我们有存取款和余额，存取款，他们改变了平衡，它们改变您调用它们的对象的状态，他们是变种人，他们是修饰语，他们改变了对象，这得到了平衡，它不是只返回信息，所以你可以在这里说常量。
你可能会说很好，为什么，有什么意义，做，我不得不这么说，我给你看，我可能要到星期三才能全部看完，但这么说，如果有人碰巧声明了一个变量，这是一个常量银行帐户变量。
或通过一个银行账户是一个常量的银行账户参考，它只允许您调用它上的方法，上面有这个骗局的关键字，这就是它如何知道哪些方法是允许的，哪些不像这里，如果我说平衡在h中是常量，我还必须回到cpp。
把它写成const，很多人把它们混在一起，他们忘记了这些必须彼此同步，但现在这样一个，有几件事会发生，当我在这里说常量，一个是如果我试着做一些不固定的事情，就像如果我说平衡加，另外，这就像嘿。
你答应过不会那样做的，所以它实际上不让我编译，所以这很酷，好的，让我们摆脱它，另一件事是在客户端，如果你把这叫做，它知道这种方法不会修改银行账户，就像这里的一个例子，你可能会做一些像void这样的事情。
做事做事做事，对银行账户做一些事情，做一个，你可以对银行账户做一些事情，嗯，我可能会通过，我应该参考一下，但你可以做的是你和说好，我想确保打电话的人，知道我不会修改这个，所以我会说缺点是一口井。
如果你想做这种事，B A存款，B A撤回，B得到平衡，它不会让你存取款，因为它就像嘿，3。你坚持要我改变这个主意，但你想改变它，所以常量在类中限制，客户可以用什么方式使用它，如果他们的参数或变量是常量。
所以这有点有趣，事实上，如果你看看斯坦福图书馆，像向量类或哈希映射类，如果你往里面看，其中一些方法实际上是常量。
差不多该走了，但这是我给你看的最后一件事，如果你去找斯坦福大学图书馆的文档，你向上看就像矢量什么的，矢量在哪里，所以如果你看这些标题，比如void add，有道理，空白清除。
但是如果你看看这些方法中的一些，比如get it说const，因为你可以从矢量中得到东西，它不会改变，向量插入，常量不是吗，但像常量一样是空的，所以你可以这样计算，我到底要不要改变这个东西，我不是。
我要在上面写上const这个词。
所以客户端知道它不会改变对象，好吧好吧，这不是我们想说的关于物体的一切，但我最好在那里停下来，祝你学习顺利，星期三的课我在这里等你们。
【编程抽象方法 cs106x 2017】斯坦福—中英字幕 - P17：Lecture 17 - Classes 2; Skip Lists - 加加zero - BV1By411h75g
好啦，为什么我们现在不出发呢？嗯当然，这是呃，考试前的最后一堂课，右拳，明晚，星期四晚上，晚上七点到九点，你们收到我关于房间的电子邮件了吗，是啊，是啊，好啦，如果你不知道我在说什么，那就去班级网站看看。
要么在头版，要么在考试页，我现在没有工作的WiFi，但如果你翻到那些页面，它会告诉你你们被分到不同的房间，根据你的姓，所以明天一定要去对房间，考试不在这里，在这个房间里，在另外三个房间里，散落在院子里。
出于某种原因，这就是他们在斯坦福大学做事的方式，所以请一定要去正确的房间，就像我不对你负责，如果你没有去对地方，就像你来到这里，然后意识到你来错地方了，然后跑到正确的房间，迟到二十分钟。
你和现在少了20分钟的工作时间，所以这就是那种混蛋，我是所以请检查这个弄清楚你需要去哪个房间，如果你不知道怎么去那栋楼，网页上有如何在校园地图上找到它的链接，所以弄清楚你需要去哪里，如果你对此有疑问。
请发邮件给我和艾米，今天下课后的助教，我们会帮你弄明白的，好吧不管怎样，我知道你你的思想和你的压力现在可能都集中在这上面，但尽管如此，我还是要教你新的材料，无论如何，我也许可以通过告诉你。
今天的考试不包括这些材料，但那也意味着你可能不想听我说，所以我不知道如何在这里穿针引线，它对即将到来的作业和其他东西很有帮助，所以无论如何，我今天想用我们的时间做什么，我想更多地讨论类和对象。
我想结束这次讨论，我还想谈谈一些，我想回到链表，我们像上周一样做了链接列表，我想把班级的东西连接到链表上，把它们放在一起，这就是计划，所以让我来看看我的幻灯片。
我们讨论了类和对象，我们复习了一下基本知识，你有H文件，里面有你所有的原型，您有一个cpp文件，其中包含，你知道我们回顾了一些概念，我试着把注意力集中在差异上，不同的语法和东西。
所以今天我想跳到一些新的语法，就像我们在下课时看到的最后一件事，你可以在课堂上使用const这个词，所以你知道常量意味着它不会改变，这是一个常数，你不能修改它，我特别想强调这个词的最后一个用法，康斯特。
你把它放在一个方法的标题上，再一次，它的作用是，它承诺此方法不会修改对象的状态，所以任何上你课的人，他们知道如果他们调用那个方法，它不会喜欢，删除帐户或删除所有的钱或类似的东西。
它还允许编译器检查一些东西，例如，如果使用我的类的人声明了一个银行帐户对象，他们说这是骗局，它将允许他们在那个物体上戳一个平衡，但它不允许他们在那个物体上要求存款，因为存款没有声明为常量方法。
所以在作业和其他方面，你们要写的对象类，我要请你，请在你能做的地方做一个方法常量，所以我的意思是，基本上你要做的是。
你要打开你的h文件，你要把里面所有的方法都看一遍，你就会问自己，这些方法，是否修改对象，如果他们不这样做，你应该把常量放在他们身上，所以就像这里，我是说，我在上节课结束的时候已经这样做了。
就在我们结束的时候，但就像存钱会改变计数一样，它不是恒定的，要求余额是不变的，询问帐户上的名字是不变的，提款不是，以此类推，任何时候，我请你写一堂课，我要你好好想想，这方面，好啦，所以这是缺点。
你们有什么问题吗，我真的没有时间回答关于它的问题，星期一，所以说，问题，是啊，是啊，所以这是一种然后去参数，他们叫什么并不重要，哦，你是说，就像它是一个方法参数，如果这除了在任何参数，参数也可以是常量。
也可以不是常量，是独立的，就像我可以在这里传递一个向量引用，然后这个代码可以改变向量，我保证这不会改变银行账户，关于参数没有任何特别的承诺，如果我想保证关于参数，作为成本的参数，有点让人摸不着头脑。
因为大多数时候，当你想让某件事保持不变时，你在开头加上了机会这个词，你把它放在最后，你把它放在最后的原因，如果你把它放在一开始，就像你的回报是一种持续的力量，但它真正说明的是这是一个医学屏幕游戏。
我会保持不变，所以他们决定把它放在最后，所以不管，是啊，是啊，所以成本法，我想你只能调用其他conmethods，是啊，是啊，有一个短语，他们称之为常量正确性，这意味着你已经通过了你的代码。
你已经通过了你的课程，你真的仔细考虑过这个问题，你在所有合适的地方都用了const这个词，我会告诉你，对于一个项目来说，最糟糕的状态是，就是你在代码中部分地应用了常量，因为你会发现，有些东西是缺点。
有些东西不是，你会得到这些编译器错误，因为不是常量的东西正在召唤，反之亦然，就像嘿，你不能那么做，因为你不是康斯特什么的，所以如果你在常量方面有错误，可能是因为你没有足够的康纳，康纳太多了，随便啦。
我听学生们告诉我他们所做的是，他们只是试图让一切保持不变，然后他们抹去上面有错误的，嘿，如果这是需要的，好吧，我是说很酷。
但不管怎样，好啦，我想继续前进，我是说我觉得有很多关于课程和其他东西的有趣的东西，但我想我想继续前进，所以我在这里有更多的话题，所以这是常量，我想谈谈操作员重载，所以这是C++的一个非常独特的特性。
我觉得在C++中很有趣，您实际上可以在语言中为运算符添加新的含义，具体来说，您可以定义运算符如何与您的类型交互，和你的班级在一起，你在写什么，所以如果你有一个，你知道的，表示矩阵或其他东西的类。
您可以定义一个时间运算符来进行矩阵乘法，而在Java这样的语言中，你不能那么做，你得写一个叫做点乘或点阵乘法的方法，所以这有点酷，这是允许重写的所有运算符的列表，过载，我有一些这样的，啊。
可以用括号重载的内容，C加加，让我们做一些邪恶的，我不想谈论这些运营商中的一些，这是奇怪的东西，但有时你想做这些运算符，最常见的情况是我重写等号之类的东西，你知道在Java中。
如果您想编写一个可以比较的类，用C++做一个equals方法，你不做一个等于方法，重写equals运算符，所以等于运算符就可以工作了，你没有牵线，你可以在字符串上做等于等于。
这是因为字符串有一个重载的equals运算符，你知道你也可以为你的课这么做，所以这就是我喜欢我们的收藏课的东西，让操作员重载它们，如果你有一个矢量，您想添加一个元素或集合，你可以说正等于。
这实际上是一个加号运算符，我们重载了地图和哈希地图，如果要添加或访问一对，你可以用方括号来表示，这是因为我们重载了类中的方括号运算符，所以这是一个很酷的功能，嗯，只是轻微的社论，我想告诉你。
我认为这个功能很容易被滥用，如果您在类中添加一堆运算符，不是很直观的，然后它可以让写作变得非常容易，看起来很奇怪的代码，很难读懂，就像使用你代码的人在做时间和除法，再加上你决定超载。
加上接线员在银行账户上做存款，除以操作员从银行账户中提取交易费，就像你所知道的，那有点不直观，我认为你应该只使用这些运算符来做一些显而易见的事情，平起平坐，等于，应该告诉你事物是否相等。
或类似的东西在后面，是啊，是啊，加号是怎么回事，一元算子的幂加减，当你可以的时候，你可以说负一，或者你可以说a-b，所以实际上这些运算符可以作为一个单独的，在单个值前面或两个值之间，反正。
这些都是您可以重载的运算符，如果你想这么做，如果你真的想这么做，然后你要做的就是把它写成一个函数，好啦，你基本上把它看作是一个函数，但是函数的名字就像运算符加或运算符等于等于或其他什么，那是函数的名称。
唯一有点困惑的是，如果是二进制操作，就像你去的地方，A等于B，你基本上把它看作是一个叫做equals的函数，它接受两个参数，一个逗号b，就像参数一样，是两件事，即使在你的代码中，两个东西中的一个在左边。
另一件事是在右边，这就是你喜欢的语法，我们一直在做的其他课程，你在H上声明，然后你把它的主体写在CPP中，就像，让我给你看一个快速的例子。
我们有一个银行账户类，你可以在那里存取款，像这样的东西，如果你只是想检查两个银行账户是否相等，他们是否有相同的状态，您可以编写一个运算符，等于等于，你可以拿一个银行账户和一个银行账户。
少了些东西一个接线员，就像一个函数，所以它必须有一个返回类型，equals等于cool的返回类型是什么，对呀，它要么是做的，要么是做的，要么是真的，要么是假的，另一件事是，如果你把这些银行账户，请记住。
每次将对象作为参数传递时，它复制了一份，所以你可能应该通过引用和等于来做这个，不改变计数，所以你可能应该说它把他们当成了罪犯，现在又是银行帐户参考资料，我们刚刚谈到了康斯特，所以你可能会有点困惑。
你可能以为这个是放在这里的，常像那样，但是康德最后说，如果它是类中的成员函数，这实际上不是在课堂里，它只是一个自由浮动运算符，碰巧在操作数上工作，是银行账户，所以你没有说最后是常数。
如果您想保证此操作员不修改帐户，现在呢，你把Conover放在这里而不是那里，所以我不知道这是令人困惑的事情，对吧，这是运算符等于的标题，然后如果你想实现它，嗯现在，我在银行账户上。
如果你想写它的实际主体，你去这里的银行账户CPP，到下面去什么的，你又说粘贴运算符等于现在，在所有这些其他方法中，你可能还记得我写了银行账户冒号冒号，这是因为它们就像每个银行帐户对象的成员。
此运算符不是，它漂浮在全球空间，它恰好有操作数，是银行账户，所以我不说银行账户冒号冒号，所以如果我想看看他们是否平等，我的意思是你基本上只是比较物体的状态，所以你知道他们有一个身份，一个名字和一个平衡。
事实上，我不认为我们真的对ID和所有代码做任何事情，所以也许我会删除，我在这家银行不需要身份证，你的名字已经够好了，你叫什么名字？卡尔，好啦，给你20块，你很好，一定是富国银行。
我们只是为人们做免费的账户，而不问他们，然后我们拿走他们所有的钱，是呀，所以名字和平衡，如果那些是一样的，那么计数就相等了，或许你会说，你知道的，返回b a一点得到平衡，等于b a两点得到平衡。
我想你首先比较名字，你会说一个人得到名字等于爸爸两个人得到名字平衡，所以回归真，如果那是真的而返回的是假的，如果那是假的，有趣的是，this运算符调用这些方法，就像点得到平衡。
而上面的代码直接引用了这些，就像私有变量，从技术上讲，这些运算符不是类的一部分，所以实际上，如果我试着说就像两个点平衡，它其实不喜欢这样，你这里有一个小错误，它说在这种情况下余额是私人的。
所以从技术上来说，运营商是一个外部实体，嗯，如果您想编写一个能够触及私有事物的运算符，当然，你可以黑客攻击并使它们私有变量公开，但那不酷，我们不应该那样做，所以如果你想。
以便这些运算符现在可以看到私有变量，在本例中，那对我们没有多大好处，因为您可以通过调用这些get方法快速地询问私有变量的值，但是您可能没有一个针对每一个，不管出于什么原因，你可能需要把手伸进去。
所以你会喜欢这个的，C++有一种方法可以解决这个特殊的问题，你这样做的方式是你让全班，所以请记住，我们有我们的，我们的银行账户类在这里，然后在下面，我们有一个类之外的运算符，银行帐户类可以有选择地指定。
允许进入自身私有数据的各种其他代码，爪哇，你不能那样做，这不是一件事，Java就像公共和私人一样，C++有一个特殊的东西，你可以来这里，喜欢在课堂上，在某个地方，你把运算符的方法放在这里。
你把朋友这个词放在这里，我不是瞎编的，寻找颜色，这是一个真正的关键字，你知道的，我爱，如果你仔细想想，就像，是呀，对我来说，对我来说，听起来更像是有好处的朋友，但不管怎样，如果你那样做。
不管是什么函数或者运算符，允许查看类的私有数据，这将使我们，所以如果我们想在这里，我们可以说B A一个名字等于，B A两个名字和B A一个余额，所以现在，好啦，但我想也许我不是很清楚，就像这样更好吗。
喜欢这种好风格吗，或者这被认为是，我想说这通常被认为是可以的，因为有时候你需要这些操作员能够接触到并做到这一点，通常运算符定义在同一个文件中，无论如何，所以不是说，你只是在向全世界传递友谊的象征。
刺穿你的物体，或者随便什么问题，那么在课堂上的重点是什么呢，好啦，对不起，为什么我在这里或这里定义它，是啊，是啊，我们有下面的一面，对呀，对嗯，基本上你是在这里宣布的，就像对世界一样。
你在告诉全世界这个存在，站在这里就像你在说嘿，那家伙是我朋友，但就像，我很确定如果你把它放在这里，它不工作，有点像真的是这个，这个就像指水或类似的东西，你可以，你可以把这个放在私处，如果你想的话。
就像我们是朋友一样，但它有点在DL上，你知道的，我不想让别人知道他们是我的朋友，但这是一种语法，你要这么做，你可以对，私人内部的运营商，然后你得说，朋友，哎呦，你的意思是，你的意思是，别那样放在这里。
我想你两者都需要，我忘了，我的意思是，删除它，看看它是否完成，但我们不用它，问题是你必须正确地称呼它，所以如果我把那个注释掉，我想问题应该是，如果我去富国银行，我说嘿，如果b a 1等于b a 2。
看看有多哇，如果b a 1等于b a 1，那些是平等的，看出去，这是非常描述性的信息，所以我想这真的奏效了，它打印了是的，因为我和自己是平等的，但我比不上玛拉，我想我已经知道了，但不管怎样。
我想它确实起作用了，我总是看到它放在两个地方，但不管怎样，也许不需要两者都有，我想没有朋友这个词，你不能把它放在这里，说朋友对，说朋友必须在班上的那个，嗯，我是说在那里连个朋友都没有。
因为它只是声明一个运算符属于这个类，对呀，但如果你这么说，我觉得它，如果它没有，它不喜欢那样，基本上你是说我以外的那个人是我的朋友，好让他们碰我，不管他们想要什么，所以不管是什么权利，反正是那种讲座。
那就是陆上接线员，是啊，是啊，编写不是运算符的任意函数是编码风格吗，让他们成为朋友，我认为总的来说，你想尽量减少朋友的使用，如果您的代码需要查看类的私有数据，那么该代码可能应该是类的一部分。
不然它为什么需要这些数据，或者做一个方法，他们可以访问私人数据，并在不修改它或其他东西的情况下查看它，感觉就像你们已经学会的正常写作机制，课程应该大部分有效，这是一个非常具体的案例，其中必须写入运算符。
因为这些全局函数在两边都有操作数，因此，它是一种这种特征，坦率地说，几乎完全是为这种情况而建造的，哪里像，有些东西必须在我的课堂之外，但本质上与我的课程紧密相连，所以我会给你一把后门的钥匙。
到课堂上查看私人数据，是啊，是啊，我有两个问题，首先，有一个语法，我们将运算符定义为成本函数，喜欢的人谁会是对象，第二个是，是啊，是啊，是啊，是啊，嗯，所以我不想在这上面花很多时间。
但是重载运算符还有另一种语法，在那里你可以喜欢，省略第一个操作数，然后就像你一样，这是第一个鞋面，所以你可以这样做，但我更喜欢这里的语法，因为有很多运算符不能用第二种语法编写，只有一些人能。
关于它有一些奇怪的规则，到目前为止，这是更常见或鼓励的，比如语法，我想这个语法也允许像int加银行账户和银行账户这样的东西，加int，一些不对称的东西，如果是在教室里，或者你必须在操作员的左边什么的。
所以无论如何，还有其他方法可以做到这一点，但这是我认为这是最鼓励的方式，这里的另一个人叫什么名字，为什么不，我知道，我不知道如果我不在那里，当我们有两个函数，他们能用不同的，是啊，是啊。
我是说我认为重载就像在一个函数中，会像，您有一个函数foo，它接受一个int，和相同的函数foo，它接受双倍或不同类型的参数，所以就像我们已经有了一个等于运算符，它需要整数、双打和字符串。
但现在我们要超载了，所以它也可以接受一个参数，那是一个银行帐户，所以我想这就是它的名字，有一件事我想指出，我看到你的手了，我再打给你，我是这些超负荷的操作员，真的很蠢，它完全照你说的做，例如。
我在这里写了一个equals-equals运算符，所以你可能会认为现在C++知道如何测试，他们是否平等，它还必须知道如何测试，他们是否平等，因为它们显然是相反的，所以如果我在这里说不等于。
如果你试图编译，它会说你没有定义一个不等于运算符，就像，你在开玩笑吧，我，我告诉过你，你想不通，不等于，你实际上必须回到类，你实际上必须写一个单独的运算符，不平等，你也得把他当朋友，当你去，那是h文件。
现在呢，在cpp文件中，您实际上必须编写一个运算符，实际上很多人做的，你可以用结来重写这个逻辑，但是很多人不喜欢，一等于，B一个二，我觉得很愚蠢，这些不是自动从彼此推断出来的。
这就是他们在那里建立功能的方式，有这些晦涩的例子，平等和不平等并不是完全对立的，但是因为它的稀有性，他们决定把所有这些事情都分开，喜欢不到不给你，比所有那些东西都伟大，是啊，是啊。
你可以通过把自己的符号放在谷歌运算符后面来制作自己的运算符，对呀，类算子，否，我希望。
有一个名单是允许的，我知道，我知道，但就像你的猫跳到键盘上打一堆东西，就像这些是，就这样了，如果你，如果不在这一套里，这不是语言规范的一部分，它在后端不起作用，所以如果在全局命名空间中重载它。
这意味着任何与它互动的人都将接受新的定义，默认情况下的旧定义。
是啊，是啊，一旦您现在将该运算符添加到项目中，每当有人用它旁边的操作数写等于号时，它就会把这个叫做它，所以这就像，我想最好的方法是避免你自己的，因为您可能会使用其他对象，一个完全不同的物体称它们相等。
所以你不想好好利用，这并不替换int的equals或double的equals或其他，这就像如果你有相等的，它恰好在每一边都有一个银行账户，这样做，它并不取代任何其他平等的上下文。
就像在其他类型的东西上，是啊，是啊，两个问题，一个可以替换其他内容，比如整数上的运算符等式，我不认为你能，我已经有一段时间没试过这个了，a int b，会把他们，是啊，是啊，上面说你们一定有争论。
那是类或enome类型，所以我想你只能根据自己的类型来定义这个，所以我很确定你做不到，有一些编程语言可以做到这一点，就像有一种语言叫红宝石，在那里你可以做任何你想做的事。
所以你可以把int 3设置成值5，现在三等于五，你可以改加法做减法，所以你可以做各种蠢事，但不是在这里还有另一个问题，是呀，是啊，是啊，但在这种情况下，对于不等于，你只是在翻转等价物。
他们在文件中出现的顺序有关系吗，嗯不，只要他们都有一个带有分号的原型，每个人都会从原型中知道另一个，是啊，是啊，我想在一秒钟内继续前进，因为你知道我还有其他事情要做，但这可能是一个问题，是啊，是啊。
但是，而不是使用两个参数，是啊，是啊，这是她的问题，有一个语法你喜欢，这是第一个操作数，我不太想表现出来，在幻灯片里，我不打算多谈这件事，因为只有一些运算符支持这种语法，不是其他人，其中的规则有点奇怪。
这种语法更普遍，这是我认为更普遍的鼓励语法，我想继续前进，如果有其他运算符重载问题，也许我们可以晚点再吃，我只是我有很多其他的东西我想涵盖，但这是运算符重载的基本知识。
我想给你看一个特定的操作员，这是非常重要的，也是非常常见的超载，哪个是小于小于运算符，这是当你看到外面时使用的操作员，就像你打印东西的时候，所以实际上你知道在Java中，如果要使对象可打印。
你是做什么的，您编写一个双字符串方法，右Java，那就像爪哇的一个特殊公民，那个方法很特别，它将使您可以在控制台上用C++打印该对象，您可以将方法名写入字符串，但这种方法一点也不特别。
它不是用C++自动调用的，所以这种方法做不到你想要的，如果你想做一些可打印的东西，当小于小于运算符超过输出流时，您将重写它所做的操作，C out是输出流类型的对象，你的东西引用通常这样它就不会复制它。
奇怪的是，这个方法是运算符，它返回输出流作为其返回值，这有点奇怪，但它这样做的原因是当你真的看到箭头时，什么箭，什么箭，像这些子表达式中的每一个都返回看出来，以便下一个表达式可以计算查看，只是很奇怪。
别想太多，但是如果你想让你的对象原则，你写这个。
所以说，让我快速地告诉你，因为我希望你能在课堂上写那个运算符，在执行任务什么的，所以你说，小于O流参考运算符，你用一个o流引用来表示你想把它发送到的任何输出，然后你拿着，我不知道，康斯特银行账户，是A。
实际上我需要先在H文件中声明它，我刚跳转到h文件，我可以把它变成朋友，看情况，我的意思是，所以在这里，我必须包括IO流，因为我在用i o流，现在在银行帐户类中，马马虎虎，是啊，是啊。
所以我宣布这个方向在这里，现在回到这里，我说基本上你只要假装退出就是退出，所以你就像箭一样，美元符号，巴点，获得平衡，你知道类似的事情，或许你会说，获取姓名，就像那样等等，我做错了什么。
还是他们少了一个，就像一件事，你通常不会把我，因为你想让打电话的人，决定在这个末尾是否应该有一个句柄，你应该只在周围没有其他东西的情况下打印自己，现在我是如何决定给我什么格式的，就像名字逗号和钱。
现在我有了那个接线员，如果我去富国银行，我说嘿，你知道的，看出来一个是箭头，一支箭，然后我对BA2做同样的事情，所以到了这里，它将调用我的小于小于运算符，它会喜欢，运行打印代码打印我，所以它打印了一些。
B 1是马蒂0，对呀，所以相当简单，但我想让你看看，因为我是说，我不想花很多时间谈论那个特定的运算符，但就像这样你就可以把东西打印出来，是啊，是啊，你是想说服你的朋友还是，输出流。
但它不想返回输出流的副本，所以我不知道，我是说，这是这个运算符必须具有的标题，因为当你说箭头的时候，它打印的东西，然后这个表达式的计算结果是，所以如果你还有另一支箭，下一件事就会看到箭头。
它实际上是通过这些回报来做到这一点的，看看基本上，但让我们看看是不是律师，他们做了一个账户，然后就会有，返回一个关于它的参考，使它大约一美元会更好吗，是啊，是啊，我是说，我认为引用的返回是一种。
会让你的脑袋转一下，嗯，我想说总的来说，返回参考资料，你真的不应该那么做，因为如果要返回对局部变量的引用，局部变量就要被堆栈挤掉了，现在你真的返回了一个刚刚死亡的东西的引用，这将打破程序，嗯。
所以大多数情况下，你不想返回引用的东西，但偶尔你会，你只想这么做，如果你知道你归还的东西不会消失，我知道这不会消失，因为他是我的推荐人，我会把他还给你作为你的推荐人，所以他住在，不管是谁宣布他。
所以当我做完的时候他不会离开，我要宣布他，所以我不打算清理他，所以返回对事物的引用是要做的事情，很少谨慎，只是碰巧在这种情况下你必须这么做，我也不知道，我是说，为了我们需要做的，就像你总是打印一样。
然后返回传递给您的输出流，没有比这更有逻辑的了，对所以实际上，如果我更详细地说明操作员，就像一些运营商，您返回对您自己的引用，因为加等于修改你然后返回你，所以你返回这个基本上就像引用你自己一样，是啊。
是啊，明星这个其实，但是是的，你是的，有一些运算符，您可以在其中返回引用，因为这个原因，我今天不打算超载，但这是正确的想法，呃，我们要考试吗，如果是这样，是不是有一个形状，还是考试的时候要这样。
我不会要求你在期中考试时让接线员超负荷工作，否，我不会要求你那样做的，或者如果我像决赛一样，我会确保给你航向安全。
所以无论如何，我想再做一件事，我想谈谈，让我们看看，我想讲一下d结构，你们见过建造者，当一个物体诞生时，调用构造函数，可以添加参数来初始化对象，C++也有一个叫做析构函数的东西。
有时学生们称之为解构主义者，但它是一个析构函数，它不是解构器，不管它的语法是什么，你放一个波浪形，然后它看起来像一个构造函数，否则，波浪在二进制算术中表示否定，所以它的意思是，这是一个非构造函数。
有点嗯，当对象被抛出时调用它，被清理，从内存中删除，物体正在死亡，你在里面一般会做什么，你不必写这些东西，但你会做的是，如果您的对象在堆上分配了任何指针或任何新对象，你会想释放它们并在那里删除它们。
以确保您的类不会泄漏任何内存，所以实际上我不能给你看一个很好的演示，在这里用银行账户。
因为bank account类只有一个int和一个字符串或者字符串中的一个double，你不需要把它们清理干净，你唯一需要清理的情况是，如果你有一个foo star f，你做了一个新的食物。
当你的目标快要死的时候，你必须删除F，基本上你得，如果你在这里分配了某种指针，你得把它清理干净，我马上给你们看一个例子，但这是一般的想法，所以如果你想看看析构函数的作用，你可以在这里写。
银行账户是一个析构函数，然后在CPP文件中，我可以说，银行帐户冒号冒号析构函数，只是为了帮助看到它的工作，我可以做的就像看到外面的毁灭门呼叫和好的，事实上，我甚至可以说喜欢，然后我就可以这么做了。
也就是我，你知道我打印自己把星这个，因为这是指向我和星星的指针意思是指向那个，我指的是什么，但不管怎样，打印我自己，好啦，当我死的时候，打印打印我的名字什么的，所以在富国银行的客户那里。
我觉得你看到的是对的，在节目结束时，你会看到析构函数在神经元上被调用，后来他接到了马蒂的电话，所以它在最后，当程序关闭时，它在最后的原因，是因为这些物体，在缅因州的尽头。
你知道他们从梅因的开始一直生活到结束，所以这就是它摧毁它们的时候，如果你有一个生命期较短的物体，你知道虚空福，然后在这里你知道你创建了另一个银行账户，B一个三，就像，你知道，基思，施瓦茨什么的，他有。
你知道，五十块，不管他有什么，你知道这里，我可以说，阿福，那么会发生什么，它是要调用函数，它会创造基思，函数返回，它将清理基思物体，它会调用他的析构函数，所以我会在输出的前面看到关于Keith的消息。
你看到了，所以他在最初的几条打印信息后就被摧毁了，事实上，我们使用指导者定义对象而不是堆栈，当他们让观众保持正确时，我们会打电话，所以实际上，如果你有银行账户，星B A三等于新银行账户，基思·施瓦茨。
那是基思现在住在垃圾堆里，如果你运行这个，仔细观察代码，你永远不会看到一条线上写着析构函数，打电话给基思，因为我从来没有它不得到，因为这正是在堆上分配东西的意思，它不会被程序破坏，直到你删除它。
如果你叫删除，它将调用析构函数，所以是的，这是一个很好的区别，事实上，目前这个程序泄露了基思的内存，1。我找不到他了，因为我丢了他的教鞭，所以哎呀，问题，是啊，是啊，像清理，那个。
或者现在你的笔记本电脑上用的是RAM，那是为了那个物体，现在就像卡在那里一样，是啊，是啊，它是它是前者，如果我不释放记忆，就像如果我把这段记忆泄露给基思，内存被我的程序占用了，无法恢复。
直到我的程序退出，我的程序退出操作系统，抹去了我用过的所有内存，即使这么幸运被泄露了，它可以追溯到，我也不必喜欢重新启动或买一台新电脑，或者任何权利，嗯，这是个好消息，但是是的，但如果再一次。
这对这个节目来说并不重要，但如果我运行一个长寿程序，就像服务器，那东西很重要，所以如果你不知何故知道新来的人的指针，你还是会觉得，这将是相当困难的，如果我知道重点，就像你说的，在我的主课后面什么的。
是啊，是啊，如果可以的话，如果你有那个指针，那个内存地址，我可以去那里，基思的目标还在那里，如果泄露了，它还在那里，就像，我没有办法够到它来清理它，或者现在就用，当程序终止时，程序终止。
OS可能会把它都抹去，或者像我猜的那样，它通常只留下它发现时的记忆状态，但这个技术上很差的基思，帮帮我帮帮我，我漂浮在记忆中，没有人释放我，差不多吧，但我的意思是，基本上它输给了世界，是的问题，事实上。
在末尾可能会写每一个被使用的内存，不是自由，或者类似的免费的，喜欢自由大家喜欢，当我们来到这里，把他们都放了，或者只是手动，我们可以说不，我是说C++不会记录，所有这些事情就像，我们没有办法让它自由。
所有这些，嗯，Java和其他语言为我们跟踪这些东西，他们称之为自动垃圾收集，但我们这里没有，基本上是为了速度的目的，他们不想把所有的事情都列在清单上，因为那样会占用你的记忆和时间。
所以他们认为你应该跟踪它，否则就是你的问题，你知道这是一种我们正在使用的语言，所以说，好啦，银行账户类很短，也很简单。
只是想练习一下语法，我认为一个更有趣的例子是，如果将链表制作成类，我不打算和你们一起编码，但是我们写的那些方法，比如添加，删除链表前面的，你能做的就是把所有的代码，粘贴到类中，好啦。
但你要做的一个改变是，所有这些方法都是如何走在前面的，前前指针，您将从这些函数的所有标题中删除该参数，它不是一个参数，它将是链表的私有变量，所以他们有这样的通道，而不是你必须传递正面作为参数。
所以现在所有的方法都只接受参数，用户希望通过，比如值或索引，或者任何他们想操纵的东西，所以我不知道我的幻灯片里有没有那个代码，但它看起来是这样的，你知道你可以做一个链接列表，你可以添加一些东西。
你可以得到东西，你可以设置东西，你可以移除东西，这段代码是算法上的，我们上周写的代码，只是稍微重组一下，我想我没有幻灯片中的方法，但那是因为它们是我们已经生长的身体，这是一个你想破坏的地方。
因为在这里你有一个节点链，如果你永远不能把他们清除出去，然后当链表被扔掉时，您应该在奇诺节点上循环，并将它们都向上显示，这是一个例子，你会，析构函数可以帮助您做到这一点，是啊，是啊。
当您为类实现类似链表的东西时，对于大小有一个私有变量是典型的，你用一个尺寸方法，我们必须这样做，如果我们没有公共汽车，您当然可以为大小保留一个int，有时候你应该这么做，你不应该那样做，取决于，就像。
如果你的教练说你能或不能，或者如果您有一些内存限制或其他原因，但是是的，你可以把它放在里面看看大小，你可以在广告上增加它，在运动中减少它，但如果你被要求尺寸，你其实不必走过去数数。
所以这是一个很好的好处，是啊，是啊，问题，所以我们打算在我们的项目中实现一个链表，我们在哪里定义结构列表，我们会在同一个教室里做吗，一个小结构通常只是在它自己的小文件中，称为列表节点h。
它可能和这个在同一个文件里，但更常见的是，每种数据类型都有自己创建的文件，当我给你一个开始的项目，如果我想让你有某个节点，我会给你做一个H文件，里面有节点，我会把这个代码贴出来，如果你想看这个。
我不是想为你保守这个秘密，但基本上我要做的就是，将我们上周写的所有代码复制粘贴到这里，所以我想把最后几分钟，我们已经简要地讨论了几个高级版本的链表，我打算只简短地谈论它们，因为我想让你多看看他们。
作为你们家庭作业的一部分，我知道这正是你想的，现在是家庭作业，但是你可以。
你可以考试后再担心，但我想谈谈链表的两种变体。
称为双链表和跳过列表，你可能会说耶稣，为什么你要在上一节课的最后十分钟介绍这个，我是故意勇敢的，因为我想让你探索这个，但是这里有一个关于双链表的快速介绍，这个想法是每个节点不仅有一个下一个指针。
但它也有一个以前的指针，否则就是千篇一律，正如您已经看到的链表，另一个变化是，您通常会保留一个后退指针，除了保持一个前指针，这样做的主要好处是，您现在可以在列表中双向行走，如果您想转到末尾并循环到开头。
很容易做到，缺点是节点占用了更多的内存，因为他们每个人身上都有另一个指针，当你在做代码的时候，你得移动更多的箭和操纵，你得确保保持两个方向，锁链无时无刻不在纠正，所以这可以使编码稍微困难一点，对呀。
所以这取决于，如果你需要能够双向行走，你也许应该这么做，如果你不需要走两条路，那么也许你不需要后面的指针，我们之前编写的所有其他方法都不需要任何反向指针，所以好吧，所以如果你在做一个双链表。
如果你在考虑添加一些东西，基本上当列表为空时，前面和后面的指针都是no，如果添加单个元素，前面和后面都是那个音符，它没有绿色，也没有下一个，因为它是唯一的元素，如果添加另一个元素。
这取决于前面末端或者中间，如果你在最后，你得退缩，他的奶油在前面，前面的下一个在这里，你知道就像，我是，我在这里读你必须改变的所有事情，基本上如果你加上前面，你要把前面的指针换到旧的前面。
旧的战线必须回到他身边，所以有更多的箭头操作，你基本上要做两个方向的指针才能让它工作，但又一次，你们一直在练习的东西，就像我有这张照片，我想要那张照片，就像所有这些东西在这里仍然适用一样，基本上是对的。
从双链表移除，你记得如果你从一个，如果你想除掉这家伙，你让詹姆斯·邦德站在这里，你把下一个指向这里，对呀，但你也需要和这个家伙谈谈，把他的pre再指向一次，所以就像要换两支箭对吧。
所以这不是世界上最难的事情，但你得小心点，因为如果你只做一种方式，如果只移动此指针，但你不能移动指针，然后就像如果你走不同的方向，你会得到一个不同的，就像，如果你倒退，你仍然会看到这个家伙，你继续前进。
你想要，你在这个州得到了这些奇怪的不一致，基本上，这就像从双链表中删除，实际上，当你从末端移除时，你得小心后指针或前指针，或者两者都特别棘手的状态是，如果你只有一个元素，你必须同时把前面和后面都清零。
所以你得小心点，得画些画，对呀，那是一个双链表，你要在一个叫做Tiles的程序上这样做，在那里你将有一个这些矩形的链表，当你点击它们的时候，你走到前面，或者你把它们移到后面什么的，所以能够双向是很好的。
在列表中循环，找东西，抓住它，把它搬到前面，移到后面去，诸如此类的事情，你会看到下一个，这个很有趣，你会因为这个而爱上我的，你准备好了，下一个叫做跳过列表，我去滑滑梯，一秒钟内的其他幻灯片，你就像。
哦天啊，我为什么不拿一零六便士，你现在就是这么说的，我知道你在想我能从你脸上看出来，跳过列表是一个排序的链表，但除了有混合指针，它还有这样的快速通道，可以一次跳转多个节点，这种结构的好处是。
如果你在开始，你想达到一定的值，你在找值8之类的，你不必一个一个地走到那里，你可以跳过前面的路，更快地到达那里，如果你做对了，你可以在log n长的运行时间内得到一个对数。
从这个结构中查找内容或添加内容或删除内容，只有真正起作用，如果内容被排序，因为如果它们是随机排列的，然后明确不知道，不管你是否想明白，这就是这里的大意，排序列表表达式，这实际上是如何工作的。
你是怎么得到这些的，这幅画到底应该是什么，这些是节点，伟大的小部分是数据盒，像以前一样，像一英寸的数据，所有这些蓝色的家伙都是下一个指针，嗯，如何让四个下一个指针的节点，一些节点有两个下一个指针，通常。
你要做的是保持指针的向量，所以通常至少有一个向量元素，如果不是两个三个，其中的四个要素，所以这就是我的想法，这个想法很有道理，然后我想告诉你怎么做，它的一些细节在一秒钟内，但这是一般的概念吗，清除。
四七号，哦就在这里，只是碰巧是那些数字，我加了一二三五七八九，我想他们，你知道，我可以加一个四，但这恰好是我放在这里的一组数据，也许另一个问题会像，为什么这个，这么高，为什么这个这么高。
你怎么决定我想说谁有多高，一秒钟后，你可以用不同的方法来决定，但让我们经历一些事情，所以有一件事就是你通常对跳过列表所做的，你的前端实际上是一个节点，上面有毫无意义的数据，它有很多指针。
所以它帮助你穿过这里所有的小链子，这就是你的结构，你存储了某种价值，后面跟着指向nexis的指针向量，或者我们称之为假人的东西，基本上，这意味着你的朋友永远不会是空的，你总是在这里设置一个节点。
但他唯一的目的是让你开始寻找其他节点，所以换句话说，前置数据毫无意义，但是前面的下一个数据还是前面，下一个可能相关的第二个数据，这是实现细节，使编码更容易，那么现在如何在跳过列表中查找内容，没那么难。
如果你真的了解它的结构，记住它是排序的，所以你要做的是，如果你知道你有什么喜欢，这是四个层次，向量元素零到三，你三点开始，你有一些DAT到三个什么的，你看存储在3的指针，你向前看，你看到发生了什么。
你要去做什么，如果你顺着这一点，我将得到一个值为8的节点，也许我在找七个，这么说吧，我不想走这条路，太右了，因为如果是八分，而且排序太远了，七不会在八之后所以不，我不想拿那些选票。
所以我在我的水平上做负负，或者别的什么，所以如果你，如果走右边好的话，你走右边，但如果走右边不好，就像我这里的例子一样，与其把这本书写下来，不如现在把它写下来，我在第二层，我想去右边找七吗。
当然因为一切都结束了，有一个三，所以我走得还不够远，所以我现在就跳过去，我在这里，你从来不上去，你总是走右边，所以我现在在这里，我想走右边吗，如果我再右转，我到了八，太远了，我想找一个七，所以没有。
我下去，所以现在我再看一次，我想走右边吗，哎呦，看七，我找到了，所以你就这样下去了，现在，就在下面，尽你所能，你走右边，如果可以的话，尽你所能地向下，直到你找到它，或者什么，好吧好吧，如果是七。
你会什么，如果我搜索6或10，你有可能找不到它，你怎么知道你没找到，或者它不在那里，你去吧，如果你在底层，就像，我在找一个六，我有点到了我走到这里的地步，下一个是7，我不能再下去了，因为我在底层。
所以我放弃了，我可以停止，剩下的路我都不用走了，他不会在那里，是啊，是啊，如果你到了底层，如果你看到比你要找的东西更大的东西，你就停下来，就是这个想法，这就是如何搜索，好啦，所以我在这里做了一点弯曲。
找到一个7，但是如何将某些内容添加到跳过列表中呢，如果你要加一个6，从概念上讲，它就在那里，对呀，好吧好吧，所以你用同样的搜索模式，找出6的位置，就在下面，就在下面，啊哈6号应该就在这里，在这家伙之后。
在这五个之后，所以你把它加得很好，但事情没那么简单，因为那就太好了，你知道，如果你加上一个高度为1的6，但是其中一些节点应该有更多的级别，我们没有解决这个问题，然而，你怎么知道这个东西应该有几级。
有一种很酷的方式来回答这个问题，你只要抛硬币，你可能会说这听起来像BS不可能，但基本上你所做的，你从一个下一个指针开始，就像这个人，你抛一个五五分的硬币，如果你得到人头，你把它提升到两个层次。
然后你再翻转，如果你的硬币里再出现人头，你把它提升到三个层次，你翻转翻转翻转只是数学上的概率，这意味着在每个级别上大约会消除一半的节点，大约一半，所以你的水平会有一些像这样的小尖刺，就像我的照片上一样。
不完美，但大致上，你可以做一些证明，它基本上是大致的，所以再一次，抛硬币，掷硬币掷硬币，所以当你要添加一个节点时，你所做的就是翻转，翻转来决定它应该有多少个级别，一旦你决定像这个例子有一个级别。
如果它有两个，你得把它绑在两条链子上，如果它有三个，你得把它绑在三条链子上，如果它有四个，你得把它绑在四条链子上，基本上，不管它有多少锁链，你得找个合适的地方，你得把所有的链子都钩进去。
所以它会成为所有合适的，跳过列表中的快速车道，是啊，是啊，假设你看着真实的，您只需要在这一点上添加另一个指针，如果你说真话，真，真，你又翻转了一个真，你只需要让它成为另一个，你得走了，它是一个向量。
所以你可以回到这里，扩展，正在修建一条新的高速公路，只为我，因为我比任何人都高，所以去争取吧，是啊，是啊，所以你用同样的搜索逻辑，如果可以的话，你侧身走，你下去，如果你不能，但如果你到了。
你的人有一个水平，你不能再横冲直撞了，因为没有合理的侧向，你需要把你的指南贴在那里，基本上如果我要去，那是什么，如果你把这六个，基本上你从六级的顶层开始，就在这里，你侧身走，直到你看到，在这个链子里。
一个6在一个3之后应该在哪里，但在8之前，所以你要做的就是把这个指针连接到6的顶部，然后你下去，你继续做同样的过程，我还想在这里加一个6，因为他在7号之前，所以我把这支箭，我把他绑在那边六层楼的第二层。
我下去，我不想把六附加在这里，因为5比他少，所以我向右走，我确实想让他在这之前来，所以基本上你向左或向右向下，往下走往下走，你把它贴在他按正确顺序的地方，一旦你这么做了，你重建了剑。
你已经把快车道上所有不同的线重新贴在你的收藏上了，是啊，是啊，什么事？如果，在这里找到一个6，如果你实际上有一个更均匀的分布，就像一二一四一二一八，当然某些形状，这些高度的某些形状绝对更适合某些搜索。
但既然要保持完美的身材真的很难，在添加、删除和重新排列的空间中，基本上，这种掷硬币的东西在高处洗牌，足够让你渐近地接近，就像，什么是真正好的高度分布，这只是我在幻灯片上的例子。
但你得相信我硬币就像比我聪明的人一样，做了严格的证据证明抛硬币是个好策略，它提供了一个良好的运行时，我得停下来，因为我没时间做你的家庭作业了，你得试试这个，以及其他有趣的事情，别担心那个，就目前而言。
你可以去紧张我的胸部，第一批，祝你学习顺利，明晚见。
【编程抽象方法 cs106x 2017】斯坦福—中英字幕 - P18：Lecture 18 - Arrays - 加加zero - BV1By411h75g
昨晚过得怎么样，嗯嗯，我不会说这是一次艰难的考验，但它让我的头发都掉光了，只是在写，太不可思议了，是啊，是啊，我知道，每次考试我都很投入，如果你的测试里有刮胡子的痕迹，那件事我很抱歉，所以是的。
这个周末我们要给考试打分，只要我能，我会把成绩公之于众，这样你就能看到你做得怎么样，我们将使用这个数字系统，这样你就可以在网上看考试了，看到点，看看你做了什么，诸如此类的事情。
希望我们能尽快把这些信息告诉你，我也会试着给你信息，一旦我可以关于曲线，会有一个曲线吗，分数会有什么调整吗，你知道我需要知道之前的平均值，我可以告诉你，所以只要我能，我去给你拿，应该是这个周末。
可能是星期天，你应该知道我们在哪里找到的，是啊，是啊，我会在电子邮件中给你发一个信息，上面有链接什么的，我会给你发一个去哪里的链接，是的，是的，我对此一无所知，因为我还没评分，不过，我们走着瞧。
如果分数太低，我把它们弄弯，你知道一切都会好起来的，我们会想出办法的，我会在这个周末发布一个答案，以此类推，有一群人给我们发邮件，就像他们试图运行的支持会议，你们收到邮件了吗，他们就像，他们正在开会。
他们想把人们聚集在一起谈论我们的期中考试，或者别的什么他们想问我，如果我想告诉你们这件事什么的，并为他们的事情做广告，我不知道我是不是，我刚收到这封邮件就在我走到这里之前，所以我没有时间真正看它。
但对我来说有点奇怪，嘿伙计们，你讨厌我的考试吗，如果是这样，到这里来，所以我不知道我只想说清楚，就像我和那个事件没有任何联系一样，我刚听说，所以我甚至不知道我是否对此有意见。
但我只想说清楚那不是部门赞助的活动，我想这是我唯一能说的，有任何关于，嗯，但是你看，我猜我想说的是，让我们在喜欢状态之前把分数拿回来，我们对一切的看法，我想很多时候人们做得比他们想象的要好。
也可能是曲线固定，他们对分数的担忧，所以让我们谈一次，我们都知道我们是怎么做的，好啦，所以这就是我要说的，关于期中考试，我也会补充，我很感激你们，我知道这一周很难熬，我知道你们很努力。
我很感激你今天能来，在座的各位，我很感激你的好意，有时考试后的第二天，房间有点空，但感觉我们这里有我们通常的核心人员，很酷，你了解我的，我们继续前进，我们不打算沉湎于过去，我们在向未来前进。
我会在一个小的方面承认网站是错误的，呃，今天我们不讨论二叉树，对不起，对不起，我们要做它在，星期一，我们是，但我只是我不能进入网站去改变它，但我们要谈谈滑梯上的东西，我们要谈谈提高模板，我觉得这也很酷。
所以嗯，反正，是啊，是啊，我们就在那里，作业五就在考试前贴出来了，你得抽时间在下周末之前把它做完，所以去看看。
那是一个以链表和指针为中心的家庭作业，所以嗯，好啦，让我们继续讨论新的东西，稍微谈谈数组。
其中一些来自课本的第十一和第十四章，我们是一个关于实现数据结构的大材料单元的一部分，我们做了链表，现在我想谈谈数组，像向量这样的东西，其中一些其他类型的集合是使用数组实现的，数组没那么难。
你可能已经做了很多，所以我不想在他们身上花很多时间，但我们今天要讲的是，好啦，下面是如何在C Plus中声明数组，另外，你写的类型，然后是要给数组的变量名，然后你写方括号并指出元素的数量，数组的长度。
这与Java的语法不太一样，Java语法看起来更像这个数组名称等于新数组，你把链接，所以这可能对以前做过Java的人来说很熟悉，但是声明数组有两种语法，取决于您希望数组位于堆栈上还是堆上。
我们已经了解了堆栈和堆，对，堆叠内存将在你的函数中，当你的任务完成后，记忆被丢弃，热记忆通常是某个地方的云，它不会在你的功能结束时消失，因此，取决于您需要数组的时间，你得挑一个你想要的。
这是更简单和专家的工作人员，一旦你分配了它，这就是它将永远的大小，第一次初始化数组时，数组的内容是随机垃圾，所以这七个元素都没有设置为零，它们被设置为以前记忆中的任何东西，所以你要注意这一点。
如果你想让它们是零，有办法做到这一点，但不会是零，一开始，此版本在堆上分配数组，两者的行为是一样的，它们都是数组，只是功能完成后这个会留下来，语法的一个小区别是在Java中。
您会说类型括号括号名称等于新类型，在C++中，加上类型指针名称等于新类型，所以这有点有趣，因为C++在这里的作用，它分配的内存，适合这么多这种类型的东西，所以如果一个输入占用了4个字节，你要求一个数组。
它将分配44 x 10字节，它将返回由四个设备组成的块的开始的内存地址，所以它只是存放这十样东西的地址，所以实际上如果你和C程序员交谈，他们认为指针和数组是相同的，或者他们很相似，这就是它的来源。
这是因为数组是内存的砖块，如果你在中断开始时有一个内存地址，你可以去那里把东西放进大块里，所以这就是我的想法，我在这里看到一只手，堆栈指针的类型是什么，从技术上讲，即使它是一个指针，嗯。
我的意思是这种数组相似点就在那里，就像你说家庭作业成绩为零，用这个或者用这个语法，你说的是跟着指针走，然后在它的内存中向前移动零，所以如果你说家庭作业成绩排在第三位，它到家庭作业成绩地址。
它向前移动三倍于一英寸大小才能到达那里，所以这个或这个都是真的，所以技术上来说，如果你只是在没有语法下标的情况下引用家庭作业成绩，严格来说你是，那是恒星的内存地址，从技术上讲，它是一个类型指针。
但是你知道，主要是我想避免对数组使用指针语法，当我不用的时候，那更多的是使用指针，它打算做一个射线的东西更多的是一个C的东西，如果你在做c+加，你就不必经常这样做了，但是我们不要在这里谈论常规的C编程。
如果我们能避免，你可以，你可以在其他课上忍受，改天吧，好啦，嗯是的，是啊，是啊，其他班级，对不起，所以是的，反正，这个就像链接节点一样，所有这些东西，这是一个会泄漏内存的，如果你没有释放它。
在以后的课程中，你必须注意这一点，这种语法的另一个优点是，如果您使数组具有一定的大小，然后您决定现在要一个更大的数组，数组永远不能调整大小，但是你可以做一个更大的数组，比如20个而不是10个。
您可以告诉这个指针指向较大的数组，而不是较小的数组，所以现在你基本上有了一个比以前更大的数组，尽管旧的那个，旧的没有长大，只是你指了一个更大的新的，你知道，这些是声明数组的语法，当然这里的上下文是。
我们要做一个，我们将实现一个基于数组的数据结构，所以我们需要知道如何申报一个，所以这里有一张堆栈和堆之类的快速图片，所以这里有一个函数，我宣布两个，INI声明一个saarray。
我声明一个大小相同的堆数组，所以记忆的模糊画面，你得到了x和y，这是在这里的堆栈上，你有x和y，A也在，当你分配一个2，2实际上只是指向内存中数组的指针，当您完成make数组时，所有这些都消失了。
但这不是，嗯，是的，实际上有一件事，也许我说得不太好，访问元素的语法是相同的吗，所以如果你说一个括号0，这里是42，如果你说一个双括号零，在这里得到支持，所以你不必像刀疤一样说两个括号零。
括号表示跟随此内存地址，跟着这句话暗示的指针走，好啦，这就是数组的语法，在堆栈和堆上，我说过元素是如何垃圾的，当您第一次使用任何一种语法声明数组时，还有另一种语法，您可以在后面加上括号，这就告诉C++。
你想把元素归零，默认情况下，你可能会说，为什么他们不总是把元素归零，原因是C++是一种为速度而构建的语言，如果你不需要把它们清零，然后他们不想花时间走过去把它们归零，归零。
记忆需要n个时间才能在某物的元素中归零，所以他们不想那样做，如果你不需要，其他语言如java和python做出了相反的选择，他们说好，这会导致bug具有垃圾值，所以我们要把所有的东西都归零。
即使它使我们的程序运行得更慢，因为它更安全，那是，您能在静态上使用此语法吗，静止的鳄鱼，我觉得你可以，我们可以在QT创建者中尝试。
我想我最近没有尝试过那种语法，我们要用数组做一个堆栈，这就是我们的节目，但如果我做int括号，插入括号四，然后我算出0是，如果我做一个for循环，对int的权利，我等于零，我不到四岁。
我加加然后让我们看看里面有什么，a i是加上ai之类的，为了说明里面的垃圾，哦，我不得不等待这整个愚蠢的事情，哦天啊，为什么，为什么哦天哪，好吧好吧，我很确定这会打印垃圾值。
真正的问题是我是否能把括号放在那里，我们马上就会知道，但是。
好啦，让我跳回这里，以防有其他事情，我想在这里说一件事，如果你是这样，如果你用括号，然后你打印出来的值将是零而不是橙色，对呀，所以你可以用它，啊，所以有垃圾，我们预计，我看到你的手了，我马上给你打电话。
所以我们认为那是垃圾，只是随机数，基本上在那里，然后如果我。
如果我说括号，它不喜欢那样，所以现在不如，如果我说int指针a等于圆括号中的一个新int，它工作，它打印零，所以是的，我想这只是堆，我不太清楚为什么它不让你这么做，我可以用一个for循环在它们上面循环。
然后把它们都设置为零，后面有人有问题，是啊，是啊，替换不同的圆括号，用一些初始化的东西得到这个空间，哦，我能像94岁一样通过吗，然后他们都设置到94，我不这么认为，你可以做，有一个支架，括号语法。
我想你可以做一个，我觉得你能做到，然后它将值设置为，是呀，我想那应该在幻灯片上，我现在不是真的把那个，其实嗯，如果你在做堆栈，把一个分配到四个，我想你可以用同样的语法，然后就出来了，是啊，是啊。
所以值的括号，你能做到的，我不知道，我不知道为什么，我没有把它包括在幻灯片上，是啊，是啊，错开的气候，如果你让那些括号继续播放，得到一个七，哦所以，如果我就这样走，是呀，也许是这样，让我们试试，哦酷。
我喜欢很酷，今天大家都在学习，包括我很好，谢谢太棒了，是啊，是啊，我是说，我不知道语言句法的每一个角落，你可以做很多奇怪的事情，这种行为有点令人惊讶，有时候无论如何，不管怎样。
加薪有很多可爱的事情可以做，是呀，问题，你能再做一次吗，你能为数组上的每个，就像数组中的int n一样，一个看到和结束，都是这样，我猜，让我们把一些元素放在这里，95负，十七零，四十五。
你得把元素打印出来，是的，是的，所以对于数组上的每个循环，是的，是的，好啦，你能为每个循环，如果是一个，如果是指针，如果是一堆，我认为在星形中a等于新的int，呃，哎呦，它不喜欢，是啊，是啊，它不喜欢。
它在寻找一种叫做带开始的迭代器的东西，然后不管，所以是的，我不经常为数组上的每个循环做。
但关于数组，我要说的一件事是，你知道我们为什么要等这么久，就像课程的第六周结束，我们只是在讨论加薪，你知道我们为什么要等这么久，我想简单的回答是，数组真的吸收了C++，加上我们一直在使用向量。
任何我们想要数组的地方，因为矢量的行为大多是合理的。
就像这里，这里有一个有趣的，看看我是如何有四个元素的，看着看着这个看到一个七结束，那里有什么，哦对不起，它是，还有之前的另一个错误，但是七号元素里的东西，因为在C++中，你可以离开数组的末尾。
你想要的一切都没有问题，嘿嘿，你想看看真正有趣的东西吗，整数x等于五，五个，五个，整数y等于七，七七，让我们打印一张底片，一个，哎呦，是零，嗯，负2呢，有时候，如果你喜欢玩下标之类的东西。
让我们用这些元素做int 4，负2是什么，嘿嘿，五点了，五五，为什么这是负面的，七点了，七七，我们能由此得出什么结论呢？是啊，是啊，但这个的内存地址就在这个的后面，就在那个的后面，如果我去那个地址。
我倒退了一年的记忆，我到了那里，有一个很有趣的虫子，我能浪费两分钟的上课时间吗，可以吗，你们从来不点头，如此猛烈，是呀，浪费两分钟，好啦，看这个，我想这个会有效的，int x=4 int y=5，好啦。
好吧，就这样吧，然后我就停止了功能，对呀，所以现在我有了空栏，我想这行得通，我只是不一致，但我想它会起作用的，然后B然后就没事了，所以我有未初始化的变量，好的，我正在打印，所以它可能是任何值对。
所以如果我做foo条，然后让我们做返回零，所以它不会执行其他代码，会发生什么，哦，它说A是未初始化的，所以实际上问题是，我在我的建筑里设置了一个警告标志，所以它会等待，我把这个锁起来了。
所以它不让我这么做，最快的方法是什么？我可以解决这个问题，首字母，见，我在我们的项目中设置了这个标志，所以你不能这么做，因为我不想让你有这种虫子，但让我们危险地生活，不要对我指手画脚，爸爸。
你不再是我的老板了，我叫阿福，它分配这些变量，它设置它们的值，然后Foo回来了，因此foo的内存将从堆栈中删除，它被扔掉了，但它实际上并没有把任何东西擦洗掉，它只是在某种程度上标志着记忆不再被使用。
里面的碎片还在里面，所以值4离顶部的开始还有一英寸，那个东西什么的，但当我打电话给巴尔巴尔时，巴尔也说，我给自己做一个堆栈区，它使它在同一个地方，以前的食物，它不会清零任何东西。
所以那些碎片里的东西仍然在那些碎片里，而这恰好是它，但它是x和y，所以当我进来的时候，它碰巧设置A和B就像偏移量一样，这就是为什么我以前住在，所以当我打印它们的时候，它能打印出，好啦，所以无论如何。
这不是一种愚蠢的语言吗来吧。
我知道这有点好笑，但是男人，来吧所以好吧，反正，回到任务中，让我们多谈加薪，所以是的，有时您有初始化的值，有时你有垃圾值，你可以小心点，你看，我老了，我受够了这些虫子，我喜欢简单的事情。
所以我有点喜欢清零我的记忆，但也许那只是我，所以嗯，让我们来谈谈我们所做的一些收藏，它们是如何工作的，向量和堆栈，我很久以前就提到过这一点，基本上他们所做的是，他们在里面有一个数组。
它们在数组中有额外的空间，这比你添加的元素的数量还要大，如果你用完了空间，你成长为一个更大的数组，所以这是一个大致的想法，你有一个数组，你在容量中保留一个尺寸，除了客户端实际添加了多少元素之外。
容量是我们总共有多少点可以添加更多的元素，如有必要，呃，关于C++中的数组有一点是，它们实际上并不把它们的尺寸储存在任何地方，所以如果你有一个数组，然后你想问嘿数组，你存储了多少元素。
没有办法回答这个问题，没有点链接或点大小或任何东西，数组没有功能，它们只是记忆，它们只是记忆的碎片，等于元素的大小乘以，元素的数量就是这样，没有办法，没有大小字段，所以你不能问数组的大小。
你实际上必须保留一个变量，不知何故，我记得我看到的尺寸，我最终是，我做了吗，我践踏了你的问题，那是你的尺码吗，是呀，好啦，是呀，你的问题，如果它没有大小，这四个怎么样，哎呦，哦耶，这也是为什么早些时候。
我不想卷入其中，但我试着为下面的每个循环写一个，它在这个数组上工作，但在堆上不起作用，它对这个起作用的原因是，而不是在堆上，因为它可以看着它，看这里有四个，但热的那个只是一个指针，它不知道它指向什么。
它不知道它指向多少元素，所以它无法判断要打印多少个循环，所以是的，这与为什么，它没有让我对每一个循环都这样做，所以，但它能做到这一点的原因是它可以看到。
堆叠的东西，计算出大小，但不管怎样，任何你不能计算出一般尺寸的东西，但这个概念我们称之为未填充，数组位于许多构建在数组上的不同数据结构之下，好啦，所以我想和你们做的是，我想写一个名为数组堆栈的类。
只是快速实现堆栈，使用数组，这并不意味着很难，但我只想玩数组，所以这就是这样做的借口，推弹出偷看是空的，和打印操作员小于，我们将有一个未填充的数组，我们从十号开始，数组的长度为十。
所以如果你来找可爱的造物主，我有一个叫数组堆栈的文件，点CPP和擦除堆栈H，我们一直在学习如何上课什么的，所以我想要一个构造函数和析构函数，我希望这些方法就在这里，我还没有为他们写原型。
所以也许现在我们要存储一叠int，所以也许你可以说void push int然后弹出，弹出顶部元素，然后在峰值中，看顶部的元素，但不把它拿出来，对呀，游泳池是空的，对，然后操作符小于这里，是啊，是啊。
也许我们可以做朋友，朋友，有好处的朋友，你知道那些东西，好啦，那么现在成员变量是什么，嗯，我们需要一个数组，我已经说过了，它将是数组的堆栈样式，或者数组的堆样式，我想这是令人困惑的措辞。
因为我们在做一堆，但是堆栈的数据结构和内存位置之间是有区别的，调用堆栈右，所以我想我要说的是，我应该在这里写10吗，或者我应该在这里写像int star a一样，比如哪个更好，还是有关系，你说在星星上。
我觉得第一个，第一个，摆脱它，会过去的，我没必要把它处理掉，有一个更有效的答案，我想我认为总的来说指针，第二个比较好，你说的都是真的，如果我们这样分配，那么它就不需要那么多的新的和删除，管理记忆之类的。
这绝对是一个有效的评论，但这样做有一个很大的问题，如果我们需要十种以上的元素，这是行不通的，比如如果我们想添加第十一个元素，实际上没有办法用这个做到这一点，变化无常，正确使用我的指针语法的好处。
我们可以从十个开始，如果我们把它们都用完了，我们可以用20个，抄送大家，然后指着那个，现在我们有20个数组，因为这个原因，这基本上是唯一的原因，我想我们需要使用指针语法，如果我们没有问题。
如果我们只需要十个，那么这个语法就更好了，但正因为如此，我认为指针是我们必须使用的，所以我把它叫做元素而不是，我们还需要跟踪数组的大小，我们需要跟踪数组的长度，就像，但这两个术语有点相似。
所以有时我喜欢称之为容量，因为这就是数组的长度，而且尺寸是，他们推了多少次，所以这就是区别，尺寸在任何时候都应小于或等于容量。
对呀，就像在我的照片里，把指针指向这个，最初的大小是什么都没有，但它会随着他们的推动而增长，容量总是。
好啦，所以这些就是我们现在的成员，让我们去CPP文件，我们需要用身体来写所有这些东西，所以cpp文件里面什么都没有，我得把这些换成大括号，对呀，还有什么对不起，慢，就像，像那样像那样，好啦。
这里的语法还有什么需要更改的，是啊，是啊，我需要在所有方法名和所有成员前面，我不得不说数组堆栈，冒号，冒号，对呀，因为我必须告诉编译器这些是一个类的成员，不仅仅是全局函数，所以必须这么做。
在高峰的时候有点讨厌，而且是空的，就像这样，我最终要写这个运算符，我还没有一个方向，所以让我把它复制粘贴到这里，所以让我们从顶部开始，当您构造一个新的数组堆栈时，让我们从构造函数开始。
无论何时你有任何你应该喜欢的构造函数，正确初始化所有私有变量，所以让我们最后做数组，我们先做尺寸和容量，新创建的堆栈的大小是多少，大小是，里面什么都没有，堆栈的容量是多少，我想我们从十个开始。
然后元素数组是什么，组成一个大小为10或容量为10的新int数组的集合是什么，对呀，像这样对吧，好的很好，我们都准备好了，如果你想变酷，像我一样，你可以把小圆括号，把他们清零，我很酷。
这是我唯一酷的地方，我总是把我的记忆归零，是啊，是啊，去吧，哎呦，你得按照你的装饰顺序，但这有关系吗并不重要，我刚把它们移到，因为我想按照那个顺序初始化它们，所以我认为这样做完全没问题，这确实很重要。
因为在记忆中，它真的会把它们按那个顺序排列，但我永远不会在我的代码中以这种方式遍历内存，希望这对我来说并不重要，好啦，所以我得到了我的元素，我有我的尺码，顺便说一句，我得到了我的能力。
我只想指出当你在做Java的时候，人们习惯说，你知道等于零，还是你，你不知道你C加+，你真的不能那样做，你得在这里申报所有东西，你得在另一个地方设置所有的值，这就是为什么我认为即使在Java中。
我们告诉你们声明并初始化你们的成员，在不同的地方，不过，好吧，随便啦，所以现在我们设置了析构函数，这里是当堆栈被扔掉的时候，当它超出范围时，我们得自己收拾，就像一般情况一样，如果你只有普通字段。
如尺寸或容量，你不需要说像删除大小或删除容量，就像int，像那样去清理一下，但是数组自从我说新的并把它放在堆上，那个确实需要清理一下，所以你需要说删除元素，像这样删除数组，我们在这里分配的。
但为了让它更有趣而说话，你得说删除数组元素，删除数组有一个单独的语法，为什么是分开的，因为数组只是指针，所以它很难区分，那是指向一端的指针吗，或者指向一堆移民局的指针，为了区分它们，你说得好。
这是一个数组，然后它去查找一些内部数据，并说，哎呦，我知道有多少字节，那就是，我知道该怎么做，它确实保持了尺寸，有人知道，但不是以一种我们可以告诉我们的方式，我知道，听着伙计，我不是在这里提倡这种语言。
这种语言烂透了，是啊，是啊，有人知道它的尺寸，但他们没告诉你，是啊，是啊，所以无论如何，你得说删除括号括号，好啦，所以现在我们有了，我们在这里建立了簿记，所以现在让我们把元素推到堆栈上，你有一个问题。
是啊，是啊，去吧，为什么你有这个括号应该只是指向，这是语言所期望的，3。我不知道我是否能令人满意地回答你，就像它的内部簿记，对内存管理系统有帮助，要知道这个指针实际上是数组的开始。
与指向int的指针相反，因为int星可以指向，或者它可以指向数组中的第一个int，很难区分这两件事，否则，这里的这个括号说，我在指针中删除这个，它是数组的开始，不仅仅是四个字节，可能会更多。
所以我想这就是为什么它需要知道，我觉得如果你把托架拿掉，很糟糕，我认为记忆中发生的坏事没有得到适当的清理，好的，推推的意思是添加到堆栈中，当然不是一堆。
这真的是一个数组对吧，所以基本上我们需要去一个索引，那是可用的，当我们把东西放进去的时候，就在我的照片里，当我按下这三个，我是这样放进去的，我想这暗示了这里的秩序，对，因为堆栈更垂直。
它有一个顶部和底部，那么底部在哪里，零，顶部是大小或n或任何正确的，所以我想这提出了一个问题，就像我们选择了那个有关系吗还是我们已经做到了，另一种方法是顶部最好是正确的，还是说谈话和笑声一样好。
你对此有什么看法，有人还没有叫它，是啊，是啊，左边的软件，然后你得把一切都推到一切之上，你想添加一些东西，这将是，是啊，是啊，请记住，对于这些操作，堆栈应该是快速的，就像推来推去，是的。
如果你把东西添加到数组的末尾，你可以去做，但是如果你想在开头添加一些东西，你得把每个人都转移到所有的加法上，移除我们要做的是在堆栈的顶部，对呀，那么是什么使这堆东西的顶部，做一个很便宜的地方，东西。
明白就像在这里加一个大O，在这里加上他们进去，你得换班，所以我们不要一开始就加，让我们在末尾加上，让我们加上使顶部成为结束，所以如果你想添加一些东西。
如果你想把东西推到堆栈上，这意味着您希望转到第一个可用的索引并将元素放在那里。
你怎么知道第一个可用的索引是什么，这里有一张照片，我有一些元素，你应该把新推送的项目放在哪个索引处，基本上是大小，是啊，是啊，如果有三个元素，你知道指数是0或2，所以索引数大小是下一个正确的。
所以转到元素括号大小，并将其设置为，我们还需要做什么，是呀，是呀，哦哦，是啊，是啊，这其实是一个很好的观点，如果尺寸至少和容量一样大，那我就没有地方放这个了，就像如果我已经有十个元素在这里。
所以我要写自己，这是一个很好的老式做法，我绝对想解决这个问题，但我想回来，因为这需要一点点修理，所以假设我们在这里，我们有空间。
我们把它放在那里，所以我们继续把第四个元素，在我们的代码中还有什么需要做的吗，我们得增加尺寸，对呀，因为现在我们又多了一件所以尺码加尺码加尺码。
其实呢，如果你想变得很酷，你可以把你的加号放在这里，对呀，但不管怎样，我不会那样做的，我没那么酷，是啊，是啊。
就像容量减去没有容量并不表示有多少可用的插槽，它是插槽总数的指示，不下去，好啦，所以这是向右推，这些都是简单的操作，堆栈快，那是因为操作很简单。
所以推，是吗？现在我们有了，让我们在流行音乐之前做顶峰，所以峰值是看堆栈顶部的元素，对呀，所以我要返回数组中某个元素的值，上面的元素大小减去一的索引是多少，是啊，是啊，那很好。
这里有什么我可能没有想到的情况吗，如果没有任何元素对，比如什么，如果堆栈为空，我们还没有我们还没有写这些空，但我们会再写一次，啊，她是什么，我不知道像，扔一个阿拉伯人，那是个错误案例，对吧。
我们不应该这样做，因为，就像我们几分钟前看到的，从附近的内存中随机抽取垃圾，数组，让我们不要这样就不会抛出一个例外，必要的，我们应该抛出一个异常，所以OK是空的，那只是回报，如果大小为零，对呀。
所以这很容易，好啦，流行所以流行有相同的方面，就像你不应该从空的堆栈里弹出来一样，所以也许我会，哎呀哎呀，我做了什么，也许我会把同样的，如果检查，您可能需要创建一个helper函数，不过，好吧。
所以现在流行音乐和巅峰基本上是一样的，但是我们必须删除元素并正确地返回它，所以我的意思是，基本上你把它从数组中拿出来放在一边，所以你确实喜欢int结果等于元素，支架尺寸减1。
或者你甚至可以说等于峰值大小减去减去，然后返回结果。
我们在这里没有做的一件事是，想象一下，如果我们把他抓回来，所以我们把尺寸缩小到两个，我们可以进来把他干掉。
我们可以说，呃，零。
所以这样做就像，如果我是，如果我突然出现，我把他带到一个叫做卖出和零出局的临时变量里，我把尺寸设为2，然后我把我留在一边的十七个还给你，结果，对，一切都很好，我想指出的是，虽然我们在技术上不需要清零。
这个东西，你知道为什么，如果我把尺寸增加到两个，我就把他们留在那里，就像，4。我怎么能就这样走了呢？我答应过你，我要把这个元素弹出来，但它还在里面，尺寸，是啊，是啊，我是说，我想这里的答案是。
结构的内部是有区别的，和结构的外观图，就像那十七还在那里，但如果他们想，他们拿不到十七个，下一次他们尝试尺寸将是两个，好让我们抓住这家伙，所以从客户的角度来看，十七岁不在那里。
至少不是以他们永远不会看到的方式，如果我有两个元素，我按下它就会超过17，所以如果我推的时候看不到，我咳嗽的时候看不见，它不在客户那里，所以你实际上不需要把它归零，那是一条有趣的皱纹。
如果你真的想把它归零也没关系，只是为了帮你调试什么的，但实际上并不像，如果你真的想为了速度而写这么快，你知道你不会把它归零，这是一种C加+的方式，只留下一些垃圾。
事实上，在程序的一开始，我就把整个数组清零了，我没必要那么做，我可以把这些括号删掉，让这一切都成为垃圾，如果大小为零，我绝不会让你看任何垃圾，所以谁在乎呢，这是一个有趣的皱纹，你知道吗，好吧。
我想我差不多做完了，我还没有找到打印操作员，我们现在就写吧，因为打印操作员与堆栈是最好的朋友，它可以看到内部数组的内部，与任何其他代码不同，它是允许的，或者，与任何客户端代码不同。
我是说它可以看到内部数组，我是说打印东西的模板是，你把花括号，然后你把用逗号分隔的元素，就像我觉得我写了代码，很多时候，它只是一种栅栏柱的东西，基本上你要做的就是说卷曲。
然后在最后的某个地方你会说另一个卷曲，然后你会说出去，那将永远存在，即使它是空的，但是如果传入的堆栈不是空的，然后打印元素，元素就打印出来了，就像用栅栏柱，中间有逗号的，对呀，所以你会做。
然后在后面的每个元素上加上一个逗号，加上元素，你知道我的意思，因为int i等于1，I小于堆栈大小，那里，所以我想现在管用了，如果我在那里开得快一点，我是说基本上这个在外面，然后从1开始。
这样我以前就没有逗号了，第一个是栅栏柱的东西，堆栈点元素的语法是，因为从技术上讲，这个函数在堆栈类之外，所以我指的是堆栈，伸手到他体内，利用他的私有变量，但我用的是外部语法，因为这个函数不在类中。
我向上移动尺寸，这有道理吗，我正在打印出来，这就是这个操作员被调用的输出流，很可能会被淘汰，但也可能是别的什么，所以我只想去测试一下，我已经设置好了测试代码，哦有趣，这个东西采用常量数组堆栈。
它不让我打电话是空的，因为它说你不能调用常量堆栈上的空，所以我们制作了不完全常量正确的代码，你明白吗，就像这个打印操作员，他保证不修改堆栈，所以他说我会让他保持不变，但是当你保证不修改堆栈时。
这意味着您只需要调用堆栈上的常量方法，我们没有任何常量方法，所以它不会让我们调用任何方法，应该引起哪些方法，是的，是空的，不会改变任何事情，峰值也会回来，它查看数据，但它不会改变它，它只是给你价值。
所以这也是常量，推和弹，显然修改堆栈，他们不是骗子，好啦，是呀，现在我想，如果我们编译一个灯泡，呃，我不知道，它走了吗，哦，那里，上面写的是什么，哦，那是因为CPL中的H文件，CPP文件必须匹配。
如果你让其中一个常量，你需要让另一个常量，所以我想在顶峰应该说这里是常量，里面是空的，这里应该写常量，好啦，所以我认为它起作用了，所有这些警告都在客户端代码中，我们之前做的那些蠢事。
所以我在这里真正想做的是，让我把这些东西评论出来，那与我们目前正在做的事情无关，评论出去，这一切，好啦，我真正想做的是，这些东西就在这里吗，所以让我把它拉起来一点浆糊，我听到松懈的信息进来，那里很好。
好啦，所以我应该做的是做一堆东西推一些东西，打印堆栈，所以我推，推，推，推和我打印之间，然后我流行流行流行流行和我打印，所以我只是想测试一下这些方法，好啦，所以让我们试试吧，所以我推。
我得到42个看起来像我添加的元素，然后当我把它们弹开的时候，我得到88然后我得到17，然后我得到负3，然后我得到42，然后它是所以我认为它通常是工作的，所以我是说我不是真的选这个。
就像一件超级超级难实现的事情，但我想向你展示如何实现一个数据结构，它的内部结构是基于，你知道记住如何释放所有的记忆是很重要的，当您使用完堆栈后，我可以打印声明来验证它是这么叫的。
但我想我会节省这样做的时间，所以到目前为止我们所看到的祝福你，你对数组有什么问题吗，或者关于基于数组实现这样的结构，是啊，是啊，所以为了实现，你要达到十个要素，每次加十个会不会更有效。
或者是基于大小的增量，所以一旦你有了五万到十五万，你不必每十次就执行一次，如果它像一个巨大的，是啊，是啊，是啊，是啊，嗯好吧，嗯，让我们谈谈那个，所以他问我们应该增加多少，其实呢，我应该向她道歉。
她让我调整尺寸，我放弃了她的想法大概有20分钟再也没有回来，所以让我们把它修好，如果我们没有空间添加这个东西，让我们做一个更大的数组，并继续使用它，但是如果我们做一个更大的数组。
我们必须获取我们较小数组的内容，我们必须将它们复制到，所以这看起来像这样，在更大的等于一个新的数组，现在呢，这就提出了一个问题，即较大的数组应该有多大，应该有一定的尺寸，那口井比较大，你可以像容量一样。
再加上十个就像它能再容纳十个一样，他说得很好，我可以加50，它的容量可能是1000倍，可能有很多不同的事情对吧，先不说细节，我告诉你这很重要，它是一个倍数，而不仅仅是添加，加五加十，加一百不好。
你想要时间，二或五倍，你想要时间，简而言之，这是因为这确保了你，你越来越不会经常遇到这种情况，如果你在做一个非常大的结构，你必须调整它的大小，每10个元素或每50个元素复制一次。
那么建造一个由两千万个元素组成的结构真的会用所有这些副本杀死你，所以翻倍或三倍，或者类似的东西对你来说更好，去一个更大的，一个更好的大O，不会伤害你的地方，同样多的事情要做，随着时间的推移。
这些首先调整大小，所以到目前为止，最常见的事情是在这样的情况下将大小增加一倍，所以这就是我认为我们应该做的，嗯，所以我会把它清零，我猜，然后我所做的是为了int，我等于零，i小于大小或容量。
他们在这一点上都是一样的，那我说大一点，我等于我的元素，I，您必须这样做，将每个单独的元素复制到，如果你试图做一些像，喜欢将元素内容复制到更大的，你明白那是什么感觉吗，如果我有两个数组。
我想把这个的内容复制到那个里，这个语句只是将指向这个点的指针指向那个点，现在我失去了我更大的数组，我仍然指向较小的数组，感觉很糟，情况不妙，你知道你不想那样做，所以你得一个接一个地复制元素，像这样。
一旦我们完成，我们还有两件事要做，我们现在创建了一个新数组，那个更大，储存的东西和以前一样，实际上我们需要做三件事就是少了三个陈述，告诉我一个声明，我应该补充一点，是啊，是啊，会是，啊，是啊，是啊。
我应该删除旧数组，因为我们不想再用他了，所以那个小的有十个大的，把它扔了吧，我现在要留着那个大的，那我还需要做什么，除此之外，我的元素数组应该指向更大的，从现在开始我要用那个作为元素，是呀，好呀。
我还需要做一件事，我需要说容量乘以2，因为我需要记住我有更多的空间完全正确，我不需要改变尺寸，因为我没有改变我存储了多少元素，这就是调整大小的操作，你可以看到，也许我为什么跳过它。
因为这是代码中最难的部分，所有其他的方法都很简短简单，这就有点棘手了，但这就是我们回到那条路的原因，好啦，是啊，是啊，去吧，但是你想要什么开始你的能力和一个向上调整的力量，很高兴认识你，是啊，是啊。
你可以，我是说，有很多人研究这个，它们就像这些东西的合适尺寸，有一个权衡，就像如果你开始得太大，你浪费空间建造小建筑，我觉得一个处理了一大堆程序的人，发现像很多程序列表一样，平均只有零到三个元素。
或者类似的东西，令人惊讶的是，有很多这样的小名单，所以如果他们都是从一百个或五十个点开始的，或者你是说2的幂，取决于2的幂是多少，你知道我不认为它必须是二的幂，你知道吗，不管我怎么想，这是第二次很重要。
但是从倍数或2的次方开始并不重要，我刚说八点，当然看起来不错，你可以从八个开始，你想做八个，好啦，你的门在这儿，当然我们是很好的程序员，我们很小心没有写数字十，其他地方，对呀，那不是真的吗？在那里吗。
这里还有其他十个吗，没有井，但是没关系，我原谅那个我们不换到86英尺10英寸，就是这样，没有其他十了，嘿元素是红色的，你是田纳西人吗？因为我在计算你的元素，不要紧，你是唯一的十个，原来如此，来吧，来吧。
你们还没听过，呃随便吧，所以说，嗯，这就是这个的核心，好啦，我想尽快再做几件事，这里我想谈谈一个常见的特殊bug。
称为浅拷贝错误，这很微妙，我将很快向你们展示，如果创建一个数组堆栈，就像我在这里做的那样，这是我们写的代码，放点东西进去，您可以创建另一个数组堆栈，你把它设置为第一个，所以等于运算符一般是做什么的。
是把记忆中的东西，把它贴到另一个东西上，所以第一口井的内容会被复制到第二口井里，s的内容是什么，一个大小，一个容量和一个数组，数组被构建为指针，对呀，开始了吗，当我设置这个的时候，它的两端看起来像这样。
真正重要的是，它们都指向同一个数组，为什么它没有复制好，记住指针是什么，写下内存地址和数字，所以它就把这个数字复制到这里，这实际上意味着它们都指向同一个地方，对呀，他们共享一个数组。
所以现在如果我设置S的两点推，它就会把它放进去，它会增加这里的大小，但它会改变这家伙的数组，但他的体型不会，基本上现在真的很糟糕的事情开始发生，因为他们彼此分享记忆，他们是他们是，他们要相撞了。
最具破坏性的是，如果这两个中的一个超出了范围，他要删除数组，另一个人会喜欢，试着继续使用它，然后那里会发生非常糟糕的事情，对呀，所以你看到了吗，这个bug，这是个问题，这就像一个C+的问题。
它在其他语言中也出现过，这叫浅拷贝，肤浅的复制问题，好的，好的，所以这很糟糕，所以如果你想解决这个问题，有几种方法可以做到这一点，一种方法是你可以写一个叫做复制构造函数的东西，它是擦除资产的构造函数。
它接受另一个具有参数的数组，现在在这里，你可以写一些代码，实际上是数组的完整副本，这是一个新的数组，复制了其他人的所有元素，然后你就不会有一个肤浅的副本，您还可以编写一个equals运算符。
所以创建一个堆栈和创建一个堆栈是有区别的，使用另一个堆栈的内容，或者把一堆同理心和内容设置为另一堆，这些都是你需要做的独立的事情来处理，一个堆栈被分配给另一个堆栈的情况，所以在C++中有一个普遍的原理。
叫做三法则，三的规则是，如果您有任何内存要分配给新的，你需要在教练那里清理，那么你可能应该把另外两件事也写下来，以确保你没有一本肤浅的抄本，所以基本上就像如果你需要这三个中的任何一个，你可能需要这三个。
或者你可以做我喜欢做的事，就是说，你知道的，我不想处理这个，所以你可以禁止复制，你可以声明我刚才在幻灯片上的另外两件事，但你可以声明它们是私人的，这意味着任何人都不允许对你的班级做这些事情。
所以就像我的意思，我不知道我是否能在这里很好地演示这个bug，但是如果Main在之后做了另一个堆栈，我做了所有这些事情，如果我做另一个数组堆栈，S 2等于，S一个，我现在有窃丨听丨器了，否则我会有虫子。
所以如果我不想让这一切发生，我可以去数组堆栈点h，我可以说让我们做一个新的构造函数，对于接受对另一个数组堆栈的常量引用的数组堆栈，但我们不要把它放在这里，我们把它放在私密区吧，3。
别人不允许把自己的私事告诉别人，让我们也写，一个运算符等于它将数组堆栈，equals运算符的返回类型是对自己的引用，所以我会把这两个都写在这里，并把它们保密，有什么用呢，如果我没记错的话，哦。
它不叫它的一个，它叫做堆栈，但现在我们将汇编，它会说你不能这么做，你可能会说，好吧，这是相当蹩脚的，但至少我的意思是这比浅薄的抄本要好，因为肤浅的复制虫很乐意向前犁，然后你的程序做了可怕的事情。
所以编译器错误总比可怕的事情好，我认为，是啊，是啊，那么为什么在他们的引用中有不同类型的等式呢，哎呦，为什么是参考，因为你可以把一个相等的语句作为一个更大语句的一部分，它返回等式左边的东西，你指的是谁。
被分配到，那只是运算符的实现细节，是啊，是啊，问题是复制构造函数特殊，或者它只是一个构造函数，它只是一个构造函数，它叫它有点特别，他们称之为复制构造函数，但它有一个特殊名字的唯一原因。
只是它采用与参数相同的类型，除了任何特殊的语法或任何东西，没有比这更好的了，我的意思是，如果你如果你做并删除堆栈二，把调用复制构造函数的圆括号，如果您没有定义复制构造函数，如果你根本没有定义一个，是啊。
是啊，你没有保密，没有那样的东西，然后你试着这么做，不，看看你有没有复制构造函数，就像，等式或类似的东西有某种默认值吗，是啊，是啊，我有时对这些有点困惑，但这两种方法都是有效的让一件事基于另一件事。
这是一种愚蠢的东西，但基本上你不想让别人这么做，如果他们要做指向记忆的指针，他们会与你的记忆发生冲突，所以你不想让客户这么做，我没时间了，但如果你有兴趣，今天的演讲台上还有一些幻灯片。
如果我们想让这个属性能够支持其他类型，除了整数，我们可以做一个叫做模板的东西，但我会停下来继续，星期一，谢谢你陪我度过了艰难的一周。
享受你的周末，回头见，星期一。
【编程抽象方法 cs106x 2017】斯坦福—中英字幕 - P19：Lecture 19 - Graph 1, DFS - 加加zero - BV1By411h75g
我上周不在，我告诉艾米取消所有的讲座，你们上周什么都没学到，对不对，我什么都没学到，好啦，我要教你们一个叫做二叉树的东西，上周我有一个重要的商务会议要去，我开玩笑的，其实呢，我去了夏威夷，是啊，是啊。
我妻子怀孕了，所以就像我们最后一次旅行一样，这只是我们两个喜欢，可能再也不会了，你知道的，原来如此，真的很酷，真的很有趣很浪漫，我本来想给你看一些照片，但我没时间带他们来，我星期三带来。
但整个旅行的亮点是，我们在夏威夷群岛上发现的，有一个猫科动物的庇护所，因为我猜夏威夷有很多猫科动物，因为没有很多掠食者，这个疯狂的猫女就像围捕一样，像一千只猫，就像把它们放在钢笔里一样，你可以去抚摸。
他们所有人和我妻子都喜欢她听说存在的那一刻，她说我们明天就去，所以我们花了一整天的时间抚摸一千只猫，她能回大陆真是奇迹，不管怎样，真的，所以这就是我一直在做的，我知道你们一直在为跳过列表和二叉树而苦恼。
还有各种好玩的东西，本周我们将学习一个叫做图的新集合，我觉得图表很酷，他们是，它们是，到目前为止，我们看到的许多想法，在我们了解到的许多其他结构中，所以你知道我就开门见山了，我猜。
这周末我会给你们布置家庭作业，它将是关于图表的，只是为了跟踪我们的日程安排，让我指出几件事，上周五你们布置了第六份家庭作业，那是现在，你可以看看那个，又是一个短的，你只有一个星期，只有两部分。
但你有一个星期，这个星期五你们要做关于图表的家庭作业，下一周就是感恩节了，我知道给你一个任务有点糟糕，就在感恩节之前，只是想说清楚，我并不特别期望你会在休息时间研究它，我希望你和你的家人玩得开心。
或者你想做的任何事，嗯，到期的任务，就要到期了，感恩节假期后的胜利之夜，所以我没意见，如果你想完全忽略它，直到我们回来，你会在那里呆上三四天，你一度假回来就可以看，那很好，或者你想看这里或者这里。
那很好，也是，由你决定，我们总是有迟到的时候，所以你可以决定如何预算你的时间，休息之后会有第八个也是最后一个任务，这将在最后一个周末到期，以此类推，所以我们装了更多的东西，但这是未来的路线图，好啦。
所以说。
让我们谈谈图表，所以让我打开今天的幻灯片，这来自课本的第十八章，如果你想一起读的话，那么什么是图表呢，嗯，我的意思是你们可能认为一个图就像一个笛卡尔，你知道x y类的图形，那不是计算机科学家所认为的。
当你说图形这个词的时候，计算机科学图是一种数据结构，它包含两个主要组成部分，它包含一组顶点，这些顶点有时被称为节点，它还包含一组顶点之间的连接，他们称之为边，所以当我说一组顶点在一组边中，我的意思是。
就像你知道他们都是不同的，它们在某些方面都是独一无二的，就像从B到C有一条边，所以这是一件独特的事情，有时有些图在b和c之间有多条边，但每一个边缘都有自己的身份什么的，视情况而定，你在看什么书。
或者你在看什么术语，有人称之为顶点和边，那是我见得最多的，这就是我要提到的，一些人称之为节点和弧线，或者其他事情，但不管怎样，就像我有时想的那样，如果你翻阅这本书，您可能会看到节点这个词出现得很多。
但他们说的是顶点，当他们这么说的时候，这里有一个图表的例子，现在我为什么要这样的东西，或者我为什么要关心这个，嗯，这种类型的结构对于建模非常有用，计算机科学中的许多问题。
所以我想我的下一张幻灯片有一些例子，就像，如果你有社交网络，像脸书或推特，你可以让人们或用户，顶点在图中，和朋友或互相追随的人，就像两个顶点之间的边，你可以举个例子，我用了很多像旅行和地图。
就像城市间的航班，你知道，我刚坐上飞机回来，从毛伊岛到旧金山，你知道你可以在这些城市之间画出边缘，那是航班往返的地方，你知道你可以做各种各样的事情，你甚至可以做一些看起来不是很多人想到空间的事情，就像。
我只是说像地图什么的，但这可能是一门课程的先决条件，或者说每个航向都是一个顶点，你很有优势，如果这两个力之间有一个先决条件的关系，或者类似的东西，然后我现在写了家谱，你可能会说等等，家谱不是图表。
那是一棵树，上面写着，这叫做家谱，不是家谱，但是是的，让我来，我会回来的，我是说树和图之间有相似之处，是啊，是啊，所以所有的东西都可以用这个结构建模，我会告诉你，你知道我们要在图表上花一周的时间。
我们将了解他们的许多情况，但我只想告诉你，有一吨的东西，你可以学习图形，你可以花一辈子的时间研究它们，你可以在他们身上获得博士学位，并对他们进行研究，然后呢，一群聪明人，一堆关于图的好算法。
我们将学习其中的一些算法，关于图形的一个很酷的事情是，你开始看到计算机科学中许多想法的普遍性，当你试图解决某个问题时，如果你能想出一种方法把你的问题看作是一个图形问题。
或者将您的数据转换为可以存储为图形的表单，然后你就可以接触到所有这些聪明的人所做的漂亮的图形算法，你可以在你的问题上运行这些算法，然后你就会发现，啊，那是送你去度假的最便宜的航班，或者哦。
那是你二表妹的第四个室友是那个人，或者任何你能做的，你可以凯文·培根和这个人在这部电影里，哦，那个人的熏肉数是四，啊，那是个图形问题，你可以解决所有这些有趣的问题，如果你了解图形，这是个好主意。
不管怎样，这就是我们将要学习的，这就是这里的大局，所以我确实认为，思考一些我们以前已经思考过的事情是很有趣的，以及如何将它们建模为图表，所以我不知道，如果你想逃离一个迷宫，你可以想到像个别的地点。
在迷宫中作为顶点，你可以把这里想象成顶点之间的一条边，如果你被允许从那个地方到另一个地方，所以首先在这些相邻的正方形之间会有一条边，但是从这里到这里，因为有一堵墙挡住了，你不能从这里走到这里。
像这样的事情现在又来了，为什么你要把迷宫想象成一个图表，嗯，因为有很多很好的图算法已经很好地定义了，在维基百科或者你的书里，或者别的什么，在那里你可以说，我在这里，我想去这里，我如何运行这个算法。
我会得到答案，我已经这么做了，那是件好事，你也知道我们谈过拼字游戏，你可以把切换想象成一个图表，你知道看起来不像，就像一个网格，或者二维数组之类的东西，但实际上你可以把它想象成一个图表，就像字母是顶点。
两者之间有一个边缘，如果他们是邻居，如果有一个，如果你的单词搜索可以从这里到这里，或者从这里到这里，但是从这里跳到那里是不可能的，所以再一次，就像你可能在网格中寻找某些路径。
即使它看起来真的不是一个图表，把它看作是一个，好啦，所以让我们来谈谈一些术语，就像我要用术语来刺激你一样，在这里有点快，当你浏览图表时，很多时候你对寻找路径感兴趣，比如我怎么从这里到那里。
路径被形式化地指定为一系列的边或一系列的顶点，如果你喜欢，把你从一个地方带到另一个地方，隐式地表示路径中的每个相邻对之间都有边，如果我想从b到z，我可以去做XZ，或者我可以去WY XE，或任何其他路径。
这些都是有效的，我们有不同长度的不同属性，有多少，它们包含多少个顶点，但它们都是从一个地方到另一个地方的小路，对呀，嗯，这些字母是顶点名，这些小写字母只是边缘的名字，所以我们讨论了路径的长度。
我们还将讨论相邻的顶点，就像你或邻居，或者它们相邻，或者类似的东西，所以很多时候，如果你有一个图表，你说你有一个图形算法，你会为我的每一个邻居说好话的，我想做这个或那个，那就意味着，如果我在这里。
我的每个邻居都会，哎呀哎呀，当它试图动画时发生了什么，坚果，Linux不喜欢它，嗯好吧，所以就有了这样一个概念，即它是否可以到达，一个顶点是否可以从另一个顶点到达，这意味着如果你从一个顶点开始。
有没有什么路径能让你到达另一个顶点，所以我想，在这个例子中，每个顶点都可以从其他顶点到达，因为它们都是由边缘连接在一起的，事实上，如果每个顶点都能到达其他顶点，我们称之为连通图，所以这个是这个没有连接。
因为这三个够不着这两个，反之亦然，一个完整的图就像每个顶点都有一条到其他顶点的边，不是很常见，但有时会发生，这就像如果你有一家航空公司，他们在每对城市之间飞行，他们飞往大多数航空公司不这样做。
所以你知道他们不会有一个完整的图表，对呀，有循环也有循环，基本上，我们的道路回到他们开始的地方，所以一个循环就像你从x开始，你四处移动一段时间，你最终回到X，通常，这里的定义会说不允许重用边。
所以你不能像x w x那样用边缘，E两次，我们可以说一旦你在这条路上用了一条边，你为了那条路已经把它用完了，你知道的，所以有时候你在寻找，这个图有循环吗？一些算法，只处理没有循环的图，或者有些图。
有些算法对图中是否存在循环是特别的，所以我们说的是一个图，循环或无环，它有循环吗，实际上，你可以编写代码，查看一个图，会发现一个图形是循环的还是asic的，你能想出来的，你知道的，和一个循环。
循环是当顶点本身有边的时候，我想你知道，当我做这个讲座的时候，很多学生都喜欢，等等什么，你为什么要那样，我觉得问题是，如果你在想一个空间类比，就像这些是航空公司的航班，那就像一架飞机在旧金山起飞。
然后旋转，在旧金山着陆，那有点蠢，好像你不会，你不会买那班机的机票，除非你真的很喜欢那些椒盐卷饼，或者他们吃了饼干，现在这些都很好，但你可以在贸易商买一包，乔的什么的，存点钱，所以是的，你不会自己飞的。
在那样的模型里，但就像有一些图形的例子，它可能是，能够有自己的优势可能是有意义的，就像有时在一个消息程序上，你可以把自己加为好友，给自己发信息，它允许您出于测试目的这样做，所以这就像是一个自我边缘。
或者类似的东西什么的，有很多例子，你可能允许或不允许，但实际上很多图表都不允许，如果你试图在同一顶点之间添加一条边，它会，它将禁止，好啦，所以这些是循环和循环，让我们来谈谈图的一些变体，一些不同的属性。
图可以有也可以没有，有些图叫做加权图，绘制图形的方法是，当边缘有某种数量或成本或重量时，现在呢，重量意味着什么，嗯，它可能意味着任何事情，这取决于什么数据是正确的，所以在这个例子中，这是一堆机场。
我认为这里的数字应该表示这些城市之间的里程数，我不知道，我不记得我从哪里得到这些涂鸦，所以我不记得这是否准确了，也许有人在这里编造了数字，但是嗯，里程数，从这里到那里要飞多少英里，好吧好吧。
有些图有权重，有些人不是你可以想象的那样，如果你想把事情简单化，你可以把它想象成，如果一个图表没有任何权重，你可以把它想象成他们都有一个重量，但它们都一样重，所以一个人的体重和其他人没有区别。
有些人把它定义为一的重量，或者都是零的重量之类的，但不管怎样，很多时候，但并不总是图表要求权重是非负的，当然如果你想举个例子，像航空公司，你不能飞负英里，除非你喜欢颠倒和奇怪的东西什么的。
也许那里的航班是负英里，我不知道，但像你一样，从一个城市到另一个城市，你必须飞行非负英里数，有些图允许负权，我想不出一个图表的例子，它就会这样，但有些人这样做了，是啊，是啊，我是说这个例子的权重是英里。
你能想到其他，如果是航班，你能想到任何其他东西可能像重量，什么对不起，什么耶，只是货币成本，如果你想买张从这里到那里的机票，也许这趟飞机要花你两百块，也许这次飞行会花你一百块钱。
所以我的意思是我含蓄地认为，你可能会储存重量的原因，你可能在寻找一条低权重的道路，我想要，如果，如果，如果边缘是，呃，货币成本，我要从这里到那里最便宜的机票，对或者如果是里程，也许我想要最低的里程数。
也许有很多关于飞行的东西，就像周围的一切，像这样去迈阿密，但也许这很荒谬，因为我得跳十下或者十下，你知道的，在中间机场停留以到达我想去的地方，也许我不想那么做，取决于重量是多少。
你可能在优化一件事而不是另一件事，你呀，好啦，所以这是一个加权图，到目前为止，关于这些东西有什么问题吗，主要是概念，术语，很简单的东西，对呀，有些图是我们所说的有向图，有向图意味着边只往一个方向走。
所以这里的这幅画，我的意思是，通常我们把它画成小箭头，所以像a一样，边变成b，但它只能这样传播，你想从A到A，那样做并没有什么好处，所以你不能走那条路，但我的意思是，有时你可以做到这一点。
但你只需要走一条不同的路，就像也许你可以去b d c a，你可以得到一个，也许但不是直接穿过树篱，这可能更适用于飞机飞行，也许航班真的只是单向飞行，可能会有航班碰巧两者兼而有之。
或者你可以在有向图中有双向的边，只是我们把它看作是两个不同的边缘，他们都是单向的，你可能两者都有，也可能没有，所以我想我认为这里的类比就像，如果你想考虑不同的图的例子，他们什么时候会被指示。
他们什么时候不被指示，我是说我喜欢Facebook和Twitter的例子，就像如果Facebook是你的图表，当你的朋友，Facebook上的某人，它是对等的，你们两个都是朋友，就在那里没有。
我想他们现在有名人，大家可以关注一下，但这基本上只是复制推特，所以如果你通常有一个朋友，你让你们成为朋友，就像两个方向，但在推特上，你知道我可以跟着斯嘉丽，约翰逊什么的，她似乎不想跟我回去。
这就像我们想要的一个单向图，但它是一个有向图，那个例子是对的，当然，这些东西可以混合匹配，您可以有一个加权有向图或一个未加权有向图，所有这些东西都可以组合使用，对吧，所以我之前提到过。
你可能有一些课程是先决条件，也许前置词被表示为右边的边，所以你有一个零六个A，你有一个零六个b，你在他们之间有边缘什么的，所以我认为这是一个有趣的例子，我想我没有幻灯片，我要等吗，让我看看这个真正的快。
我有斯坦福球场的幻灯片吗，我想我不好，如果你把斯坦福的课程画成一个图表。
让我弹出这个记事本程序。
只是为了让我得到一个白色的背景，所以如果你喜欢，你知道cs1 0 6 a，然后你有像CS，1，0，6，B或X或其他什么，我想很多人都想做的是，他们还好吗，那是个顶点，然后在1 0 6 a之后。
你可以拿一个零六个b，所以他们就像这样抽出来，似乎很简单，就像你走那条路，你拿一个然后你去那里，但我想指出的是，有时方向，有时候你得换个角度想想，你可能想把它储存起来。
就像从一个类指向它所依赖的所有东西一样，现在你可能会说好吧，有什么区别，这真的有关系吗，你为什么要那样，我觉得事情就像，有时上完课，突然间你可以上87节课，现在所有的箭都射了出来，到处都是，这有点乱。
但通常一个给定的类最多有两三个直接预言者，所以这可能会让你的图表更清晰一点，你明白我的意思吗，好像我不知道，我不知道斯坦福到底是怎么回事，但也许在一个，你可以拿一大堆东西，之后呢，喔喔。
就像一只触手怪物，但是嗯，但如果我们能简单点，我们阻止它，离开这里，每当我画得太左，我整个电脑都搞混了，就是这样，我要把这一切都烧掉，好啦，对不起，不管怎样，对不起，有时按另一个顺序做边缘是有意义的。
所以我想我的总体建议是，我看到学生，也许对图形的空间化思考，他们认为图表就像我站在这里，如果我走到那个边缘，我要走过去，否则我就飞过去，这有时完全是图表的意思。
但有时不是这样所以你只想想想顶点到底是什么，到底边缘是什么，为什么我想要边缘，我要怎么处理边缘等等，因为你想从这张图中得到的，想一想，你为什么想要这个图表，我们到底在做什么，我是说这是我编造的。
但就像为什么，为什么我们会有这口井，我可能用它来检查，无论你是否被允许报名上课，我是说我知道斯坦福很奇怪，他们不检查这些东西，你可以报名参加任何，如果你想对，但想象一下，我们在一所关心先决条件的大学。
所以你想报名参加一个零，六b和x，所以如果我在写我的计算机程序，我走到那个顶点，我走得很好，我被允许上这门课还是不好，我可能想走着去所有的先决条件，就像如果有一个数学预科，如果有其他的先决条件。
想去看看那些，看看你是否拿对了，就像我在乎什么，如果在B和X之后，你可以做这四件事，我不在乎，那不是我现在编码的，我不在乎你接下来会拿什么，如果这就是我关心的，也许我真的想翻转图表，所以不管怎样。
这取决于你做对了什么，所以是的，预科和课程有向图形方向。
在那里做事情，对呀，所以好吧，我之前提到过家谱有点像图表，但它当然叫树，那口井是怎么回事？链表和树都是图，它们都被小心地限制着，图的子集，二叉树是有向的图，它是无环的。
因为如果你有一个指向根的指针或一些不正确的东西，你知道你不能指着一棵树，所以它是针对像，有一些其他的限制，就像你可以有一个外在的，我们称之为度，你有多少条边，或者在你的顶点之外。
所以你最多可以有一个向内的程度，有人指着你，你最多可以有两个向外的程度，只有一种方法可以到达每个节点，就像那边那个家伙没有优势一样，或者类似的东西，其他一些小限制，但这基本上就是二叉树，它是一个图。
链表也是一个图，更多的限制，你只能有一个非常接近的程度，所以是的，这些都是专业，把一些东西放在一起，马马虎虎，当然你想的是，哎呦，妈的，妈的，这意味着我还没有完成指针和递归，然而，我是不是，你是对的。
是啊，是啊，图是很多关于图的算法都是递归的，因为你说好，我在一个顶点，所以这样做，然后递归地对我的邻居也这样做，也从那里搜索，很多节点和边是事物之间的指针，所以这些算法看起来有点像树算法。
就像你上周学的那样，和助教一起给客座演讲，所以这很酷，嗯，现在我想给你看，我们斯坦福图书馆有一门课，这是一个你可以使用的图表，我想玩一两分钟，只是想看看它是怎么工作的，那么我只是我想这将表明我们喜欢。
哎呦，你可以用这个解决一些问题，这是一个有用的对象，这周晚些时候我们将学习，喜欢好，它是如何工作的，怎么样怎么样，如何实现图形，你知道，我会先教你怎么用，所以在我们的库中有一个类叫做基本图。
如果你声明一个基本图，你知道你把大多数收藏放在支架上，比如它是什么类型的图形，还是一个，它是字符串的向量吗，或者是哈希，事件集，或者别的什么，有一个基本图，您不必在括号中指定任何类型，因为。
存储的数据类型类似于顶点和边，顶点通常由字符串表示，哪些是它们的名字，边缘也可以有名字，如果你想让他们，所以如果你做一个基本图，它开始时没有任何顶点或边缘，但是你可以添加顶点，然后在你编辑完顶点之后。
你可以在它们之间添加边，它是一个有向加权图，所以如果你给它加一个边，它只是从A指向C，只有一个方向，是啊，是啊，你为什么要把它喝了，啊，我为什么不用指针，这里有一些指针，我一会儿就给你看。
但基本上我认为这家伙的目标是，这样你就可以避免指针，除非你需要他们，我觉得说好更容易，这些都是城市，所以我要做一个叫迈阿密的顶点，然后我想问迈阿密附近的所有城市，与这个恒星变量指针相反，东西。
我有它只是，这有点像，里面有指针，我会告诉你如何走进去看他们，但主要是这家伙在管理，就像我说的加顶点，它进去做一些小指针，把里面的东西给你，你以后可以和它说话，如果你想，所以说，当我们谈论图形时。
看起来不像，任何一个顶点都被认为是彼此不同的，在某种程度上，当我们查看图的示例树时，我们必须称之为左边的顶点之一，其中一个你必须找到合适的，图表上有什么术语吗，我们给连接不同事物的不同边缘贴上标签。
是啊，是啊，是啊，是啊，我稍微重复一下，录像上说你问的是，如果一个图被用来表示一棵树，我如何记住或跟踪，就像，这个是根，这个是左边还是右边，我想说实际上，我不知道，我不打算这样编码。
我不打算用图给树编码，我只想让你看到，从概念上讲，树根据定义是所有图的集合的子集，所以我们可以学到的一些关于图的东西也适用于树，反之亦然，但是是的，就像我认为实际上，如果我们知道我们在处理一个二叉树。
我们应该编写更有针对性的代码，而不是试图写一个brack算法，它恰好运行在一个二进制的东西上，你知道大多数时候，如果我们知道我们在处理一个链表，让我们编写链表代码，但有趣的是，链表是图，例如。
我给你们看这张幻灯片的主要原因是，部分像，哎呦，这里有一些更大的主题，也有一部分像，哎呦，如果有什么，我们证明了这对所有的图都是正确的，然后我们就知道这也适用于所有的二叉树和链接。
或者如果我们想出一些很棒的算法，对图表做一些事情，理论上，该算法应该可以在树或链表上运行，所以它更多的是一个概念理论的观点，无论如何，那是一个基本图表，您可以包括基本图H，下面是基本图的一些方法。
我是说，这是不言自明的，就像你可以添加顶点和边，你可以把它们都移除，你可以要求所有的边缘并在上面循环，我想这返回了一组边缘，你可以要求，给定顶点的邻居是谁，你可以通过这个顶点的边直接到达的顶点是谁。
你可以，还有很多其他的事情，这两个是邻居吗，等等，你可以把图表打印出来，它会打印所有的顶点和东西，嗯，所以就有了，这是你一分钟前谈论指针的另一件事，所以从技术上讲，当你添加一个顶点，当你说顶点，字母C。
从技术上讲，它应该在里面，它使这个叫做顶点的小结构，顶点结构保留了关于顶点的内部信息，如果你想访问那东西，你可以说得到顶点c，所以你传递顶点的名字，然后返回这个指针，这种结构有它的名字。
它还有一组从那里出来的所有向外的边缘，里面还有其他几个成员，所以就像，如果您想将这些顶点作为指针进行对话，您可以，但是当你把它们加起来的时候，您可以使用名称的字符串添加它们，所以说。
但为什么它像一个评估是你为什么，啊，为什么这是哈希集，是啊，是啊，我相信，因为如果你把它做成一套，它根据邻居的名字对它们进行排序，那样，当你为他们每个人，你会让邻居按字母顺序，我觉得图书馆的设计者。
部分是我，部分是埃里克罗伯茨决定，这将是很好的，如果它按abc顺序移动，所以这就是为什么，是啊，是啊，然后你也可以给出一个表示边缘的对象，所以你说，我想把边从a到c，我想得到那个边缘的破坏性信息。
在那里有一个指针指向它开始的顶点，指向顶点的指针以，还有其他一些事情，事实上，我认为有一个，这里有一块田，我也许应该列出，这里有一个双倍的重量，所以如果你想把边缘设置成一个重量。
你可以拿着这个把重量放进去，一点点指针，图表中的内容，我们不会马上使用，但那以后会有用的，好啦，我想问你们一个小问题，我提到过社交网络可以是图表，所以想象一下我有一个满是Twitter的文件，遵循关系。
每行包含两个字符串，两个单词，每个单词代表Twitter上的用户名，所以如果它说名字一名字二意思是名字一跟着名字二，所以我想知道谁是整个档案中最酷的人，我选了一个非常特别的酷的定义，因为我老了。
所以我真的不知道什么是酷了，所以我把酷定义为拥有最多追随者的人，如果你有四个朋友，但那四个朋友有一百个朋友，那么你的冷却等级是100，所以我想看到你是最酷的点，好吧，我想用一个基本的图表来做。
在基本图中，边是无向的，边缘是有方向的，是啊，是啊，所以如果你从a到b加一条边，它只走那条路，还有推特，这应该是推特，Twitter确实有一个定向跟踪模型，如果是脸书，我想要一个双向的。
我不是真的这么说，但是如果你，如果你想要双向边缘，或者喜欢两种方式，你可以添加边缘VC和C，所以这基本上给了你一个双向的优势，基本上。
所以让我们使用基本图，我这里有一个可爱的创作者项目。
嗯，我不知道已经一个星期了，我不知道我是否还记得如何编码E、C、Plus，什么是溪流，是做比特还是字节的，哦不，那是霍夫曼的事，没关系嗯所以是的，我要打开一个文件，我要运行最酷，我要看看谁是最酷的人。
我要把它打印出来，所以我们要写这个最酷的东西，所以你看，困难的部分我来做，我想我需要一个基本的图形命名为图形，好啦，现在什么现在记得，记住这个文件的每一行都是这样的，它有几个名字，斯图尔特跟随马蒂。
海伦跟随埃尔默等，所以记住我想，我想知道谁的追随者最多，也许你能帮我看一下这张图表，什么是顶点，什么是边，好啦，顶点是人，用户，是啊，是啊，好的当然，所以我想我可以做一些，我也有份，所以让我们做弦乐。
说出一个，然后说出两个，当我能够从输入中读取，一个名字和一个要做的名字，你知道你可以用这种语法，当我能从输入中读出两个单词时，那么我想你的意思是，你想让我把这两个人都加到图表里，所以图点顺便加顶点。
我只想指出当你开始像点一样打字时，添加库具有，你可以称之为顶点或，或者你可以叫它安卓，弧线，我不能，埃里克罗伯森，我对如何称呼他意见不一，我很坚决，就像顶点说的埃里克罗伯茨就像显然不，这是一个弧线。
所以我就像，哦，你把你的动物两个两个地带走了吗，无人注意的方舟之类的，反正每个人，所以呃呃不，埃里克比我聪明，比我有更多的权力，所以他得到了他的节点和弧线，但他同意让我也加上一个叫顶点和边的。
所以我要用这些顶点的名字1，呃，别告诉他，我加了这些方法，我就把这段视频给烧了，把这两个顶点，然后你说边缘就像下面的关系，所以你想让我像图形点一样，加边名一名二，名字一跟着名字二，并确保它是。
搜查令什么意思，也许是在我们关心的事情上，谁有最多的追随者或追随者，所以我们希望能够很快地告诉你他们的追随者是谁，所以也许我们想从某人指向他们的追随者，好的，好的，是啊，是啊，所以呃，我想他有所发现。
他说，就像我又想给你画一幅蹩脚的画一样，刀疤乔来了，斯佳丽·约翰逊，然后就像你知道的，我跟着她，也许是假设，我只是喜欢黑寡妇电影，仅此而已，也许我后面跟着RTA，艾米，我不认为她在推特上关注我。
我不够酷，但是，如果我有兴趣了解更多关于Scarjo，她有多少追随者，你知道你可能会说，艾米跟着马蒂，所以这是一个优势，然后马蒂跟着斯卡约，所以这是一个优势，但我真的要看着斯卡乔，试图向跟随她的她学习。
然后是谁跟踪那些人，所以我想你可能是对的，也许我想做的是，也许我想指出谁是Scarjo，然后是，马蒂是谁？尽管这与我们对社交网络的概念不符，我们只是用这个图表来回答这个特殊的问题。
所以也许我应该倒转边缘，实际上你可以这样做，我想我想你是对的，说出两个名字说出一个名字，你知道一个优势，从名字二到名字一，这是刀疤乔给马蒂的，如果这让人困惑，然后你可能想在这里加一个评论。
就像你知道它从一个人到跟随他们的人，或者类似的东西，这就是边缘的作用，或者你甚至可以把它重命名为喜欢后面跟着，或者类似的描述性的东西，好的，好的，所以加上这些顶点和边，我忘了图表是做什么的。
如果那个顶点已经在那里了，你试着再加一次，所以我们会看到一些骗局，比如a跟b，a跟c，所以我不会忘记如果它抛出错误，如果你加上不，让我看看它是做什么的，如果它已经在那里，只是顶点已经存在。
所以把它还回去吧，好吧那就，它只是默默地什么也不做，如果我们尝试添加等待，所以他们为什么要先说出一秒钟的名字，或者喜欢相反的，我只是为了这个才这么做的，所以斯卡约被命名为二号，我是第一个。
所以我只想让边缘往那边走，如果你想，如果我们把它调包，然后，我想它将在一分钟内，当我们写剩下的代码，我觉得从斯卡乔身上看出来，谁跟着她，所以这就是为什么我想我们要这样，好吧，现在在这一点上。
我想我们会让所有的人，我可以看看图表，看看它是否有效，是啊，是啊，我是说，有点难读，但就像这里是所有的顶点，然后像唐纳德一样，唐纳德后面跟着马龙，是真的吗？这一切都随之而来，上面应该写着梅龙，是啊。
是啊，唐老鸭后面跟着我，好啦，我想它起作用了，所以嗯酷，我们现在有一张图表，我们要知道谁的追随者最多，所以这部分就像读，文件成图形，然后就像知道是谁，我想我该怎么做，我知道你只是在学习这个图书馆。
但也许你可以从概念上描述一下我需要做什么，避免了追随者的重复，您可以为每个追随者做，嗯，我明白你明白，你先把图中所有的，为了找到面具，好啦，仔细观察每一个人的想法，我查看每个相邻节点的内部，如果你加上。
如果将每个相邻的相邻节点添加到一个集合中，并且，如果集合的大小大于最大值，它是最大的，最后你没事了，知道了知道了，所以里面有些东西，让我把它打开一点，所以这是一个最大化问题，所以任何最大化问题。
你对每一件事都说，计算出它的价值，如果这是我见过的最多的，那就记住那件事，然后在最后返回最多的，我曾经如此，最大化问题相当简单，但是我如何计算这些人的数字，你也描述了，你说过如果我看着刀疤乔。
也许我会留意她的追随者我也会留意他们的追随者，我想召集所有的人，我不想要复制品，所以也许我把它们都扔在一套里，在我做完这些之后，我看到有多少名字在集合中，告诉我这个人有多少，是啊，是啊。
所以像这样的东西，我觉得，V在图点中得到顶点集，这样它就不会在字符串上循环，顶点名称，它是在这些小指针上循环的吗，如果你想知道顶点的名字，你可以说出名字，这是每个人的名字，或者别的什么。
所以对于每个人来说，我想把所有跟踪那个人的人都查一遍，所以要让跟踪一个人的人，那些是有边缘的，也是，对呀，所以要让那些，有优势的人，你说，图点获取邻居，V那是一群人，然后我想对每个顶点，邻居在那里。
所以现在我循环，邻居是像这样的人，在本例中，就像斯卡乔是V，然后邻居就像马蒂，在这个例子中，现在我想让马蒂的追随者，所以我想再去一次，我想我在这里做的是我想，我想把这个顶点，五，所以也许我要做的是。
我会把一串像这样的东西弄空，然后对于每个邻居，那个邻居有一群追随者，就像图中的每个顶点，找邻居的邻居，对呀，FS点添加名称右，这有道理吗，V是斯卡乔，邻居就是我，任何蠢到跟踪我的人。
然后那个人的名字把他们放在一组，把他们都召集起来，集的大小是您有多少fps，是的问题，你怎么谈论时间，它也许是无穷无尽的大小，哦耶，这是个好问题，就像大O对吧，因为我在努力推销，这都是有联系的。
那么课程中的那个主题呢，我要来了，可能是星期三，我是说你不再谈论N了，他们是大O在图表中仍然很重要，你还在说大O，但你有你的顶点，你有你的优势，所以有时你说这是V的大O，你的脊椎数量。
或者这是v乘以e的大o，因为它不仅与你有多少顶点有关，但是顶点有多少邻居，会显示这个循环会走多远，所以是的，你会在一个像v的图上有一个算法，平方log e，或者类似的东西，所以这两个都有点像结尾。
是大O表达式的一部分，我认为这实际上是一个有趣的例子，因为，嗯，你知道吗，你总是习惯于说大O是后面跟着N的东西，但并不是每个问题都有一个单独的变量，它与，这就是一个很好的例子，嗯，反正。
所以我这里有一些FS，那么fs点的大小就是这个人有多少fs，所以说，我想我想要的是，我想要整数最大值s等于零，字符串酷名称等于空，就像我需要记住，谁是迄今为止我见过的最酷的人？
所以如果off的大小大于max，泡芙，对了，这就是你说的最大化部分，那么最大fs等于fs大小，然后很酷的名字是这个人的名字，是V的名字，对呀，然后当我做完，我再也不用看图表了，我会把酷人的名字还给你。
差不多吧，让我们试试，最酷的人是唐纳德，嗯，我知道推特上有个唐纳德，他有很多追随者，但这不是我的计划，嗯，他很酷吗，我不知道是唐纳德，最酷的，我想我不知道，这个很难查，因为它是追随者的追随者。
所以实际上等等，只有梅龙跟着唐纳德，对呀，等等，是这样吗，没有两个人跌倒，两个人跟着，斯图尔特跟着马龙，马蒂跟着马龙，那么，这难道不意味着，唐纳德有两个FS，是这样吗，这似乎不对，我们搞砸了吗。
一直期待着，这里，我告诉你吧，我可以告诉你什么是印刷好，好吧，让我确定我觉得这是不对的，看出去，FA手柄，所以呢，我要在这里得到一堆类似foy的打印件，是这样吗，我认识马龙，例如，是啊，是啊，马蒂。
上面写着秋天在哪里，我想你不算，邻居不会看到的，我以前做过这个例子，我认为正确的答案是玛拉，因为我以为我喜欢，我总是喜欢让他成为最好的一个，因为他同意我加薪，所以我想每个人都很棒，他有很多很酷的地方。
嗯，我是说他有，他是，但我以为他有三个，我以为数据集会让他自由，我有另一份档案，我还有一些其他的输入文件，如果我看不到，我不知道这是不是错的，但我认为这对吗，让我们来看看有多少美元，是啊，是啊。
我是马蒂，所以马蒂，马蒂，原来如此，所以这是没有欺骗，那又怎样，所以这是斯图尔特追随米隆的一个想法，然后马蒂跟着我，然后呢，好啦，里德跟着斯图尔特怎么样，那小费不是应该，是啊，是啊，所以这应该给。
这个例子的主要目的是，我只是想玩一下这个图书馆，看看你是一个愤世嫉俗的人还是一个实际的人，你可能会说我可以用哈希图或其他东西来解决这个问题，而且是的，当然好，好啦，你可以，但有些问题感觉像图形问题。
一旦你学会了图形，有时候你开始说，哎呦，如果我用图表来表示，我很清楚该怎么做，我去找最近的邻居，废话废话，然后我就完蛋了，就像，它只是工具箱里的另一个工具，这对某些问题很有效，我想这就是其中之一。
但不管怎样，我要继续前进，我认为这看起来像它的工作。
但我想谈谈，我不打算结束这一切，关于寻找路径，我有几件事想谈谈，我想我今天会通过其中一个，我星期三继续，我想再讲一下两种搜索算法，我可能只读到第一本，这叫做深度优先搜索，这里的目标是。
如何在图中找到路径，嗯，这取决于你想做什么，有时候你只想知道，我可以从a地到b地吗，顶点A到顶点B，有时这就是你想要的，他们能联系到吗，其他时候你想要尽可能短的路径，最低跳跃次数是多少。
我认为航空公司的类比很有效，这里，我要直达班机，最短路径，或者你说，我不在乎，如果我必须飞往拉斯维加斯作为中途停留，如果便宜一点的话，我会不停地做那件事，我不愿意付钱，直达航班额外150元。
所以有时你优化重量或成本与路径长度的关系，对呀，所以我认为航空公司是一个很好的例子，所以我想在这个数据中，我不打算看它，但我很确定从迈阿密出发的最短路径，总是与最小成本路径不同。
但因为我认为有一个直接的为什么不，你不可能，如果你先飞到檀香山再飞到旧金山，这是两个跳跃，那是最少的跳跃，但是这比你直接飞到达拉斯要贵得多，然后向右松懈，我想这就是答案，不过，好吧，所以一个算法。
在图中寻找路径的众所周知的算法称为深度，这个想法是你从一个顶点开始，从那里你尽可能深入，看看你能从这里得到什么，如果从这里你能到达目的地，有你的路，所以当我说深，我的意思是你从这里开始然后选择一条路。
你尽你所能，在你放弃尝试另一种方式之前，所以就像看，下面是实际的算法，如果您试图运行dfs，也许这是参数或顶点的函数，顶点二，然后很多这些算法都涉及到将一个顶点标记为被访问，因为你不想陷入一个循环。
你就像回到了你开始的地方，所以标记访问过的顶点，一旦你为每一个未访问的邻居做了这件事，没有标记为访问的，您尝试递归地，从该邻居到目标进行深度优先搜索，如果你找到了目的地，如果没有，你试试下一个邻居。
这看起来像什么，就我们所学到的课程材料而言，这里的代码中有什么样的课程概念，是啊，是啊，这是递归回溯，是呀，因为你对每一个邻居，你选择了那个邻居，你探索，或者你可以从邻居那里得到。
如果它不能让你到达那里，您选择并备份并尝试下一个，完全是递归回溯，我是说你可以在这里看到递归，因为它调用了我的函数，但就像你知道的，寻找一个成功的州的概念，然后如果不成功，尝试另一个。
这在很大程度上是一种回溯算法，在这个算法中你会发现什么，深度优先再搜索，它之所以被称为深度优先搜索，就像你挑了个没人拜访的邻居，我是说，就像回溯，选择一个东西，你探索所有可能跟随这个选择的东西。
你在回来之前探索所有这些并尝试不同的选择对吗，那么这说明了你将要找到的道路，就像，如果你先对这张图进行深度搜索，当我说每一个邻居，假设它按字母顺序发射邻居，你会怎么做，如果从a到f进行搜索。
你应该先试试B，然后你会尝试d，然后你会尝试e，所以如果你先尝试b，那会让你到E，这将使你正确，所以你最终会得到一个B E F，但你不会注意到有一个AE F，算法不会发现。
所以这个算法不能保证找到尽可能短的路径，我要停止，但周三，我将讨论一种不同的算法，称为广度优先搜索，找到最短的路径，从以前的课程材料来看，这也很熟悉。
反正，祝你下午愉快，我们星期三见。
