[音乐]
>> DAVID J. MALAN：好吧，这是CS50。
而这是一个星期。
所以，记得最后一次是在零一周， 我们专注于计算思维。
而我们从转变，要 从无到有，图形化编程
从我们的朋友的语言 在麻省理工学院的媒体实验室。
>> 并与划痕，没有我们探讨 想法一样的功能，和条件，
和循环，和变量，甚至 事件，以及线程，以及更多。
而今天，我们要 继续使用这些想法，
真正带他们 理所当然，但他们翻译
被称为现在C.另一种语言， C是一个更传统的语言。
这是一个较低的水平 语言，如果你愿意。
>> 这纯粹是文字。
所以乍看之下，它的 一切都将看起来相当神秘
如果你从来没有编程。
我们将有 分号和括号，
和大括号，等等。
但是认识到，即使 虽然语法
即将看起来有点陌生 大多数的你，看过去那种。
并尝试看看的想法 这的确都是熟悉的，
因为在这里每周有什么 我们将开始做的是比较，
最初，耐刮与C.
>> 所以，举例来说，回想一下，当我们 实现了第一个我们的节目
最后一次，我们有看起来块 有点像this--时
绿旗点击，然后我们有 一个或多个拼图在它下面，
在这种情况下，就是说，世界你好。
因此，事实上，在划痕， 当我点击了绿色环保标志
运行我的程序，所以 可以说，这些都是
得到执行的块，或运行。
和，特别是，临时 说，你好，世界。
>> 现在，我可以指定 这里不同的话。
但是我们会发现，事实上，许多 这些blocks--确实的，
用C许多functions--可 参数化或定制
做不同的事情。
事实上，在C，如果我们 要转换，现在，
这耐刮划 这个其他语言，
我们将写一 小这样的事情。
>> 当然，有一些陌生 语法有最有可能，INT，
和括号，和无效的。
但是，尽管你甚至会printf-- 认为这将只是打印。
但是打印表示打印 格式化，因为我们很快就会看到。
这从字面上将打印 到屏幕上的任何
是那些括号内，这 当然，在这种情况下，世界你好。
>> 但你会发现一些其他的 语法，一些双引号，
，在结束括号， 分号等。
因此，有一点开销， 可以这么说，无论是认知
和语法，我们要去 有不久记住。
但要意识到联系实际， 这将开始在你跳出来。
>> 事实上，让我们专注于一个 功能specifically--在这种情况下，
打招呼的世界。
所以说是功能。
你好世界是它的参数， 或参数，它的定制。
>> 而在C中的等价只是 要在这里成为这一行，
在这里的printf相当于，说， 双引号字符串，你好
世界是等效的，当然， 什么是在白框那里。
和反斜线N，虽然有点 奇怪的并从头缺席，
简单地说就是将有我们的影响 看到一台电脑，像我的Mac或PC，
只是移动 光标移到下一行。
这就像打 键盘上的Enter。
>> 因此，我们将不久再次看到这一点。
但首先，让我们来看看这个 在循环的情况下，其他的例子。
我们有这样永远循环最后一次， 这是一系列的拼图
那做了字面上 forever--在这种情况下，
说，你好世界，你好世界， 世界你好，你好世界。
所以这是设计一个无限循环。
>> 在C中，如果我们想实现这个 同样的想法，我们可以简单地做到这一点。
虽然如此，printf的招呼现在天下 - 同时，刚刚语义，那种
联想到做的念头 重复的事情，又一次，又一次，
多长时间？
那么，true--回忆一下， 真正是刚上或1。
>> 而真正的，当然，总是如此。
所以这是一种毫无意义的 声明只是说真的。
但事实上，这是故意的， 因为如果真的仅仅是总是正确的，
而不是真正的就是意味着， 如果有点间接的，
那下面的代码行 在这些大括号
应该只是又一次，又一次执行， 又一次，从来没有真正停止。
>> 但是，如果你希望你的 循环停止，因为我们
跟上次喜欢的东西 这种重复以下50次，
用C我们可以做什么是相同的 被称为为loop--关键字
不是一阵子，而是。
然后，我们有一些新的语法在这里， 使用int i等于0，我不到50，
我++。
我们会回来这一点。
但是，这仅仅是我们如何会 翻译组划痕块
一组的码C的行。
>> 同时，考虑的变量。
而且，事实上，我们只是 看见一个人刚才。
并且在暂存的情况下，如果我们 要声明一个叫做变量i
因为我是整数，只是一个数字， 我们希望将它设置为某个值，
我们将使用这个橙色 阻断这里 - 我设置为0。
>> 而我们今天将看到和 超越，就像上周，
程序员做几乎总是 从零开始计数，真
按照惯例。
但也因为召回 我们的二元讨论，
最小的号码，你可以 用任何数目的位表示
只是将是0本身。
所以，我们通常会开始 即使初始化我们的变量为0。
>> 而在C ++做的一样， 我们会说INT
为整数，我只是按照惯例。
我可以叫这个变量 任何我想要的，就像在刮。
然后等于0只是受让人 从右侧的值0
并将其放入变量，或 储存容器有，在左侧。
和分号，我们会see--和 我们已经看到了一些这些already--的
只是意味着思想的终结。
继续做别的事情 在接下来的线。
>> 现在，关于布尔表达式？
回想一下，在刮， 这些人表情
那些是真 或false--问题，
真的，要么是真还是假。
因此，在划痕的情况下，我们可能 问一个简单的问题，这样，
为i小于50？
所以我，再次是整数。
也许我们正在使用它 在临时计划
保持比分的轨道 或类似的东西。
所以这个语法在这里划痕 只是手段，是我不到50？
好了，幸运的是，事情是 简单的C。和翻译，
这一点，我们就简单的说我少 50，使用熟悉的关键
键盘上。
>> 同时，如果你想 说一些比较一般，
像，很好，比y这里每个x少 x和y的本身变量？
我们可以做同样的事情 在C，只要我们已经
创建这些变量了。
我们将看到如何 这样做不久。
我们就简单的说比Y X更少。
>> 所以，你开始 看到一些相似之处。
和谁做那些人 从无到有是肯定
通过其中的一些基本思想的启发。
你会看到这样的 语法在很多languages​​--
不只是划伤， 只是C，但是Python，
和JavaScript，以及 其他语言依旧。
>> 让我们考虑另一种结构 从C，条件的概念，
做一些有条件。
如果事情是真的，做到这一点。
如果别的东西是真实的，做到这一点。
这有点编程的 在一个岔路口的等价物。
也许这是一个叉双向的， 三通叉，或更多。
而在划痕，我们可能有 看到这样的事情。
>> 所以这一块是一个大的。
但考虑到相对 逻辑简单性。
如果x小于y，然后说x是少 比Y，否则如果x大于y，
然后说x是大于y。
然后，在逻辑上，如果， 回想一下划痕
或者只是你自己的人的直觉， 好吧，如果x不大于y，并且x
不除Y更小，则当然 x被将是等于y。
因此，在这种情况下，通过嵌套 这些划痕块，
我们可以实现一个三 在行进的方式叉？
>> 同时，如果我们想 这样做，在C，它可以说是
看起来至少有一点simpler-- 一旦你熟悉的语法。
如果x小于y， printf的x是小于y。
否则如果x大于y， printf的x是大于y。
其他的printf x等于y--和， 再次，与那些反斜杠只
对于这些新的生产线，这样，如果你 居然跑这种方案
它只是移动 光标最终
到屏幕的下一行。
>> 现在，同时有划痕等 更复杂的功能，只
其中有些我们要 最初移动到C的世界
其中之一是 称为划痕列表。
这是一个特殊的 变量的类型
允许你存储多个事 在回来，背，背，背。
>> 在C中，它不具有 名单，本身的事，但
是更一般 所谓的阵列，虽然我们
回来以后这个学期 要寻找的东西
所谓的名单，还是真的链表。
但现在，最接近 相当于C语言为我们
会是什么 称为阵列。
和阵列是一个简单的 特殊类型的可变的
这允许你存储数据 背，背，背，背到。
>> 而且，事实上，在划痕， 如果我们想访问
数组的第一元素或 一个列表中 - 我要去称呼它，
按照惯例，argv的，说法 矢量，但不久还有更多。
如果我想要得到的第一个元素 ARGV的，在刮的世界
你实际上做一般 从1开始计数。
>> 所以，我可能会得到argv的第1项。
这是麻省理工学院的只是如何实现的 列表的概念。
但在C，我要去 更简单地只是说，ARGV，
这又是对我的名字 列表中 - 或者是明确的，一个数组。
如果我想第一 元素，我要去
用方括号，你 可能不会经常键盘下使用。
>> 但是，0只是意味着，拿到我的第一。
等等场合和 久而久之，我们要去
开始看到这些二分法 划痕和C之间，
即刮使用一个。
我们用C在这里使用0。
但你会很快看到 一旦你理解
每种语言的基础，即 这些事情开始变得更加
熟悉通过实践和实践。
>> 因此，让我们实际上是在一个程序现在看起来。
这里应是第一个我们的C 完整程序的源代码。
而该计划，我们要去 提供审议
就是这相当于一个 那个早期的刮片。
>> 所以在这里，我们有什么 可以说是最简单的C程序
你可以写 实际上做什么。
现在，我们来看看过去， 现在，已经包括，
标准io.h，而这些角度 括号和int和无效的，
及大括号，和类似物。
>> 而我们只专注于 什么，至少直觉，
可能会对你已经跳出。
事实上，主要的，我不知道 一定知道这是什么，
但就像刮了，当 绿旗点击拼图，
这样做C作为编程语言 有一个主一段代码，
被默认执行。而且，事实上， 它字面上将被称为主。
>> 所以主要是一个函数。
而且它是一个真实存在的特殊功能 用C，当你运行一个程序，
它是由被主运行 默认。在划痕的世界里，
它通常是，当绿旗 点击的得到了默认情况下运行。
>> 同时，我们已经见过这个， printf的或打印的格式，这是
也会有一些自带的功能 C，伴随着一大堆别人的，
从时间和时间的意愿 再次，为了准确地做
正如它的名字所暗示的，打印的东西。
我们究竟要打印？
好吧，我们会看到， 由封闭字符
像these--世界你好， 反斜杠n的双引号，
我们可以告诉准确的printf 什么要打印在屏幕上。
>> 但为了做 这一点，我们很遗憾
需要采取的东西是 已经隐晦了我们人类，
但至少它有点readable-- 犀利包括标准io.h，INT，
主要的，无效的printf，所有的神奇 咒语刚才我们看到在屏幕上。
但是实际上我们要 走得更神秘依旧。
我们首先需要翻译的代码 我们编写成机器代码。
而从上周回顾机， 至少那些我们知道这里，
在一天结束的时候只 了解零和一。
>> 我的上帝，如果我们写这些 零和的实际计划，
它会非常快 采取乐趣的事情。
但事实证明，每上周， 该零和一的这些模式
只是有特殊的意义。
在某些情况下， 他们可能意味着数。
>> 在某些情况下，它们可能意味着 字母或颜色，或任何数目的
其他抽象存在于。
但是，就像你的电脑有 一个CPU，中央处理单元，
或您的计算机内的大脑。
它通常是英特尔 在里面，因为这是
最大的公司之一 这使得CPU的电脑。
>> 那么，英特尔的CPU及其他 只需提前决定
该零点的某些模式和 那些指具体的事情。
零和一的某种模式 将意味着，打印此屏幕，
或加这两个数字，或 减去这两个数字，
或将这块数据从 我的电脑的记忆在这里，
或任何数量的其他非常低的水平， 但最终有用的，运营。
不过，值得庆幸的是，我们人类都不会 需要知道这些细节。
事实上，和上次一样，我们在那里 又一次，又一次，又一次抽象，
从很低水平建设 基元像零和一
更高层次的概念 像数字和字母，
和颜色，以及多， 所以我们可以为程序员
站在肩上 别人在我们面前谁也来了
和使用的软件，其他 人前us--采写
即所谓的程序编译器。
>> C是一种语言， 通常编译，
这意味着从转换 源代码的机器代码。
特别是，这意味着什么 是，如果你有你的源代码
代码，您自己写，因为我们很快 将在刚刚在屏幕上的时刻，
并且希望将其转换 最终以机器代码 -
这些零和那些 只有你的Mac或PC机
understands--你已经有了一个第一 养活源代码作为
输入到一个特 程序调用一个编译器，
输出其中我们 应当看到的是机器代码。
而且，事实上，上次我们聊 一下，果然，在一天结束的时候，
解决问题。
你有投入。
和你有输出。
和你有某种 在中间算法。
>> 算法可以肯定是 在软件中实现，
正如我们所看到上周伪 当我们将与实际的代码看
本星期。
所以编译器真的只是 有一组算法内
它知道如何 转换成特殊的关键字，
像主，和printf， 和其他人，我们只是
只见到零的模式和 那些Intel Inside和其他CPU
其实理解。
那么，如何才能做到这一点？
我们在哪里可以得到一个编译器？
>> 我们中的大多数在这里有一台Mac或PC。
而你运行Mac OS，或 Windows或Linux或Solaris，
或任何数量的其他 操作系统。
而且，事实上，我们可以 走出去到网上
并下载一个编译器 为您的Mac或PC机
为您的特定的操作系统。
但是，我们都将是上 不同的页面，可以这么说。
我们会略有 不同的配置。
而事情是行不通的都是一样的。
而且，事实上，这些天 我们很多人不使用
仅运行在我们的笔记本电脑的软件。
相反，我们使用的东西 像的浏览器
允许我们访问基于Web的 在云应用。
后来这个学期， 我们将这样做。
我们将编写应用程序或 使用代码 - 软件不是C，
但其他语言如Python和 JavaScript--在云中运行。
>> 要做到这一点，我们自己 在本学期
将实际使用基于云计算的 环境被称为CS50 IDE。
这是一个基于网络的编程 环境，或集成开发
环境，IDE，它内建一些之上 所谓云9开源软件。
我们已经取得了一定的教学 简化到它
从而隐藏某些功能 我们并不需要在第一周，
之后就可以 揭示他们做最
任何你想要的环境。
>> 它让我们也一样，要 预安装某些软件。
比如像所谓的CS50 图书馆，我们很快就会看到
为我们提供了用C与一些 附加功能。
所以，如果你去，最终CS50.io， 你会被提​​示登录，
一旦你这样做，并创建 一个是免费的账号，
你将能够访问 环境看起来很喜欢这一点。
>> 现在，这是默认模式。
一切都是好的， 明亮的屏幕上。
我们很多人都习惯 工作CS50一块是
挺到深夜。
所以，有些人可能更喜欢 把它变成夜间模式，可以这么说。
>> 但是，最终，你在做什么 要CS50 IDE中看到
是三个不同的areas-- 在离开的地方面积
您的文件将要在 云，在右上方的区域
在您的代码将是编辑。
您可以打开 对于任何程序各个选项卡
你写的里面这学期 最重要的是右上角。
然后最arcanely， 然而有力，
将是这个东西在 底部被称​​为一个终端窗口。
>> 这是一个老同学 命令行界面，
或CLI，允许 你执行命令
在这种情况下，computer--， 在cloud--电脑
做事喜欢编译代码 从源代码到机器码，
运行您的程序，或者启动 Web服务器或访问数据库，
和任意数量的其他技术 我们将开始不久使用。
但到那里，我们 去居然有
到网上去，并开始播放。
要做到这一点，让我们先 开始摆弄为主，
写一个程序的主要部分。
让我们使用这个函数 printf的，这是我们前面使用，
简单地说几句。
>> 所以我在这里已经CS50 IDE里面。
我登录的进步。
我完全屏蔽的窗口。
所以，最终，你 过在未来的问题
将遵循类似步骤 将提供在线文档。
所以你不必担心 每吸收一点技术一步
我今天在这里做。
>> 但你会得到这样的画面。
我碰巧在夜间模式。
你可以照亮一切 同比禁用夜间模式。
而在底了 一天，你会看到
这三个主要areas--文件 在浏览器的左边，代码标签向上顶，
和在底部的终端窗口。
>> 让我继续前进， 写我的第一个程序。
我要抢先去文件， 保存，我的文件保存为hello.c的。
事实上，按照惯例，任何程序我们 写是写C语言
名称应该 C点，按照约定。
所以，我打算将其命名为hello.c的，因为 我只是想打个招呼世界。
现在，我要放大 并点击保存。
和所有我现在这里是一个标签 在我可以开始编写代码。
>> 这不会编译。
这意味着什么。
所以，即使我转换 这对零和一，
在CPU将不得不无 知道发生了什么绕来绕去。
但是，如果我写的线条那些匹配 就以C的conventions-- C是，
再次，这language--语法像 对此，printf的招呼天下 - 我已经
得到舒服 这样随着时间的推移。
所以，我不认为我做了 任何印刷错误。
>> 但是，不约而同地，第一个 你这样做的时候，你会的。
什么我将做很可能会 也不会为你工作的第一次。
而这完全确定， 因为现在你
可能只是看到一大堆新奇的， 但随着时间的推移，一旦你熟悉
与此环境下，并 这种语言，等人，
你会开始看到的东西， 要么是正确或不正确。
>> 这是什么 教学研究员，当然
助理在得到随着时间的推移这么好，是 察觉你的代码错误或错误。
但我要求有 在这段代码中没有错误。
所以，我现在要运行这个程序。
>> 现在我自己的Mac或PC，我在 中双击图标的习惯
当我要运行一些程序。
但是，这不是模型在这里。
在这样的环境中，这是CS50的IDE。
我们使用的操作系统 系统称为Linux。
Linux是让人联想到另一 操作系统，通常已知
作为Unix的。
而Linux是特别出名 有一个命令行环境，CLI。
现在，我们使用一个特定的 Linux的味道叫做Ubuntu Linux系统。
和Ubuntu是一个简单的 某些版本的Linux。
>> 但是这些的Linux的这些天真正做到 配备了图形用户界面。
和一个我们碰巧 在这里使用是基于Web的。
因此，这可能看起来甚至 从东西有点不同
你自己可能有 看到或跑过去。
>> 所以我要继续前进 现在做到以下几点。
我已经保存此文件的hello.c。
我要继续前进， 类型clanghello.c所以锵
对于C语言编译器。
这是预安装在CS50 IDE。
你完全可以下载 在自己的Mac或PC上安装它。
>> 但是，同样，你不会有所有的 为您预先配置完成。
所以现在，我只是 要运行clanghello.c。
而现在注意到这一点语法 这里最终将
认识只是意味着我在 文件夹或目录被称为工作区。
这个美元符号仅仅是惯例 为内涵，在这里输入你的命令。
>> 这就是被称为一个提示，只是 按照惯例是美元符号。
如果我继续前进，现在并点击 回车后，似乎没有任何已经发生。
但是，这实际上是一件好事。
出现这种情况就少 您的屏幕，越有可能
你的代码是正确， 至少语法。
>> 所以，如果我想运行此 程序，我该怎么办？
嗯，事实证明， 按照惯例默认名称
对于程序时，您不指定 名称为您的计划仅仅是为a.out。
而这也是语法，你会 熟悉不久。
>> 点斜线只是意味着，哎，CS50 IDE，运行一个名为a.out的程序
这是我的当前目录里。
这点是指当前目录。
我们会看到什么其他的这些序列 人物不久手段。
>> 所以在这里我们去，回车，世界你好。
你会发现，发生了什么？
它不仅打印的hello world。
它也感动 光标移到下一行。
>> 以及为什么呢？
那是什么，我们以前写的代码 即确保该光标将
继续下一行？
大约一个有趣的事情 计算机是它一定会
做字面上你告诉它做。
>> 所以，如果你告诉它给printf你好， 逗号，空间，世界，接近报价，
它字面上只打算 打印这些字符。
但我有这个特殊字符 在年底，召回，反斜线ñ。
而这正是保证 该字符去
到屏幕的下一行。
>> 事实上，让我去做到这一点。
让我继续前进，删除。
现在，请注意 我的屏幕上方有
一个小红灯 标签显示，
哎，你不保存文件。
所以，我要与控制继续前进 S或命令S，保存文件。
现在goes--去了moment--绿色。
而现在又回到了 只是作为一个关闭图标。
>> 如果我现在再次运行clanghello.c， 进入，点斜线，a.out的，回车，
你会看到，它仍然工作。
但它可以说是一个小马车。
现在，我的工作区prompt--， 然后是美元符号，
然后我的实际prompt-- 是所有在同一行上。
所以这肯定是一个错误的审美， 即使它不是一个真正的逻辑错误。
>> 所以，我要撤销我只是做了。
我要重新运行的a.out。
请注意，我已经添加了 换行符回来。
我保存的文件。
>> 所以，我要的a.out重新运行，还有 - 该死，一个bug，错误的意思的错误。
因此，错误是，即使 我加了反斜线Ñ那里，
重新保存，重新运行该程序， 的行为是相同的。
为什么会是这样？
>> 我缺少的一个步骤，对不对？
这关键的一步早前是你有 当你改变你的源代码中场休息，
事实证明也办 它通过编译
再次让你获得新的机器代码。
和机器代码， 在零和一，
将要几乎相同，但 不完全是这样，因为我们需要的，
当然，新的线路。
>> 因此，要解决这个问题，我会需要 重新运行clanghello.c，输入，点
斜线，a.out的。
而现在，世界您好又回来了 在那里我希望它是。
因此，这是一切优秀和良好。
但a.out的是一个相当愚蠢的名字 方案，即使它正好是，
由于历史的原因， default--意思装配输出。
>> 但让我继续在这里 而不同的做到这一点。
我希望我的Hello World程序 实际上叫你好。
所以，如果它是一个图标我 台式机，它不会被A.OUT。
它会被称为打招呼。
>> 因此，要做到这一点，事实证明 那铛，像许多节目，
支持命令行参数， 或标志，或开关
它只是影响其行为。
具体来说，锵支持破折号Ø 标志，然后拿着第二个字。
在这种情况下，我会随意， 但合理的，把它打个招呼。
但我可以把它叫做什么 我想，除了a.out的，这
会相当除了点。
>> 然后只需指定名称 文件我确实想编译。
所以，现在即使在开始 命令我仍然有铛的，
在命令结束时 我仍然有文件名，
我现在有这些命令行 参数，这些标志是在说，
哦，对了，输出-O，文件 名为hello，而不是默认的a.out。
>> 所以，现在如果我打回车键，没什么 似乎已经发生了。
而且，然而，现在我可以做点斜线打招呼。
所以这是相同的程序。
在零和一的 相同在一天结束。
>> 但是他们两个 不同files--的a.out，
这是第一个版本 和公正的愚蠢命名，
现在你好，这是一个非常 更引人注目的名字的程序。
但是，说实话，我从来没有 又要记住这一点，
又一次，又一次。
而且，事实上，正如我们写 更复杂的程序，
你的命令 不得不写
要报复 更复杂的仍。
>> 所以不用担心。
事实证明，人类前 我们已经意识到，他们也
有这个相同的问题。
他们也没有享受不必 键入相当长的，神秘的命令，
更不用说记住他们。
所以，摆在我们面前的人类已经取得 其他程序，可以更容易
编译软件。
>> 而且，事实上，这样的一个 计划被称为制作。
所以我要继续前进，并做到这一点。
我要撤销我的一切 正好在下面的方式一样。
让我LS型。
你会注意到三个things-- a.out的，和一个明星，你好
和一个明星，而hello.c中。
但愿，这应该 有一点直观，
只要前面有 没有在此工作空间。
没有什么，我有 创建，直到我们开始上课。
>> 和我创建的hello.c。
然后我编译它，并把它称为a.out的。
然后我再编译稍微 不同，称之为打招呼。
所以我有这个目录中的三个文件， 在这个文件夹叫工作空间。
现在，我可以看到，以及 如果我缩小实际。
>> 如果我缩小这里 看那个右上角
角落里，如许左 屏幕的右侧
总是会告诉你 什么是在您的帐户，有什么
里面CS50的IDE。
而且有三个文件存在。
>> 所以，我想摆脱的a.out和打招呼。
正如你可能 想象直观，你
可以控制排序点击 或右键点击这个。
而这个小菜单弹出。
您也可以下载文件，运行 它，预览，刷新，重命名，
或什么不是。
>> 而且我可能只是删除， 它会消失。
但是让我们做的事情有一个命令 行了，这样才能让自己舒服
这一点，并做到以下几点。
我要继续前进，并删除 通过键入字面上rma.out的a.out。
原来，该命令 去除或删除的东西，
是不是删除或删除。
>> 这是更简洁RM，只是为了节省 你一些按键，并按下回车键。
现在，我们要有点 神秘地删除常规文件的a.out。
我真的不知道是什么的 不规​​则的文件会呢。
但我要删除它。
>> 所以，我要键入Y（是）。
或者，我可以键入它，然后按Enter键。
并再次，好像没有什么改变。
但是，这是一般，是一件好事。
>> 如果我输入ls这一次， 我应该怎么看？
我们希望，只是打招呼，hello.c中。
现在，顺便说一句，你会 注意到这一点明星，星号，
这是在我的节目的结束。
而且他们也显示为绿色。
这仅仅是CS50 IDE的方式 cluing你到事实的
那这不是源代码。
这是一个可执行文件，可运行 你可以实际运行的程序
通过做点斜杠，然后它的名字。
>> 现在，让我继续和删除 对此，RM你好，回车，定期删除
文件你好，是的。
现在，如果我输入LS， 我们又回到hello.c中。
尽量不要删除 实际的源代码。
即使有特点 内置IDE CS50在哪里
你可以通过你的修订历史记录 并及时退，如果你不小心
删除一些东西，做铭记 按照这些提示是或否，
什么你真正想做的事情。
如果我去到顶部 这里左手角落，
剩下的工作就是hello.c中。
因此，有一束束 其他命令你
可在Linux世界执行， 其中之一是，再次进行。
而我们要制作 我现在的程序如下。
>> 而不是做铛的， 而不是做铛-O，
我要简单地 从字面上类型，制造打招呼。
而现在发现，我 不打字做的hello.c。
我打字做打招呼。
>> 而这个节目的制作 自带CS50 IDE，以及更多
一般的Linux， 是一个程序，是
要做一个名为Hello程序。
而且它要承担，按照惯例， 如果可以进行该程序，
它会从一个源发 代码文件中C点结束，hello.c中。
>> 所以，现在如果我打回车，通知， 这被执行的命令
实际上甚至更长 前比以前。
那是因为我们已经 预配置CS50 IDE有
建于一些额外的功能 我们并不需要，只是还没有，但很快会。
但关键的事情来实现 现在我有一个Hello程序。
>> 如果我再次键入LS，我 有一个hello程序。
而且我可以运行它 点斜线a.out的，不，
因为这个整点 演习点斜线打招呼。
现在，我有我的Hello World程序。
所以向前走， 我们几乎永远只是
要编译我们的节目 使用命令make。
然后，我们将通过为它们运行 点斜线，程序的名字。
但要意识到什么使正在为 你，是它本身不是一个编译器。
这只是一个方便程序 知道如何触发一个编译器
运行，让你自己可以使用它。
>> 还有什么其他的命令中存在 Linux和依次CS50的IDE？
我们很快就会看到，有一个 CD命令，切换目录。
这允许您在 你的命令行界面
继续前进，和背部， 并打开不同的文件夹
不使用鼠标。
>> 我们看到了LS，代表名单 在当前目录中的文件。
让迪尔，你可以 可能开始推断
这些意味着什么now--创建目录， 如果你想创建一个文件夹。
RM为删除，RM为迪尔 删除directory--而这些，
再次，是命令行 什么你现金等价物
可在CS50 IDE与你的鼠标。
但是，你很快就会发现 有时它只是
速度快了很多做 事用键盘，
最终很多更强大。
>> 但是，这很难说 任何事情我们一直在做，到目前为止
是所有强大的，当所有 我们一直在说的是，世界你好。
而且，事实上，我的硬编码 也就是说世界你好了我的计划。
有没有活力呢。
划痕是一个数量级 更有趣的最后一周。
>> 所以，让我们在那里。
让我们走向一个一步 一些这些功能的方法。
所以不仅ç配备的printf， 其它的功能和束
其中的一些，我们会看到 随着时间的推移，它不
使这一切容易右出 在获取用户输入的栅极。
>> 弱点事实上，人们 的语言，如C，
甚至Java和尚未 别人是，它不
可以很容易地只得到一样的东西 从用户或字符串，整数的话，
和短语，让喜欢独处的东西 浮点值，或实数
带有小数点的，真 长数字，因为我们很快就会看到。
所以功能这个名单在这里，这些 就像其他的划痕拼图
我们已经预先安装在CS50 IDE，我们将用数周
作为各种训练车轮，和 最终把他们赶走，并期待
引擎盖，也许，在下方 这些东西是如何实现的。
>> 但要做到这一点，让我们 其实写一个程序。
现在让我先走。
而且我要创建一个新的 通过点击这个小加档，
然后单击新建文件。
>> 我要救这下 一个作为，让我们说，string.c，
因为我想用绳子玩。
和字符串在C是刚 字符序列。
所以，现在让我们继续 并做到以下几点。
>> 包括标准IO.h--和 事实证明标准IO，
IO只是意味着输入和输出。
所以，事实证明， 这里这条线是什么
在相邻的我们用printf。
printf的，当然，产生输出。
因此，为了用printf，原来 出你必须有这行代码
在你的文件的顶部。
>> 我们会回来的是什么 不久的真正含义。
事实证明，在 任何C程序我写的，
我必须与启动 代码如下所示。
你会发现CS50 IDE和 其他集成开发
喜欢它的环境， 要尽可能在
他们可以完成你的想法。
其实，刚才我是否撤消 我只是做了，我打回车键。
>> 然后我打左大 撑，命中再次输入。
它完成了我的想法。
它给了我一个新的生产线，缩进不会少 对于好的文体的原因，我们拭目以待。
然后它会自动给我 那花括号来完成我的想法。
现在，它并不总是 猜你想要做什么。
但在很大程度上，它确实 为您节省一些按键。
所以，刚才，我们跑这program-- 你好，世界，然后编译它，
然后运行它。
但这里有没有活力。
如果我们想 做不同的事情？
好吧，如果我想实际 获取来自用户的字符串？
我将使用一块拼图 正是所谓的that--得到的字符串。
>> 用C原来，当你不想要 提供输入到一块拼图，
或者更恰当给一个函数，你 从字面上只是做开括号，
右括号。
因此，这好像有 没有白框键入。
之前说块 有一个白色的小盒子。
我们没有白框现在。
>> 但是，当我调用get字符串，我 想不想找个地方把结果。
所以在C很常见的模式是 这里调用一个函数，以获得更多的字符串，
然后存储它的返回值。
它的结果其 努力的东西。
>> 什么是 构造在编程，
无论是在划痕或现在C，我们 可以使用实际存储的东西吗？
称它是可变的，对不对？
而在划伤，我们真的不 关心变量打算。
>> 但是，在这种情况下，我们实际上做的。
我要说的字符串。
然后，我可以打电话给 这样的事情我想要的。
我要叫它 名称，获取得到的字符串。
>> 现在，即使你 有点新本，
注意到，我缺少一些细节。
我忘了一个分号。
我需要完成这一思想。
所以，我打算将我的光标， 并创下分号那里。
和你有我只是做了什么？
在这行代码， 此刻号5，
我调用get字符串，没有投入。
因此，有不小的白色 像盒保存块。
>> 我只是说，嘿， 电脑，给我一个字符串。
等号是不是真的 一个等号，本身。
这是分配 操作者，这意味着，
哎，电脑，移动值 从以上至左右。
而在左边，我有以下。
>> 嘿，电脑，给我一个string-- 字符序列。
并调用该字符串名称。
我甚至不具备调用它的名称。
>> 我可以调用它，按照惯例， 像S，
就像我们用我来 调用变量i。
但现在我需要用它做什么。
这将是非常愚蠢的 尝试编译这段代码，运行
这个程序，即使 我得到一个字符串，
因为它仍然只是 去打招呼的世界。
>> 但是，如果我不想要什么来改变这种状况。
我为什么不这样做呢？
％的S，逗号秒。
这是一个有点神秘依旧。
>> 所以，让我的变量更加清晰。
让我这个变量名称。
让我们看看如果我们不能去惹 除了这里发生了什么。
>> 因此，对五号线，我得到的字符串。
而我存储这个字符串， 无论用户已键入的
在他或她的键盘， 在一个名为名称的变量。
而事实证明， printf的不只是
采取双重一个参数 引号，在双引号的输入。
>> 它可以采取两个或三个，或更多，如 使第二，或第三，或第四，
是变量所有的名字， 或者特别重视，
要插入， 动态，用引号引起该字符串。
换句话说，什么 将问题呢？
如果我只是说你好名称，反斜线 N，救了我的文件，我的编译代码，
跑了这一点，会发生什么？
>> 它只是会说，你好 名字，从字面上N-A-M-E，
这是一种愚蠢的，因为 这是一个从世界上没有什么不同。
因此，在行情是什么 什么字面上被打印出来。
所以，如果我想有 一个占位符那里，
我真正需要使用 一些特殊的语法。
而事实证明，如果你读了 对于printf函数的文档，
它会告诉你， 如果你使用％的S，
您可以按如下替换值。
>> 后一个逗号后 双引号，你只需
写的名字 要变
插上到该格式 代码或格式说明，
％的S代表字符串。
现在，如果我救了我的文件， 我回去到我的终端。
而I型制作绳， 因为，再次，在此名称
我之前选择的文件是string.c。
>> 所以，我要说让字符串，请输入。
我的天哪，看看所有的 错误我们已经取得了。
而这is--什么，这实在是 像六，七行程序？
因此，这是它可以很 快速获得压倒性的。
>> 该终端窗口有 现在只是反刍
数量巨大的错误消息。
当然，我没有更多的错误 消息比我行代码。
那么到底是怎么回事？
>> 那么，最好的策略 做到任何时候你
确实遇到了压倒性 这样的错误列表，
被回滚，查找命令 你刚刚运行，这在我的情况下，
为使字符串。
看看什么使所做的，就是这样 长铛命令，没什么大不了的存在。
>> 但红色是坏的。
格林试图将 温柔，乐于助人。
但它仍然很糟糕，在这种情况下。
但是，在这样做不好？
>> String.c，五号线，性格五位。
所以这只是常见的约定。
结肠癌的东西意味着什么 行数和字符数。
错误，使用未申报 标识字符串。
你的意思是标准？
>> 所以，不幸的是，锵 试图有所帮助。
但是，它是错的，在这种情况下。
不，锵，我不是故意的标准IO。
我的意思是在同一行，不错。
>> 但是，五号线在这里这一个。
而锵不 了解S-T-R-I-N-G。
这是一个未声明的标识符， 一句话，它只是从来没有见过的。
那是因为C，语言 我们在写代码的权利，
不具有的变量称为串。
>> 这不，在默认情况下，支持 所谓的字符串。
这是一个CS50一块 行话，但很传统。
但是，我可以按如下方式解决这个问题。
>> 如果我添加一行代码 这个程序的顶部，
包括CS50.h，这是另一种文件 里面的某个地方IDE CS50的某处
在硬盘上，可以这么说， 在Ubuntu操作系统
我参加竞选，这 是的文件
要教工作 系统中的字符串是什么，只是
像标准io.h是文件 在操作系统中那
要教它是什么的printf。
>> 事实上，我们会得到 一个非常类似的消息
如果IO也认标准 IO.h并试图用printf。
所以我要继续前进，只是 采取控制L到清除我的屏幕。
或者，您可以键入清晰，它会 只是清除终端窗口。
但你仍然可以在时间上向后滚动。
>> 而我要重新运行制作绳。
穿过我的手指此时，回车。
哦，我的上帝，它的工作。
它显示了我很长的神秘命令 这是通过锵请生成的内容，
但没有错误消息。
所以实现的，即使 你可能会得到完全
此番与 错误信息的数量，
也许会是这恼人的级联 实际上，在那里锵不明白
一方面，这意味着它然后 不理解下一个字，
或下一行。
所以它只是扼流圈您的代码。
但是，该补丁可能很简单。
所以始终围绕 输出的第一行。
如果你不这样做 理解，只是看
关键字，可能是 线索，并且行号，
和字符，其中 这种错误可能是。
>> 现在让我先走，然后键入 点斜线，字符串，请输入。
嗯，这不是打个招呼什么。
为什么？
好了，还记得，它在哪儿跑？
>> 它可能停留在此刻 在一个循环中，如果你愿意，六线，
因为设计的GET字符串， 通过CS50的工作人员写的，
字面意思只是坐在 在那里等着，等着，
并等待一个字符串。
所有我们所说的字符串是人力的投入。
所以，你知道吗？
让我先走。
而就心血来潮，让我 输入我的名字，大卫进入。
现在我有一个更加动态的程序。
它说，你好大卫。
>> 如果我继续前进，再次运行此， 让我试试说Zamila名称，输入。
现在我们有一个动态的程序。
我没有硬编码的世界。
我没有硬编码 名称或大卫，或Zamila。
>> 现在它更像程序 我们知道，在那里，如果需要输入，
它产生的输出结果略有不同。
现在，这并不是最好的 用户体验，或者UX。
我运行该程序。
>> 我不知道我应该 这样做，除非我其实看
或记住的源代码。
因此，让用户 遇到好一点
用最简单的事情。
让我回去到这个 程序，简单地说printf的。
>> 让我继续说名字，结肠， 和一个空间，然后分号。
而只是踢，无隙ñ。
这就是故意的， 因为我不想
提示移动到下一行。
>> 我想，相反，这样做，使串 重新编译我的代码到新机
代码点斜线的字符串。
啊，这是非常漂亮。
现在，我实际上知道什么是电脑 要我做的，给它一个名字。
>> 所以我要继续前进，并键入 在罗布，进入，你好，罗布。
因此，实现，这仍然是，在结束 当天，只有一个九行程序。
但是，我们已经采取了这些婴儿的步骤。
>> 我们写了一行与我们 熟悉，printf的，世界你好。
然后，我们毁掉了那一点。
而我们实际使用的GET字符串。
而我们在扔一个变量值。
然后我们说干就干，提高 它进一步与第三行。
与此迭代过程 写软件是真正的关键。
在CS50，而在一般的生活， 一般情况下不应坐下，
心中有一个程序，并尝试写作 整个该死的事情一下子。
>> 这将不可避免地导致的方式 更多的错误比我们自己在这里看到。
就连我，为了这一天，不断 让其他愚蠢的错误，
其实更难错误 这是很难搞清楚。
但你会犯更多的错误越多 行代码你写的一次。
所以这种做法， 编写代码一点点
你是舒服，编译 它，运行它，更普遍的测试，
然后移动on--所以就像我们不停 分层和上周层次感，
从建筑的东西很 简单，更复杂的东西，
做同样的在这里。
不要坐下来，并尝试 写一个完整的问题。
实际上采取这些婴儿的步骤。
>> 现在，字符串是不是所有的 对自己有用。
实际上，我们应该，理想情况下，喜欢 在我们的工具包东西。
因此，让我们真正做到这一点。
>> 现在让我继续前进，掀起 一个稍微不同的程序。
我们会打电话给这个int.c，为整数。
我要去，同样， 包括CS550.h。
我将包括标准IO。
而这将是很常见 在类的这些最初几天。
>> 而我要准备好 我自己用的主要功能。
而现在，而不是得到一个字符串， 让我们继续前进，并得到一个int。
让我们把它叫做我，并把它弄 INT，关闭括号，分号。
现在，让我们做 东西吧，printf的。
>> 比方说像 你好，反斜杠N，逗号我。
所以，我几乎模仿 我所做的只是一个刚才。
我有一个占位符在这里。
我在这里用逗号我，因为我想 堵塞我到该占位符。
>> 因此，让我们继续前进，并尝试 编译此程序。
该文件称为int.c.
所以我要说，让INT输入。
噢，我的上帝，但没什么大不了的，对不对？
有一个错误。
>> 有一个语法错误 这里是程序不能
里面int.c，行编译 七，性格27，错误格式
指定char类型 明星，不管它是什么。
不过，参数类型为int。
>> 所以在这里，我们不打算中场休息 虽然今天是很多的材料，
我们要以压倒你 绝对的C每一个功能，
和编程更一般地， 在短短的这些最初的几个星期。
因此，有经常将是行话 与你不熟悉。
而且，事实上，焦炭星是什么 我们要回来
在两个星期的时间。
>> 但现在，让我们看看如果我们能 解析是熟悉的字眼。
Formats--所以我们听到的格式 说明，格式代码之前。
这是熟悉的。
类型 - 但参数的类型为int。
等一下，我是一个int。
>> 也许％的5事实上 有一些定义的含义。
而且，事实上，它的作用。
一个整数，如果你想 printf的替代它，
你确实有使用 不同的格式说明。
你不会知道这 除非有人告诉你，
或者你已经这样做。
但是我百分之什么 可共同使用
在printf中的一个整数堵塞。
您还可以使用百分比 d表示十进制整数。
但我是好的，简单的在这里。
因此，我们将与该走了。
>> 现在让我继续前进， 重新运行化妆INT，回车。
这是很好的，没有错误。
点斜线int-- OK，不好的用户体验， 因为我没有告诉自己
该怎么办。
但是，这很好。
我迅速迎头赶上。
>> 现在让我去前进， 键入大卫，OK，Zamila，罗布。
好了，所以这是一件好事。
这一次，我使用的功能， 一个拼图，名为get int类型。
而事实证明out--，我们将 看到这个以后在term--
该工作人员CS50已实施 以这样的方式获得的字符串
它只会物理 得到你的字符串。
>> 它已经实施的get int类型 这样一种方式，它仅将
得到一个整数你。
如果你的人， 不配合，这是
从字面上只是要 说重试，重试，重试，
从字面上坐在那里循环，直到 你迫使一些神奇的数字，
像50和50打招呼。
>> 或者，如果我们再次运行此 并键入42，你好42。
这样一来，GET INT功能 那一块拼图内
足够的逻辑，足够的思想， 要弄清楚，什么是一个字？
什么是多少？
只有接受，最终的数字。
>> 因此，原来这 是不是所有的表现力。
至今。
所以，耶，我们最后一次 去很快
为实现游戏和动画， 在划痕和艺术作品。
而在这里，我们正在内容 与世界你好，你好和50。
>> 这是不是所有的令人振奋。
而且，事实上，这些前几 实施例将需要一些时间
在兴奋的增产行动。
但是，我们有这么多 现在控制，实际上。
而且我们要非常 快速启动分层
这些基本的原语的顶部。
>> 但首先，让我们了解 什么限制是。
的东西事实上，人们 刮不容易
让我们做的是真正审视 引擎盖下，
并且明白什么是 计算机是，它能做什么，
和它的局限性是什么。
而且，事实上，缺乏的 理解，潜在地，长期
可以导致我们自己的写作mistakes-- 错误，写出不安全的软件，
以某种方式被黑客攻击。
>> 因此，让我们对一些步骤 理解这一点更好一点通过
的，这样说了，下面的例子。
我要继续前进，实现 真正的快一个叫做加法程序。
像，让我们添加一些数字加在一起。
而且我要编写一些角落 在这里，只是复制和粘贴
我在那里之前，恰好 所以我们可以得到更快去。
所以，现在我已经得到了基本的开端 一个叫做加法器程序。
>> 让我们继续前进，做到这一点。
我要继续前进， 比方说和INTx得到得到int类型。
你知道吗？
让我们做一个更好的用户体验。
>> 所以让我们只说X是有效的 提示用户给我们的X.
然后让我先走，说的printf 怎么样y是，这一次期待
从用户的两个值。
然后就让我们继续前进， 比方说，printf的，x和y的总和为。
现在我不想做百分之秒。
我想做％的我，反斜线 N，再插上总和值。
>> 所以，我怎么能去这样做？
你知道吗？
我知道如何使用变量。
让我声明一个新的，INT态。
>> 而我要在这里采取了猜测。
如果在此等号 语言，也许我可以做X加Y，
只要我结束我的 用分号想？
现在我可以回到这里了，插上Z， 完成本以为用分号。
而且，我们现在看到的，如果这些 lines-- x的序列是获得int类型。
Y是获得int类型。
>> 添加x和y，存储在值z-- 所以，再一次，记住等号
是不相等的。
这是从右到左分配。
让我们打印出的总和 x和y的是不是字面上Z，
但什么的Z里面。
所以，让我们做加法 - 不错，没有错误这一次。
点斜线加法器，输入， x被将是1。
>> Y为将是2。
x和y的总和为3。
所以这是一切优秀和良好。
>> 所以，你会想象数学 应该在这样的程序中工作。
但是，你知道吗？
这是可变的，行 12，甚至是必要的？
你不需要的习惯得到 只是存储在变数的事情
只是因为你可以。
并且，实际上，它通常是 认为是不好的设计
如果您正在创建一个变量，叫 中的Z这种情况下，存储在它的东西，
然后立即 使用它，但从来没有一次。
为什么要给东西的名字 像Z如果你从字面上
要使用该 事仅一次，所以
近端创建哪里 它摆在首位，
如此接近的代码行的条款？
所以，你知道吗？
事实证明，C是非常灵活。
如果我真的想 插件值这里，
我并不需要声明一个新的变量。
我可以外挂x加 Y，因为C理解
算术和数学运算。
>> 所以，我可以简单地说，这样做数学， X加Y，无论这些值，
堵塞造成 整成字符串。
因此，这可能是，虽然 只有一条线短，
一个更好的设计，更好的节目， 因为有更少的代码，因此
少我明白。
而且这也只是清洁， 只要我们不是
引进新词， 新的符号，比如Z，
即使他们真的不 服务太大的目的。
>> 不幸的是，数学不是 所有可靠的时候。
让我们继续前进，并做到这一点。
我要继续前进 现在做到以下几点。
>> 让我们做的printf，我百分之，百分之加 我，应该我百分之，反斜线ñ。
而我要做的this-- XYX加y。
所以我只是要改写 此略有不同在这里。
我只想做一个快速的健全性检查。
再次，让我们不要超前。
做加法，点斜线加法器。
x为1，y为2，1加2是3。
所以这是很好的。
但是，让我们现在这个复杂 了一下，并创建一个新的文件。
>> 我会打电话给这一个， 说，整型，复数的整数。
让我先在那里我是刚才。
但是，现在让我们做一些其他的线路。
让我继续前进，做到以下几点， printf的，我百分比，减去％的我，
是我百分之逗号X，逗号YX减Y。
所以我稍微做 不同的数学存在。
让我们做一个又一个。
所以，我百分之百分之倍 我是百分之一，反斜线ñ。
让我们插件x和y，以及x乘以y。
我们将使用星号上 您的计算机时代。
>> 你不会用x。 x是 这里变量名。
你用乘法的明星。
让我们做一个。
百分之printf的我，分 由百分之一，百分之是我，
反斜杠ñ。 XY由y--分 所以你用C中的正斜杠
做除法。
让我们做一个其他的。
我百分比剩余，分 由百分之一，百分之是我。
xy--现在剩下的 是什么遗留下来的。
当您尝试将一 分母变成分子，
有多少是遗留下来 你不能分裂出去？
>> 所以是不是真的， 必须地，一个符号
我们在小学用于此。
但是，在C.你可以 例如x模y，其中
在这个context--这个百分号 容易混淆的，当你在里面
双引号的， 里面的printf，百分比
用作格式说明。
>> 当您使用百分比之外 在数学表达式，
它是模块化模运算符 arithmetic--我们的目的
在这里，只是意味着，什么是 x的剩余除以y？
所以x除以y为x斜线年。
什么是x的除以y的余数？
它的x模Y，作为一个程序员会说。
>> 所以，如果我在这里没有失误，让我 继续前进，使整型，复数，美观大方，
和点斜线整数。
让我们继续前进， 这样做，比方说，1，10。
好吧，1加10是11，检查。
1减去10为负9，检查。
>> 1次10是10，检查。
1 10 is--分 OK，我们将跳过一个。
余数1除以10为1。
这是正确的。
但有一个错误在这里。
>> 所以，一个我把我的 交出，不正确的。
我的意思是，这是接近0。
1除以10，你知道，如果我们 削减一些角落，当然，它是零。
但它确实应该1/10， 0.1或0.10，0.1000，或等等。
>> 它真的不应该是零。
那么，事实证明，电脑 从字面上做什么，我们告诉它做的事。
我们正在做数学一样x除以y。
和x和y，每行 代码前，都是整数。
>> 此外，第15行，我们都 告诉printf的，嘿嘿，printf的插件
的整数，插件的整数， 插件的integer--具体
x，然后y和则x 除以y。 x和y是整数。
我们是好那里。
>> 但是，为x除以x？
点¯x分由y是应该的， 数学上，1/10，或0.1，
这是一个实数，一个实数 有潜在的，一个小数点。
这不是一个整数。
>> 但是，什么是最接近 整数到1/10，或0.1？
是的，这一种是零。
0.1是这个样子了。
和1是本得多。
所以1/10更接近 0比它为一个。
>> 所以什么C是做us-- 样的，因为我们告诉它中场休息
被截断的整数。
它采取的值，而这又是 应该是这样的0.1000，
0等等。
而且这一切截断 小数点后
这样，所有这一切 的东西，因为它没有
适合的整数的概念，这 就像负1，0，1的数，
上下，它抛出了一切 小数点，因​​为你以后
不适合小数点 在由定义的整数。
>> 因此，这里的答案是零。
那么，我们如何解决这个问题？
我们需要另一种解决方案都在一起。
我们可以做到这一点，如下所示。
>> 让我继续前进，创造一个新的 文件中，这个叫floats.c。
这里保存了 同一目录下，float.c。
让我继续和复制 一些早期的代码。
>> 但是，而不是领 一个int，让我们做到这一点。
给我一个浮点值 名为x。其中，浮点
值只是从字面上 一些与一个浮点。
它可以移动到左边，在右边。
这是一个实数。
>> 让我没有打电话 得到INT，但得到浮动，
这也就是菜单中 在C250库选项。
让我们修改y为float。
因此，这将成为获取浮动。
>> 而现在，我们不希望在整数堵塞。
事实证明，我们必须使用百分 如欲浮动，浮法％的楼
现在保存它。
而现在，手指交叉，使 彩车，美观大方，点斜线浮动。
x被打算当1ÿ 将会再次成为10。
>> 而且，美观大方，OK我除了是正确的。
我希望更多的， 但我忘了写。
因此，让我们去解决这个逻辑上的错误。
>> 让我们继续前进，抓住以下。
我们只是做一些复制和粘贴。
而我要说负。
>> 而我要说倍。
而我要说的分歧。
而且我不会做模， 这是不一样锗这里，
用f分割，时间plus-- 好吧，让我们再次做到这一点。
>> 制作花车，点斜线花车， 1，10，还有 - 不错，没有，OK。
所以，我是个白痴。
因此，这是很常见 在计算机科学
做出愚蠢的错误是这样的。
>> 用于教导的目的， 我真正想做的事
在这里改变科学 要加，零下，到时候，
和来划分，你希望 这个练习过程中发现。
现在让我们重新编译这个 节目，做点斜线浮动。
>> 而第三次，我们 看它是否符合我的期望。
1，10，输入，是的，OK，1.000， 由10.000分，是0.100000。
而事实证明，我们能控制多少 数字是那些小数点后。
实际上，我们会的。
我们会回来这一点。
>> 但现在，其实数学是正确的。
那么，又是什么这里的外卖？
事实证明，在C，有 不仅只是strings--，事实上，
有没有真正的，因为我们 添加这些与CS50库。
但也有不只是整数。
>> 也有浮动。
而事实证明了一堆其他数据 类型也一样，我们将在不久使用。
事实证明，如果你想单 字符，而不是一个字符串，
你可以只使用一个char。
>> 事实证明，如果你想有一个布尔值， 一个布尔值，只有真或假，
感谢CS50库，我们已经 添加到C BOOL数据类型为好。
但它也存在于 许多其他语言。
而事实证明，有时你 需要更大的数字则默认情况下都
与整型和浮点型。
>> 并且，实际上，双是一个数字 使用不是32位，但64位。
和长隆是一个数字， 不使用32位，但64位，
分别为浮点 值和整数，分别为。
所以，让我们现在实际上 看到这个动作。
>> 我要在这里继续 并掀起另一个程序。
在这里，我要继续前进 并且确实包括CS50.h.
让我走，包括标准IO.h.
>> 你会发现什么 时髦发生在这里。
这不是颜色编码的东西 以同样的方式，因为它以前那样。
而事实证明，那是因为我 没有给的东西的文件名。
>> 我会打电话给这一个 sizeof.c，并创下保存。
并注意发生了什么我很 白色的代码针对黑色背景。
现在，至少有 一些紫色在那里。
它是语法高亮。
>> 这是因为，很简单，我已经 告诉IDE哪些类型的文件
它是由给它一个名称， 具体的文件扩展名。
现在，让我们继续前进，做到这一点。
我要继续前进，很 简单地打印出following--布尔
是百分之LU。
>> 我们会回来的 在短短的时刻。
然后我要去 布尔的打印尺寸。
而现在，只是为了节省 我有一段时间，我
要做一个整体 这些一堆一次。
而且，具体而言，我要去 更改为一个char和char。
这一次，我要改变 以一张双人床和一个双。
>> 这一次，我要改变 一个浮子和一个浮动。
这一次，我要去 更改为int和一个int。
而这一次，我要去 更改为一个很长很长。
它仍然采取 时间长了，很长很长。
>> 然后，最后，我放弃 我太多了，字符串。
事实证明，在C，有 被称为特殊的运算符
那大小是字面上 要在运行时，
告诉我们的大小 这些变量。
这是一种方式，现在， 我们可以连接回
上周的讨论 数据和代表性。
>> 让我继续前进，编译 的点斜线大小的尺寸。
让我们来看看。
事实证明，在C， 特别是在CS50 IDE，
特别是在 操作系统Ubuntu的，
这是一个64位操作 系统在此情况下，
一个布尔打算 使用的空间的一个字节。
这就是大小如何衡量， 不在位，但在字节。
并且记得，一个字节为8位。
因此，一个布尔值，即使你 技术上只需要一个0或1，
这是一个有点浪费 如何我们已经实现了它。
它实际上是要使用一个整体 byte--因此所有零，也许是
所有的人，或者类似的东西， 或只是一个1间八位。
>> 一个char，同时，用于字符 每一样上周ASCII字符，
将是一个字符。
这SYNCHS与我们的观念 它是不超过256 bits--相当，
SYNCHS了它是没有 超过8位，这
为我们提供了多达256个值。
双打算 为8字节或64位。
>> 一个浮点是4。
一个int是4。
长，长为8。
和一个字符串为8。
但是不要担心。
我们要剥开那层。
事实证明，字符串可以 超过8个字节。
>> 而且，事实上，我们已经写 弦已经，世界你好，
超过8个字节。
但是，我们会回来的 在短短的时刻。
但带走这里如下。
>> 任何计算机中仅具有有限 的存储器和空间量。
你只能储存那么多 你的Mac或PC上的文件。
您只能存储在这么多程序 RAM运行一次，一定，甚至
使用虚拟内存，因为 你的内存有限数量。
>> 而只是为了picture--如果 你从来没有打开一台笔记本电脑
或下令额外的内存 对于一台电脑，你
可能不知道 你的电脑里面
是一些看起来 有点像这样。
所以，这只是一个普通的公司命名为 至关重要的是，使计算机的RAM。
和RAM就是程序 而他们正在运行生活。
>> 所以每次Mac或PC，当您双击上 点击一个程序，它打开了，
它打开了一些Word文档 或类似的东西，
它存储在临时 RAM，RAM因为速度更快
比你的硬盘上，或 你的固态硬盘。
所以，这只是程序的地方去 当他们正在运行的生活，
或当正在使用的文件。
>> 所以，你有事情看起来 这样你的笔记本电脑里面，
或者稍微大一点的东西 里面的桌面。
但关键是你只有一个 有限数量的这些事情。
还有的只是一个有限的 硬件坐在这张桌子右边
这里。
>> 因此，可以肯定，我们不能存储 无限长的数字。
而且，然而，如果你想回 小学的时候，有多少位可以
你有权利 一个小数点？
对于这个问题，有多少位可以 你有一个小数点左边？
真的，无限多的。
>> 现在，我们人类唯一可能 知道如何发音万元，
和十亿，万亿，和 万亿和三次方。
而我推的限制我 understanding--或my--我明白
数字，但我 数字的发音。
但他们可以得到无限大 无限多的数字向左
或小数点的右边。
>> 但电脑只有一个 内存量有限，
晶体管的一个有限数量，一 数量有限的内部灯泡。
会发生什么时 您运行的空间？
换句话说，如果 回想起上周
当我们谈到数字 自己被代表二进制，
假设我们有 这8位值在这里。
>> 而且我们有七个1的和一个0。
而假设我们想 添加1至这个值。
这是一个非常大的数字现在。
>> 这是254，如果我没有记错 从上周权的数学。
但是，如果我改变 最右边是0到1？
整数， 当然，成为8个1的。
所以，我们还是不错的。
>> 这可能代表 255，虽然根据上下文
它实际上代表 负数。
但更多的是另一次。
这感觉就像它是关于 高达我可以指望。
>> 现在，它只有8位。
而我的Mac，当然，有办法 内存大于8位。
但它确实有有限的。
所以同样的观点也适用，即使我们 有更多的人，这些在屏幕上。
>> 但是，如果你发生了什么 存储该号码，255，
并且要算1位高？
你想去从255到256。
的问题，当然，是如果 从零开始，就像上周算起，
你不能指望高 256，更不用说257，
别说258，男因为什么 当您添加1会怎么样？
如果你做旧小学 方法，你把这里1，
然后1加1是2，但是这 真的是零，你扛1，
扛1，携带1。
所有这些事情， 这些1的，去到零。
和你风，是的，正如有人 在左手侧所指出的，一个1。
但是，一切都可以 真正看到并装入内存
是只有八0年代，这是说 在某些时候，如果你一台电脑，
试着计数足够高了，你 要环绕，这似乎
零，或者甚至负 号，这是大于零甚至更低。
>> 我们可以样的看到这一点。
我要继续写 一个真正的快速程序在这里。
我要继续写 一个叫溢出程序。
包括CS50.h包括 标准IO.h--哦，
我真的很想念我的语法高亮。
因此，让我们这个保存为overflow.c。
>> 而现在INT主要void-- 过不了多久，我们就会
回过头来解释为什么 我们继续写INT主作废。
但现在，我们只是做 它，视之为理所当然。
让我们给自己一个int， 并初始化为0。
>> 让我们再对INT做我得到zero-- 其实，让我们做一个无限循环
看看会发生什么。
虽然如此，那么让我们打印出ñ 是我百分比，反斜线N，插件在正。
但是，现在，让我们做n得到n与1。
>> 因此，换句话说，在每 这个无限循环迭代，
让我们取n的值， 并把它加1，然后
将结果存储回在正在左侧。
而且，事实上，我们已经看到了语法 微微就是这样，简单。
一个很棒的技巧反而 编写出这一切的，
你可以居然说一个n加等于1。
>> 或者，如果你真的想成为幻想， 你可以说n与加分号。
但后两个都只是 我们会打电话语法糖
对的第一件事。
>> 的第一件事是更加明确， 完全正常的，完全正确的。
但是，这是比较常见的，我会说。
所以，我们会为短短的时刻做到这一点。
>> 现在，让我们做溢出，这听起来 而不祥，点斜线溢出。
让我们来看看，正变得越来越蛮大的。
但我们认为，有多大可能得到ň？
>> n是一个int。
我们看到刚才用的大小 例子，一个int是四个字节。
我们从上周知道，四个字节是 32位，因为8次4，这是32。
那将是4个十亿。
>> 而我们可达80万。
这将永远采取 数高达我所能。
所以我要继续前进， 正如你可能过不了多久，
并创下控制C--坦言，控制 C，很多，其中对照C一般
手段取消。
不幸的是，因为这 在云中运行时，
有时云 吐出了这么多东西，
如此多的产量，这将 取一小会儿我输入
去云。
所以，即使我打 对照C几秒钟前，
这绝对是侧 无限循环的效果。
>> 因此在这种情况下，我们 要离开的是。
而且我们要增加另一个 在这里的终端窗口
与加，这当然不 这样，因为它仍在思考。
让我们继续前进，并 多了几分合理性。
>> 我要继续前进，做 这只有有限多次。
让我们用一个for循环， 我前面提到。
我们开工吧。
再给我一次变量int我得到0。
我不到，比方说，64个I ++。
现在让我继续和打印 出n是百分之一，逗号ñ。
然后N--这仍然是 要采取永远。
我们开工吧。
>> n得到n次2。
或者我们可以被看中 做次等于2。
但是，让我们只说ñ 等于本身，乘以2。
换句话说，在该 程序的新版本，
我不想永远等待 从像80万至4十亿。
就让我们这种过度使用。
>> 让我们实际上每次加倍ñ。
其中，召回，加倍是 对面有当然的。
和而上周我们有 重复的事情，并再次，
又一次，超快速， 加倍必将
1让我们以最大的可能 值，我们可以用一个int计数。
>> 因此，让我们做的正是这一点。
我们再回过头来此不久。
但是这又好比 在从无到有的重复块。
你会不久使用。
>> 这也就意味着，从零计数 达，但不相等，为64。
而在此每次迭代 循环，只是不停地增加i。
所以，我++ - 这一般结构 第7行仅仅是一个超级常见的方式
重复的部分线路 代码，一些次数。
哪行代码？
这些大括号，如你 可能从现在收集，
手段，做到以下几点。
>> 它像划痕，当 它具有黄色块
和其他颜色的那种 拥抱或拥抱其他块。
这就是那些花 括号在这里做。
所以，如果我得到了我的语法right--你 可以看到C表示胡萝卜符号
这就是我多少次 试图解决这个问题。
因此，让我们摆脱的那一个 干脆，并关闭该窗口。
我们将使用新的。
使溢出，点斜杠 溢出，进入，所有的权利，
它看起来坏在第一。
但是，让我们向后滚动的时候， 因为我这样做64次。
>> 和在第一时间通知，n是1。
第二次，n为2， 然后4，然后按8，然后16。
并尽快似乎 我得到低于约1十亿，
如果我再翻一番它， 应该给我两十亿。
但事实证明，这是 正确的风口浪尖上。
>> 所以它实际上溢出 1十亿一个int
大致2负 十亿，因为一个整数，
不像我们的数字 上周假设，
既可以是正和负 在现实中，并在一台计算机。
而这些，所以至少一个 位被有效被盗。
所以，我们真的只有31位， 或2十亿可能的值。
>> 但就目前而言，外卖相当 简单地说，不管这些数字
而无论数学， 有坏事发生，最终，
因为最终你试图 重排的位太多次。
你有效地都去 1对也许所有0，或者
只是一些其他的模式，它 清楚地，根据上下文，
可以理解为一个负数。
因此它似乎最高的I 可以在这个特定的程序计数
只有大约1十亿。
但是，这里有一个部分解决方案。
你知道吗？
>> 让我从改变 诠释一个很长很长。
让我继续在这里 和say--我将有
要改变这种为unsigned long。
或者，让我们来看看，我从来不记得自己。
>> 让我们继续前进，使溢出。
不，这不是它，LLD，谢谢。
所以有时锵能有所帮助。
我不记得是什么格式 说明是一个很长很长。
>> 但是，事实上，锵告诉我的。
绿色是某种好， 仍然意味着你犯了一个错误。
它是猜，我的意思是LLD。
>> 因此，让我把它的建议，长 长十进制数，保存。
让我重新运行它，点 斜线溢出，回车。
现在什么是酷是这样的。
>> 如果我回卷的时候，我们还是开始 在同一place--计数1，2，4，
8，16。
请注意，我们得到了所有的 一路攀升至1十亿。
但是，我们安全到达2十亿。
>> 然后我们4十亿， 然后从8十亿，17个十亿。
而我们走的更高，而且 越来越高。
最终，这也算休息。
>> 最终，用长长的， 它是64位的值，而不是
一个32位的值，如果算上 过高，环绕0。
在这种情况下，我们碰巧 结束了一个负数。
>> 因此，这是一个问题。
而事实证明，这 问题是，不是所有的神秘。
即使我刻意 这些错误引起的，
事实证明，我们那种看到它的全部 我们，或者至少我们中的一些周围的人。
>> 因此，在乐高星球大战，如果 你曾经玩过的游戏，
事实证明，你可以去周围 打破东西在世界乐高，
和收集硬币，本质上。
如果你打过 这个游戏了太多的时间，
因为这无名的个人 在这里做到了，总数
你可以收集硬币 是，它似乎，4个十亿。
>> 现在，它的实际四舍五入。
所以LEGO试图 让事情变得人性化。
他们没有做到这一点正是2 32次幂，每上周。
但4个十亿是一个道理。
看来，基于该信息， 这LEGO，该公司的
使这个实际的软件，决定 该硬币的最大数目
用户可以积累 确实是，4个十亿，
因为他们选择在自己的代码 使用不是很长很长，很显然，
但仅仅是一个整数，一个无符号 整数，只有一个正整数，其
最大值大约是这一点。
那么，这里的另一个有趣的。
所以在游戏中文明，这 有些人可能很熟悉，与
原来，几年前有 在本场比赛由此错误
如果你所扮演的角色 甘地在比赛中，
代替他的是非常和平， 反而是令人难以置信的，令人难以置信
攻击性，在某些情况下。
特别是，方式文明 作品是，如果您的播放器，
采取民主，你 侵略性成绩获得
由两个，所以减去递减 减，再减去负。
>> 所以你减去2从 实际的迭代。
不幸的是，如果你的是迭代 最初1，你从中减去2
采用经过民主 甘地在这里可能
这样做，是因为他很passive-- 1对侵略性的规模。
但是，如果他采取民主，那么 他去从1到1负。
>> 不幸的是，它们是 使用无符号数，
这意味着他们对待甚至是负 数字，好像他们是积极的。
而且事实证明， 负1阳性当量，
在典型的计算机程序，为255。
因此，如果采用甘地 ，因此具有民主
他的侵略性评分下降， 它实际上来临时，以255
而让他最 侵略性的比赛。
所以，你可以在此Google了。
而且，的确是一个 意外编程错误，
但是这相当进入 绝杀至今。
>> 这是所有的乐趣和可爱。
更可怕的是，当实际 真实世界的设备，而不是游戏，
有这些相同的错误。
事实上，就在一年前的一篇文章来了 更多关于波音787梦想飞机。
>> 和制品在第一 读取一目了然有点神秘。
但它说，这是一家软件 在波音公司的脆弱性
新型787梦想飞机具有 可能造成飞行员
失去控制 飞机，可能
在飞行中，美国联邦航空局官员 告诫航空公司最近。
这是确定 一个模型787
已通电飞机 连续248天
可能会失去所有的交流电流，交流， 电功率，由于发电机
控制单元，同时GCUs， 进入故障安全模式。
这是一种失去我的。
但备忘录说，好了，现在我得到的， 条件是由软件引起的
专柜内部 发电机控制
单元后，将溢出 248天连续功率。
颁发本 注意防止损失
所有交流电 功率，这可能导致
在飞机的失控。
>> 所以，从字面上看，有一些整数， 或者一些等价的数据类型，
在软件被使用 在实际的飞机
如果你保持你的飞机 足够长的时间，这显然
可如果你只是运行情况 他们不断地从不拔下
你的飞机，现在看来，还是 让其电池不行了，
将最终计数和向上， 和起来，向上，及以上，和向上。
>> 并且，按质，一 内存数量有限
会溢出，回滚到 零或者一些负值，
其中的一个副作用是 实得吓人现实
这架飞机可能需要 必须重新启动，有效，
也可能下降，更糟糕的，因为它飞起来。
所以这类问题 仍然伴随着我们，
even--这是一个2015年的文章， 所有的更可怕
当你不一定 理解，欣赏，或预期
这些类型的错误。
>> 因此，原来还有另一个 有关数据表示坏事。
事实证明，即使花车 样的缺陷，因为花车也是如此，
我提出的是32位的，或 也许64如果你使用双。
但是，这仍然是有限的。
>> 而美中不足的是，如果你能 把数的无限数量
小数点后， 没有办法，你
可以代表所有可能的 我们被教导号码
在小学可以在世界上存在。
一台电脑，从本质上讲，有 选择这些数字的一个子集
准确地表示。
>> 现在，该计算机可以 轮也许一点点，
并且可以让你大致店 任何号码，你有可能会需要。
但是，仅仅凭直觉，如果你 有比特的有限数目，
你只能他们重排 在很多方面有限。
所以，你不可能 用有限数量的
比特置换， 零和一的模式，
代表无限 号的数目，
这表明计算机可能 很好是对我们撒谎的时候。
>> 事实上，让我们做到这一点。
让我重新回到CS50 IDE。
让我继续前进， 创建一个小程序
叫不精确，就表明 电脑的确都是不精确的。
>> 让我继续前进，并与开始 一些代码来自之前，
现在只要做到以下几点。
我要继续做的printf，百分比 楼反斜线N，1除以10。
换句话说，让我们在更深的下潜 到1/10，象1和除以10。
当然，一个计算机可以代表1/10。
>> 因此，让我们继续前进，使不精确。
让我们来看看。
格式指定double类型。
但参数的类型为int。
这是怎么回事？
>> 呵呵，有意思，所以这是一个 从课前的教训。
我说，哎，电脑展 我百分之F A浮动。
但我给它2个整数。
所以，事实证明，我可以修复 这几种方式。
>> 我只是把一成1.0，和 10到10.0，这，的确，
有转换的效果 他们进入floats--仍有望
相同的号码。
或者，它原来有什么东西 我们不久再见到。
你可以投中的数字。
>> 您可以使用此括号 表达式，你可以说，
哎，电脑，借此 10，我知道是一个int。
但是对待它，请 就好像它是一个浮动。
但这种感觉过于复杂。
>> 对于我们今天的目的， 我们只是从字面上
让他们浮点值 带小数点，就像这样。
让我继续前进并重新运行，使 不精确，好，点斜线
不精确，进入。
OK，我们正在寻找好的。
>> 1除以10，按照我的 苹果在这里，的确是0.100000。
现在，我学会了上小学的时候有 应该是0的无限数量。
因此，让我们至少尝试 看到其中的一些。
事实证明，printf的是一个小 票友仍然比我们一直在使用。
原来你没有指定 刚刚％的F或只是我百分比。
实际上，你可以指定 这里的一些控制选项。
>> 具体来说，我要去 就是说，哎，printf的，
居然告诉我10小数点。
所以它看起来有点怪异。
但是你说个百分点， 点，多少号
你想以后看到 小数点，以及则f
平，只是因为这是 文件说什么。
让我继续前进并保存。
>> 并注意过，我越来越 厌倦了重复输入的事情。
所以我只是设置和 在这里我的钥匙向下箭头。
如果我继续打了，你 可以看到所有的命令
我犯了，或不正确的。
>> 而我现在要继续前进， 没有实际使用，显然。
让不精确，点 斜线imprecision--所以
我所教 小学检查出来。
即使我把它打印到10进制 地方，它确实是0.10000。
但是，你知道吗？
>> 让我们有点贪心。
比方说，比如，告诉我55 小数点后点。
让我们真的采取这种 划出来兜风。
让我用make改造它 不精确，点斜线，不精确。
>> 现在我们开始。
你的童年是一个谎言。
很显然，1除以10的确 0.100000000000000005551115123--
>> 到底是怎么回事？
那么，事实证明，如果你种 看远远不够出在底层
这表示 数目，它实际上
是不完全的1/10，或0.1和 无限数量的零。
现在，这是为什么？
>> 那么，即使这是一个简单的 我们人类数，1除以10，
它仍然是无限多的一个 数字，我们能想到的。
但是，一台电脑只能代表 有限多个这样的数字。
所以，有效的，是什么 电脑正显示出我们的是其最接近
近似​​与数 我们愿意相信是1/10，
还是真的0.10000循环往复。
>> 而，虽然，这是 尽可能接近，因为它可以得到的。
而且，事实上，如果你看看 引擎盖下，
因为我们在这里通过看 小数点后55位，
实际上我们看到的现实。
现在，顺便说一句，如果你 见过movie--
大多数人可能haven't-- 但超人3若干年前，
理查德·普赖尔基本上是利用这 现实中，他的公司窃取了很多
便士的分数和分数的， 因为我记得在company--，
它是一个while--基本上是 扔掉任何东西，不适合
进入仙的概念。
>> 但是，如果你把所有这些 很小，很小，很小的数字再次，
又一次，又一次，你可以象在 他的情况下，赚钱的一个良好的数额。
>> 那同样的想法被扯掉 更近，但还是现在年纪大了
电影，叫办公空间， 凡在那部电影的家伙，
做同样的事情，搞砸了 彻底，结束了太多
钱在自己的银行账户。
这一切都是很可疑。
但在一天结束时， 不精确就在我们身边。
>> 并且，也可以是 令人震惊的情况。
原来，3超人 和办公空间之外，还有
可能有一些非常现实的 世界后果
不精确的现实 数据的表示
即使我们人类 这一天不一定
理解，以及我们应该， 或记住尽可能多我们应该。
而且，事实上，以下剪辑是 从看一些很真实的世界
如果你会发生什么后果 不欣赏的不精确性
在数字代表出现。
>> [视频回放]
>> -Computers，我们都逐渐接受 经常令人沮丧的问题，
去them--错误，病毒， 和软件故障，
对于小的价格支付 为方便。
但是，在高科技和高速度 军事和航天计划的应用，
最小的问题即可 被放大成灾难。
>> 在1996年6月4日，科学家们准备 发射无人阿丽亚娜5型火箭。
它携带的科学 卫星设计
建立精确如何 地球的磁场相互作用
与太阳风。
火箭是专为 欧洲航天局，
并从其设施升空 在法属圭亚那的海岸。
>> -At约37秒进 飞行中，他们首先
注意到某些事正在错误的。
喷嘴在被旋转 某种意义上说，他们实在不应该。
大约40秒后进入飞行， 显然，车辆遇到了麻烦。
>> 那就是当他们做了 决定摧毁它。
该范围内的安全官员，与 巨大的胆量，按下按钮，
炸毁了火箭，它可能前 成为对公众安全造成危害。
>> - 这是处女 阿丽亚娜5的航程。
而其毁灭了 地方，因为一个缺陷
嵌入火箭的软件。
在阿丽亚​​娜-The问题是 认为有许多
需要64位来表示。
他们想转换 它的16位数字。
他们假定 数字是永远不会
是非常大的，大多数的那些 在一个64位的号码数字是零。
但他们错了。
>> -The无力之一 软件程序接受
所产生的那种数 另一种是在失败的根源。
软件开发已经成为一个 的新技术非常昂贵的部分。
该阿丽亚娜火箭已经很 成功，那么多的软件
创造了它也是 在阿丽亚​​娜5中。
>> -The根本的问题是，阿丽亚娜 5增快，加速快。
而且软件早已不是 占了点。
>> 火箭-The破坏 是一个巨大的金融灾难，
一切缘于一分钟，软件错误。
但是，这不是第一次 实时数据转换问题
一直困扰现代火箭技术。
>> -in 1991年，开始时 第一次海湾战争中，
爱国者导弹 经历了类似的一种
数转换的问题。
而作为一个结果，28人， 28名美国士兵，
被打死，约 100人受伤，
当爱国者，这本来是 防止传入的飞毛腿导弹，
没有发射导弹。
>> - 当伊拉克入侵科威特和美国 在1991年年初推出沙漠风暴
爱国者导弹部署 保护沙特阿拉伯和以色列
伊拉克飞毛腿导弹袭击。
爱国者是美国中程 表面空气系统，制造
由雷神公司。
>> 爱国者拦截-The大小 本身是关于约20英尺长。
它重约2000磅。
同时还可以进行约一个弹头， 我认为这是大约150磅。
和弹头本身 高爆发力，这
周围有碎片。
弹头的外壳是 旨在像大号铅弹。
>> -The导弹进行 百分之四的容器中，
和由半拖车运输。
>> -The爱国者反导弹系统 追溯到现在至少有20年。
它最初的设计 作为防空导弹
击落敌人的飞机。
在第一次海湾战争， 当战争来了，
陆军想用它来 击落飞毛腿导弹，而不是飞机。
>> 伊拉克空军 没有那么多的问题。
但军队是担心飞毛腿导弹。
所以他们试图 升级爱国者。
>> -Intercepting敌人 在导弹5马赫旅行
将要被足够的挑战性。
但是，当爱国者 被送往投入服务，
陆军不知道的 伊拉克的修改，使得
他们的飞毛腿导弹几乎是不可能的打击。
>> - 什么事是飞毛腿导弹的 要来的是不稳定的。
他们在晃动。
这样做的原因是 伊拉克人，为了
获得600公里 出300公里
中程导弹，重了 从前面弹头。
他们提出的弹头更轻。
>> 所以，现在的爱国者 苦思的飞毛腿。
和大部分的时间，该 绝大多数的时间，
它只是由飞毛腿飞。
一旦爱国者系统运营商 实现了爱国者错过了目标，
他们引爆爱国者的弹头 以避免如果可能的人员伤亡
被允许倒在地上。
>> - 那是大多数人所看到的， 在天空中那些大火球，
和误解成 飞毛腿弹头的拦截。
>> - 虽然在夜间 天空，出现了爱国者
要成功地 摧毁飞毛腿导弹，在宰赫兰
有可能是没有错 关于它的性能。
目前，爱国者的雷达系统 失去了进入的飞毛腿的轨道，
从不因推出 到一个软件缺陷。
这是谁首先发现了以色列人 的时间越长该系统上，
越大时间差异 成为，由于嵌入的时钟
在系统的计算机。
>> - 关于前两周 悲剧发生在宰赫兰
以色列人报 国防部
该系统正在失去的时间。
约8小时运行之后， 他们注意到，该系统
变得明显不准确。
国防部回应 告诉所有的爱国者电池
不离开系统 上很长一段时间。
他们从来不说什么了很久was-- 八小时，10小时，千小时。
没有人知道。
>> -The爱国者电池 驻扎在军营
在宰赫兰和内部缺陷 时钟已经超过100小时一直在
2月25日的夜晚。
>> - 它跟踪的时间精度 约一秒钟的十分之一。
现在，第二的第十 是一个有趣的数字，
因为它不能表示 二进制准确地说，这
意味着它不能精确地表达 在任何现代数字计算机。
很难相信。
>> 但是使用此作为一个例子。
让我们来数三分之一。
三分之一不能 十进制明确地表达。
三分之一是0.333 持续了无穷大。
>> 有没有办法做到这一点与 绝对精度十进制。
这正是那种问题 这发生在爱国者。
时间越长，系统运行时， 更糟糕的时间误差成了。
>> - 后运行100小时后， 在时间误差仅为约三分之一
的第二。
但是，在一个目标的角度 导弹在5马赫旅行，
它导致了跟踪 超过600米错误。
这将是一个致命的错误 对于什么战士
碰巧是飞毛腿发射是 通过预警卫星检测
他们知道，是飞毛腿 未来在他们的大方向。
他们不知道有人来了。
>> - 它现在要由雷达 爱国者系统的组成部分
卫冕达兰定位和保持 跟踪来袭的敌方导弹。
>> -The雷达是非常聪明的。
它实际上是将跟踪 飞毛腿的位置，
然后预测出可能 将是下一个时间的雷达发送
脉冲出来。
这是所谓的范围内门。
>> - 然后，一旦爱国者 决定时间已够
传递回去检查下 此检测物体的位置，
它可以追溯到。
因此，当它回到了错 地方，然后看见没有对象。
和它决定，没有 对象，这是一个错误的检测，
和下降的轨道。
>> -The传入飞毛腿消失 从雷达屏幕上。
几秒钟后，它 撞上军营。
飞毛腿打死28，并且是最后一个 在第一次海湾战争中开火。
>> 可悲的是，更新的软件 抵达宰赫兰的第二天。
该软件有缺陷 得到修复，闭合
在陷入困境的一章 爱国者导弹的历史。
>> [视频回放]
DAVID J. MALAN：所以这是所有 说，溢出的这些问题
和不精确都太真实了。
那么我们是如何来到这里的？
我们开始只是谈论的printf。
再次，此函数 打印一些东西到屏幕上，
我们随后推出 几个其他功能
从所谓CS50的库。
我们将继续 看到这些在适当的时候。
而我们，尤其是使用的GET字符串， 并获得INT，现在还可以获得浮动，
还有一些仍然会遇到我们 不久使用自己。
>> 但有时，有 我们已经看到有必要
存储什么这些功能的手背？
他们一方面我们回到一个字符串， 或int或浮动。
有时，我们需要把该 字符串或int，或float地方。
>> 并存储那些东西，只是召回 就像在刮，我们有变数。
但与划痕， 在C中有实际的类型
variables--数据 类型，更generally--
其中，一个字符串，一个int，一个 浮动，而这些人依然。
>> 所以，当我们用C声明变量， 我们必须声明的数据类型。
这不是我们 必须在学期过去了做
因为我们过渡到其他语言。
但现在，我们确实需要 到预先先验，
解释计算机是什么类型 可变的，我们希望它给我们。
>> 现在，同时，进行打印 这些类型的数据类型，
我们要告诉printf的什么期望。
我们看到字符串％的S， 和我百分之整数，
和其他几个人了。
而这些仅仅是要求 对于视觉呈现
这些信息。
>> 而且每个这些其实是可以 参数化或以某种方式调整，
如果你想进一步控制 你得到的输出类型。
而且，事实上，它不仅证明 有反斜杠n，则新行。
还有别的东西叫反斜线 r代表回车，这
更类似于一个 老同学打字机，
并且还视窗使用多年。
>> 有制表符反斜杠吨。
事实证明，如果你想 字符串里面的双引号，
我们已经使用召回 双引号双
引用在左侧和右 迄今为止，我们的字符串结束。
这似乎混淆的东西。
>> 如果你想要把双引号中 一个string--，实际上中间，
它是混乱看到的。
所以你要逃跑，所以 说话，用的东西一个双引号
像，从字面上看，反斜杠双引号。
而且还有一些其他的还在。
我们将看到更多的这些 在不久的实际使用。
>> 现在让我们从过渡 数据和代表性，
和算术运算符，所有 这给了我们一些建筑
与玩积木。
但现在，让我们实际上给 我们的词汇的其余部分
我们已经完成了 上周与划痕
通过一些其他的考虑看看 在C--结构不是所有的人。
但是我们的想法 就要看真的只是
要强调从翻译 一种语言，从无到有，到另一个，C.
>> 随着时间的推移，我们会拿起 更多的工具，我们的工具包，
可以这么说，语法上。
而且，事实上，你会看到的想法 现在从上周相当熟悉。
因此，让我们做到这一点。
>> 让我们继续前进，并掀起程序 实际使用一些表情，
布尔表达式。
让我继续在这里 并创建一个新的文件。
我会打电话给这个condition.c。
>> 让我继续前进， 包括CS50库。
让我继续前进，包括 标准IO.h我们的功能，
和printf，更分别。
让我给自己的样板 INT主要无效，其解释我们
回来的未来。
>> 现在让我先走，并把 我通过get INT一个int。
然后让我继续前进，做到这一点。
我想说，如果我是less--让我们 正，负区分
或零值。
>> 所以，如果我是小于零，让我 只是有这个计划简单地说，
负，反斜线N，否则 如果i大于零。
现在，我当然会说 printf的正面，反斜线ñ。
然后，其他if--我能做到这一点。
>> 如果我等于0，我可以做的。
但我在做被 至少一个错误了。
回想一下，等号 不相等的，因为我们人类知道这一点。
>> 但它的赋值操作符。
而我们不希望在采取0 权利，把它放在我的左边。
因此，为了避免这种混乱，或 也许是平等的滥用签收，
人类决定几年前 在许多编程语言
当您要检查等式 左和右之间，
你实际使用等于等号。
所以，你打等号的两倍。
当你想从分配权 到左，你用一个等号。
因此，我们可以做别的this-- 如果我等于为零。
>> 然后，我可以去 打开我的大括号，
并说，printf的0，反斜线N，完成。
但要记住，这些是如何 在岔路口能正常工作。
而且，真的，只是想想逻辑。
i是一个数字。
这是一个整数，具体。
这意味着它将会是少 大于0，或者大于0，或者0大。
因此，有一种这样 隐含的默认情况。
>> 因此，我们可以，就像 划伤，免除了其他如，
而只是说别的。
从逻辑上讲，如果您在 程序员知道，只有
三个存储成一个 情况可能fall--第一，
第二，或第三 在这个case--不
懒得添加额外的精度 和附加​​逻辑那里。
只是继续用 默认情况下，这里的人。
>> 现在，让我们继续 保存此之后，使
条件斜线点条件 - 不是一个伟大的用户界面，
因为我不惹得 用户，正如我前面提到的。
但是，这很好。
我们将保持简单。
让我们尝试数字42。
这就是积极的。
让我们尝试次数 负42负。
>> 让我们尝试值0。
而且，事实上，它的工作原理。
现在，你将与之前看到的问题 长，检测的事三次，
可能不充分。
你可能想测试一些 更大的数字，一些规模较小的
数字，一些角落情况下，如 我们会来描述它们。
>> 但现在，这是一个 很简单的程序。
而且我敢肯定，在逻辑上， 它分为三种情况。
而且，事实上，即使我们只是 集中在潜在的缺点
不精确和溢出，在 现实中，许多的CS50的问题，
我们不会担心 一下，所有的时间，
溢出的这些问题， 不精确的，因为，事实上，在C，
它实际上不是所有的 容易避免这些东西。
如果你想计数 大，大，大，
事实证明，有技术，您 可以使用，常累及东西叫做
图书馆的馆藏代码，即 其他人写的，你可以使用，
和其他语言如 Java和其他人，其实
让人们更方便 数甚至更高。
因此，它确实是有些危险 您使用的语言的函数。
并在未来几周内，我们将 看有多危险真的Ç
可如果不正确地使用它。
但是从那里，并与 蟒蛇，和JavaScript，将
我们图层上的某些额外的保护， 并运行这些风险较少。
>> 因此，让多一点 有趣的逻辑在我们的节目。
因此，让我继续创建 一个叫做逻辑程序
只是这样我就可以玩一些 实际的逻辑，logical.c。
我只是复制和粘贴一些 从早期的代码，所以我回来
这个漂亮的出发点。
>> 让我这个时候做字符C.我 打算给​​它的C名称
只是因为它的传统， 获取来自用户的字符。
让我们假装 我实施的一部分
该室的方案，删除 在此之前，程序提示用户
删除文件。
我们怎么能做到这一点？
>> 我想说的是，如果C等于 等于，报价引文结束，
Y，然后我要去承担 该用户已经是选择。
我只是要打印的是。
如果它被实际编写 拆除程序，
我们可以删除文件 有更多行的代码。
但我们会保持它的简单。
>> 如果C等于等于N-- 现在这里，我会说，
用户必须意味着没有。
然后别的，你知道吗？
我不知道还有什么 用户将要输入。
所以，我只是说， 这是一个错误，无论
他或她实际键入。
>> 那么是什么回事？
有一个根本的区别 与我在过去所做的那样。
双引号，双引号，双 报价和，但是，单引号
单引号。
原来，在C，当 你想要写一个字符串，
你使用双引号，就像我们已经 使用所有这一次的printf了。
>> 但是，如果你要处理的只是一个 单个字符，所谓字符，
那么你实际使用单引号。
你们当中谁已设定 之前，你可能没有
不用担心这个 区别在某些语言。
在C中，这非常重要。
所以，当我得到一个char，我想 使用equals来比较字符
等于像y或n一些信，我做的， 的确，需要有单引号。
>> 现在，让我们继续前进，做到这一点。
让我们继续前进，不要做 逻辑点斜线逻辑。
而现在我被提示。
因此，据推测，更好的用户体验 实际上告诉我在这里做什么。
但我要去只是盲目 说Y（是），不错，真不错。
>> 让我们再次运行它，正因为没有，美观大方。
假设像某些人我知道， 我的大写锁定键是所有过于频繁。
所以我做资本Y，回车，错误。
OK，这不是正是我期待的。
的确，计算机 简直是在做什么
我告诉它do--检查 小写字母y和小写的n。
这并不觉得自己是最好 用户体验，虽然。
让我索取，接受采访 无论是小写或大写。
因此，原来，你可能想 说类似的划痕，
像字面上或C等于 等于资本单引号年。
事实证明，C没有 这个文字关键字或。
>> 但它确实有两个竖条。
你要平时按住Shift， 如果您使用的是美式键盘，
并击中竖线 按键上的回车键。
但是，这竖线 竖线表示或。
>> 如果，相反，我们希望 说，就像在刮，
我们可以做的符号与符号。
这使得没有任何逻辑意义在这里， 因为人不可能
键入y和小写ÿ 和资本y为相同的字符。
所以，还是就是我们打算在这里。
>> 所以，如果我这样做，在这两个地方，或c 等于等于资本N，现在重新运行，
使逻辑，重新运行逻辑。
现在，我可以键入y。
而且我可以再做一次 资本Y，或资本N.
而且我可以添加额外的 组合依然。
>> 因此，这是一个逻辑 程序只要现在
我检查的逻辑 这个值或该值。
我不就得了，必然， 拿出两个IFS否则IFS。
其实我可以结合一些 以这种方式将相关逻辑。
因此，这将是更好 设计不是简单的
他说，如果C等于较低的情况下，y， 打印是的，如果C等于资本Y，
打印是的，如果C等于 lower--换句话说，
你不必有 越来越多的分支。
您可以结合一些等价的 分支逻辑，如在这种方式。
>> 因此，让我们来看看只有一个 最后一个要素，一是最终的构建，
这C允许。
我们会回来的 今后其他的还是。
然后我们通过观察得出结论： 在代码 - 不正确性
让代码work--而设计 的代码，建厂初期这些种子。
>> 因此，让我继续前进， 在这里开辟一个新的文件。
你知道吗？
我要重新实现 同样的程序，
但使用不同的构建体。
>> 因此，让我赶紧给自己 获得包括CS50.h
为CS50库， 标准Io.h像printf。
给我INT主要无效。
然后在这里，让 我继续前进，做到这一点。
>> 煤焦Ç得到得到CHAR，就像以前一样。
而且我将使用一个新的结构 now--切换，什么角色？
因此，开关是一种像 切换火车轨道。
或者，真的，这是怎么样的 如果一个别人，如果别人如果
但写的有些不同。
>> 开关看起来是这样的。
你有开关，然后什么 字符或你想看看号码，
然后一些大括号喜欢 划痕，只是说做这个东西。
然后你有不同的情况。
>> 你不if和else使用。
你从字面上用字情况。
你会说这样的事情。
>> 因此，在一个小写y的情况下， 或在资本Y的情况下，
继续前进并打印出肯定的。
然后打出来的开关。
而已。
我们就大功告成了。
>> 否则，如果，可以这么说， 小写n或大写字母N，
然后继续和打印 出去不，再突破。
Else--和这种是 默认情况下indeed--的printf error--
和公正的良好措施，但 这在逻辑​​上破则没有必要
因为我们是在最后 反正开关，
现在我打破了开关了​​。
因此，这看起来有点不同。
>> 但是，从逻辑上讲，它是 实际上相当于。
你为什么要使用 一个比其他？
有时候，只是个人喜好， 有时美学，
如果我看了一眼这个 现在，有什么东西
以说是为 这个代码的可读性。
我的意思是，心中永远的事实，这 代码是新的在房间里我们许多人。
>> 但它只是一种很漂亮。
你看小写字母Y，资本Y， 小写N，大写字母N默认情况下，
它只是一种跳跃 出你的方式
如此，可以说，也许 在前面的例子
与如果，和垂直杆， 和其他IFS，可能没有。
因此，这是真正的个人问题 选择，真的，还是可读性，
的代码。
>> 但在功能方面，让我 继续前进，使开关，点斜杠
开关，现在键入小写字母Y， 资本Y，小写的n，资本N，
大卫，重试，因为这是 不是单个字符。
让我们做X，错误，符合市场预期。
和，logically--这是值得 我会鼓励general--甚至
虽然我们只是刮伤 的一些功能上。
>> 它可能不是很明显，当你 自己坐到键盘，
这个怎么用？
你会这样吗？
关于有美丽的东西 膝上型或桌面，或访问
与编译器的计算机， 与这样的代码编辑器，
是你几乎总是可以回答这些 问题为自己只是尝试。
>> 例如，如果修辞 在眼前的问题是，
如果你忘记了，会发生什么 你break语句？
这实际上是一个 很平常的事，
因为它看起来并不 就像你真的需要它们。
他们并不真正完成 像想一个括号或卷曲
括号一样。
让我们继续前进， 重新编译代码，看看。
因此，请开关，点斜线开关。
让我们输入小写 Y，顶的情况下，回车。
所以我输入年。
>> 该计划说的没错，没有，错误， 因为虽然它是改变了主意。
但是，那种是的，因为会发生什么 有开关是第一种情况是
比赛实际上意味着，哎电脑， 执行所有代码的下方。
如果你不说破，或 不说破，还是不说破，
电脑会爆 通过所有这些行
并执行所有的人，直到 它获取到大括号。
因此，刹车，的确有必要。
但这里外卖，当 有疑问，尝试一些东西。
也许先救你的代码， 或将其保存在一个额外的文件
如果你真的很担心 搞乱了，不得不恢复
你知道的工作是工作。
>> 但尝试的事情。
不要像害怕，也许， 什么样的电脑可能会做，
或者，你可能碰坏。
您可以随时恢复 一些早期版本。
>> 因此，让我们通过观察结束 在代码的设计。
现在，我们有这个能力来写 的条件下，与写循环，
和变量，和通话功能。
因此，坦率地说，我们是那种回 我们是一个星期前从无到有，
尽管有一个不太引人注目的文本 环境比刮允许。
>> 但是请注意，我们的速度已经获得 那个词汇，即使是
要带一小会儿下沉， 所以，我们现在可以使用这个词汇
写出比较有趣的节目。
让我们一起来小步 往那，如下所示。
让我继续前进， 在这里创建一个新文件。
>> 我要调用此 prototype.c，并引进
首次的能力 使自己的功能。
有些人可能有 有划痕做到了这一点，
让你可以创建你 在刮自己的自定义模块，
然后将它们拖放到的地方 无论你想在C.
而在大多数编程 语言，你可以做完全
that--使自己的功能， 如果它们不存在。
>> 所以，举例来说，让我先走 和包括CS50.h，并且包括
标准IO.h，INT主要作废。
现在我们有一个 占位蓄势待发。
我一直在承印物 像今天的人的名字。
那种感觉like-- 不会是很好，如果有
是所谓的打印功能的名称？
我没有用printf。
我不必记住 所有的格式代码。
为什么不要我，为什么 没有人在我面前，
创建一个函数调用打印 名，给予一定的名字，
简单地打印出来？
>> 换句话说，如果我说，嘿， 电脑，给我一个字符串
通过询问用户这样， 通过CS50的get字符串函数。
嘿，计算机，把那个字符串 在左手侧的变量，
并称之为秒。
然后，嘿嘿计算机，勇往直前 并打印此人的姓名，完成。
>> 现在，这将是很好的，因为 这一方案，适当命名的，
告诉我这是什么应该做的 这些函数的名称的方式。
让我走，让原型，回车。
而且，不幸的是， 这是不会飞。
>> Prototype.c，7号线，字符 5，错误，隐式声明
函数打印名字 在C99，C99是无效的
这意味着一个版本的C ，在1999年就出来了。
就这样。
>> 所以，我不知道是什么 所有这一切意味着呢。
但我认识到红色的错误。
这是很明显的。
>> 并且似乎与 绿色性格在这里，
问题是打印的名字，开 括号S，右括号，分号。
但隐式声明 函数，我们确实看到前面简单。
这意味着，简单地说，锵 不知道我的意思。
>> 我用一个词汇词，它的 以前从未见过或被教导。
所以，我要教它 这个函数是什么意思。
所以我要继续前进，并做到这一点。
>> 我要继续前进，实现 我自己的函数调用打印名称。
而我要说，如下所示，这 它这样做，printf的，你好，百分比
S，反斜线N，名称，分号。
那么，为什么我只是做？
>> 因此，原来，为了 实现自己的功能，
我们种借用一些 相同的结构主要
我们刚刚得到 理所当然的，我
知道刚才复制和 粘贴几乎什么
我已经写了过去​​。
但这里要注意的格局。
诠释，主，无效的，我们将梳理出 没过多久什么实际意义。
>> 但在今天，只是 注意到并行性。
太虚，打印的名字， 字符串名称，所以有
一个紫色的关键字，这 我们要开始
调用返回类型，名称 的功能，并且然后将输入。
所以，实际上，我们可以提炼出 这种上周一样的
如，这是名称或 我们的代码算法
去写 - 的 底层算法
代码我们将书写。
>> 这是它的输入。
这是它的输出。
此功能，打印的名字，是 设计上采用了一个名为名称的字符串，
也好，作为输入，然后空隙。
它不返回任何东西， 像得到字符串或得到INT一样。
所以它要交给我的东西回来。
它只是将有一个 副作用，可以这么说，
印刷一个人的名字。
因此注意到，7号线，我 可以调用打印名称。
10号线，我可以定义 或实施打印的名称。
但不幸的是，这还不够。
>> 让我继续前进， 保存后重新编译这一点。
哇，现在，我做了它 更糟的是，它似乎。
这样的隐式声明 功能打印名称无效。
并再次，还有更多的错误。
但正如我前面提醒，即使 如果你不知所措，
还是有点难过，看到这么多 错误，只专注于第一
最初，因为它可能只是 产生了连锁效应。
所以C，或锵更具体地， 仍不能识别打印的名称。
>> 那是因为铛， 在设计上，是种愚蠢。
它只做你告诉它做什么。
而且只在该命令这样做 在你告诉它做。
>> 所以我定义主四线， 就像我们一直很经常做的事情。
我在第10行定义的打印名称。
但我想使用 在七号线打印的名称。
>> 这太快了，还不存在。
所以，我可能是聪明，像， 好了，我们只是一起玩，
和移动打印的名字了 这里，和重新编译。
哦，我的上帝。
有效。
它是那样简单。
>> 但逻辑正是如此。
你要教锵什么 是通过首先确定函数。
然后你可以使用它。
但是，坦率地说，这种感觉 像滑坡。
>> 所以每次我运行 一个问题，我只是
要突出显示并复制代码 我写的，就把它和它粘贴在这里了。
而且，可以肯定，我们可以 图谋一些场景
其中一个可能的功能 需要调用另一个。
而你只是不能把每 功能上面隔。
>> 因此，原来在那里的 一个更好的解决方案。
我们可以离开这个可以。
而且，坦率地说，这是普遍不错， 方便，良好的设计
把主要一是因为，再次， 主要就好像当绿旗点击，
这是函数是 被默认执行。
所以，你不妨把 它在该文件的顶部
所以，当您或任何 其他人查看文件
你知道这是怎么回事 通过阅读主要首位。
所以，事实证明，我们可以告诉锵 主动，嘿嘿，锵，四线，
我答应实施 一个函数调用打印
名称以一个字符串名为name 作为输入，并且没有返回的，无效的。
我会避开 后来实现它。
>> 这里谈到主。
现在主要在第9行可以使用 打印名称，因为锵
被信任的是，最终， 它会遇到的定义
姓名正楷的实施。
所以，救了我的文件之后，让 我继续前进，使原型，
看起来不错，这一次。
点斜线，原型，让我 继续前进，键入一个名称。
大卫，你好大卫Zamila，你好 Zamila，事实上，现在的作品。
>> 因此，这里的成分是，我们已经 做了一个自定义的功能，如自定义
划痕块中，我们要调用它。
但是，与划痕在那里你可以 只是创建它，并开始使用它，
现在我们要成为一个 多一点迂腐，
实际上训练锵 使用，或指望它。
现在，顺便说一句，为什么这段时间有 我们一直只是盲目信仰，包括
CS50.h，并且包括标准IO.h？
>> 那么，事实证明， 其中一些其他的东西，
所有的这些点^ h 文件，这恰好是文件。
他们在头文件，可以这么说。
他们还在用C写的但是 他们是不同类型的文件。
>> 现在，你几乎可以承担 所有这是CS50.h内
一些单行尚且如此， 名为打印名称的功能，
但对于获取字符串，获取 浮动，和其他几个人。
而也有类似的原型， 单行，标准IO.h内
像printf，这是现在在 我自己打印名称的功能。
因此，换句话说，这整个时间内，我们 刚刚被盲目复制和粘贴
包括这一点，包括 这，这是怎么回事？
这些仅仅是一种线索 以铛，以什么功能
的确都是执行，只是 在不同的文件别处
别处在系统上。
>> 因此，我们已经实现打印的名称。
它确实有这种副作用 打印屏幕上的内容。
但它实际上并没有 递给我的东西回来。
我们如何去 执行一个程序，
并交给我的东西回来？
>> 好吧，让我们试试这个。
我要继续贯彻 一个名为return.c
所以我们可以演示如何的东西 以获得更多的字符串，或得到诠释，
实际上回国 回馈给用户。
让我们继续前进，并确定主要INT无效。
>> 并再次，在未来，我们将 解释什么是int和这一空白
其实这样做。
但今天，我们将 理所当然。
我会继续和printf， 一个良好的用户体验，x是。
然后，我会等待 用户给我x，其中GET INT。
>> 然后我要继续前进 并打印出X到广场。
所以，当你只有一个 键盘，一般的人
使用小萝卜 键盘上的符号
代表的功率 的，或者的指数。
SO x的平方是目前我。
>> 现在我要做到这一点。
我可以do--什么的x 平方？点¯x平方为x倍的X.
>> 我们这样做了一些 今天已经很久以前。
这种感觉并不像 那么多的进展。
你知道吗？
让我们利用一些想法 从抽象的最后一次。
>> 那岂不是很好，如果 有一个调用的函数
方认为正是这么做的？
它仍然在的结束 一天，做了同样的数学。
但是，让我们抽象 拿走的想法
一个数字乘以 另一个，只要给它一个名称，
像方此值。
>> 并且，换句话说，在 C，让我们创建一个功能
叫方认为正是这么做的。
这将被调用方。
这将需要一个int。
我们会只是 称之为N，默认情况下。
>> 但我们可以把它叫做什么，我们想要的。
和所有它会 这样做，从字面上看，就是回报
n次n的结果。
但是，因为它是 回国东西，这
在紫色我们已经关键字 以前从未见过，我，第11行，
不能说作废这个时候。
>> 太虚，在这个例子中，我们刚才看到 而打印的名字，只是表示，
做一点事。
但是，不要递给我的东西回来。
在这种情况下，我想 返回n次N，
或者不管它是什么，该号码。
>> 所以，我不能说，哎，电脑， 我返回任何结果，无效的。
这将返回在本质上，一个int。
所以，这是所有在这里吗。
>> 输入方 将是一个int。
因此，我们可以使用它，它有 有一个名字，N.这将输出
一个int并不需要一个名字。
我们可以把它交给主，或者是谁 用我记住，如果我们这个值
想拥有自己的变量。
>> 并再次，唯一的新 关键字这里是回归。
而我只是在做一些数学。
如果我真的想成为不必要的， 我可以说INT产品得到n次ñ。
>> 然后，我可以说，回归产品。
但同样，我的观点同期 这恰恰不是好的设计 -
喜欢，为什么引入一个名字， 一个符号，如产品，
只是立即返回呢？
这是一个有点清洁， 有点紧张，所以
说话，只是说回n倍 N，摆脱这一行干脆。
>> 它只是较少的代码阅读， 失误少的机会。
让我们看看这个 其实现在的作品。
现在，我要去 提前做出回报。
>> 嗯，哦，功能隐式声明。
我以前犯了这个错误，没什么大不了的。
我只需键入，或突出显示和 复制，完全相同的函数原型，
或签名，该功能在这里的。
或者，我可以移动整个功能。
>> 但是，这是一个有点懒惰。
因此，我们不会那么做。
现在，让我回 再次，点斜线回报。
>> x为2。X的平方等于4。 x被。X的平方等于9。
而功能似乎 现在的工作。
那么，有什么区别吗？
我有一个这就是所谓的平方函数， 在这种情况下，我把在一个输入。
而我回来的输出。
然而，此前，如果 我打开其他的例子
从早期的，这 被称为prototype.c，
我有打印的名称， 退回作废，可以这么说，
或者，它返回什么， 简单地产生了副作用。
>> 那么是什么回事？
那么，考虑功能 得到的字符串只是一瞬间。
我们一直在使用功能 得到以下列方式串。
>> 我们有一个函数来获取 字符串，如包括CS50.h，
包括标准IO.h，INT，主要的，无效的。
然后每一次我 名为get字符串到目前为止，
我说的一样，字符串s 得到得到的字符串，因为GET string--
我们称之为get.c-- GET字符串 本身返回一个字符串，我可以再
用了，说，你好，逗号， ％的S，反斜线N，S。
>> 因此，这是相同的例子， 真的，我们前面了。
因此，获得字符串返回一个值。
但是刚才，打印字符串 没有返回值。
它只是有一个副作用。
所以这是一个根本的区别。
我们已经看到了不同的 类型的功能现在，
其中一些已经返回 值，其中一些则没有。
因此，也许它的字符串或整型，浮点或。
或者，也许它只是无效。
>> 不同的是 这些函数
获取数据并返回一个值实际上是 把东西回表，
可以这么说。
因此，让我们继续前进， 看一眼决胜盘
的实施例，给出了一个感，现在的 我们怎么可能，的确，抽象更好，
更好，更好或更多 多，而且多，为了
写，最终更好的代码。
让我们继续前进，并在精神 刮，做到以下几点。
>> 让我继续前进，包括 CS50.h和标准IO.h.
让我先走，并把 我自己一个int，主要的，无效的。
让我先走，称此cough.c。
>> 让我继续前进，只是 像划痕，打印出咳嗽/ N。
我想这样做三次。
所以我，当然，只是去 复制和粘贴三次。
我现在要作 咳嗽点斜线咳嗽。
让我们给自己多一点的房间 在这里，回车，咳，咳，咳。
>> 还有，很明显，已经是一个 机会改善。
我复制并粘贴 今天一几次。
但是，这是唯一的，所以我没有 必须输入尽可能多的字符。
我还是改变了什么 这些代码行。
>> 这三条线是相同的， 这感觉懒惰，的确是，
而可能是不正确的方法。
那么什么成分 我们可以改善这个代码？
我们不必复制和粘贴的代码。
>> 而且，事实上，任何时候你感觉 自己复制和粘贴，
即使不更改代码， 赔率是有一个更好的办法。
而且，事实上，有。
让我继续前进，循环做了， 即使语法可能不
自然来呢。
>> 这样做三次，只需 通过执行following--
我碰巧从实践中知道这一点。
但是，我们有一些例子吧。
你会看到在线 更多的参考依然。
>> 这是第6行的句法，即 就像从头开始重复
块，重复下面的三倍。
这是一个有点神奇现在。
但是，这会得到更多， 越来越熟悉。
>> 而且它会重复 八号线三次，
所以，如果我重新编译化妆咳嗽， 点斜线咳，咳，咳，咳。
它仍然以同样的方式。
所以这是一切优秀和良好。
但是，这不是很抽象。
>> 这是完全正确的。
但感觉好像有 可能是一个机会，
作为在世界 从无到有，来样开始
在这里添加一些语义使 我不只是有一定的循环，
和一个函数，说 咳嗽，还是咳嗽。
你知道吗？
我想做个 有点凉比，
实际上编写一个函数， 有一定的副作用，称之为咳嗽。
>> 而且它没有输入， 无返回值作为输出。
但是你知道它做什么？
它this--的printf， 报价引文结束，咳嗽。
>> 现在在这里，我要去 继续前进，对于int，
我得到零，我不到3，我加再加。
我会不会做的printf，这是 可以说是一个低层次的实现
详情。
我不在乎怎么咳嗽。
我只是想用止咳的功能。
而我只是要打电话咳嗽。
>> 现在，请注意二分法。
当你调用一个函数，如果你不 想给它输入，完全罚款。
只要做开括号，接近 括号，就大功告成了。
>> 当你定义一个函数，或 声明函数的原型，
如果你事先知道这不是 要采取任何参数，
说这些括号出现空白。
这使某些你 会不小心误用。
让我继续前进，使咳嗽。
而且，当然，我犯了一个错误。
>> 该死的，还有那 隐式声明。
但是，这很好。
这是一个容易解决。
我需要的只是原型上涨 在我的文件比我实际使用它。
>> 所以，现在让我又咳嗽，美观大方。
现在，它的工作原理。
让咳，咳，咳，咳。
所以，你可能会认为我们真的 刚过工程这个问题。
而且，事实上，我们是。
这不是一个好 的程序的候补
在时刻 重构，做什么
所谓的层次分解， 在这里你需要一些代码，然后
有种你因子东西出来，这样 归于更多的语义他们，
和重用它最终长期的。
但它是一个构建块朝 更复杂的程序
我们将开始 之前写了长
让我们有词汇 与写出更好的代码。
而且，事实上，让我们看看，如果我们 不能一概而论进一步此。
>> 这似乎有点跛，我，主， 需要担心这个该死的for循环，
并一再呼吁咳嗽。
为什么我不能只是告诉咳嗽， 请咳嗽三次？
换句话说，为什么我不能只是 给输入咳嗽，做到这一点？
>> 为什么我不能只是说，在 主咳嗽三次。
而现在，这是种神奇。
这是非常反复的在这里。
而且它是，事实上，一个婴儿的一步。
>> 但就在能力上说， 八号线，咳嗽三次，
它只是这么多的可读性。
而且，再加上，我不必知道 或护理咳嗽是如何实现的。
而且，事实上，在后来的 长期和最终项目，
如果你处理一个项目 一个同学或两位同学，
你会意识到，你要 有，或者想，分工。
>> 而你会想决定 事先，谁去做些什么，
并在其中部分？
而不会是好的 如果，例如，
负责撰写主力，完成。
而你的室友，或者你 伙伴更一般地，
负责实施的咳嗽。
>> 而且这种划分，这些 抽象的墙，
抽象或层，如果 你会，是超级强大，
因为特别是较大的， 更复杂的程序和系统，
它允许多个人建 东西放在一起，最终
缝合在一起以这种方式工作。
但是，当然，我们 现在需要解决的咳嗽。
我们需要告诉咳嗽 ，嘿，你知道吗？
你将需要采取 input--所以并不作废，int和现在。
让我们继续前进并投入 咳嗽整型。我得到零。
>> i小于多少倍。
我以前说过三种。
但是，这不是我想要的。
我想咳嗽推广到 支持任何数量的迭代。
>> 所以，事实上，它是n表示我想， 无论用户告诉我。
现在，我可以继续说打印咳嗽。
无论什么号码 用户通过在，
我会重复很多次。
>> 这样在一天结束时， 程序是相同的。
但是请注意，所有的这些东西 甚至可以是在另一文件中。
事实上，我不知道在 此刻怎么printf的实现。
>> 我不知道此刻怎么弄 串，或得到int或获得浮动
的贯彻落实。
而且我不希望 看到他们我的屏幕上。
正因为如此，我开始专注于 我的程序，而不是那些功能。
>> 所以，事实上，只要你 开始分解这样的代码了，
可能我们连招咳嗽 到一个单独的文件？
别人可以实现它。
你和你的程序成为 很漂亮，非常具有可读性，
可以说，真正的4 行程序就在那里。
>> 现在让我们继续前进 并作一次改变。
请注意，我的原型 必须改变往上顶。
因此，让我解决，这么 我没有得到大声呵斥。
>> 使咳嗽，让我跑一次咳嗽 更多的，仍然在做同样的事情。
但现在，看到我们有一个 成分为最后一个版本。
你知道吗？
我不希望只是咳嗽，不一定。
我希望有更多的东西一般。
所以，你知道吗？
我想这样做。
我想有，就像刮 确实，一说块，但不只是
说些什么的时候一定数目。
我希望它说一个非常具体的字符串。
，因此，我不知道 希望它只是说咳嗽。
我希望它说什么 字符串在通过。
>> 所以请注意，我全身 这让现在
比方说感觉就像一个好名字 对于这一点，喜欢从无到有，
有两个参数，不像划伤。
之一是一个字符串。
一个是一个int。
>> 我可以切换。
我只是有点像的想法 说字符串，然后再
多少次以后。
虚空意味着它仍然 不返回任何东西。
这些仅仅是视觉方面 效果，像[？乔丹？]
大呼小叫的口头副作用。
它仍然做了n次， 0到，但不等于n。
这意味着全部N次。
然后只需打印出 无论是字符串。
所以，我真的全身 这行代码。
所以，现在，我该如何实现 咳嗽功能？
>> 我可以做无效咳嗽。
我仍然可以在如何 你想多次咳嗽。
但是，你知道吗？
现在我可以踢的话。
>> 我可以调用的说 字咳嗽，经过n的。
如果我想，也能实现， 只是为了好玩，一个喷嚏功能，
我打喷嚏的时候一定数目。
我可以继续重用N，因为 注意到在这种情况下或范围是m
只有在这个函数中存在。
>> 和N在这种情况下只 这里这个函数中存在。
因此，我们会回来的 范围这些问题。
而在这里，我只是说， ACHOO，然后n倍，分号。
>> 而现在，我只需要借用 这些功能在这里签名了。
所以咳嗽是正确的。
虚空喷嚏现在是正确的。
>> 我仍然只是需要说。
所以我要说，说 字符串s，诠释N，分号。
所以，我已经过度设计的 赫克出这个计划。
>> 这并不 一定意味着这是
写作时你应该做的 节目即使是最简单。
就拿东西是很明显 很简单，真的很短，
并重新实现它 使用太多的代码。
但是，你实际看到的，而在 时间回头看这些例子，
与实现，哦，那些步骤 我们采取了实际一概而论，
要因素出来的东西， 直到在一天结束
我的代码实际上是非常合理的。
因为如果我想咳嗽3 次，然后打喷嚏三次，
我只是要重新运行此， 计划使咳嗽，并运行咳嗽。
而且我有三个咳嗽 和三个喷嚏。
>> 所以这是一个基本的 范例，如果你愿意，
对于我们如何去 实际执行的程序。
但是让我们只看到现在是什么 我们一直在做这一切的时候，
什么一些最终件 这是简单的命令后面。
在一天结束的时候，我们已经 使用锵作为我们编译了。
我们一直在写源 代码，将其转换
通过锵成机器代码。
>> 而且我们一直在使用刚刚制作 以方便我们这样的击键
我们不必记住 锵本身的咒语。
但是，什么是让真正在做什么？
并且，反过来，是什么 锵实际上做？
>> 事实证明，尽管我们已经简化 说今天的讨论，
你把源代码，把它作为 输入一个编译器，它给你
机的输出 代码，原来有
里边有几个不同的步骤。
和编译恰好是伞 术语一大堆的步骤。
但是，我们只是戏弄 这一点真的很快。
>> 事实证明，我们一直在做 更多的事情我每次运行一个程序的时候，
或每次我今天编译程序。
因此，预处理是指 在C程序this--什么，
如我们一次又一次地看到， 与此井号开始，
还是这里的＃标签符号，意味着 这是一个预处理指令。
这意味着，在这种情况下，喂 计算机，做一些与此文件
在你真正编译自己的代码。
>> 在此情况下，散列包括就是 本质上，C的说法方式，
哎电脑，去获得内容 CS50.h，并将其粘贴在这里。
嘿电脑，去获得的 标准IO.h的内容，
无论是在 硬盘驱动器，它贴在这里。
因此，这些事情发生 预处理时先。
>> 而锵做这一切对我们来说。
并且实现起来这么混账 快，你甚至不
看到四个不同的事情发生。
但是，这是第一个这样的一步。
>> 其实什么接下来会发生？
好了，接下来的正式 一步是编译。
而事实证明， 编译程序
技术上意味着从去 源代码，我们已经东东
今天一直在写，东西 所谓的汇编代码，东西
看起来有点不同。
>> 而且，事实上，我们可以真正快速的看到这一点。
让我真正进入我的IDE。
让我继续前进，开放的hello.c，这 是第一个程序，使用它我们
今天开始了。
让我继续运行锵一 有点不同，锵-S，hello.c中，
这实际上是要 给我另一个文件hello.s。
>> 我们可能永远不会 再次看到这种代码。
如果你把一个较低的水平 系统类像CS61，
你会看到更多 的这种代码。
但是，这是汇编语言。
这是X86汇编语言 这是基本的CPU
CS50 IDE实际上理解。
>> 和隐蔽因为它 看，那是什么
计算机理解得很好。
子Q，这是一个减法。
有动作。
>> 还有的调用函数在这里， 点¯xO形圈，一个动作，一个插件，弹出，
回报。
因此，有一些非常 低级别的指令
该CPU的理解， 我前面提到。
这就是英特尔内部。
>> 有模式 零和一其
映射到这些措辞arcanely，但 有些良好的命名，说明，
可以这么说。
那是发生在什么 您编译代码。
你得到总成 语言出来，这
装置的第三个步骤是组装 该汇编代码进入，最终，
机代码 - 零和一，而不是 文本刚才我们看到刚才。
>> 因此，预处理这是否找到 和替换，以及一些其他的东西。
编译把你的源代码 从C代码，源代码
我们写的，到组装 代码，我们只是看了一眼。
组装需要该程序集 码到零和一
该CPU真的会 理解在一天结束。
和链接是最后一步 出现这种情况的再次us--，
如此之快，我们甚至不 notice--，上面写着：
哎电脑，采取所有的 在零和一的
源于编译大卫的代码， 和他在这种情况下，主要的功能。
>> 哎电脑，去获得 所有的零和一
该工作人员CS50写道： 在CS50库内。
混合那些与大卫的。
哎电脑，去获得所有的零 和那些别人写了几年
以前像printf。
而这些添加进 整个事情，让我们已经
得到了我的零和一的 CS50员工的零和的，
printf的的零和一， 和我们使用其他任何东西。
>> 它们都能够结合在一起成一个 程序调用，在这种情况下，喂。
所以，从今以后，我们将只 用这个词编译。
我们会理所当然地认为，当 我们说，编译你的程序，这意味着，
哎做预处理， 汇编和连接。
但实际上有一些多汁的东西 对那里发生的引擎盖下面。
特别是如果你 让好奇的一段时间，
你可以开始戳 围绕在这个较低的水平。
但是现在，意识到 在外卖今天之一
是很简单的 开始的过程中，
越来越舒服的 类似的hello world。
事实上，大多数的我们今天做了 当然不会下沉超快。
它会采取一些 时间，以及一些实践。
赔率是，你将整理 的想打你的键盘
或者在屏幕大喊大叫。
而所有的这行。
不过，也许是尽量不要 这样做在图书馆这么多。
>> 最终，你会 被能够虽然，以启动
眼看模式，无论是在好的代码 你写在错误
你所做的。
和很像的过程 成为一个TF或CA是什么样子，
你会开始变得更好， 在看到这些模式比较好，
和公正的解决您的 自己的问题最终。
在此期间，将有大量 我们借给你们的支持，让你
通过这个。
而在写窗口 对于所有的问题
你会通过引导 所有的命令
我当然知道，从 现在大量的实践，
但可能已飞过 在一个人的头了。
这是完全的罚款。
>> 但是，最终，你会 开始看到的模式出现。
而一旦你过去所有的 愚蠢的细节，比如括号，
和大括号和分号， 和东西，坦率地说，
这不是在所有的 智力有趣。
它不是客观 服用任何入门级。
它是将要事情的想法。
>> 它的循环，而 条件，以及功能，
和更有力的抽象， 与上面的代码保理，
和良好的设计，以及良好的 风格，最终的正确性
你的代码，这是最终 事情影响最大。
所以下周，我们将采取以下 想法，我们第一次看到划痕
现在已经翻译 到C.我们将开始
引进第一的 当然，真实世界的领域。
>> 我们将专注于安全领域， 更具体密码学，
艺术扰码信息。
和第一批 你自己的问题，你
将得到超越写 与一些语法的打
和解决一些逻辑 问题，最终没多久，
是真正争我夺，或加密， 并最终解密信息。
而我们所做的一切 今天，将相当低
的水平，只是要允许 我们采取之一，和一，
以上朝着一个步骤 写作最有趣的代码呢。
>> 因此，更多的是在下周。
>> [视频回放]
>> - 什么，你能告诉我 您看见他是什么时候？
- 什么我可以说，真的吗？
我的意思是，它像任何其他 生产前的排练，
但有些事情，他说 在最后与我卡住了。
>> - 这是CS50。
>> - 那是一个切大家， 在排练伟大的工作。
>> - 这就是午餐？
>> 是啊，你和我可以 抢位三明治。
我只是听取汇报 大卫真的很快。
大卫？
>> [结束播放]