0:14 大家好，我是你们的 Shraddha didi，
0:16 欢迎来到今天的 C 教程
0:19 我从基础到高级都完成了
0:21 如果你已经完成了整个 C，那么请观看此视频
0:23 看完之后你将能够学习编码编程
0:26 你会学到它，如果你在大学参加考试
0:28 如果有人问起里面的人，那么他的
0:30 本教程将帮助您做好一切准备
0:32 我们将其分为 11 章
0:35 低于这个数字，你就会得到时间难题
0:37 如果你在那里，那么你也可以单独
0:39 如果你想读这个主题，那么你也可以去读它
0:41 加上章节，我们有 100
0:43 本视频中包含的问题
0:46 其中我亲自回答了70个问题。
0:49 我已经解决了你面前的问题和30
0:50 我已经准备好了练习题
0:53 家庭作业与视频一起提供
0:55 任意数量的代码或注释
0:58 您还可以在下面找到他们的链接。
1:00 所以一旦你完成教程
1:03 您可以随时来免费修改
1:05 如果你觉得
1:07 你认为这重要吗或者你可以告诉我
1:09 如果你想要的话请在下面评论我
1:11 你可以通过这样做来告诉我，如果你
1:13 我想收藏任何讲座
1:16 您必须将以下主题添加为书签
1:18 只需写下时间并评论即可
1:20 下次我们来的时候给我们，然后评论
1:22 我们可以在上面看到它，所以让我们开始吧
1:25 最新最棒的 C 教程
1:29 因此，在使用 C 语言编写代码之前，让我们
1:30 系统内部要安装的东西
1:32 必须要做的第一件事是
1:35 我们的 VS Code，即代码编辑器，现在是代码
1:37 编辑器就像一本笔记本。
1:39 我们在笔记本里用英语和印地语书写
1:42 以与编写代码相同的方式编写代码
1:44 我们在编辑器上写了一些代码，然后
1:46 您将使用的代码编辑器
1:49 名字是 VS 代码现在你已经看到了这个
1:51 这种情况会发生在大学里，学校里
1:52 有些人正在研究代码块
1:54 有些人正在开发其他软件
1:57 但这里我们使用的是 VS Code，所以
1:58 我正在使用它，因为它非常好
2:01 它是一个软件，您只需使用其中的 C 键即可
2:03 如果你不编程，那么你需要学习 c+
2:05 使用 Java 或任何其他语言
2:08 如果你想编程，我们也可以
2:10 通过像这样准备你的整个氛围
2:12 我会告诉你不要安装任何其他东西
2:15 如果我们从一开始就看，当我们写出好的代码时
2:16 如果你是一名编辑，那么有很多
2:19 所有的好处都是我们第二件事
2:21 您需要安装我们的编译器
2:24 我们现在将搜索 gcc
2:26 编译器是一个系统，也是一个软件
2:28 它里面写有规则
2:31 我们的编程语言是C语言
2:33 将会有一个编译器，其中将使用 C 语言
2:35 无论有什么规则，都必须写下来，然后你
2:37 无论你写什么代码，它都会根据你的代码
2:39 之后它会检查你是否正确输入了代码
2:42 编写并运行该代码的任务也是
2:44 如果编译器能做到这一点，那么它就与编译器有关
2:46 我们稍后会详细阅读。
2:48 首先，安装你的代码
2:51 转到编辑器，即 VS Code，然后转到 VS Code
2:53 要安装，请点击屏幕 首先
3:03 立即在此处加载适用于 Wind 的 VS Code
3:05 首先，我们会选择去 Vijay's
3:33 现在，在“下一步”上，将出现一个复选框列表。
3:35 她肯定要来找我们了，我们该怎么办？
3:37 你必须勾选所有复选框
3:39 必须这样做上面说的是桌面
3:42 但是如果为我们创建了一个图标那么
3:44 许多较低的路径等等
3:46 如果你向我们提供信息，那么所有的检查
3:48 勾选方框，然后
3:51 我们最终将安装 VS Code
3:53 它将为我们安装并单击
3:56 我们将完成它，但现在我们将启动系统
3:58 你可以去搜索 VS Code VS
4:00 搜索代码后它将打开并看起来像这样
4:03 有些出现在屏幕上
4:05 首先，我们将有一个主题
4:07 我们可以根据自己的意愿选择
4:09 选择浅色主题或深色主题
4:11 所以在那之后我们会去黑暗的地方
4:13 进入下一部分
4:16 如果我们愿意，我们也可以安装组
4:18 但我们现在不会为该集团工作
4:20 我现在不会安装它并标记它
4:22 VS Code 内部会给我们 As Done Now
4:24 我们必须打开一个新文件，在其中写入内容
4:27 如果可能的话，您可以单击新文件并
4:29 在这些文件中我们可以找到不同的
4:31 现在你将编写代码和程序
4:33 我们已经下载了 VS Code，但是
4:35 如果你还想使用其他代码编辑器
4:37 我希望你已经下载了它
4:39 所以你也可以使用它
4:41 代码我们要做的另一件事是
4:44 您现在将下载该 C 编译器
4:47 下载编译器
5:00 我们应该能够看到 chromecast.com
5:02 如果您想点击然后为我们下载
5:04 第一个启动的窗口
5:06 将会出现一个弹出窗口
5:17 那些已经存在的文件将继续被下载，然后再下载一个
5:19 将会打开一个窗口，要求我们
5:21 我们还需要下载哪些软件包？
5:23 如果有，那么我们将在其中得到复选框
5:25 这是针对不同语言的
5:28 目前我们要做什么基础工作？
5:30 如果您下载它然后将其安装在所有设备上
5:32 我们必须点击所有复选框。
5:34 你必须勾选它然后向左点击
5:37 安装选项将会出现
5:40 我们必须点击选项，然后
5:43 对于所有人，单击“应用更改”
5:45 我们需要下载我们的软件包
5:47 这些套餐可以提高您的网速
5:49 如果过了一段时间后它被下载了
5:52 你可能得等一会儿
5:54 现在，只要下载这些包
5:56 不，在那之后我们就会明白，一切都会改变
5:59 如果我们成功应用它那么我们就可以
6:01 我们将关闭它，所以现在我们已经关闭了代码
6:03 下载编辑器，即 VS Code
6:05 我们下载了CK编译器
6:07 我已经安装了，但还有一件小事
6:10 这就是我们现在的环境变量。
6:12 什么是环境变量或它是什么
6:14 我们在这一步到底在做什么
6:16 我们不会深入讨论它的细节，它是基本的
6:18 你必须明白，如果你想用 C 代码来
6:21 如果你想在系统内运行它，那么在此之前
6:23 你必须遵循所有这些步骤
6:25 为此，我们首先要做什么
6:28 我们将在我们的计算机系统中完成
6:31 前往文件并点击这台电脑
6:33 我们将进入这台电脑进行搜索
6:37 为 mji dmin gd 做搜索
6:40 完成此操作后，你必须进入 Majeed 的文件夹
6:42 我们必须进入 bin 文件夹
6:45 所以当整个东西都在 bin 文件夹中时
6:47 当我们
6:49 当我们点击时，我们的一条路径将会突出显示。
6:54 hoga 是 c 盘 smjid bin 是
6:56 我们需要复制整个路径。
6:57 因为我们将其用作我们系统的一部分
7:00 添加到环境变量
7:02 因此我们将右键单击并复制它。
7:04 现在我们要做的就是
7:06 控制搜索计算机内部
7:09 进入控制面板
7:11 我们将进入系统，进入系统内部
7:13 我们将进入高级系统设置
7:15 现在，只要我点击“高级系统设置”
7:17 当我们去的时候，我们会在屏幕上看到一个弹出窗口
7:20 但是里面我们有这个环境变量
7:22 如果你想去选项，那么再来一个
7:24 我们可以选择环境变量
7:28 此选项必须已在此环境中
7:30 在变量下面的系统变量中
7:33 我们必须找到这条路。一旦我们找到路径
7:35 如果我们必须走，我们会找到路
7:37 一旦我们的蓝色光标出现在路径上
7:40 然后我们将编辑它并更改路径
7:43 我们将在此编辑一条新路径
7:45 我们将编辑它并将其复制到新路径中
7:49 我们将向您提供我们的位置，
7:52 该位置是 Maji Dab 的 bin 文件夹
7:54 我们复制了该位置。
7:57 粘贴后按 Enter 键
7:59 然后再次按 OK，然后按 KK End
8:03 最后ka ok 所以这就是我们的
8:05 在路径变量内部，我们有
8:08 添加您最喜欢的垃圾箱的路径
8:10 现在我们将打开 VS Code，然后
8:12 我要通过编写示例代码来做什么
8:15 我只是通过运行它来向你展示
8:16 我们还没有明白 CK
8:19 内部编程是如何完成的？
8:20 或者如何让事情运转起来或者无论我们
8:23 你写的这些是什么意思？
8:25 我们必须看到，一旦我们了解了我们的环境
8:28 我们已经将我们的任何 C 代码都设置在此
8:31 如果它运行，那么我打开文件并看到
8:34 我将编写示例代码，因此我将使用 VS 代码
8:36 我们将在里面打开一个新文件
8:53 在执行 world.con 之前在 VS 代码中进行一些操作
8:56 我们需要安装一些扩展
8:58 这样 VS Code 就能理解
9:00 您要运行哪个代码？
9:02 为此，您需要一些额外的功能
9:05 如果你把它带给我，你会看到下面的扩展
9:07 您现在将获得运行 C 的选项
9:11 为此我们需要 c c+ p 的扩展包
9:13 在 VS Code 中安装
9:15 我们必须安装一次
9:17 因此我们将转到上面的终端并打开它。
9:20 新终端现在我可以输入一些命令
9:27 非常擅长写复杂的
9:28 编写高级 C 程序
9:30 如果你即将这么做，那么现在就不用担心 这
9:35 如果你要做肤色，那么我已经做了一些
9:38 我写了下面的代码和命令，然后我
9:40 我为我自己编写了命令 hello world
9:43 它将打印在我的屏幕上，
9:44 你会注意到上面的代码中我也有
9:46 打印 f 里面写了一些东西
9:48 我写了 hello world 所以我写了上面的
9:50 代码也写在我的屏幕下面
9:53 如果它也来了那么在我们的情况下就是这样的
10:01 我还为
10:03 如果你已经发生过，那么如果你有任何疑问
10:06 在安装过程中，您可以保存该特定视频
10:08 你可以去看看，里面有很多
10:10 你的疑问现在就被解答了
10:12 要编写 C 代码，我们首先需要
10:14 将创建一个文件创建文件
10:16 要做到这一点，请进入文件，然后
10:19 您必须单击“打开”，然后在“打开”内
10:21 我们将有选择，有人会来找我们
10:23 如果是旧文件夹，我们应该先打开它。
10:25 但我们要创建一个新文件夹。
10:29 我们将其命名为 C 教程
10:33 现在我们要打开这个C文件夹。
10:35 我们有一个打开的文件夹用于此
10:37 里面没有文件，所以首先我们
10:40 我们将像我们所做的那样放置一个 C 文件
10:42 您以前做过实用文件吧？
10:44 在学校里，我们所有人
10:46 我们以前也用现在的方式记录事情
10:48 我们将创建一个文件，其中所有内容
10:50 我们将编写代码来创建文件
10:52 为此，我们将点击此图标，然后我们的
10:56 我们将文件命名为 hellodc，因此
10:57 我们的文件已经到了，我们可以从这里开始
11:00 让我们关闭它。现在我们在这里命名了文件
11:02 h.我们可以给我们的文件起任何名字
11:05 我们可能想把它写下来
11:06 首先，我们可以编写程序
11:09 第一个程序是这个 doss
11:11 例如如果我们取 t a t
11:14 您是否曾在记事本上为 Vij 创建过文件？
11:29 它写道
11:31 如果写成 pe dot pwa，则扩展名
11:33 它告诉文件里面
11:36 这里点 c 是什么，是 c
11:38 有一个扩展，它告诉我们
11:41 我们已经创建了一个 C 文件，现在在这个
11:43 我们将在文件中执行的是示例代码
11:46 我们将编写 C。从这段代码中我们将了解到 C
11:48 写起来多么容易，而且完全一样
11:50 人们告诉我编程编码
11:52 这是一件非常大的事情，但没那么大
11:54 这很简单，我们可以看到一些东西
11:57 写下我们还不明白的事情
11:59 但一旦我们的第一章完成
12:02 一切都会变得清晰
12:06 但我们要写下一些事情
12:10 外星语言或许看起来像是性病警报
12:17 a int main 打印 f hello world 返回
12:19 Ro 现在我们已经写了 hello world
12:22 这是一种惯例，无论新
12:23 你学习编程语言吗？
12:26 其中第一个代码是这个规则
12:28 你在编码世界里的第一个代码
12:30 如果你必须写 hello world 那么它的
12:32 我们已经编写了代码，该代码的作用是
12:34 在屏幕上打印 hello world
12:37 如果你给了，让我们看看我们能怎么做
12:39 保存并运行任何 C 代码
12:41 我们必须去航站楼
12:44 将在新终端中打开新终端
12:48 首先我们写一行 gcc h s
12:50 这里的 GCC 是我们的编译器
12:53 是 c 的，所以我们调用该编译器
12:56 然后写下你的文件的名称
12:58 所以基本上我们要说的是我们的
13:00 我们编译文件中的代码
13:02 编译这个，这个词太难了
13:04 在第一章结束时，这一点也不会清楚
13:06 所以我们现在已经编译了文件
13:09 我们将运行这个我们将如何运行代码
13:15 将默认写入/添加此内容
13:17 创建的文件的扩展名为
13:20 它是点输出，即点输出，我们称之为
13:22 如果你运行它，它将为我们打印出来你好
13:24 现在全世界都知道程序员都在使用 Windows
13:27 这里你必须写 d a.exe 因为
13:30 默认情况下，Windows 中会创建一个 .exe 文件
13:32 其扩展名是 dati，即
13:34 可执行文件，但学生 我们的
14:01 这非常简单，非常合乎逻辑，如果有点
14:03 现在如果我们可以学习编码那么我们
14:04 我们将发现我们可以从中学到多少东西
14:07 如果你能做出有趣的东西，那么写下来
14:09 我们已经给出了我们的 Hello World 程序
14:12 这里面主要包含什么
14:14 发生了什么事为什么这里写有哈希
14:16 发生了什么事为什么这些
14:18 我们逐渐理解了它的含义
14:19 现在在第一章中我们将讨论一些
14:21 你将学习你需要学习的基本概念
14:23 后来我们开始理解编程
14:26 我们将首先进入这个
14:28 关于变量的关键词是什么？
14:30 我们的常数是什么
14:32 如何撰写评论
14:34 我们刚刚完成的是一个基本的 C 程序
14:35 它的结构是什么？
14:38 这就是我们在汇编中讨论的内容
14:40 代码在这台机器上实际运行情况如何
14:42 但我们将在这台计算机上讨论这一切。
14:44 我只会读第一章和其余的
14:47 您将学习的第一个主题是
14:49 这就是我们要开始的
14:52 如果我们讨论变量的定义
14:54 如果你这样做，那么这就是记忆的名字
14:57 存储某些数据的位置现在是可变的
15:00 每当我们
15:02 需要为此存储一些东西
15:04 首先，需要一个地方，例如，假设
15:05 如果我们想保留任何鞋子，那么对于鞋子
15:07 首先，任何商店都有盒子，对吧？
15:09 每个盒子里都装着一些鞋子
15:12 高跟鞋必须放在盒子里
15:14 如果拖鞋放在盒子里，那么
15:16 那些是拖鞋 那些是高跟鞋 那些是鞋子
15:19 这些都是运动鞋，它们都是我们的数据
15:22 我们可以把这个盒子称为容器
15:24 我们的数据存储在哪里以及
15:26 如果我们给容器命名，那么它
15:29 我们的变量将以相同的方式命名
15:31 当妈妈在厨房里放了很多香料时
15:34 假设有一个盒子，里面
15:35 有一个盒子，里面装着扁豆
15:37 姜黄存放在存放盐的盒子里
15:40 这些是里面的容器
15:42 我们拥有自己的数据，这意味着没有人可以窃取我们的数据
15:44 外面的集装箱里装有货物
15:46 现在我们称它为变量
15:48 这样，计算机也会存储一些数据
15:51 这些数据去往何处并存储于何处
15:53 假设这是我们的电脑
15:56 记忆，并在其中制作了一些自己的盒子
15:59 已经发生过，在这段记忆中如果我们
16:01 如果需要存储数字 25，那么我们可以将其存储在某个
16:03 我会把它存放在一个盒子里，那个盒子
16:06 我们将给它起一个名字，就是这里的名字
16:10 我们现在将这个变量称为
16:12 假设这之后没有数字，任何字符
16:14 如果我们想存储这个字符，那么我们可以将其转换为字符
16:16 存储在新的内存位置，即新盒子
16:19 我们将获得该内存位置的名称。
16:22 将给出 b，这个 b 将被称为什么，这将被称为
16:25 我们的变量在内存中，如果我们
16:27 如果你存储任何东西那么那个记忆
16:29 当一个地点被赋予名字时
16:30 我们给盒子起个名字
16:33 现在变量实际上被称为变量
16:35 如何通过编写代码实现
16:38 让我们看看这一行
16:41 你必须删除所有这些代码
16:43 这是我们的默认代码，即我们使用这个
16:45 我们每次都会写这个
16:46 现在不要注意，我们必须经过一些中间
16:49 假设我们必须关注的是
16:52 如果我们想存储 25 号，那么我们就去这里
16:56 我们将写入 int 数等于 25，因此
16:58 由于单行我们的人数是25
17:00 它被存放在我的那个盒子里
17:02 去吧，我们在这里给那个盒子命名了
17:05 如果有任何字符，则以相同的方式获取数字
17:09 Carestar 等于商店
17:11 星星在我们的记忆里
17:13 我们看到了键盘上的星星
17:15 存储在内存中，并且该变量
17:18 我们将该容器命名为 Star
17:21 同样，如果我们想存储年龄
17:24 因此我们将 int a e 写为 22
17:27 这是我们 Edge 22 内存中的
17:29 我们把它存储起来并给出了该位置的名称
17:32 diya edge 这里是 int 是什么
17:34 什么是性格，我们现在就来看看
17:36 会忽略并只关注这一点
17:38 类似地，假设我们有一条线
17:41 如果我们必须存储十进制值，那么我们
17:45 我们将写 float pa =
17:47 3.14 这就是圆周率的值
17:50 这是 3.14，现在也进入内存中
17:52 存储，并且该内存位置用于
17:55 我们给容器起的名字是这样的
17:57 某种程度上，任何数字、任何值都可以
17:59 我们可以把它存储在内存中，
18:02 我们知道它的存储容器
18:04 如果我们能记住名称，那么我们就可以称它们为变量
18:07 现在假设我们必须在 c 中写入变量
18:09 其中大多数都有一些规则
18:12 我们的第一条规则是变量 r 的情况
18:15 区分大小写是什么意思？
18:18 小 a 和大 a 会有所不同，
18:20 我们有大写字母 a 和小写字母 a
18:22 这些可能有所不同，我们不认为它们相同
18:25 例如，如果我们需要存储一个数字
18:28 是 30 那么我们可以写 int a = 30 然后
18:31 30 存储在内存中，并且
18:32 存储位置的名称
18:34 我们给了现在我们得到了第二个号码商店
18:39 如果我们想得到 40，那么我们写 int a = 40
18:42 因此我们在第二个地点有 40 家商店
18:44 我们去了，并给那个地方起了首都和名字
18:47 这里给出了这个 sl a 和这个大写 a
18:49 两者是不同的变量，并不相同
18:51 关于变量 c 的第二条规则是
18:53 关于这一点，他首先说
18:56 字符是字母，下划线是其
18:59 变量名称中的“whatever”是什么意思
19:01 我们的第一个角色要么是
19:03 它可以是普通的英文字符或
19:06 那么下划线可以是除
19:09 不可能有任何价值，就像我们有边缘
19:11 如果我们必须存储它，那么我们在这里写了什么
19:14 但是我们把它写成了int edge，我们这样使用它
19:18 int a = 22 但也可以写成
19:22 我们不能写 Heine a = 22，因为
19:24 我们的红线将会到达这里，这是错误的
19:26 如果我们写一个年龄也会发生这种情况
19:29 如果你愿意，它会变成红色，这意味着错误，继续吧
19:32 任何英文字符或下划线
19:34 变量名中只能出现第三个字母
19:37 我们的规则规定不能使用逗号和空格
19:38 空格表示变量名称中没有空格
19:40 可能有逗号或空格
19:42 比如我们得到最终价格
19:47 如果我们想存储它，那么我们将写入 int final
19:51 下划线价格 e e ₹ 1 现在这是
19:54 下划线并不是唯一的特殊之处
19:56 变量名称中出现的字符
19:58 可以这样说
20:01 如果我们在这里留出空间，那么这里
20:03 但我们会得到一个错误，因为我们在太空中
20:05 不能用于变量名或
20:07 即使我们用逗号代替空格
20:10 发生错误，因为我们甚至不能放逗号
20:11 只能使用一个特殊字符
20:13 是带有下划线的变量
20:16 这就引出了第四条规则
20:18 除了下划线之外没有其他符号可以
20:21 关于使用 now 变量的一个特殊之处
20:23 thing 变量的值是固定的
20:26 不，它可以像我们所做的那样改变
20:28 定义年龄变量是因为
20:31 截至今天我的年龄是 22 岁
20:34 但明天，也就是两年后，我们的年龄将是 24 岁
20:36 它将会更新那么我们该怎么做呢
20:38 从将写为我等
20:42 24 所以之前我们的年龄变量是
20:44 该内存位置存储了 22
20:46 但现在我们年龄已经 2 岁了
20:49 如果存储了 24，那么以这种方式
20:51 我们可以更新变量的值
20:53 因此，我们的代码中的变量
20:55 它们不断变化，事实上
20:57 变量的英文意思也是
21:00 有些东西在不断变化
21:02 所以现在一切都说得通了，当变量
21:04 我们还会每天写一个特别提示
21:07 给资深程序员
21:09 程序员给出变量的定义
21:11 名字应该总是有意义的。
21:13 一旦我们读到变量，我们就明白了
21:15 进来吧，里面存放着什么
21:17 就像我们在这里存储边缘一样，变量
21:20 它被命名为 Edge，并成为一家明星商店
21:22 所以我把它命名为 Star 和一些随机数字
21:24 如果存储了，那么我们已经给出了名称和编号
21:27 有时随机是的我们是 A B C 像这样
21:29 你可以给它命名，因为它很容易发音
21:31 但是每当我们编写一个大型程序时
21:33 里面有很多 A B C，对吧？
21:35 会有变量，所以 如果
21:38 如果
21:40 接下来你参加面试
21:42 在公司或任何
21:44 让你的项目达到良好的水平
21:46 如果你从事自由职业，那么请保持你的
21:48 我们需要把变量名写得非常整齐
21:51 比如如果我们只能存储 100 个
21:53 所以我们可以在这里简单地写 F。
21:55 但我们写了全名最终价格
21:58 从中可以理解100是一个价格
21:59 接下来我们要讨论的是
22:01 读取变量后，即我们的
22:04 数据类型 C 中的大量数据
22:06 这些是不同类型的数据
22:08 我们已经为您提供了它们的类型列表
22:10 您可以在下面看到所有这些幻灯片。
22:12 如果描述框中有
22:14 这里仍然没有什么值得记住的
22:16 事实上我们并不记得所有的人
22:18 你甚至不必这么做，有些事情是这样的
22:20 我们在编码时肯定会记得
22:22 如果发生这种情况，那么所有的事情都源于此
22:24 需要记住的数据类型
22:26 您在内存中存储什么类型的数据？
22:29 存储和任何类型的数据
22:30 确实会发生这种情况，这不是有具体规定吗？
22:32 它将消耗与
22:34 当你购买一个 U 盘时，上面会写有
22:36 这是 8GB 的 U 盘还是 16GB 的
22:38 就像我们的U盘一样
22:41 字符类型数据是账号
22:44 如果我们的一个字节内存被转换成一个整数
22:45 如果我们谈论数据类型，那么它占
22:48 如果我们的 2 字节内存用于浮点数据
22:50 说到这里，他吃了我们的四块
22:53 现在正在向学生传授记忆术
22:55 学习语言之后，我正在学习 C
22:57 是的，他和我一样有点惊讶
22:59 他们为什么要去，因为他们知道
23:01 C 语言中不使用布尔类型的数据
23:03 数据是string类型吗？
23:06 这两种类型都存在于 C 中
23:08 他们没有，因为 C 先出现
23:11 这意味着 C 出现在 1970 年，之后 C+P 出现
23:13 之后就有了 Java
23:15 当 JavaScript 出现时，我们变得非常
23:17 这是一种古老的语言，因此它有很多
23:19 有各种各样的东西，比如物体和
23:21 如果缺少课程，那么这些
23:23 对于这些概念我们需要另一个
23:25 如果你以后要学习语言，那么这些
23:27 在所有数据类型中，我们可以了解一些事情：
23:29 重要的数据类型
23:31 我会把它们写下来，现在只写它们
23:33 我们现在必须记住我们其他人
23:35 如果不需要，则在您的代码中
23:37 我们已经写了很多东西
23:39 删除一次，得到三条数据
23:42 这里我们先讨论一下类型
23:44 数据类型是 int 我们的 int 什么存储
23:46 存储 int 存储整数
23:48 价值观，也就是我们拥有的价值观
23:50 可以是正数，也可以是
23:53 可以是负数，例如 + 1 变成 + 2
23:56 完成 + 5 完成 -1 完成 0 完成 这
23:59 这种方法的值，所以如果我们必须存储边缘
24:01 如果我们想完成它，那么我们就会有完整的价值
24:03 通常我们会将其存储在 int 中
24:06 在数据类型中，我们将 int 写为 e
24:09 等于 22，所以从这一行我们得到三件事
24:11 我发现我们存储的第一个数据
24:14 它所在的内存位置是22
24:16 我们建了一家商店，并将其命名为 Edge
24:19 数据类型为整数
24:21 同样，如果我们要找到 π 的值
24:23 如果我们可以存储它，我们的整数将是
24:25 如果不存在，则使用十进制值
24:27 所以我们将其存储为浮点数
24:30 在数据类型中，我们将在这里写入浮点数
24:33 我们将写下 pi 并给出它的值
24:36 3.14 所以这是一个有小数的数字
24:38 我们将其存储在浮点数据类型中
24:41 除此之外，现在又添加了一个数据类型
24:43 谁的名字是角色那么谁
24:45 我们也有特殊字符，对吗？
24:48 一旦我们的哈希完成，我们的速率就在 M 上
24:50 Ho Gaya Star Ho Gaya IE AST 风险联合国
24:51 我们将所有内容都存储为字符数据类型。
24:53 我必须为这个角色写作
24:55 Carr，假设我们写
24:58 你的性爱
25:01 首先将字符存储在这里
25:03 为了做到这一点，我们必须写单引号
25:05 在里面我们可以写
25:08 这就是我们照顾角色的方式
25:10 存储了 float 类型的变量
25:12 我现在已经把砖砌好了
25:14 因为我们从基层做起
25:16 这三个是主要的，我们
25:19 我们需要记住，我们其他人会随着时间而前进
25:21 现在我们将继续学习更多
25:23 我们将要讨论的主题是
25:26 我们之前讨论过的常量
25:27 这个变量有什么问题 如果
25:30 如果
25:32 每当我们在大公司工作时，我们都会变得很大
25:34 让软件像管理员一样
25:37 我们创建了一个面板并为其建立了一个网站
25:39 我们为测试目的所做的工作
25:41 保留您自己的电子邮件密码
25:42 这是固定的，其值我们
25:44 不要每次都更改相同的电子邮件密码
25:46 如果我们想从这里登录，那么我们应该怎么做
25:48 可以将电子邮件放入文件中
25:49 您可以创建密码变量
25:51 以及两者内的任何值
25:54 我们可以在 C 中存储这些值
25:56 始终是常数，其值为
25:58 我们称它们为不变的事物
26:00 我们的三种常量
26:02 其中第一个是
26:05 Jar Constants 就像我们的第一名
26:07 一个人的价值永远是
26:11 该值可以是负 1 或 0 或负 fvo
26:13 一个人的价值不可能总是
26:16 如果它保持不变，它保持不变，那么我们的 1
26:19 2 3 0 -1 -2 此类型的常数
26:21 这些被称为整数常量
26:23 之后才是我们真正的
26:25 实常数，即
26:29 里面现在有像 1 0 这样的实数
26:33 还有 1.01，但它是一个实数常数
26:35 表明它的边是 0
26:38 Extra 的写法与 2 相同
26:40 如果只有两个，则写入 p0 extra
26:43 如果是的话，那么这个整数就会变成一个常数。
26:46 现在这就是真正的常数 3.14。
26:50 我们应该得到-2.4，那么这个
26:52 现在会有一个实数常数，第三种
26:54 我们的常数是字符
26:56 角色中有哪些常数？
26:58 我们所有的字母都来自
27:01 大写小写我们有
27:03 大写字母 A 在此处，特殊字符也在此处
27:06 就像我们有哈希一样
27:09 M%已经到来，我们的最高风险已经到来
27:12 或者除此之外，如果我们的投标率已经到来，那么这个
27:14 所有这种类型的人物加在一起就是我们的
27:16 创建字符常量和一件事
27:18 你必须在这里注意，角色
27:20 常数，即这个大写的
27:22 价值永远是资本
27:24 每当角色
27:26 常量必须写在代码里面
27:29 所以我们用单一代码来写它们
27:31 也就是说，每当我们定义一个字符常量
27:33 如果我们把它写在代码中，那么我们将得到单个
27:36 现在你必须应用代码，下一个主题
27:38 我们要讨论的就是关键词。
27:41 就像字典里有一些单词
27:43 每个词都有其固定的含义
27:45 我们无法改变它，每次都一样
27:46 编程语言有自己的
27:48 C也有自己的字典
27:50 有一本词典，里面有一些单词
27:52 是的，它们是保留的，即它们是固定的
27:55 它的意义对我们来说是一样的
27:57 不能用作变量名
27:58 应该做同样的事情
28:00 所以同样地，C 中也有一些保留的东西
28:03 有些词有特殊含义，
28:05 如果编译器知道这个意思，那么 C
28:07 编程语言内幕 32
28:10 有关键词，我们需要使用这些关键词。
28:12 如果这 32 个列表
28:15 如果我们谈论它，那么我们的 32 个关键词是这样的
28:17 在 C 语言的这个列表中，我们有
28:19 可以看出我们的 int 是保留的
28:22 word 是我们的关键字是 C，所以这个
28:24 即我们不能将任何变量命名为 int
28:27 如果我们出去寻找它，我们就能以同样的方式保留它
28:29 float 也是我们的关键词之一
28:32 此外，性格也是我们的关键词之一，
28:34 这些都是关键词吧？
28:36 现在，在我们整个课程的某个地方，我们
28:38 如果我们探索某个地方，我们就会知道
28:40 哪些是关键词，这就是为什么当
28:42 我们在节目中也看到过它，对吗？
28:44 就像我们在这里写的这个 int
28:46 具有只有编译器才知道的特殊含义
28:48 如果我们知道任何变量的名称，那么我们可以
28:50 不要保留int这是返回返回也是一个
28:52 关键字是任何变量的名称
28:54 我不会保留任何回报，因为这是特殊的
28:56 有些词有固定的含义
28:58 编译器现在知道一旦它的
29:00 了解程序的结构
29:02 我们编写的任何程序、任何代码
29:05 我们怎样才能真正理解它
29:08 它是如何像人类一样制造的
29:09 每个人都有骨架，就像每个人一样
29:11 每个代码都有一个程序
29:13 如果我们
29:15 谈论程序的结构
29:17 我们的程序看起来像这样
29:19 这是我们编写的初始代码
29:21 它首先写入哈希包括
29:23 然后我们有尖括号和
29:27 中间发生了性病，这叫做
29:29 我们是我们的预
29:33 处理器指令现在是一个预处理器
29:34 什么是指令，我们稍后会告诉你
29:37 现在，我们必须明白，
29:39 我们应该始终在代码中添加
29:42 否则我们的 C 代码将无法运行
29:45 在那之后，我们一定有一段时间总是会写下这句话
29:48 int men 然后我们的pensies 然后
29:51 花括号和花括号内
29:52 无论写哪一部分都会发生这种情况
29:55 我们程序的主要代码
29:57 执行发生在主函数中
29:59 从这个函数开始，即函数
30:01 我们的代码中有这样一段内容
30:03 它给我们一些工作要做，我们完成了功能
30:05 我也会详细阅读
30:07 任何 C 程序总是以函数开始
30:09 执行将开始，并且执行
30:11 它会逐行发生，也就是说，首先是这个
30:14 如果存在一行，则将首先执行
30:16 然后出现这一行，执行它
30:18 此后我们的主要功能将是
30:20 现在结束你会注意到每一个
30:23 代码行后面有一个分号
30:25 这意味着这条线后面也有一条线。
30:27 半微积分也写在这条线后面
30:29 半微积分写成这个半微积分我们的线
30:31 i 就像一个句号，就好像我们
30:33 我们用印地语写上句号
30:35 英语句子末尾的点
30:37 我们应用它，也就是说我们以同样的方式应用句号
30:39 我们可以在 C 程序中编写半微积分。
30:41 通过把这个我们表明这里我们的
30:43 现在这一行已经结束了，无论接下来写什么
30:46 他来自下一行，整个事情
30:48 我们也可以在这里写下这个东西，之后
30:50 我们就会知道他是下一个
30:52 因为它位于分号之后，
30:54 除此之外，我们的代码也是
30:56 所有指令均区分大小写，即
31:00 这里如果我们想写 int main 那么
31:02 这将是错误的，因为这些都是大写的
31:05 因为 C 是一种敏感语言
31:07 那么较小的那个将保留在小盒子里
31:10 大写字母将保留大写，我们称之为
31:13 不能互换或更换，那么这个
31:15 无论何时，道路的结构都会保留下来
31:17 让我们创建一个上面的 C 程序
31:19 始终使用头文件或预处理器
31:21 指令被包含，后跟 int
31:23 我想写并加上这些花括号
31:26 我们可以写任何东西
31:28 但最终我们总会有回报
31:31 在返回行中写入零
31:33 该行显示零错误，即我们的代码
31:35 这些是否都成功执行了？
31:37 如果没有发生错误，则此返回始终为零。
31:40 最后，我将这部分写在这里。
31:42 我们可以在代码中随时随地使用它
31:44 现在你可以改变下一个主题
31:46 在本章中我们将阅读
31:48 我们的评论就像我们的生活
31:50 人们一直在发表一些评论，对吗？
31:59 编写不属于我们代码的内容
32:01 有一些额外的部分评论英文
32:03 其中可能也有一些语言
32:04 允许我们的评论
32:06 我们还使用不同的语言写作
32:08 俄罗斯人可以用中文写评论
32:10 所以这是
32:12 这不包含在我们的代码中
32:14 现在有额外的说明
32:16 C 语言中有两种类型的注释
32:18 首先是我们的单行
32:21 我们用双斜线写的注释
32:23 然后我们就得到了倍数
32:25 我们称之为这种格式的行注释
32:27 现在让我们把它写到代码中
32:29 让我们写评论，看看如何写
32:32 就像在这段代码中我们有
32:34 解释了什么是数据类型
32:36 在这里我们可以写双
32:42 此代码显示如何通过斜线显示数据
32:46 类型在 c 中起作用，所以这是
32:49 它是用英语写的，部分代码
32:51 事实并非如此，假设我们有多个
32:53 如果我们必须在线写评论，那么我们
32:58 写 slush ast 风险和 ast 风险
33:00 我们可以在斜线和这个之间写任何东西
33:06 这是一个多行注释，所以这是我们的
33:09 我们在多行中写了一些内容
33:12 我们要走了，这都是评论的一部分
33:14 现在如果我们删除这个，那么这个英语
33:17 问题是这会给我们一个错误，因为
33:19 实际上 C 无法理解这一点
33:21 编译器无法理解这意味着什么
33:23 这是什么实际上写的是什么
33:25 这就是为什么那部分没有意义
33:27 对于编译器，我们总是在评论中提到它
33:28 他们像在大公司那样写作
33:31 如果你尝试编写代码，那么代码将如下所示
33:33 变成数千行代码
33:35 这就是为什么它变得难以理解
33:37 帮助其他程序员
33:38 我们在代码中写注释
33:41 告诉他们代码的哪一部分
33:43 该部件现在执行什么功能
33:45 我们将要研究的下一个主题是
33:47 无论何时我们以任何语言输出
33:49 编程时，有很多输入和输出
33:51 Essential 是非常重要的部分
33:53 首先，我们将学习 C 语言编程
33:55 之后我们如何显示输出
33:57 我们将学习如何在 C 中获取输入
33:59 然后在 C 内部显示输出
34:02 我们刚刚写了一份声明
34:04 打印 f 然后应用它
34:07 括号内的括号我们写双
34:09 我们可以在引号和双引号内写任何内容。
34:11 也许我们已经写了 hello world
34:14 在这里我们可以写你好 shraddha
34:17 在这里我们可以写你好我们的大学
34:20 这里我们可以写 hello c 或者其他东西
34:22 也可以写在这些双重代码里面
34:25 无论我们写什么，都将保持不变
34:27 我们会把它打印在屏幕上，
34:28 获得此印刷品
34:31 责任就是这个打印f名称
34:33 printf 类型的函数
34:35 为您丝网印刷任何东西
34:37 在这一行的末尾，我们将
34:39 半微积分表明这里的线
34:41 如果它的例子结束
34:44 如果你查看我们的代码，我们在这里写
34:46 可以打印 f 并在其中写入
34:50 你好，让我们把它保存在顶部
34:52 吹掉多余的空间并运行
34:55 让我们这样做：打开终端并在上面输入你的代码
34:58 会来帮我们打印
35:00 完成了你好 C 现在假设我们必须一遍又一遍地重复
35:02 我想重复打印 hello c，怎么做
35:05 我们将打印它，我们将复制这一行
35:09 是的，粘贴粘贴粘贴所以我们已经做了四次
35:11 你好，我已经打印了C并且保存了。
35:14 让我们把它拿出来并在这里再次运行。
35:16 现在我们在上面印上了 Hello C
35:19 紧接着，hello c又被打印出来
35:21 它以这种方式印刷了四次，但我们
35:23 希望在下一行
35:25 如果打印出来，那么它应该总是在下一行
35:27 为此，我们必须在这里写一件事
35:32 有一个特别的东西，那就是我们的包
35:34 这句话表明，无论我们
35:36 你必须在 print f 中打印它，
35:38 将在下一行之后打印
35:41 它会来的，在这里写相同的 bean
35:42 即使这样，我仍然希望下一行
35:45 即使在此之后，下一行也是必需的，在此之后
35:47 如果你还想要下一行，那么这样做
35:49 让我们保存它并在这里再次运行它。
35:52 现在我们的输出是
35:55 一切是否顺利，实际发生了什么
35:57 它打印了 hello c 所以 hello c
36:00 打印完成后，将打印件装入袋子
36:02 如果你这样做，然后返回 sl a，即下一行
36:04 我们又来了你好
36:06 打印出来后我又坐了下来
36:08 当你以这种方式到达下一行时
36:10 我们需要将输出移到下一行
36:13 我们也不写 ba s n 现在值
36:15 假设我们为自己创建了一个变量
36:19 就像在代码中我们写了 int a e
36:23 等于 22，我们想要打印这个边。
36:26 如何在屏幕上打印
36:28 如果您达到这个年龄，请写信给我们
36:33 必须按原样打印 f 我们应该写成
36:36 一旦完成，我们就会看到边缘的输出
36:39 就像这样，这就是我们在双引号里的内容
36:41 还写了这个我们称之为字符串
36:43 这意味着这个东西将按原样打印
36:46 但我们需要其边缘内的数字
36:48 如果你想打印，那么打印输出
36:51 有些情况是在完成的过程中出现的
36:53 第一种情况是
36:56 即使我们需要打印任何整数
36:58 为此，我们必须在打印语句中写入打印语句
37:01 首先你必须写出百分比
37:04 符号和 d 这个 d 代表双精度值
37:05 Double 也是一种数据类型，了解一下
37:08 我们稍后会学习百分比
37:10 和 d 的符号，然后一旦该线
37:13 一旦结束，我们会写一个逗号，然后再写
37:15 每当
37:17 整个内容都会被打印出来，对吗？
37:20 将被打印，并将该百分比放置在 D 的位置
37:22 我们这个时代的价值将会到来，
37:25 如果它是真的，它会以同样的方式替换它
37:27 如果你想用数字来完成，那么我们写
37:29 我们将写出百分比 f，然后我们将写出
37:31 变量，然后这将替换变量的值
37:33 每当输出此百分比 f
37:36 如果对字符完成，将会打印
37:38 如果是，则写百分比 c，然后写
37:41 如果你给出变量，那么这里的变量将会像这样
37:43 百分比将取代 c，那么这个
37:46 这样，每当我们打印一个变量
37:48 这需要完成数据类型是
37:50 如果有人有某种类型，那么我们
37:52 以整数类型写入百分比 D
37:54 让我们用实数表示百分比 f，
37:56 百分比以字符表示，
37:59 实际上，在 C 语言中我们称这三种。
38:01 它说格式
38:04 指定输出的格式
38:06 我会来找我们，这个印刷品 f
38:08 这实际上是我们的库函数
38:10 这是一个默认提供给我们函数的函数
38:12 如果提前送达，则
38:15 我们也看一下这些输出的情况
38:17 执行完这个之后，如果我们必须写 edge
38:19 所以我们知道我们必须在这里写
38:21 此处必须应用百分比 D
38:23 逗号，在这里我们写成让我们这样做
38:26 现在让我们保存它并打开我们的终端。
38:30 我们已经把它打印出来了，年龄是 22 岁
38:32 这就是为什么这个百分比符号出现在这里
38:34 因为我们还没有给出下一行
38:37 所以如果我们保存它并给出下一行
38:40 现在我们22岁了
38:42 这样，如果我们要打印的不是边缘
38:44 如果我们想知道 Pi 的值，我们会把它写下来
38:47 浮点数pa=
38:52 3.14 在这里我们写下百分比 f 和
38:55 这里我们将写饼图，让我们保存它
38:59 现在我们有印刷边缘
39:02 3.14 因此默认情况下，float 内的任何内容
39:04 有一些小数总是打印
39:06 如果它们真的发生了，那么我们就把它们包括在这里
39:08 我已经打印出来了，现在你一定在想
39:10 这句话一遍又一遍地重复，就是执行
39:12 情况如何，所以你的箭头键
39:15 在键盘上，你可以使用上面的键来解锁它们
39:16 如果你能按旧的，那么
39:18 你可以输入命令然后你
39:19 重复执行整个语句
39:21 你不必直接写信
39:23 按下该键即可执行它。
39:25 现在以类似的方式如果我们有任何
39:26 假设我们想要打印一个字符
39:29 这个角色成就了一位明星
39:33 是变量的名称，里面有星号
39:35 如果已存储，我们将在此处写入
39:39 明星在这里将会到来百分比 c 和
39:42 明星会来到这里，让我们拯救它
39:45 当我们运行它时，我们得到了输出
39:48 星盘是这样的
39:51 我们在
39:53 现在您可以在屏幕上打印
39:55 下一个概念非常重要
39:59 这种语言的概念是我们的
40:02 为了获取输入单元内的输入，我们使用
40:05 使用实现另一个函数的函数
40:07 有一个名为 scan 的库函数
40:10 用于像 f 一样打印
40:12 打印 f 同样接受任何输入
40:15 要扫描此文件，您将使用扫描 f
40:16 现在它的格式是无论谁
40:20 我们需要先将值作为输入
40:22 如果你输入，格式将是
40:25 指定的百分比 d 表明
40:27 我们可以将 int 类型的值作为输入。
40:29 如果你要去，那么首先把你的报价
40:34 将赋予双引号其自己的格式
40:37 我们必须逐个指定逗号
40:38 这是我们正在获取的输入值
40:41 我们已经了解了类型，现在该输入哪一个
40:44 如果你想将它存储在变量中，那么写
40:46 你的变量的名称和该变量的名称
40:49 我会把 M 百分比放在这个 M 百分比之前
40:52 这意味着，实际上它是一个地址，这是
40:55 这是变量的地址，即它将做什么
40:59 记忆里的边缘没有记忆
41:02 区块将到达给定的地址
41:05 无论我们得到什么反馈，我们都会
41:08 如果它获取地址并存储它那么它将是这样的
41:11 scanf 仍然有效，现在怎么办？
41:13 让我们以数字作为输入并看看
41:15 这实际上是扫描 f，也就是扫描
41:18 这个数字我们把它变成一个
41:21 变量 edge 现在将写入此处 print f
41:24 Enter Edge 现在将扫描此变量
41:29 是从地址边缘开始的扫描百分比，
41:31 无论我们去那里有什么价值
41:33 我们将存储它，并将其打印出来
41:35 将再次给出这意味着百分比 D
41:39 首先让我们写下年龄就是年龄，让我们这样做
41:41 让我们保存，然后打开我们的终端
41:45 首先，我们必须进入我们的年龄
41:47 我们将输入 22 我们已经打印出来了
41:50 年龄是 22 岁，所以无论我们进入那个年龄
41:53 它在这里重新印刷
41:56 scanf 做了什么进入边缘
41:58 以及内存中的边缘变量
42:00 我去那里后指着位置
42:03 我们保存了那个边缘，那个数字 22
42:05 当 Print F 说
42:07 如果你回来询问号码，我们就会得到它
42:10 它按原样打印出来，在这里
42:12 表明打印 int 类型的值是
42:14 然后我们从边缘内部提取数据
42:16 它显示在你的屏幕上然后像这样
42:18 输入输出的工作方式
42:21 现在在 C 里面，我们有一个小的
42:22 打算做一个这么小的程序
42:25 你将如何在程序中对数字 a 进行操作
42:28 将接受输入 a 数字 b 将接受输入和
42:31 我们将输出这两者的总和。
42:34 所以我们要写这段小代码
42:36 为此，首先我们创建这些数字
42:40 如果我们这样做，那么 int A & B 将成为第一个
42:45 打印 f 输入 a 然后扫描
42:51 将执行 A 到 D&A 然后打印
42:55 将执行 f 输入 b 然后 scanf 它
43:00 将接受输入，并且 b 现在等于这两个
43:02 将存储在第三个变量中
43:09 即 int sum i e a + b 所以这里也加上
43:12 减乘除提醒这一切
43:14 如果你喜欢数学，那么加法
43:16 加号代表减号
43:18 符号，这相当于做什么
43:20 它将计算这两个值，并且
43:23 这相当于将其放入总和中
43:25 这叫做赋值运算符加
43:29 我们使用它作为加法运算符
43:31 这些运营商有何不同
43:32 无论 c 里面是什么，我们
43:35 如果你正在详细讨论，那么这
43:37 我们已经收到款项，立即打印
43:40 将打印 f 到 sum
43:42 是百分比
43:46 让我们把这段代码保存在里面
43:49 我们所做的是创建两个变量 a 和 b
43:52 首先输入一个，所以我们写了一个
43:54 我让他输入它，然后他添加了那个变量
43:56 存储在内存位置
43:58 之后我让 b 输入它，
44:00 存储在内存位置
44:02 之后创建一个新变量，其值为
44:04 将 a 和 b 相加得到的最终值
44:07 我把它存起来了，之后我们
44:10 现在已经打印出总数
44:12 打开终端并显示其输出
44:15 首先，让我们分析一下
44:18 如果输入值，则按 Enter
44:21 然后我们将在其中输入b的值
44:23 输入 5，这样我们就有
44:26 输出结果为 sum is seven，这样就有两个
44:29 五加二等于七
44:31 现在打印出来了，我们将向你们展示一个小的
44:34 这是要学习的第三个技巧
44:37 我们创建了变量 sam，所以我们将其删除
44:40 给出它，你会在这个问题上直接做什么
44:44 通过删除 a，我们将在这里写 a + b，然后执行此操作
44:46 让我们保存它，再一次，
44:50 如果我们运行代码 2 5 然后直接
44:52 我们有七样东西与我们平等
44:54 一旦打印出来，我们需要第三个变量
44:56 没有必要在我们有
44:57 如果您想打印，请点击此处
44:59 如果我们还必须打印差额，那么我们会加上
45:01 你可以用减号代替 0
45:04 如果产品必须打印，那么 Asteris
45:06 你也可以通过这样做来将它们相乘，所以这
45:08 无论你想以这种方式打印什么值
45:10 您可以直接对其执行操作，
45:12 我们可以在这里写下来，现在我们有
45:15 我学到了很多 C 语言知识，
45:18 他是如何管理这一切的？
45:20 我们将其写入一个文件中，然后从该文件中
45:22 我们不断得到输出，现在整个
45:25 我们把整个过程称为编译
45:27 让我们了解实际发生的过程
45:30 编译的定义是什么
45:33 是一个翻译的计算机程序
45:37 C 代码转换成机器码，那么编译器是这样的
45:39 编写 C 代码的程序
45:41 并将其翻译成机器代码
45:44 就像我们的议会
45:46 如果有外国客人来那里
45:48 如果法语
45:49 当首相介入时
45:52 会有一位懂法语的翻译
45:53 总理指的是印度总理。
45:56 将以与我们相同的方式将其交给部长
45:58 对于计算机内部的语言也是如此
46:00 计算机是翻译器
46:03 我们的 Windows 机器不懂 C。
46:29 有一个名为 linux.com 的文件，我们使用了它
46:31 将其发送给编译器，然后 C 编译器
46:34 它首先会检查文件
46:36 是定义规则的 C
46:38 语法定义全部遵循它们
46:40 这没有任何错误
46:42 我们的变量没有错误
46:45 它的名字不是以数字开头
46:47 我做到了，我只是在开头加了一个下划线
46:49 所以他们应该检查这种方法的基本错误。
46:52 如果有错误，那么他们
46:55 导致编译失败，但如果
46:57 我们的文件被编译了，这意味着没有
47:00 不包含语法错误，然后
47:04 编译器将其转换为
47:06 将其转换为 windows.exe 文件 和
47:24 您还可以在 linux.com 上创建 DSLR，并且
47:25 我也可以画出一个点，但是再见
47:28 您将看到的默认扩展名是
47:31 这将是您机器内的扩展
47:33 所以如果你
47:35 我看到屏幕上有一个点，
47:37 如果您在屏幕上看到点，那么
47:40 现在我们已经学习了C的基本概念。
47:42 我们已经明白了，到目前为止我们已经得到了一点
47:44 我认为
47:46 什么是编程，那么在它里面我们有两个
47:49 你会解决这样的问题，如果你是一个大学生
47:51 如果你正在学习，那么通常里面有基础知识
47:53 如果有人问你任何简单问题
47:56 如果是这样，那么它们看起来会像这样，大多数
47:57 我们将要解决的第一个练习题
47:59 我们要做的是编写一个程序来
48:02 计算正方形的面积
48:04 我们需要计算边的面积
48:06 我们有知识，我们懂数学
48:08 我曾在低年级学习过
48:11 边长乘以面积是多少
48:14 所以我们要做的是一个像这样的程序
48:16 其中一方将接受输入，
48:19 然后你将代码的输出提供给该区域
48:22 让我们在里面尝试一下，看看上面的评论
48:23 写下面积
48:27 off square 首先定义一个变量
48:29 我们将进行侧面处理，然后将其打印出来 是
48:31 是
48:36 现在进入侧面扫描 f 并拿走它
48:39 如果有输入，我们将写入百分比 D 和
48:44 现在我们可以打印区域了
48:50 百分比 d 是边对边的
48:52 让我们保存它并打开我们的终端
48:56 让我们在我们这边运行它，我们输入
48:58 如果是四，那么我们的正方形面积是
49:02 16 因为这里现在需要 4 * 4 e 16
49:03 并不是说站在我们这边的人都会是一个实体
49:06 如果是的话，它也可以是我们的浮点值
49:09 如果边是我们的浮点值，那么这个
49:11 如果这里不是百分比 d
49:14 百分比 f 也会来到这里
49:15 会出现，因为两个浮点数如果
49:17 如果相乘则为浮点值
49:20 它被生产出来，我们会保存它，
49:23 所以现在如果我们再次尝试跑步，那么侧面
49:26 输入四那么我们将得到面积是 秒
49:27 秒
49:30 16.00 所以他把自动四挡放进去
49:33 现在内部转换为浮点型
49:35 我们接下来要做的练习题是
49:38 它说编写一个程序来
49:40 计算圆的面积我们在这里得到这个
49:42 旁边写着
49:46 已知圆的半径和面积
49:48 一个圆圈我们知道我们有一个圆圈
49:51 r s pa 的值已知
49:54 该常数为 3.14。其中，r 是
49:56 如果我们将其相乘，那么面积将如下所示
49:58 一个圆圈将会来到我们身边
50:01 让我们稍微改变一下程序
50:05 我们写浮点半径，并写在这里
50:06 我们给予 进入
50:08 进入
50:13 现在半径无论我们输入什么值
50:15 无论输入什么值，我们都将其称为半径
50:18 我们将把它存储在一个变量中。现在我们将写 区域
50:19 区域
50:25 是 pi，即 3.14 乘以
50:29 半径逐个半径，因为我们必须采取
50:31 这是半径的平方，我们这样做
50:34 保存在这里我们定义半径
50:37 然后用 print f 写入变量
50:39 我们按下 Enter Radius，然后在屏幕上按下 Radius
50:41 我们把它存放起来，然后清理了该区域
50:43 该区域是如何存储的？
50:46 将 3.14 乘以半径，得到
50:49 我再次乘以半径
50:53 如果出现以下情况，我们在终端中运行 radius
50:56 如果我们按下回车键，就会出现输出
51:00 圆的面积是 28.2 600，那么
51:02 我们怎样才能解决这些问题
51:05 到目前为止，我们在本章中学到的一切
51:07 我已经在里面看到，我们的第一章刚刚结束。
51:10 我们从这里开始了第一章，即：
51:12 C 的所有基本概念都非常容易理解。
51:14 我已经成功完成了所有这些
51:16 此类问题使用概念
51:18 有时发生在你的学期中期或
51:20 在期末考试中被问到
51:22 比如从华氏度到摄氏度
51:24 应从摄氏度进行转换
51:26 应提供华氏度转换或
51:28 要计算简单利息，我们有
51:29 让我告诉你这个公式
51:32 应用公式或像这里一样
51:34 我们找到了半径，并根据半径得到了面积
51:36 我顺便计算了正方形的面积
51:38 矩形的面积可以称为三角形
51:40 可以说话或说话的区域
51:42 如果你计算复利，那么
51:44 基本上通过使用小数学公式
51:47 无论什么事情可能或输入
51:49 输出可能的一切
51:52 理解了该方法的概念之后，我们
51:54 我现在可以得到代码了，下一章就在这里
51:56 我们第二章即说明结束
51:58 演说家在此我们将读到 c k
52:01 里面的指令和操作符怎么样
52:03 这意味着现在在本章中我们
52:04 会做很多数字的事情
52:07 我们将一起与数学相关
52:09 我们将学到很多新概念，所以如果我们
52:11 查看笔记中的此类页面
52:13 里面写了很多信息
52:15 那么不要惊慌，因为那些事情
52:17 我们不需要一次性记住所有内容
52:19 您可以在下方找到所有笔记
52:21 当你想复习的时候
52:23 你感觉我现在记得这些事
52:25 需要在考试前一天做
52:27 如果在面试前或为了面试而修改
52:29 然后你可以通过访问这些
52:32 你现在就可以读出名字，因为课程正在进行中。
52:34 当时留在我们脑海里的事情
52:36 我们必须自然地记住它们
52:38 现在我们必须记住一些东西
52:41 如果你不想麻烦
52:43 首先，让我们开始本章
52:45 您将阅读哪些说明
52:47 指令内部的基本定义
52:49 碰巧这些是
52:51 程序意味着到目前为止我们已经有
52:54 每个人都在编写程序，每个人都在编写代码
52:55 指令序列是什么
52:58 一个接一个
53:00 每当我们
53:02 我们先看看程序的官方定义
53:04 它也不是指令序列
53:06 例如，假设我们必须制作 Maggi
53:08 什么是指令序列
53:10 首先把水烧开，然后把 Maggi 放进去
53:12 添加香料和你的实际
53:15 加入 Maggi 并使其升温，然后再加入茶
53:16 如果你想做的话，先加水
53:19 他们把我们的牛奶放进去并加糖
53:21 让我加茶叶，加姜
53:24 然后煮沸
53:25 如果我们将其过滤掉，那么这些就是一些序列
53:27 说明与任何相同
53:29 程序中的一系列事件
53:30 是运行程序的指令
53:33 告诉她现在该做什么
53:35 当我们阅读各种类型的指令时
53:36 因此，我们最常遇到的有三种类型
53:39 第一个类型声明指令第二个
53:41 我们的律中有指示，
53:43 第三个是我们的
53:45 这三个指令都有不同的功能
53:47 他们的名字是根据他们的工作而命名的
53:50 所以记住它们并不是很难
53:52 如果我们先讨论类型，那就比较困难了
53:54 申报类型说明
53:56 你如何理解声明领带类型
53:58 声明意味着任何变量
54:01 用它的类型来声明它，所以每当
54:03 我们写这样的语句
54:05 写出我们有的说明
54:08 我们必须指定变量及其类型
54:09 我们必须声明它，我们输入
54:12 我们经常给出声明
54:13 在你的 C 代码中输入时间
54:16 编写声明语句
54:18 我们可以这样写
54:22 int a = 4 这也是我们的类型声明
54:25 该语句是如果我们写字符 c e
54:28 等于ast风险，这也是我们的类型之一
54:30 有一个声明，但每当我们说这个
54:32 当你写声明时，一个小错误
54:35 我们往往会忘记一条规则
54:38 我们的规则是先声明变量
54:41 使用它每当我们使用变量
54:44 在使用它之前我们应该
54:46 你必须声明，也就是说你必须看到
54:48 其中一定有一些有效的价值，我们
54:50 编译器预先被告知这个
54:52 变量存在于代码中，然后我们
54:55 如果不是这种情况，请使用 C 编译器。
54:57 会突然看到一个变量
55:00 它从哪里来，然后它会抛出一个错误
55:02 如果我们看一下它的有效例子，那么
55:05 这里我们将 int a 声明为
55:08 22 那么 int b 包含 a 的值
55:10 把它放在 b 中，这是绝对正确的，因为 a
55:12 它已经被声明，然后在 b
55:15 它的价值就消失了，如果我们编写这个代码
55:17 如果我们尝试将其写成如下形式，那么我们的函数
55:22 在里面我们可以写 int a = 22 和
55:25 然后写如果 int b = a 那么就没有
55:28 我们也没有收到任何错误此代码是
55:30 此后我们的工作将会非常顺利
55:32 如果我们能做什么
55:35 也写 int c = int b + 1 即
55:37 已经有一个声明的变量，您可以在其中
55:40 您是否添加了某些内容或者它是 -1
55:43 或者会是 2 的倍数
55:46 如果除以 3，那么也会像这样
55:49 如果我们要对红斑进行手术，右手
55:51 然后将其分配给 c
55:54 所以这也是有效的，而且是绝对正确的。
55:55 让我们实际写一下并看看程序
55:59 在 c 中，如果 b，则 i 等于我们的
56:02 当我乘以 6 时，没有出现错误。
56:05 因为我们有一个有效的陈述
56:06 另一种有效指令是什么
56:11 int d = 1 e 我们在这里得到了什么
56:14 发生的事情是，我们声明了一个变量 d
56:16 我们已经赋予了它价值
56:18 声明另一个整数变量 e
56:21 但我们还没有赋予 e 任何价值。
56:23 所以这是一个完全有效的陈述
56:25 d 的值被赋值，但 e 的值没有被赋值
56:27 我们也可以通过在代码中写入来实现这一点
56:30 整数
56:33 = 我们给了森林，但没有人把它给
56:36 如果你不提供任何价值，那么这也绝对有效
56:38 该声明将是现在让我们看一些例子
56:41 c 中有无效语句
56:45 就像我们现在创建一个变量 oldAge
56:47 如果我们在老年变量中添加任何
56:50 存储值为 22，然后
56:54 我们将创建一个新变量 newAge newAge
56:57 让我们一起老去
57:00 加上年数意味着已经过去了多少年
57:02 所以这里的老年变量已经存在
57:05 有，但是没有年份，现在接受年份
57:07 我们也出去宣布 int 年 i
57:11 等式 2 两年后我们的年龄是多少
57:13 我告诉过你，这得花好几年
57:15 在代码中它的值是 2，但仍然
57:17 为什么红线会到这里来
57:19 我们在讲述年份之前就用过它
57:22 然后声明变量
57:24 当我们第一次使用它时，它
57:27 在 s 中出现错误，即编译器是什么
57:28 一行一行地
57:30 我读到过，老年是一个变量
57:33 它的值为 22，在此行中读取
57:35 我理所当然地认为这些新时代也是我们的一部分。
57:37 是一个变量，其值为老年
57:39 他知道它的价值加上几年
57:41 现在他会在这里感到困惑，那几年
57:43 所以我还没有读过这些年，所以
57:46 正要读下一行，所以如果
57:47 如果有这样的陈述，那么它
57:51 年份必须高于这个数字，才有效
57:53 只有当我们的类型
57:54 声明语句是他们的
57:57 现在里面不会再有错误了
57:59 我们理解有效语句如果然后多个
58:01 我们可以一起声明变量
58:03 这意味着我们已经在这里宣布了它们。
58:07 给定 int a b c 然后 a 到 b 到 c
58:09 我给这三个都分配了相同的值
58:11 是一 一的值是如何分配的？
58:13 赋给 c 的值，然后 c 的值
58:15 即 v 被赋值给 b，那么 b 的值
58:17 这意味着如果它被分配给那么它应该是这样的
58:20 该过程在我们的代码中执行一次，我们
58:23 我们也来试试吧，比如我们做点什么
58:27 让我们声明变量 x y 和 z
58:32 所以我们可以给出值 x = y = z = 4
58:35 因此，像这样的语句适用于 c
58:37 它在内部是有效的，但如果是另一个我们
58:40 请参阅声明时的版本
58:42 但这里给我四个
58:46 让我们把所有这些都平等起来，让我们思考
58:49 我们跳过了一行
58:51 为什么要在这里写红线呢？
58:54 为什么会自动出现这个红线？
58:57 因为当我们将 4 赋值给 z
59:00 那么它的值接近 y
59:03 到现在他还在想 z 是什么
59:05 因为编译器不知道
59:07 这条线还没有完成 同一条线
59:10 在里面我们还可以为 z 分配一个值。
59:11 并将其价值赋予他人
59:14 在同一个语句中，我们将为 y 赋值
59:16 也分配值，然后
59:18 也给予别人价值
59:21 use 和 declared 不能一起使用
59:23 你必须先声明它，然后
59:26 你必须使用变量，否则 c
59:28 它会给我们一个错误，所以这种类型的错误
59:30 我们不必在多个
59:32 用 c 定义变量
59:34 如果你在里面声明它们，那么就一起声明它们
59:36 声明它们，但它们的值是
59:39 它们的使用将在稍后进行，下一步
59:40 C语言中的指令类型
59:42 她存在于我们的红斑中
59:45 说明 Aerith 有一句话
59:47 我们读的是 11 年级、12 年级、10 年级或 6 年级
59:49 你一定读过 Aerith 的数学
59:51 我们理解 ik 的含义，即
59:54 减乘除，这一切都在进行
59:56 它基本上与数学有关
59:58 所有的事情都与数学有关，如果我们做任何
60:01 看一下这样的语句，假设我们取 a + b 如果我们以……为例，那么它里面的东西
60:04 如果我们以……为例，那么它里面的东西 但操作已执行，即加法
60:06 但操作已执行，即加法 正在成倍增加的东西
60:08 正在成倍增加的东西 分裂正在发生，我们发出提醒
60:09 分裂正在发生，我们发出提醒 他们在问问题，我们称他们为
60:12 他们在问问题，我们称他们为 正在运作，所以这里将成为我们的
60:15 正在运作，所以这里将成为我们的 操作者一号将成为我们的操作者二号
60:18 操作者一号将成为我们的操作者二号 同样，如果有任何其他声明
60:20 同样，如果有任何其他声明 像 a + b - c ld ba d 所以这里 a b c
60:25 像 a + b - c ld ba d 所以这里 a b c d 我们有四个操作员，另一个
60:29 d 我们有四个操作员，另一个 我们需要学习的术语是
60:31 我们需要学习的术语是 什么是操作员？运算符号是
60:34 什么是操作员？运算符号是 指示操作是否执行
60:36 指示操作是否执行 就像这里我们有我们的操作员
60:39 就像这里我们有我们的操作员 您可以在这里获取您的 plus 运营商
60:41 您可以在这里获取您的 plus 运营商 正在执行减号字幕
60:43 正在执行减号字幕 如果正在执行，那么我们的减法将是
60:45 如果正在执行，那么我们的减法将是 如果他成为我们的接线员
60:47 如果他成为我们的接线员 如果发生乘法，那么风险将是
60:49 如果发生乘法，那么风险将是 我们的运营商将会被分割
60:51 我们的运营商将会被分割 所以如果我们把这个斜线称为运算符，
60:54 所以如果我们把这个斜线称为运算符， 里面是里面的说明
60:56 里面是里面的说明 有些操作数是一些
60:57 有些操作数是一些 有一些运算符，我们在 Arith 中称之为运算符
60:59 有一些运算符，我们在 Arith 中称之为运算符 现在 Aerith 中的说明是
61:01 现在 Aerith 中的说明是 指令示例有哪些
61:03 指令示例有哪些 我们可以通过把它们写下来看到它们
61:05 我们可以通过把它们写下来看到它们 如果我们定义一个新变量 int a
61:08 如果我们定义一个新变量 int a = 1 且 b = 2，这样我们就得到了新的
61:13 = 1 且 b = 2，这样我们就得到了新的 让我们定义变量 sum = a + b，然后
61:17 让我们定义变量 sum = a + b，然后 这是红斑狼疮
61:24 取 a 和 b 为操作数加 我们有一个操作员，现在我们有一个新的
61:27 我们有一个操作员，现在我们有一个新的 它是一个变量，我们给它分配一个值
61:29 它是一个变量，我们给它分配一个值 它发生了，即它去了商店
61:31 它发生了，即它去了商店 像这样我们可以做到
61:35 像这样我们可以做到 int multiply = a * b 现在在这里
61:41 int multiply = a * b 现在在这里 multiply 是一个带有 * 的变量
61:43 multiply 是一个带有 * 的变量 b 的值现在被存储
61:45 b 的值现在被存储 我们也讨论 erythm 中的指令
61:47 我们也讨论 erythm 中的指令 我们必须注意一件特别的事情
61:49 我们必须注意一件特别的事情 你需要做的就是把一个变量放在
61:51 你需要做的就是把一个变量放在 每当我们看到任何红色时，左手边
61:54 每当我们看到任何红色时，左手边 他们执行所有操作
61:57 他们执行所有操作 到我们的右手边，即
61:59 到我们的右手边，即 + b - c * ba d 类似这样的我们有
62:03 + b - c * ba d 类似这样的我们有 表达式将是其所有
62:06 表达式将是其所有 分配给左边的变量
62:09 分配给左边的变量 它会写在左边，所有这些
62:11 它会写在左边，所有这些 所有值都是从右到左
62:14 所有值都是从右到左 它将被存储，在左侧我们将
62:16 它将被存储，在左侧我们将 永远记住，单个变量
62:19 永远记住，单个变量 我们在单个变量内
62:21 我们在单个变量内 取出所有输出并去商店
62:24 取出所有输出并去商店 如果我们把它放在左边，那么
62:27 如果我们把它放在左边，那么 想要存储两个变量 int x y
62:31 想要存储两个变量 int x y = a * b 那么在这种情况下会发生什么 a * b
62:37 = a * b 那么在这种情况下会发生什么 a * b 的值将分配给 y，但不会分配给 x
62:39 的值将分配给 y，但不会分配给 x 不会被分配，因为这里我们有
62:41 不会被分配，因为这里我们有 刚刚声明了一个新变量
62:43 刚刚声明了一个新变量 声明一个新变量 y，其中包含
62:45 声明一个新变量 y，其中包含 * 如果给出了 b 的值，则表示在左侧
62:48 * 如果给出了 b 的值，则表示在左侧 我们只有 y 作为表达式
62:50 我们只有 y 作为表达式 在其中存储其值，此后
62:53 在其中存储其值，此后 我们要和erythm谈谈
62:54 我们要和erythm谈谈 我们在教学中有什么
62:55 我们在教学中有什么 哪些表达式是有效的？
62:57 哪些表达式是有效的？ 我们不会理解一些基本操作
63:00 我们不会理解一些基本操作 在我们的指导中
63:02 在我们的指导中 加法运算符与减法运算符接近
63:05 加法运算符与减法运算符接近 乘法运算符和除法运算符是
63:08 乘法运算符和除法运算符是 我们还有另一位操作员
63:10 我们还有另一位操作员 我们现在要学习的模块
63:12 我们现在要学习的模块 这五个都在本章中
63:14 这五个都在本章中 主要操作符现在在此有效
63:17 主要操作符现在在此有效 像 a = b + 这样的语句是什么
63:19 像 a = b + 这样的语句是什么 c 我们已经写了这是一个有效的声明
63:22 c 我们已经写了这是一个有效的声明 这意味着这两个人就是我们的操作员。
63:24 这意味着这两个人就是我们的操作员。 这是运算符，左侧有
63:26 这是运算符，左侧有 single 是一个变量，写为
63:28 single 是一个变量，写为 接下来讨论，b*c 也是一个有效的
63:31 接下来讨论，b*c 也是一个有效的 操作，因为我们有
63:32 操作，因为我们有 乘法来了，我们把它放在
63:34 乘法来了，我们把它放在 现在存储在右侧
63:36 现在存储在右侧 如果我们谈论无效，那么右手
63:38 如果我们谈论无效，那么右手 侧面是 a，左边是 b +
63:41 侧面是 a，左边是 b + c 现在，如果我们学习数学，那么这个
63:43 c 现在，如果我们学习数学，那么这个 根据数学，这是一个完全正确的陈述
63:45 根据数学，这是一个完全正确的陈述 但对于我们来说，这是完全错误的。
63:47 但对于我们来说，这是完全错误的。 语句该语句告诉编译器
63:50 语句该语句告诉编译器 取 a 的值并将其乘以 b +
63:52 取 a 的值并将其乘以 b + 将其存储在 c 中，而 b + c 是单个
63:55 将其存储在 c 中，而 b + c 是单个 不是变量，因为左边
63:56 不是变量，因为左边 如果没有写入单个变量，则
63:58 如果没有写入单个变量，则 我们的声明被证明是完全错误的
64:01 我们的声明被证明是完全错误的 让我们用代码写一次，像这样
64:03 让我们用代码写一次，像这样 如果我们现在在这里写 int b + c = a
64:07 如果我们现在在这里写 int b + c = a 但红线出现了，因为这句话
64:09 但红线出现了，因为这句话 是错误的，因为在左边我们有
64:10 是错误的，因为在左边我们有 其中必须只有一个变量
64:12 其中必须只有一个变量 值被存储，但是如果我们
64:14 值被存储，但是如果我们 我们将把它反转，也就是说，我们将在这里写一个和
64:16 我们将把它反转，也就是说，我们将在这里写一个和 如果我们在这里写 b + c 那么它将是正确的
64:19 如果我们在这里写 b + c 那么它将是正确的 但上面我们必须定义 b 和 c
64:23 但上面我们必须定义 b 和 c 如果我们写 b = c = 1 那么
64:28 如果我们写 b = c = 1 那么 现在这个说法绝对正确
64:30 现在这个说法绝对正确 因为所有变量都已定义并保留
64:31 因为所有变量都已定义并保留 在旁边我们刚刚写了现在和
64:34 在旁边我们刚刚写了现在和 有没有像数学这样的表达方式
64:36 有没有像数学这样的表达方式 我们在两个数字里面写什么
64:38 我们在两个数字里面写什么 如果我们想乘以，那么我们将其写为
64:39 如果我们想乘以，那么我们将其写为 e x = 2 * 3 我们在那里放一个点
64:44 e x = 2 * 3 我们在那里放一个点 甚至可以进行 2 * 3 乘法。
64:47 甚至可以进行 2 * 3 乘法。 它看起来像一个东西，但它和 c 是同一个东西
64:49 它看起来像一个东西，但它和 c 是同一个东西 在 c 中是无效的，如果你写
64:52 在 c 中是无效的，如果你写 将给出一个=
64:57 它不会被视为错误 它将会看到它的例子是什么
64:59 它将会看到它的例子是什么 例如我们可以写 int d =
65:14 bc-c 那么从 b c 开始 a 中存储的内容 将会有分裂，无论发生什么
65:17 将会有分裂，无论发生什么 它将进入并存储在那里
65:19 它将进入并存储在那里 无效表达式可能是
65:21 无效表达式可能是 我们在某处看到过，b 的幂是 c
65:24 我们在某处看到过，b 的幂是 c 如果我们必须写，我们会怎么写？
65:25 如果我们必须写，我们会怎么写？ 是的 b c 这个表达是错误的
65:29 是的 b c 这个表达是错误的 c 里面有力量 c 里面有力量 我们的
65:32 c 里面有力量 c 里面有力量 我们的 没有单一的权力运营商
65:34 没有单一的权力运营商 为此，我们必须使用一个函数
65:37 为此，我们必须使用一个函数 首先我们将在其中放入 b 然后我们将
65:39 首先我们将在其中放入 b 然后我们将 将 c 这将给我们值 b 到
65:41 将 c 这将给我们值 b 到 功率 c 所以如果我们必须存储在
65:44 功率 c 所以如果我们必须存储在 是 b 的幂的 c 幂，所以我们这样做
65:47 是 b 的幂的 c 幂，所以我们这样做 你会写如果我们写了这个那么这个
65:49 你会写如果我们写了这个那么这个 我们的价值观会是错误的，这个价值观是正确的
65:52 我们的价值观会是错误的，这个价值观是正确的 会发生的，让我们看看你的例子
65:53 会发生的，让我们看看你的例子 代码中的 int
65:56 代码中的 int e 次方等于 b 的 c 次方，我们只需要
66:01 e 次方等于 b 的 c 次方，我们只需要 需要包含另一个头文件
66:04 需要包含另一个头文件 包括
66:05 包括 方法 h 此方法 a 是一个头文件，即
66:09 方法 h 此方法 a 是一个头文件，即 其中已经有一些内容我们
66:11 其中已经有一些内容我们 我们可以利用我们需要的力量来运作
66:14 我们可以利用我们需要的力量来运作 您正在使用的方法来自 h 本身
66:16 您正在使用的方法来自 h 本身 我们现在有权力打印
66:19 我们现在有权力打印 如果我们完成了，那么我们已经知道了1的力量
66:21 如果我们完成了，那么我们已经知道了1的力量 只需一次印刷，我们就能获得这种力量
66:24 只需一次印刷，我们就能获得这种力量 我们想打印
66:26 我们想打印 让我们保存它，然后得分
66:29 让我们保存它，然后得分 我们在那里印了一张
66:31 我们在那里印了一张 这里如果我们写 b 那么如果我们保存它
66:34 这里如果我们写 b 那么如果我们保存它 如果我们运行这个，我们会得到什么输出
66:36 如果我们运行这个，我们会得到什么输出 我们现在得到了这样的输出
66:40 我们现在得到了这样的输出 为什么会出现这种情况，这应该是个错误
66:42 为什么会出现这种情况，这应该是个错误 因为权力不存在
66:44 因为权力不存在 事实上这是这个的操作员
66:46 事实上这是这个的操作员 这里面叫做 JOR 操作符。
66:49 这里面叫做 JOR 操作符。 我们稍后会了解这一点
66:50 我们稍后会了解这一点 要执行按位运算，
66:52 要执行按位运算， 我们知道 c 中的每个数字
66:55 我们知道 c 中的每个数字 机器能理解
66:57 机器能理解 机器能理解哪些代码
66:58 机器能理解哪些代码 机器能够理解所编写的机器代码
67:01 机器能够理解所编写的机器代码 发生在零和一中，所以每当我们
67:03 发生在零和一中，所以每当我们 零和一之间的运算
67:05 零和一之间的运算 这些是我们的按位运算
67:07 这些是我们的按位运算 这是我们的一位作业操作员
67:09 这是我们的一位作业操作员 位之间进行按位运算
67:11 位之间进行按位运算 ka 表示当你强制时在相同的位之间
67:13 ka 表示当你强制时在相同的位之间 如果你这样做那么我们肯定会得到它的输出
67:16 如果你这样做那么我们肯定会得到它的输出 现在我们来讨论按位运算符
67:18 现在我们来讨论按位运算符 您稍后会阅读它，但现在 b 到
67:20 您稍后会阅读它，但现在 b 到 如果我们尝试这样写，那么功率 c
67:22 如果我们尝试这样写，那么功率 c 尝试一下，这是一个像这样的有效语句
67:24 尝试一下，这是一个像这样的有效语句 如果不存在，编译器会报错，但输出将是
67:27 如果不存在，编译器会报错，但输出将是 我们会得到错误的 b 的 c 次方
67:29 我们会得到错误的 b 的 c 次方 输出不会出现，输出将是其他东西
67:31 输出不会出现，输出将是其他东西 这就是为什么如果我们有权力我们就不会写它
67:33 这就是为什么如果我们有权力我们就不会写它 如果你想展示你的力量，那么
67:35 如果你想展示你的力量，那么 我们必须使用方法 A 并使用
67:38 我们必须使用方法 A 并使用 你必须执行幂函数的下一步
67:40 你必须执行幂函数的下一步 我们要讨论的主题是
67:42 我们要讨论的主题是 我们的模块化运算符，所以这被称为模块化
67:46 我们的模块化运算符，所以这被称为模块化 或者也叫modelo，是百分比
67:50 或者也叫modelo，是百分比 无论那里有什么标志，这都是我们的模块
67:53 无论那里有什么标志，这都是我们的模块 运算符如果我们
67:55 运算符如果我们 如果它写为 modelo b 那么它会返回我们
67:59 如果它写为 modelo b 那么它会返回我们 会让人想起 did ba b ka 就像它
68:03 会让人想起 did ba b ka 就像它 如果我们看一些例子，4 个模型 2
68:06 如果我们看一些例子，4 个模型 2 将返回我们 ro 5 模型 3 给我们
68:09 将返回我们 ro 5 模型 3 给我们 将返回 u，因为四可以转换成二
68:12 将返回 u，因为四可以转换成二 如果我们分裂，提醒就会来到我们身边
68:14 如果我们分裂，提醒就会来到我们身边 如果我们将五除以三，那么
68:16 如果我们将五除以三，那么 下午 2 点我们会收到提醒
68:19 下午 2 点我们会收到提醒 一个，所以如果我们做 5/3 那么我们就有
68:23 一个，所以如果我们做 5/3 那么我们就有 如果森林在这里给出模块和命令那么
68:26 如果森林在这里给出模块和命令那么 我们收到了同样的提醒
68:28 我们收到了同样的提醒 12 如果你做模块 10，那么只提醒你
68:31 12 如果你做模块 10，那么只提醒你 如果你完成了 20 个模块和 10 个模块，那么你将收到提醒
68:34 如果你完成了 20 个模块和 10 个模块，那么你将收到提醒 如果我们得到零，那么它将是这样的
68:37 如果我们得到零，那么它将是这样的 当你需要查找提醒时
68:39 当你需要查找提醒时 让我们使用模块运算符来做到这一点
68:41 让我们使用模块运算符来做到这一点 让我们写下一个例子，看看我们是否
68:43 让我们写下一个例子，看看我们是否 打印 f 是一个整数值
68:46 打印 f 是一个整数值 我们要打印 16 个泥浆
68:48 我们要打印 16 个泥浆 10 所以我们已经知道答案是我们的
68:51 10 所以我们已经知道答案是我们的 什么应该接近，答案应该是六
68:54 什么应该接近，答案应该是六 答案就印在我们的
68:55 答案就印在我们的 传递 6，因为除以 10 时为 16
68:59 传递 6，因为除以 10 时为 16 如果你这样做，它将被保存在六个提醒中
69:00 如果你这样做，它将被保存在六个提醒中 模运算符，即我们的浮点数
69:03 模运算符，即我们的浮点数 不适用于像我们这样的价值观
69:05 不适用于像我们这样的价值观 在这里写入1.6/1.0并保存。
69:10 在这里写入1.6/1.0并保存。 如果我们想得分，他就不会得分
69:12 如果我们想得分，他就不会得分 因为有无效的操作数 操作数是
69:14 因为有无效的操作数 操作数是 我们的是 1.6，另一个操作员是 1.0，所以
69:18 我们的是 1.6，另一个操作员是 1.0，所以 模运算符仅适用于整数
69:20 模运算符仅适用于整数 将整数转换为整数时有效
69:22 将整数转换为整数时有效 如果我们分割它，它就会归还给我们
69:24 如果我们分割它，它就会归还给我们 是整数提醒值现在为整数
69:27 是整数提醒值现在为整数 身体里有两种情况
69:29 身体里有两种情况 数字可以是正数或
69:30 数字可以是正数或 我们的命理学在任何时候都可能是负面的
69:33 我们的命理学在任何时候都可能是负面的 如果我们的命理是积极的，那么我们的
69:35 如果我们的命理是积极的，那么我们的 给你的提醒也是积极的
69:37 给你的提醒也是积极的 但当我们计数时，提醒就会到来
69:39 但当我们计数时，提醒就会到来 如果结果是负面的，那么我们的提醒也是负面的
69:42 如果结果是负面的，那么我们的提醒也是负面的 我们得到了这样的负面例子
69:44 我们得到了这样的负面例子 如果我们写的话我们怎么才能看到这里
69:48 如果我们写的话我们怎么才能看到这里 -8 模型 3 让我们保存这个和
69:53 -8 模型 3 让我们保存这个和 如果我们运行，那么我们得到的答案是 -2
69:57 如果我们运行，那么我们得到的答案是 -2 因为当你用 8 除以 3 时，
69:59 因为当你用 8 除以 3 时， 二会提醒我们，因为我们的六是
70:01 二会提醒我们，因为我们的六是 它将已经被分割，因为我们的
70:04 它将已经被分割，因为我们的 如果数值为负数，那么答案也是负数
70:05 如果数值为负数，那么答案也是负数 这是负面提醒
70:08 这是负面提醒 如果我们创建一个正八并保存它
70:10 如果我们创建一个正八并保存它 如果你运行它，那么输出将是 + 2
70:14 如果你运行它，那么输出将是 + 2 这样，每当我们得到负面结果时
70:15 这样，每当我们得到负面结果时 如果你需要提醒，我们已经使用了数字
70:17 如果你需要提醒，我们已经使用了数字 每当有积极的提醒时，就必须保留消极的提醒
70:19 每当有积极的提醒时，就必须保留消极的提醒 如果你愿意，那么保持你的命理积极
70:21 如果你愿意，那么保持你的命理积极 这是我们接下来要讨论的话题
70:22 这是我们接下来要讨论的话题 Aerith Mein，这是说明书上她的名字
70:24 Aerith Mein，这是说明书上她的名字 每当我们的不同
70:27 每当我们的不同 如果它们相同，则有不同的运算符
70:30 如果它们相同，则有不同的运算符 如果是类型，那么输出也将是同一类型
70:32 如果是类型，那么输出也将是同一类型 但如果它们的数据类型不同，那么
70:34 但如果它们的数据类型不同，那么 每当我们
70:38 每当我们 对 int 执行运算
70:40 对 int 执行运算 那么输出将是 int
70:43 那么输出将是 int 使用 float 执行浮点运算
70:45 使用 float 执行浮点运算 那么输出将是浮点数，但如果
70:48 那么输出将是浮点数，但如果 如果将 int 与 float 进行运算，则输出为
70:50 如果将 int 与 float 进行运算，则输出为 当我们定义数据类型时，float 将会发挥作用
70:53 当我们定义数据类型时，float 将会发挥作用 那我们来谈谈桌子吧
70:55 那我们来谈谈桌子吧 谁吃了我们的，谁就多吃两口
70:57 谁吃了我们的，谁就多吃两口 float 占用四个字节，因此
70:59 float 占用四个字节，因此 该数据用于将浮动容器存储在浮动容器中。
71:02 该数据用于将浮动容器存储在浮动容器中。 该类型的容器较大，即
71:03 该类型的容器较大，即 可以存储比C更多的价值
71:05 可以存储比C更多的价值 编译器所做的是一些逻辑
71:07 编译器所做的是一些逻辑 如何应用逻辑，如果一个 int
71:10 如何应用逻辑，如果一个 int 值较小但浮动
71:12 值较小但浮动 价值很大，不是吗？中间没有任何东西
71:14 价值很大，不是吗？中间没有任何东西 操作发生假设加发生或
71:15 操作发生假设加发生或 乘以或除以一
71:18 乘以或除以一 现在大数字将出现在输出中
71:20 现在大数字将出现在输出中 一个很大的数字来存储数字
71:22 一个很大的数字来存储数字 需要一个容器，例如 float 容器
71:24 需要一个容器，例如 float 容器 如果你愿意，那么这就是为什么我们不想把 int 放进去
71:26 如果你愿意，那么这就是为什么我们不想把 int 放进去 如果我们保留浮点数，那么每当我们使用 int
71:29 如果我们保留浮点数，那么每当我们使用 int 手术将使用我们的浮标进行
71:30 手术将使用我们的浮标进行 浮点数将出现在输出中
71:32 浮点数将出现在输出中 可以举出哪些例子？
71:34 可以举出哪些例子？ 例如，如果我们将 int 与 int 相乘
71:37 例如，如果我们将 int 与 int 相乘 如果您做两个，那么答案就是四。
71:39 如果您做两个，那么答案就是四。 乘以 2.0 如果与 2 则
71:43 乘以 2.0 如果与 2 则 在输出中我们将得到 4.0，这里
71:46 在输出中我们将得到 4.0，这里 将 2.0 乘以 2.0，然后
71:49 将 2.0 乘以 2.0，然后 输出为 4.0
71:52 输出为 4.0
71:54 如果我们通过输入看到它，那么首先打印 f 我们会完成的
71:55 我们会完成的 2 * 2 如果我们保存它，那么输出将是
71:59 2 * 2 如果我们保存它，那么输出将是 4 来了，但如果我们乘以 2.0
72:03 4 来了，但如果我们乘以 2.0 有两个，所以这里这个错误最
72:06 有两个，所以这里这个错误最 为什么会出现这个错误，因为输出
72:08 为什么会出现这个错误，因为输出 应该是一个浮点值，但我们
72:10 应该是一个浮点值，但我们 表示输出将是一个整数值
72:12 表示输出将是一个整数值 现在我们必须将其更改为 f
72:15 现在我们必须将其更改为 f 让我们保存它并再次执行
72:17 让我们保存它并再次执行 运行 run 后我们得到输出
72:20 运行 run 后我们得到输出 来了
72:21 来了 4.00 无论我们有什么浮动
72:23 4.00 无论我们有什么浮动 默认情况下，无论有多少天可用
72:26 默认情况下，无论有多少天可用 之后如果它是 2.0 * 2.0 那么在这种情况下
72:29 之后如果它是 2.0 * 2.0 那么在这种情况下 在这种情况下会发生什么，我们也有同样的
72:32 在这种情况下会发生什么，我们也有同样的 输出是一个浮点值，现在是
72:35 输出是一个浮点值，现在是 我们也可以使用除法来代替运算
72:37 我们也可以使用除法来代替运算 如果我们假设除以四
72:39 如果我们假设除以四 本来是 2.2，那么在这种情况下也是浮动
72:42 本来是 2.2，那么在这种情况下也是浮动 这是应该出现的输出，因为操作员
72:44 这是应该出现的输出，因为操作员 我们有浮点数，所以在输出中我们得到
72:47 我们有浮点数，所以在输出中我们得到 是浮点值，则按如下方式输入
72:50 是浮点值，则按如下方式输入 类型转换是如何发生的？
72:52 类型转换是如何发生的？ 如果编译器发现输出
72:55 如果编译器发现输出 它应该存放在一个大容器里
72:57 它应该存放在一个大容器里 因为产量巨大所以被迫
73:00 因为产量巨大所以被迫 没有将其存放在小容器中
73:02 没有将其存放在小容器中 它不会自己将其存储在 int 中
73:04 它不会自己将其存储在 int 中 将尝试获取此的完整输出
73:06 将尝试获取此的完整输出 如果保存了，那么它将被保存在浮动中
73:08 如果保存了，那么它将被保存在浮动中 它默认存储，现在我们
73:10 它默认存储，现在我们 让我们看看一些更特殊的情况
73:13 让我们看看一些更特殊的情况 就像如果我们将二除以三
73:15 就像如果我们将二除以三 因为他们都是我们的
73:17 因为他们都是我们的 输出是我们的整数值。
73:19 输出是我们的整数值。 输出应该会出现一次，让我们在这里看看
73:22 输出应该会出现一次，让我们在这里看看 如果出现整数，我们将其转换为 d
73:25 如果出现整数，我们将其转换为 d 输出已经来到我们这里，因为总是
73:28 输出已经来到我们这里，因为总是 当我们
73:30 当我们 如果你除以它，它将是 0 分左右
73:32 如果你除以它，它将是 0 分左右 出现某些情况是因为整数
73:34 出现某些情况是因为整数 里面的值是一个数字，我们有
73:36 里面的值是一个数字，我们有 整数存储是十进制存储
73:39 整数存储是十进制存储 如果没有，他会立即将其归零
73:41 如果没有，他会立即将其归零 但如果我们在 2.0 中就采用了它，那么现在我们的
73:44 但如果我们在 2.0 中就采用了它，那么现在我们的 输出中有一个浮点值
73:47 输出中有一个浮点值 浮点值的输出是多少？
73:48 浮点值的输出是多少？ 结果是 0.666
73:52 结果是 0.666 667 所以如果我们想要精确的输出那么
73:55 667 所以如果我们想要精确的输出那么 为此，我们将两者结合起来
73:57 为此，我们将两者结合起来 如果我们想要小数
73:59 如果我们想要小数 无论它是什么部分，都应该完全删除
74:02 无论它是什么部分，都应该完全删除 因此我们将它设为三的整数
74:05 因此我们将它设为三的整数 我们可以用三部分来划分
74:07 我们可以用三部分来划分 每当我们用二除时，这里
74:10 每当我们用二除时，这里 但我们应该得到的输出是一个整数
74:12 但我们应该得到的输出是一个整数 输出的值将是 1，但 3.0
74:17 输出的值将是 1，但 3.0 如果我们除以二，那么输出将是一
74:19 如果我们除以二，那么输出将是一 它不会来，让我们也把它作为 f 输出
74:23 它不会来，让我们也把它作为 f 输出 现在我们将得到 1.5，所以当精确
74:26 现在我们将得到 1.5，所以当精确 我们需要一个答案，然后我们必须做一个浮动，当我们
74:29 我们需要一个答案，然后我们必须做一个浮动，当我们 然后你想完全删除小数点
74:31 然后你想完全删除小数点 我们将把它变成整数类型
74:33 我们将把它变成整数类型 转换过程如下：
74:35 转换过程如下： 基于转换的非常有趣的
74:37 基于转换的非常有趣的 我们现在来解决这个问题，在这个问题中我们会发现这个
74:40 我们现在来解决这个问题，在这个问题中我们会发现这个 您需要做的是查找 int a 的值
74:42 您需要做的是查找 int a 的值 也就是 1.99999 如果
74:47 也就是 1.99999 如果 我们将这个值赋给一个整数
74:50 我们将这个值赋给一个整数 如果他这样做，那么他会怎么做呢？
74:52 如果他这样做，那么他会怎么做呢？ 将删除小数，即这部分
74:55 将删除小数，即这部分 将彻底删除它，所以这里
74:58 将彻底删除它，所以这里 该值应为 1，或者 a 的值应为 2
75:01 该值应为 1，或者 a 的值应为 2 我们应该用我们的代码来分析它
75:03 我们应该用我们的代码来分析它 在执行此操作的代码中，我们会写 int a =
75:09 在执行此操作的代码中，我们会写 int a = 1.99
75:11 1.99 999 让我们保存它并打印出来
75:15 999 让我们保存它并打印出来 我会完成我的 A 并得到它的价值
75:19 我会完成我的 A 并得到它的价值 让我们看看实际打印的内容
75:22 让我们看看实际打印的内容 首先，他给出了一个错误
75:25 首先，他给出了一个错误 可以从 double 转换为 int
75:28 可以从 double 转换为 int 不可以进行隐式转换
75:31 不可以进行隐式转换 每当类型转换既不发生在 C 中，也不发生在
75:32 每当类型转换既不发生在 C 中，也不发生在 里面有两种类型的转换，大多数
75:35 里面有两种类型的转换，大多数 我们的第一个转换是
75:38 我们的第一个转换是 编译器可以自行进行隐式转换
75:42 编译器可以自行进行隐式转换 另一种是我们的
75:44 另一种是我们的 显式转换我们作为
75:48 显式转换我们作为 我们以用户的身份对自己进行编程
75:50 我们以用户的身份对自己进行编程 我们的编译器不会为我们做这件事
75:53 我们的编译器不会为我们做这件事 融合是我们想要自己做的事情
75:55 融合是我们想要自己做的事情 如果这是一种外部趋同，那么就意味着
75:57 如果这是一种外部趋同，那么就意味着 收敛被称为小类型
76:00 收敛被称为小类型 类似 int 这样的类型可以转换为 float
76:03 类似 int 这样的类型可以转换为 float 可以将 int 等类型存储在 double 中
76:05 可以将 int 等类型存储在 double 中 可以存储为浮点型或双精度型
76:08 可以存储为浮点型或双精度型 不能存储在 int 中
76:10 不能存储在 int 中 这就是为什么它不会自动转换它
76:13 这就是为什么它不会自动转换它 但如果我们把自己想象成一个程序员，
76:15 但如果我们把自己想象成一个程序员， 如果你想转换编码器，那么我们就在这里
76:17 如果你想转换编码器，那么我们就在这里 这样，我们就可以写出两个值
76:20 这样，我们就可以写出两个值 把括号放在两者之间
76:22 把括号放在两者之间 输入我们可以转换的内容
76:24 输入我们可以转换的内容 如果你不想这样做，那么编译器会做什么
76:26 如果你不想这样做，那么编译器会做什么 编译器将强制转换
76:28 编译器将强制转换 我不想将大字体转换为小字体
76:30 我不想将大字体转换为小字体 但他必须这么做，因为我们已经写好了
76:32 但他必须这么做，因为我们已经写好了 给定下一个让我们保存这个现在
76:35 给定下一个让我们保存这个现在 我们再编译一下看看
76:37 我们再编译一下看看 现在它已经编译成功了
76:39 现在它已经编译成功了 现在如果我们运行我们的代码那么
76:41 现在如果我们运行我们的代码那么 无论何时，输出都将是
76:44 无论何时，输出都将是 它将这个双精度值转换为
76:47 它将这个双精度值转换为 默认情况下，C 中的所有浮点值
76:49 默认情况下，C 中的所有浮点值 他们被视为替身
76:50 他们被视为替身 因为 double 现在是大数据类型，当
76:53 因为 double 现在是大数据类型，当 将此 double 值转换为 int
76:55 将此 double 值转换为 int 所以它转换了这个
76:59 所以它转换了这个 999999 已完全删除，即四舍五入
77:02 999999 已完全删除，即四舍五入 C 编译器不执行算术运算
77:05 C 编译器不执行算术运算 每当我从 float 转换为 int
77:07 每当我从 float 转换为 int 如果是 1.99，则不进行四舍五入
77:10 如果是 1.99，则不进行四舍五入 制作两个，然后将两个放入整数中
77:12 制作两个，然后将两个放入整数中 这与其说是逻辑，不如说是数学
77:14 这与其说是逻辑，不如说是数学 如果要删除小数，则应将其设为整数
77:16 如果要删除小数，则应将其设为整数 将删除所有内容并仅存储一个
77:18 将删除所有内容并仅存储一个 所以我们必须特别注意这一点
77:20 所以我们必须特别注意这一点 我们也接受采访，做一些这样的事情
77:21 我们也接受采访，做一些这样的事情 我们被问到这样的问题，在 C 语言中你
77:24 我们被问到这样的问题，在 C 语言中你 告诉我或课堂测试我mit我和结束
77:26 告诉我或课堂测试我mit我和结束 同样的问题是，它的输出是什么
77:28 同样的问题是，它的输出是什么 我们在我们的
77:30 我们在我们的 接下来，你必须彻底消除小数。
77:33 接下来，你必须彻底消除小数。 我们将要讨论的主题是运算符
77:35 我们将要讨论的主题是运算符 我们数学里有一条规则，就像总统一样
77:38 我们数学里有一条规则，就像总统一样 我读过一篇我们以前称之为“董事会”的小文章
77:40 我读过一篇我们以前称之为“董事会”的小文章 马萨诸塞州规则委员会对我们说了什么？
77:42 马萨诸塞州规则委员会对我们说了什么？ 首先打开支架，然后
77:45 首先打开支架，然后 先除，再乘，再加
77:47 先除，再乘，再加 然后像这样在数学中减去它
77:49 然后像这样在数学中减去它 如果给出了许多操作，那么谁
77:51 如果给出了许多操作，那么谁 此手术前必须进行哪项手术
77:53 此手术前必须进行哪项手术 稍后再做，我们有一个
77:55 稍后再做，我们有一个 曾经有一个适当的系列和序列
77:58 曾经有一个适当的系列和序列 同样，在 C 语言中，哪个运算先发生？
78:01 同样，在 C 语言中，哪个运算先发生？ 稍后将执行哪个操作
78:02 稍后将执行哪个操作 这将在 C 编译器中执行
78:05 这将在 C 编译器中执行 我们现在已经在这个中定义了它
78:07 我们现在已经在这个中定义了它 我们把优先顺序称为总统。
78:09 我们把优先顺序称为总统。 我们给予它，即优先权更高的那个
78:12 我们给予它，即优先权更高的那个 其总统具有高度优先权
78:14 其总统具有高度优先权 如果他的总统低调，那么他将是最
78:17 如果他的总统低调，那么他将是最 优先到达我们这里
78:19 优先到达我们这里 乘除和调制运算符
78:22 乘除和调制运算符 三个运营商的优先级都排在第一位
78:25 三个运营商的优先级都排在第一位 发生于此之后，他们优先
78:27 发生于此之后，他们优先 之后加减优先
78:29 之后加减优先 这等于等于在 c 里面我们
78:33 这等于等于在 c 里面我们 赋值运算符也称为赋值
78:36 赋值运算符也称为赋值 给他一些东西
78:38 给他一些东西 就像我们以前在学校里说的那样
78:42 就像我们以前在学校里说的那样 他曾经被任命为班长，他被称为
78:43 他曾经被任命为班长，他被称为 监察员岗位已分配
78:45 监察员岗位已分配 意味着它已经被赋予了，所以每当任何
78:48 意味着它已经被赋予了，所以每当任何 我们赋予的价值就是我们所说的
78:49 我们赋予的价值就是我们所说的 赋值所以如果 a + b = c 我们写
78:53 赋值所以如果 a + b = c 我们写 因此我们在 c 中赋值了 a + b
78:56 因此我们在 c 中赋值了 a + b 如果已经完成，那么这就是我们理解的含义
78:59 如果已经完成，那么这就是我们理解的含义 下面是 c 内部事物的一个例子
79:02 下面是 c 内部事物的一个例子 如果写成 x = 4+ 9 * 10 那么
79:07 如果写成 x = 4+ 9 * 10 那么 总统先生，我们该如何解决这个问题？
79:09 总统先生，我们该如何解决这个问题？ 我们会先考虑是否应该先做 4+9 还是
79:12 我们会先考虑是否应该先做 4+9 还是 9 * 10 显然是我们的乘法键
79:15 9 * 10 显然是我们的乘法键 如果总统很高，那么 9*10 会先做 9
79:18 如果总统很高，那么 9*10 会先做 9 * 如果我们计算 10，它就变成了 90，现在我们在其中添加 4
79:21 * 如果我们计算 10，它就变成了 90，现在我们在其中添加 4 如果我们加 2 然后我们加 4 然后
79:24 如果我们加 2 然后我们加 4 然后 我们的答案是 94，它位于 x 里面。
79:26 我们的答案是 94，它位于 x 里面。 将被存储，但如果我们以错误的方式
79:29 将被存储，但如果我们以错误的方式 如果你这样做，那么如果你以错误的方式做，会发生什么
79:32 如果你这样做，那么如果你以错误的方式做，会发生什么 如果将 na 添加到 four 则变为 13
79:35 如果将 na 添加到 four 则变为 13 乘以 10，得出输出为 130
79:37 乘以 10，得出输出为 130 这本来是一个错误的输出，它是正确的输出
79:40 这本来是一个错误的输出，它是正确的输出 94 让我们尝试编码一次
79:43 94 让我们尝试编码一次 我们在内部做了多少正确的事情
79:46 我们在内部做了多少正确的事情 我们将存储 4 p 9 在 10 这样做
79:52 我们将存储 4 p 9 在 10 这样做 运行，我们得到的输出是 94
79:56 运行，我们得到的输出是 94 现在我们有另一种方法
79:59 现在我们有另一种方法 表达式可以写成
80:01 表达式可以写成 案件涉及同一位总统的行动
80:05 案件涉及同一位总统的行动 这意味着乘数也有许多总统
80:07 这意味着乘数也有许多总统 如果 Divide 也有那么多总统，那么
80:09 如果 Divide 也有那么多总统，那么 首先要解决的是
80:12 首先要解决的是 这些规则附带关联规则
80:15 这些规则附带关联规则 这看上去一定很危险，对吧？
80:17 这看上去一定很危险，对吧？ 但它非常合乎逻辑，我们现在不需要记住它
80:20 但它非常合乎逻辑，我们现在不需要记住它 当我们解决不同的问题时
80:22 当我们解决不同的问题时 你将解决你的练习问题
80:23 你将解决你的练习问题 我们也会解决这些问题，它们会自动出现，还有更多
80:26 我们也会解决这些问题，它们会自动出现，还有更多 他们的名字绝对合乎逻辑，容易理解
80:28 他们的名字绝对合乎逻辑，容易理解 记住这被称为结合律
80:31 记住这被称为结合律 他被称为总统，这是一个多么沉重的词
80:34 他被称为总统，这是一个多么沉重的词 现在完全不需要
80:36 现在完全不需要 这些笔记将完全提供给您，您可以
80:38 这些笔记将完全提供给您，您可以 你可以随时去修改
80:40 你可以随时去修改 我们可以使用以下方式访问结合性
80:43 我们可以使用以下方式访问结合性 每当他们来找我们
80:44 每当他们来找我们 同一总统任期内的运营商相同
80:47 同一总统任期内的运营商相同 就像总统任期一样，如果我们以我们为例
80:49 就像总统任期一样，如果我们以我们为例 谈论结合律时，
80:52 谈论结合律时， 从左到右，即从左到左
80:55 从左到右，即从左到左 从头到右执行操作
80:57 从头到右执行操作 如果和总统的一样，那么就像这里
81:00 如果和总统的一样，那么就像这里 乘除乘以这个
81:02 乘除乘以这个 如果是同一位总统，我们该怎么办
81:04 如果是同一位总统，我们该怎么办 我们将从左到右从左计算
81:07 我们将从左到右从左计算 如果你计算正确，那么首先
81:09 如果你计算正确，那么首先 计算结果将是4 * 3，而我们的将变为4 * 3
81:12 计算结果将是4 * 3，而我们的将变为4 * 3 12 将被计算为 12 / 6，这将变成
81:15 12 将被计算为 12 / 6，这将变成 我们的 2 将被计算为 2 * 2
81:18 我们的 2 将被计算为 2 * 2 我们的毛皮将会消失，所以首先我们必须购买四个
81:21 我们的毛皮将会消失，所以首先我们必须购买四个 乘以 thr 然后它的输出
81:24 乘以 thr 然后它的输出 我们将其除以六然后
81:26 我们将其除以六然后 我们将其输出乘以二
81:29 我们将其输出乘以二 因此我们将从左到右进行
81:31 因此我们将从左到右进行 如果将其放入括号中
81:34 如果将其放入括号中 如果我想给你看我可以写什么？
81:35 如果我想给你看我可以写什么？ 我可以先写乘法
81:37 我可以先写乘法 再次将四除以三，
81:40 再次将四除以三， 然后将其乘以二
81:42 然后将其乘以二 并将最终值赋给 x，并且
81:44 并将最终值赋给 x，并且 我们的最终价值是四
81:47 我们的最终价值是四 我们在代码中编写了此代码
81:49 我们在代码中编写了此代码 我们将写 4 * 3 / 6 * 2 让我们这样做
81:56 我们将写 4 * 3 / 6 * 2 让我们这样做 保存为这个值，我们有
81:58 保存为这个值，我们有 输出
81:59 输出 他会来的，他已经来了四次，因为这里
82:02 他会来的，他已经来了四次，因为这里 结合性规则从左到右应用
82:06 结合性规则从左到右应用 我们的计算已经完成，现在我们有
82:08 我们的计算已经完成，现在我们有 我在《爱丽丝》中读到了很多
82:10 我在《爱丽丝》中读到了很多 在说明中，我们问了他几个问题
82:12 在说明中，我们问了他几个问题 我们这样做是为了记住一切
82:14 我们这样做是为了记住一切 完成所有事情后，练习第四题。
82:17 完成所有事情后，练习第四题。 让我们解决这四个问题
82:18 让我们解决这四个问题 首先要做的是将它安装在你的电路板内
82:21 首先要做的是将它安装在你的电路板内 你会解决它并在幻灯片上看到它
82:22 你会解决它并在幻灯片上看到它 解决之后，我们再看看接下来会发生什么
82:24 解决之后，我们再看看接下来会发生什么 我们将编写其代码并验证它
82:26 我们将编写其代码并验证它 现在我们来回答第一个问题，我们有 5 * 2 -
82:30 现在我们来回答第一个问题，我们有 5 * 2 - 2 * 3 乘以这里和这个
82:32 2 * 3 乘以这里和这个 两个多国的总统都在上面，
82:35 两个多国的总统都在上面， 我们稍后必须做减法，所以
82:37 我们稍后必须做减法，所以 两位总统都有相同的乘法口诀
82:39 两位总统都有相同的乘法口诀 那么你会怎么做？你会应用左规则吗？
82:42 那么你会怎么做？你会应用左规则吗？ 首先我们将 5 * 2 相乘
82:44 首先我们将 5 * 2 相乘 而不是这样，我们将写 10，中间加一个减号
82:47 而不是这样，我们将写 10，中间加一个减号 那么必须按照总统的要求解决
82:49 那么必须按照总统的要求解决 我们需要 2 * 3，所以我们解 2 * 3
82:53 我们需要 2 * 3，所以我们解 2 * 3 写了 6 并且这两个的输出都是我们的
82:55 写了 6 并且这两个的输出都是我们的 如果你得到四，那么这个问题将首先得到解决
82:58 如果你得到四，那么这个问题将首先得到解决 因为在更高的总统和左边
83:00 因为在更高的总统和左边 也会出现，那么这个问题就会得到解决，因为更高
83:02 也会出现，那么这个问题就会得到解决，因为更高 在总统之后，向左转到右边
83:05 在总统之后，向左转到右边 然后我们的减法就会得到解决，所以这将是
83:07 然后我们的减法就会得到解决，所以这将是 将变成 10 - 6 = 4 这是代码形式
83:11 将变成 10 - 6 = 4 这是代码形式 让我们在代码中写入它，我们将写入 5 而不是 2 -
83:16 让我们在代码中写入它，我们将写入 5 而不是 2 - 3 *
83:19 3 * 2 让我们在这里发表我们的声明
83:23 2 让我们在这里发表我们的声明 Terminator Semi 被称为 Terminator
83:25 Terminator Semi 被称为 Terminator 我们的人工智能电影叫《终结者》
83:28 我们的人工智能电影叫《终结者》 不是机器人终结者，而是终结者
83:31 不是机器人终结者，而是终结者 意思是停止某事，就好像它
83:33 意思是停止某事，就好像它 电影《启示录》中就曾来过这里
83:35 电影《启示录》中就曾来过这里 但这所做的就是把声明放在那里
83:37 但这所做的就是把声明放在那里 如果它阻止了我们，那么我们现在就行动吧
83:40 如果它阻止了我们，那么我们现在就行动吧 通过编译和运行，我们得到输出
83:43 通过编译和运行，我们得到输出 我们有一个四秒的问题 5 *
83:47 我们有一个四秒的问题 5 * 这里用 2 除以 2 * 3，因为有三个
83:51 这里用 2 除以 2 * 3，因为有三个 三大运营商的总裁都是最高
83:54 三大运营商的总裁都是最高 如果它存在，那么我们将在其中应用我们的结合律
83:56 如果它存在，那么我们将在其中应用我们的结合律 规则结合性规则左边说了什么
83:58 规则结合性规则左边说了什么 所以如果你计算正确的话，兄弟，那么 5 * 2
84:01 所以如果你计算正确的话，兄弟，那么 5 * 2 首先，我们要计算
84:03 首先，我们要计算 计算 10 除以 10 再除以 2
84:06 计算 10 除以 10 再除以 2 我们现在将得到 5 它的输出
84:10 我们现在将得到 5 它的输出 5 来了，我们将用र 乘以它
84:12 5 来了，我们将用र 乘以它 因此我们将得到的输出是 15，验证一下
84:16 因此我们将得到的输出是 15，验证一下 我们也这样做，我们将通过这样做来写输出
84:19 我们也这样做，我们将通过这样做来写输出 让我们进行除法编译运行六
84:23 让我们进行除法编译运行六 我来是因为这里有 3 个 Mallas，我们两个
84:26 我来是因为这里有 3 个 Mallas，我们两个 我写道这应该真的发生2
84:27 我写道这应该真的发生2 Malla Ba 3 让我们编译它并
84:31 Malla Ba 3 让我们编译它并 在得分方面，我们获得了 15 个三柱门，
84:34 在得分方面，我们获得了 15 个三柱门， 问题是有5个泥巴2/2在3
84:40 问题是有5个泥巴2/2在3 现在如何解决这个问题
84:42 现在如何解决这个问题 Didi，我第一次看到这个括号
84:44 Didi，我第一次看到这个括号 因此，每当括号先出现
84:46 因此，每当括号先出现 你必须解决括号内的问题
84:48 你必须解决括号内的问题 这是唯一与混乱这个词相符的东西
84:50 这是唯一与混乱这个词相符的东西 如果出现括号，则第一个括号
84:52 如果出现括号，则第一个括号 如果你打开它，支架里面的东西将是最
84:54 如果你打开它，支架里面的东西将是最 首先要解决的是我们的这个表达式
84:57 首先要解决的是我们的这个表达式 现在将通过 5 malla ba 1 malla ba 3
85:02 现在将通过 5 malla ba 1 malla ba 3 现在还剩下两台手术，他们该怎么办？
85:04 现在还剩下两台手术，他们该怎么办？ 乘法和乘法
85:06 乘法和乘法 如果总统相同，则关联规则
85:08 如果总统相同，则关联规则 如果你应用这个，那么我们将有 5 * 3
85:14 如果你应用这个，那么我们将有 5 * 3 这意味着它的输出也应该是 15。
85:18 这意味着它的输出也应该是 15。 我们在这里稍微做点改变
85:20 我们在这里稍微做点改变 让我们放一个括号并这样做
85:22 让我们放一个括号并这样做 保存的输出将显示 15 和最后一个问题
85:26 保存的输出将显示 15 和最后一个问题 里面是 5 + 2 / 2 * 3
85:31 里面是 5 + 2 / 2 * 3 我们有三个
85:33 我们有三个 运算首先是加法，然后是减法
85:36 运算首先是加法，然后是减法 再次除法，乘法现在更高
85:38 再次除法，乘法现在更高 总统是最高总统
85:39 总统是最高总统 除法和乘法的键相同
85:42 除法和乘法的键相同 如果他当选总统，我们会把他放在左边
85:43 如果他当选总统，我们会把他放在左边 结合性是左结合性的函数。
85:46 结合性是左结合性的函数。 5P 先转换成哪个
85:49 5P 先转换成哪个 我会把它变成 2 / 2，然后我会把它乘以
85:52 我会把它变成 2 / 2，然后我会把它乘以 3 然后将其添加到 5 因此这将是
85:55 3 然后将其添加到 5 因此这将是 会变成5p里面的表达式变成1
85:59 会变成5p里面的表达式变成1 * 3 然后做 5 + 3 就会变成这样
86:04 * 3 然后做 5 + 3 就会变成这样 我们现在将其转换为相同的输出
86:07 我们现在将其转换为相同的输出 让我们以 5 + 2 的表达式为例
86:11 让我们以 5 + 2 的表达式为例 除以 2 加 3 让我们这样做
86:15 除以 2 加 3 让我们这样做 保存并运行。在输出中我们将有
86:18 保存并运行。在输出中我们将有 所以这些是类型的问题
86:21 所以这些是类型的问题 这些也会在你的选择题中被问到
86:23 这些也会在你的选择题中被问到 在实习期间或从你的学校
86:27 在实习期间或从你的学校 将在大学考试中被问到
86:29 将在大学考试中被问到 那么如何回答这个问题
86:31 那么如何回答这个问题 如果这是一篇理论论文，那么它应该实际解决
86:33 如果这是一篇理论论文，那么它应该实际解决 为了证明左结合性
86:35 为了证明左结合性 你怎么知道哪件事会先解决
86:38 你怎么知道哪件事会先解决 最好的方式是在您方便的时候
86:40 最好的方式是在您方便的时候 为此，你应该把这些括号放在括号中
86:42 为此，你应该把这些括号放在括号中 如果你尝试，你就会知道什么事情会先发生
86:44 如果你尝试，你就会知道什么事情会先发生 哪个事情需要解决，我们稍后再解决
86:46 哪个事情需要解决，我们稍后再解决 如果你想用代码编写，那么代码
86:48 如果你想用代码编写，那么代码 我将自动编译 C 文件
86:50 我将自动编译 C 文件 所以做这些事情很容易，比如
86:53 所以做这些事情很容易，比如 板子质量有个规律，是这样的
86:54 板子质量有个规律，是这样的 还有一条规则是问四到五个问题
86:56 还有一条规则是问四到五个问题 家庭作业问题，我们会解决的
86:58 家庭作业问题，我们会解决的 事情将会变得非常清楚
87:01 事情将会变得非常清楚 我们接下来要讨论的话题是
87:03 我们接下来要讨论的话题是 我们的控制指令现在在开头
87:06 我们的控制指令现在在开头 我们读到有三种类型的指令
87:08 我们读到有三种类型的指令 有一个类型声明，我们读到
87:10 有一个类型声明，我们读到 你必须先声明变量
87:12 你必须先声明变量 必须使用第二个我们读Aerith
87:15 必须使用第二个我们读Aerith mech 指令位于哪个模块内
87:16 mech 指令位于哪个模块内 我们学到了什么 我们学习了有关类型转换的新知识
87:19 我们学到了什么 我们学习了有关类型转换的新知识 我们了解了总统，现在我们要学习
87:21 我们了解了总统，现在我们要学习 是控制指令控制
87:24 是控制指令控制 指令是那些指令
87:25 指令是那些指令 他们决定并帮助告诉
87:28 他们决定并帮助告诉 到目前为止我们的程序流程
87:31 到目前为止我们的程序流程 您在说明序列中读到了什么
87:32 您在说明序列中读到了什么 一个代码正在运行，其中写入了第一个代码
87:34 一个代码正在运行，其中写入了第一个代码 语句将首先执行，即
87:36 语句将首先执行，即 包含的语句将首先执行
87:38 包含的语句将首先执行 之后将执行该语句
87:40 之后将执行该语句 之后该语句将被执行，但
87:42 之后该语句将被执行，但 CK代码中有一些这样的语句
87:44 CK代码中有一些这样的语句 内部可能存在一些可以改变的流量
87:46 内部可能存在一些可以改变的流量 我们首先声明如下
87:48 我们首先声明如下 它应该被执行，并且上述内容应该稍后发生
87:51 它应该被执行，并且上述内容应该稍后发生 定义流程的语句
87:53 定义流程的语句 有能力改变
87:55 有能力改变 我们称这些为控制指令，
87:58 我们称这些为控制指令， 可以控制指令流
88:00 可以控制指令流 现在在程序中它有四种类型
88:03 现在在程序中它有四种类型 第一个是序列
88:04 第一个是序列 控制序列控制指令
88:07 控制序列控制指令 按顺序继续
88:10 按顺序继续 也就是说，一个接一个，如果我们的
88:12 也就是说，一个接一个，如果我们的 当流程创建后，我们对其进行顺序控制
88:14 当流程创建后，我们对其进行顺序控制 说明书上说我们到目前为止所做的
88:16 说明书上说我们到目前为止所做的 我们一直在向他们学习这一切
88:18 我们一直在向他们学习这一切 我们的序列控制指令是
88:20 我们的序列控制指令是 第二种控制指令
88:22 第二种控制指令 决策控制和场景控制通过
88:24 决策控制和场景控制通过 我们将阅读有关 if else this that
88:27 我们将阅读有关 if else this that 有关于我们将要来的指示
88:29 有关于我们将要来的指示 应在章节中阅读
88:31 应在章节中阅读 因为详细地发现它们很困难
88:33 因为详细地发现它们很困难 所有这些加在一起使我们
88:35 所有这些加在一起使我们 形成 C 编程的基础知识
88:38 形成 C 编程的基础知识 我们在决策控制下前进
88:40 我们在决策控制下前进 我们将学习循环控制的 ifs 主题
88:43 我们将学习循环控制的 ifs 主题 里面有不同的循环
88:45 里面有不同的循环 在 C 中就像我们的 for 循环完成
88:47 在 C 中就像我们的 for 循环完成 我们的 while 循环变成了不同的循环
88:49 我们的 while 循环变成了不同的循环 如果我们必须做任何工作，我们都会研究方法
88:51 如果我们必须做任何工作，我们都会研究方法 你必须一遍又一遍地重复
88:54 你必须一遍又一遍地重复 我们可以用几行代码来循环它
88:56 我们可以用几行代码来循环它 当我们必须
88:58 当我们必须 必须决定今天是否下雨
89:01 必须决定今天是否下雨 如果您有伞，那么您应该带它吗？
89:04 如果您有伞，那么您应该带它吗？ 如果今天是星期天，有阳光，那么我们今天会开心吗？
89:07 如果今天是星期天，有阳光，那么我们今天会开心吗？ 不会有这样的决定
89:09 不会有这样的决定 每当我们在代码中编写这些内容时，我们都会编写
89:10 每当我们在代码中编写这些内容时，我们都会编写 有决策控制指令的帮助
89:13 有决策控制指令的帮助 在这之后，我们遇到了最后一个案子
89:15 在这之后，我们遇到了最后一个案子 控制指令包含一些
89:17 控制指令包含一些 我们根据具体情况采取不同的措施
89:19 我们根据具体情况采取不同的措施 比如如果是周一到周五那么就工作
89:21 比如如果是周一到周五那么就工作 我得走了，到了星期天我就得去上班
89:23 我得走了，到了星期天我就得去上班 我们不想去，那就只能在家休息了
89:25 我们不想去，那就只能在家休息了 我们必须将整个流程纳入代码中
89:29 我们必须将整个流程纳入代码中 我们如何借助变量来显示
89:31 我们如何借助变量来显示 并借助当天的案例
89:33 并借助当天的案例 你必须去上班吗？你哪些日子待在家里
89:34 你必须去上班吗？你哪些日子待在家里 所以每当我们写这些语句时
89:37 所以每当我们写这些语句时 这些指令被称为案例
89:39 这些指令被称为案例 我们已控制住这三个
89:42 我们已控制住这三个 将会在接下来的章节中阅读
89:43 将会在接下来的章节中阅读 我们已经阅读了有关序列控制的内容
89:46 我们已经阅读了有关序列控制的内容 与此同时，本章的下一个主题是
89:49 与此同时，本章的下一个主题是 我们将在里面讨论的是我们的
89:51 我们将在里面讨论的是我们的 现在的操作员我们已经有了基础知识
89:54 现在的操作员我们已经有了基础知识 我在 Arith 中看到了运算符是什么
89:56 我在 Arith 中看到了运算符是什么 曾经属于 Erith 的操作员类别
89:58 曾经属于 Erith 的操作员类别 我们得到了加减乘法
90:02 我们得到了加减乘法 除法、乘法、除法和
90:05 除法、乘法、除法和 这些就是五个主要的算术模块。
90:08 这些就是五个主要的算术模块。 我们已经阅读了 C 的运算符。
90:10 我们已经阅读了 C 的运算符。 里面有更多不同类型的操作符
90:12 里面有更多不同类型的操作符 我们有关系运算符
90:14 我们有关系运算符 描述两个运算符之间的关系
90:17 描述两个运算符之间的关系 我们有逻辑运算符
90:19 我们有逻辑运算符 谁能找到两者之间的逻辑
90:21 谁能找到两者之间的逻辑 然后我们还引入按位运算符
90:23 然后我们还引入按位运算符 我们刚刚讨论了机器
90:25 我们刚刚讨论了机器 语言中的机器代码中的所有内容
90:27 语言中的机器代码中的所有内容 是以零和一的形式出现的，而那些
90:29 是以零和一的形式出现的，而那些 在 0 和 1 之间，如果我们进行以下操作
90:31 在 0 和 1 之间，如果我们进行以下操作 我们称之为按位运算
90:33 我们称之为按位运算 还有赋值运算符
90:35 还有赋值运算符 然后有一个三元运算符，这是我们的
90:37 然后有一个三元运算符，这是我们的 它是一个条件运算符，这意味着如果有
90:40 它是一个条件运算符，这意味着如果有 我们必须根据情况做点什么
90:43 我们必须根据情况做点什么 我们不想做任何其他事情，这是三元的
90:45 我们不想做任何其他事情，这是三元的 您也可以在操作员的帮助下编写
90:48 您也可以在操作员的帮助下编写 它也是在 IFFLS 的帮助下编写的
90:50 它也是在 IFFLS 的帮助下编写的 专业也是借助这个帮助写的
90:52 专业也是借助这个帮助写的 要理解的是关系和逻辑，
90:55 要理解的是关系和逻辑， 作业：这是三个作业中最简单的一个
90:58 作业：这是三个作业中最简单的一个 我们将在 Aeryth May 之后立即阅读它们
91:00 我们将在 Aeryth May 之后立即阅读它们 我们将在下一章讨论三元运算符。
91:02 我们将在下一章讨论三元运算符。 每当我们读到条件语句
91:04 每当我们读到条件语句 我们将了解位运算符
91:07 我们将了解位运算符 如果你读了以下章节，那么首先
91:10 如果你读了以下章节，那么首先 现在我们来讨论一下关系运算符
91:12 现在我们来讨论一下关系运算符 关系运算符是两个操作数之间的关系。
91:14 关系运算符是两个操作数之间的关系。 我们用数学来解释关系
91:17 我们用数学来解释关系 我们为什么不写 a = b 并且我们需要检查
91:20 我们为什么不写 a = b 并且我们需要检查 a 等于 b，它在 c 内吗
91:23 a 等于 b，它在 c 内吗 在 c 中不能这样写
91:24 在 c 中不能这样写 如果我们在某处写 a = b 那么这意味着
91:27 如果我们在某处写 a = b 那么这意味着 将获取 b 的值并将其放入 a
91:30 将获取 b 的值并将其放入 a 这不是平等检查，所以当
91:32 这不是平等检查，所以当 还必须检查平均值
91:34 还必须检查平均值 一个值等于另一个值
91:36 一个值等于另一个值 那么我们对 a e e 应用双等于吗？
91:40 那么我们对 a e e 应用双等于吗？ = b 表示我们在这里询问的是
91:43 = b 表示我们在这里询问的是 问题是 a 的值是否与 b 的值相同
91:44 问题是 a 的值是否与 b 的值相同 值是否等于 a，a = b 是什么意思
91:47 值是否等于 a，a = b 是什么意思 也就是说，你把 b 的值放入 a
91:50 也就是说，你把 b 的值放入 a 所以每当我们谈论关系运算符
91:52 所以每当我们谈论关系运算符 如果我们谈论检查关系，那么我们
91:54 如果我们谈论检查关系，那么我们 您必须使用这个，即 double 等于二
91:56 您必须使用这个，即 double 等于二 如果我们想在代码中写入输出
92:00 如果我们想在代码中写入输出 完成它
92:01 完成它 在这里我们将写一个等于等于
92:05 在这里我们将写一个等于等于 或者 a 未定义，则 4 等于
92:08 或者 a 未定义，则 4 等于 到 4 如果我们写了这个，我们保存它，并且
92:11 到 4 如果我们写了这个，我们保存它，并且 如果我们运行它，我们将得到输出
92:14 如果我们运行它，我们将得到输出 森林将会到来，这片森林展现了什么，森林说
92:16 森林将会到来，这片森林展现了什么，森林说 语句为真，即返回 4 = e4
92:20 语句为真，即返回 4 = e4 是真的，即 C 说的是正确的事情
92:21 是真的，即 C 说的是正确的事情 在编译器上，如果这里 4 == 3，那么在这种情况下
92:26 在编译器上，如果这里 4 == 3，那么在这种情况下 在这种情况下，我们没有一个印刷品
92:28 在这种情况下，我们没有一个印刷品 行被打印，即 4 = = u 3 false
92:32 行被打印，即 4 = = u 3 false 返回 false 则 c 是一个特殊的
92:35 返回 false 则 c 是一个特殊的 这是一种没有真假的语言
92:37 这是一种没有真假的语言 我们不是真实的谎言，而是真实的
92:40 我们不是真实的谎言，而是真实的 我们附近有一片森林和一个地方
92:43 我们附近有一片森林和一个地方 实际上是任何非零整数
92:46 实际上是任何非零整数 如果我们在 c 中写入 2 3 4 5
92:51 如果我们在 c 中写入 2 3 4 5 6 7 -1 -5 所有这些都代表
92:56 6 7 -1 -5 所有这些都代表 我们做真事，但如果它变成零
92:59 我们做真事，但如果它变成零 其含义在 's' 中为假，所以无论如何
93:02 其含义在 's' 中为假，所以无论如何 学习Java后学习C的学生
93:03 学习Java后学习C的学生 javascript 之后是 c++
93:06 javascript 之后是 c++ 后来他们会发现有点奇怪
93:08 后来他们会发现有点奇怪 没有什么能比得上森林里的 True Falls
93:11 没有什么能比得上森林里的 True Falls 有零而不是真
93:13 有零而不是真 而不是 false 所以如果等于等于
93:15 而不是 false 所以如果等于等于 如果打印了则表示正确
93:18 如果打印了则表示正确 语句并打印 false，那么我们的
93:21 语句并打印 false，那么我们的 屏幕上将显示零，然后显示第二个
93:23 屏幕上将显示零，然后显示第二个 我们检查的第二个关系是
93:25 我们检查的第二个关系是 大于还是大于等于
93:28 大于还是大于等于 例如，如果我们写 3 年级 4 这
93:31 例如，如果我们写 3 年级 4 这 将返回行，因为 3 为假
93:33 将返回行，因为 3 为假 大于 4 是不正确的，但如果我们认为 4 大于
93:36 大于 4 是不正确的，但如果我们认为 4 大于 3 这样做会给我们带来 true
93:39 3 这样做会给我们带来 true 如果我们使 4 大于 4，则返回
93:41 如果我们使 4 大于 4，则返回 会哭，因为 fourer 不大于 4
93:44 会哭，因为 fourer 不大于 4 但如果我们让 4 大于等于 4，那么
93:47 但如果我们让 4 大于等于 4，那么 如果一个人回来，那么就会出现以下情况
93:49 如果一个人回来，那么就会出现以下情况 根据我们选择的输出
93:51 根据我们选择的输出 我们通过代码来生成它们
93:53 我们通过代码来生成它们 我们会看到 4 是否大于 3
93:56 我们会看到 4 是否大于 3 如果我写了，那么输出就来了
93:59 如果我写了，那么输出就来了 不，但是如果我们写 3 大于 4
94:05 不，但是如果我们写 3 大于 4 如果给定，则输出现在应该显示零
94:08 如果给定，则输出现在应该显示零 这意味着如果我们写 3 大于 3，则为 false
94:12 这意味着如果我们写 3 大于 3，则为 false 那么输出将为零，因为这是
94:14 那么输出将为零，因为这是 永远不会大于 3 但如果我们有 3 大于
94:17 永远不会大于 3 但如果我们有 3 大于 如果使其等于然后大于然后检查
94:19 如果使其等于然后大于然后检查 在这种情况下也将检查是否相等
94:22 在这种情况下也将检查是否相等 我们将得到的输出是 1，所以它大于
94:25 我们将得到的输出是 1，所以它大于 并且大于等于成为第三个
94:27 并且大于等于成为第三个 我们将要讨论的关系运算符是
94:30 我们将要讨论的关系运算符是 我们的小于等于小于和小于
94:33 我们的小于等于小于和小于 相同情况下将是 3 是车道 4
94:37 相同情况下将是 3 是车道 4 将返回 true 4 是 3 号车道
94:40 将返回 true 4 是 3 号车道 将返回 false 3 是本课程的第 3 课
94:44 将返回 false 3 是本课程的第 3 课 将返回 0 和 3，其中 len 等于 3
94:47 将返回 0 和 3，其中 len 等于 3 在这些情况下也会返回一个，即 true
94:50 在这些情况下也会返回一个，即 true 让我们让它大于等于税
94:52 让我们让它大于等于税 我们给教训等于小于等于
94:55 我们给教训等于小于等于 我们将打印 true if
94:57 我们将打印 true if 如果我们做得少一点，那么在这种情况下我们的
95:00 如果我们做得少一点，那么在这种情况下我们的 通行证打印
95:02 通行证打印 在这种情况下，如果 4 < 3 则会打印
95:08 在这种情况下，如果 4 < 3 则会打印 这将是错误的，因为这是一个错误的陈述
95:10 这将是错误的，因为这是一个错误的陈述 这意味着行，如果我们在这种情况下做了 4 课 5
95:15 这意味着行，如果我们在这种情况下做了 4 课 5 将会打印 true 所以像这样
95:18 将会打印 true 所以像这样 我们的关系陈述有效
95:20 我们的关系陈述有效 最后一个特殊关系运算符
95:23 最后一个特殊关系运算符 我们有所谓的不等于
95:26 我们有所谓的不等于 我们将其命名为不等于
95:29 我们将其命名为不等于 我们过去常常说，当两个相等时，等于二
95:33 我们过去常常说，当两个相等时，等于二 值它将返回一个，只要不是
95:35 值它将返回一个，只要不是 不相等时将返回零
95:39 不相等时将返回零 会有两个值，那么它会返回一个
95:42 会有两个值，那么它会返回一个 只要它们相等，这就是零回报
95:44 只要它们相等，这就是零回报 这意味着他们两个是互相对立的
95:48 这意味着他们两个是互相对立的 就像我们在声明中写道
95:51 就像我们在声明中写道 即使 fur 不等于 4，我们也会打印
95:56 即使 fur 不等于 4，我们也会打印 4 = u = 4，无论何时我们想要完成它
96:01 4 = u = 4，无论何时我们想要完成它 在 C 上加一个感叹号
96:03 在 C 上加一个感叹号 内部编程所以它总是
96:05 内部编程所以它总是 像诺特一样，我们必须尽可能多地阅读
96:07 像诺特一样，我们必须尽可能多地阅读 感叹词来了意思不是不是不是所以不是
96:11 感叹词来了意思不是不是不是所以不是 运算符，它是一个单独的运算符
96:13 运算符，它是一个单独的运算符 现在它是完整的，但不平等
96:16 现在它是完整的，但不平等 我们不给这两者之间留出空间
96:18 我们不给这两者之间留出空间 我们可以把这两个写在一起
96:21 我们可以把这两个写在一起 现在输出被分析一次
96:24 现在输出被分析一次 第一个语句的输出为零，即
96:26 第一个语句的输出为零，即 错误的“四不等于四”的表述
96:29 错误的“四不等于四”的表述 在这里我们说四等于四
96:31 在这里我们说四等于四 这根本没发生，这明显是假话
96:33 这根本没发生，这明显是假话 因此，打印了零秒语句
96:35 因此，打印了零秒语句 我说四等于四
96:36 我说四等于四 所以现在就在这里印了
96:39 所以现在就在这里印了 如果我们说四不等于三
96:41 如果我们说四不等于三 或者我们可以说四等于三
96:44 或者我们可以说四等于三 发生在第一个语句中
96:46 发生在第一个语句中 为什么我们会有一张印刷品？
96:50 为什么我们会有一张印刷品？ 我们说四等于三是对的
96:51 我们说四等于三是对的 这并没有发生，在第二个语句中
96:53 这并没有发生，在第二个语句中 将会打印 false 因为我们说
96:55 将会打印 false 因为我们说 四等于三，这很明显
96:56 四等于三，这很明显 如果为假那么它将打印零，所以
96:58 如果为假那么它将打印零，所以 每当你想检查是否等于方法时
97:00 每当你想检查是否等于方法时 只要不等于二，我们就应用二等于二
97:03 只要不等于二，我们就应用二等于二 如果你想检查，那么用感叹号
97:05 如果你想检查，那么用感叹号 我们称等于不等于
97:07 我们称等于不等于 我们将讨论的下一类运算符
97:09 我们将讨论的下一类运算符 我们要做的是逻辑运算符
97:11 我们要做的是逻辑运算符 有时在 c 中会发生我们必须
97:13 有时在 c 中会发生我们必须 你必须检查以下事情的逻辑
97:16 你必须检查以下事情的逻辑 在哪些情况下我们可以使用逻辑语句
97:18 在哪些情况下我们可以使用逻辑语句 我们可以使用 c
97:20 我们可以使用 c 使用编码创建了一个系统
97:22 使用编码创建了一个系统 我们赖以生存的系统
97:25 我们赖以生存的系统 如果我们说他的
97:27 如果我们说他的 如果分数超过 30 分但低于 90 分
97:31 如果分数超过 30 分但低于 90 分 如果是，则给它一个 A 级，满分 90
97:35 如果是，则给它一个 A 级，满分 90 高于或介于 100 和 90 之间
97:39 高于或介于 100 和 90 之间 如果有这样的情况就给它一个A级
97:42 如果有这样的情况就给它一个A级 如果我们想检查，那么我们必须检查
97:44 如果我们想检查，那么我们必须检查 分数应在 90 分以上或 100 分以下
97:46 分数应在 90 分以上或 100 分以下 你还必须在这里检查分数 30
97:49 你还必须在这里检查分数 30 高于和低于 90 才
97:52 高于和低于 90 才 当同时检查两个条件时，您将需要支付
97:55 当同时检查两个条件时，您将需要支付 无论你是否愿意这样做，或者接受这两个条件中的任何一个
97:57 无论你是否愿意这样做，或者接受这两个条件中的任何一个 有一个道理，就像今天是国庆节
98:00 有一个道理，就像今天是国庆节 或者今天是星期天，我们可以出去散步
98:02 或者今天是星期天，我们可以出去散步 两件事中的任何一件都是真的
98:05 两件事中的任何一件都是真的 如果要做到这一点，那么我们必须努力
98:07 如果要做到这一点，那么我们必须努力 如果两者都正确，那么你必须同时做这两件事
98:09 如果两者都正确，那么你必须同时做这两件事 即使其中一个是真的，你仍然必须这样做
98:11 即使其中一个是真的，你仍然必须这样做 现实生活中也有一些这样的情况吧？
98:13 现实生活中也有一些这样的情况吧？ 我们想要包含在代码中的案例
98:15 我们想要包含在代码中的案例 那么我们的逻辑运算符就派上用场了
98:17 那么我们的逻辑运算符就派上用场了 第一个逻辑运算符是 AND
98:20 第一个逻辑运算符是 AND 运算符我们在其中也称之为&
98:22 运算符我们在其中也称之为& 如果你注意的话，我们会把两端
98:24 如果你注意的话，我们会把两端 如果我们看 m 上的单端
98:27 如果我们看 m 上的单端 如果你写它那么它就是一个按位运算符
98:29 如果你写它那么它就是一个按位运算符 我们不应该在这里写
98:31 我们不应该在这里写 如果你总是写它那么它将是一个逻辑运算符
98:33 如果你总是写它那么它将是一个逻辑运算符 我们如何才能将其用作价值
98:35 我们如何才能将其用作价值 让我们写出第一个语句 4 e > 3
98:38 让我们写出第一个语句 4 e > 3 它会给我们带来什么？它将给我们一个，即真理
98:42 它会给我们带来什么？它将给我们一个，即真理 我们将第二条语句 5 写为
98:45 我们将第二条语句 5 写为 灰色第二这句话也会给我们森林
98:47 灰色第二这句话也会给我们森林 这意味着如果这两个陈述都是正确的
98:50 这意味着如果这两个陈述都是正确的 我们希望当
98:52 我们希望当 只有这样我们才会得到最终的输出 True
98:54 只有这样我们才会得到最终的输出 True 如果它来了，我们会把它放在这两者之间
98:56 如果它来了，我们会把它放在这两者之间 然后这才是真的，只有这样这才是真的
98:58 然后这才是真的，只有这样这才是真的 输出将为 true，但如果其中任何一个
99:00 输出将为 true，但如果其中任何一个 这不是真的，也就是说我们有
99:03 这不是真的，也就是说我们有 2 大于 5，所以他会给它
99:06 2 大于 5，所以他会给它 零表示假，因此我们得到输出
99:09 零表示假，因此我们得到输出 秋天即将结束，为此，首先必须
99:12 秋天即将结束，为此，首先必须 语句和第二个语句或任意数量的
99:14 语句和第二个语句或任意数量的 我们正在结束声明
99:16 我们正在结束声明 是的，否则它们可能都是真的
99:18 是的，否则它们可能都是真的 错误输出将像其输出一样出现
99:20 错误输出将像其输出一样出现 如果我们看这里，我们可以写
99:23 如果我们看这里，我们可以写 4 e gr 3 和 5 e gr 2 所以 ye
99:28 4 e gr 3 和 5 e gr 2 所以 ye 我们的两个陈述都是正确的，即 4 也是正确的
99:31 我们的两个陈述都是正确的，即 4 也是正确的 大于 3 且 5 也大于 2
99:34 大于 3 且 5 也大于 2 所以无论真与真的结局如何，那都是我们的
99:36 所以无论真与真的结局如何，那都是我们的 真相即将来临，但在这里我们也可以
99:38 真相即将来临，但在这里我们也可以 将其设为 false，即在此处写入 3
99:40 将其设为 false，即在此处写入 3 大于则输出此处
99:44 大于则输出此处 他会来到我们身边，这句话会到来
99:47 他会来到我们身边，这句话会到来 所以这确实是我们 5G2 的一个错误
99:50 所以这确实是我们 5G2 的一个错误 无论我走到哪里，都会有瀑布，也就是说整个东西都倒塌了
99:52 无论我走到哪里，都会有瀑布，也就是说整个东西都倒塌了 结束了，如果结束，那么两者都是假的
99:54 结束了，如果结束，那么两者都是假的 即使存在，其中之一也是谬论
99:56 即使存在，其中之一也是谬论 即使是假的，两者都是真的
99:58 即使是假的，两者都是真的 只有这样它才会是真正的印刷品，所以我们
100:00 只有这样它才会是真正的印刷品，所以我们 我也做桌子，有时是你的一张或两张
100:03 我也做桌子，有时是你的一张或两张 主题是电子产品内部
100:04 主题是电子产品内部 计算机科学中也有很多 IT 内容。
100:06 计算机科学中也有很多 IT 内容。 即使在这三个逻辑运算符里面
100:08 即使在这三个逻辑运算符里面 创建一个表，如果你使用逻辑
100:11 创建一个表，如果你使用逻辑 如果你在大学里一定研究过盖茨，那么你
100:13 如果你在大学里一定研究过盖茨，那么你 你会明白我们在谈论谁
100:15 你会明白我们在谈论谁 如果你还没读过，那就读下一篇
100:16 如果你还没读过，那就读下一篇 你可能正在按学期学习
100:18 你可能正在按学期学习 该表是通过考虑第一个表达式和
100:20 该表是通过考虑第一个表达式和 如果我们有第二个这样的表达式
100:22 如果我们有第二个这样的表达式 如果是这样，那么最终的结果会是什么？
100:25 如果是这样，那么最终的结果会是什么？ 第一个表达式为真，第二个表达式也为真
100:26 第一个表达式为真，第二个表达式也为真 如果我们按下结束键，输出将为 true
100:28 如果我们按下结束键，输出将为 true 我们正在谈论的是第一点是真的第二点
100:30 我们正在谈论的是第一点是真的第二点 如果为假，则输出将首先显示假
100:32 如果为假，则输出将首先显示假 为假，第二个为真，然后在输出中
100:34 为假，第二个为真，然后在输出中 第一个倒下，第二个也将到来
100:36 第一个倒下，第二个也将到来 即使它是假的，输出也会显示假
100:38 即使它是假的，输出也会显示假 这是一张小桌子，我们可以用它来做灯
100:41 这是一张小桌子，我们可以用它来做灯 你能想象
100:44 你能想象 只要我们使用逻辑，我们的输出就会出现
100:46 只要我们使用逻辑，我们的输出就会出现 先说结局吧，接下来我们再说
100:48 先说结局吧，接下来我们再说 要做逻辑 r，在我们的
100:51 要做逻辑 r，在我们的 键盘上有一个管道符号
100:53 键盘上有一个管道符号 也就是说，它是一条直线的符号
100:56 也就是说，它是一条直线的符号 当我们写两次时它就变成了
100:57 当我们写两次时它就变成了 我们的逻辑与运算符现在变成
101:00 我们的逻辑与运算符现在变成 单个管道也是一个运算符，那一点
101:03 单个管道也是一个运算符，那一点 更明智的是，我们在这里谈论的是
101:05 更明智的是，我们在这里谈论的是 逻辑 R 的逻辑 R 起什么作用？
101:08 逻辑 R 的逻辑 R 起什么作用？ 语句或三个语句或多达
101:10 语句或三个语句或多达 如果我们在所有人面前发表声明
101:12 如果我们在所有人面前发表声明 如果我们应用逻辑，那么即使其中一个
101:15 如果我们应用逻辑，那么即使其中一个 如果它变为真，那么我们的输出就是真的
101:17 如果它变为真，那么我们的输出就是真的 其余的都会来，即使它们是假的，但即使一个
101:20 其余的都会来，即使它们是假的，但即使一个 如果为真，则输出为真，否则
101:22 如果为真，则输出为真，否则 如果所有输出都是假的，那么它的
101:24 如果所有输出都是假的，那么它的 如果我们看一下代码，那么首先我们的
101:27 如果我们看一下代码，那么首先我们的 附近是 3 年级 4 年级，这是一个瀑布
101:29 附近是 3 年级 4 年级，这是一个瀑布 如果我们把 else 放在这里，那么语句就在这里
101:31 如果我们把 else 放在这里，那么语句就在这里 把它写下来，5 年级，所以它在这里
101:35 把它写下来，5 年级，所以它在这里 该陈述为假 该陈述为真
101:37 该陈述为假 该陈述为真 所以最终的输出是
101:39 所以最终的输出是 这是假的但我得到了真的
101:41 这是假的但我得到了真的 如果它走了那么它就可以有自己的桌子
101:45 如果它走了那么它就可以有自己的桌子 在表格中，如果我们取第一和第二
101:48 在表格中，如果我们取第一和第二 表达式，然后是最终输出
101:51 表达式，然后是最终输出 如果我们分析，那么这里如果 true 就是 true
101:53 如果我们分析，那么这里如果 true 就是 true 如果给定则输出为真
101:55 如果给定则输出为真 如果给出 false，则输出为 true
101:57 如果给出 false，则输出为 true 即使将 false 赋为 true，输出结果
101:59 即使将 false 赋为 true，输出结果 只有当两者都为假时，才会出现真
102:01 只有当两者都为假时，才会出现真 如果我们的输出出现错误，那么
102:04 如果我们的输出出现错误，那么 我们的做法合乎逻辑，除此之外还有一个
102:07 我们的做法合乎逻辑，除此之外还有一个 有一个特殊的操作员是我们的
102:09 有一个特殊的操作员是我们的 逻辑非运算符表示逻辑非运算符
102:12 逻辑非运算符表示逻辑非运算符 如果给出的是 true，那么给出的是 false
102:14 如果给出的是 true，那么给出的是 false 如果你给出了两个错误，那么就让它们成为正确的
102:16 如果你给出了两个错误，那么就让它们成为正确的 这意味着无论我们得到什么表达
102:18 这意味着无论我们得到什么表达 里面的东西必须倒过来，即使它
102:21 里面的东西必须倒过来，即使它 就像有一个表达式 3 >
102:24 就像有一个表达式 3 > 4 我们知道这会报错，但接下来
102:26 4 我们知道这会报错，但接下来 如果你刻上一个刻痕，它就会在那里显示出来
102:29 如果你刻上一个刻痕，它就会在那里显示出来 如果第二个表达式是 5 > 1，我们知道
102:32 如果第二个表达式是 5 > 1，我们知道 是的，它会显示真实，但放一个不在那里
102:34 是的，它会显示真实，但放一个不在那里 那么它将给出 false 因此每当
102:36 那么它将给出 false 因此每当 表达式的输出需要反转
102:38 表达式的输出需要反转 如果我们必须翻转，我们就会打结
102:41 如果我们必须翻转，我们就会打结 让我们看看这里我们知道 5 >
102:45 让我们看看这里我们知道 5 > 1 会给我们 true，但在它旁边放一个 not
102:48 1 会给我们 true，但在它旁边放一个 not 如果我们给出它，那么输出结果就会为 false
102:51 如果我们给出它，那么输出结果就会为 false 这意味着即使我们讨论两个表达式，也是零
102:54 这意味着即使我们讨论两个表达式，也是零 这意味着 5 gr 1 会给我们
102:57 这意味着 5 gr 1 会给我们 正确，并且或将结束放在这里
103:01 正确，并且或将结束放在这里 结束 3 gr 4 它的输出如果我们尝试猜测
103:04 结束 3 gr 4 它的输出如果我们尝试猜测 5 gr d 将给出 1 True 3 gr d 将给出 4
103:09 5 gr d 将给出 1 True 3 gr d 将给出 4 瀑布位于两端之间
103:11 瀑布位于两端之间 如果它是真或假，则输出将出现
103:13 如果它是真或假，则输出将出现 瀑布，但除此之外，我们感觉不到
103:16 瀑布，但除此之外，我们感觉不到 那么我们打印的不是 false
103:18 那么我们打印的不是 false 这是真的，这是另一个括号
103:21 这是真的，这是另一个括号 让我们把它放到输出中，这样我们就知道
103:23 让我们把它放到输出中，这样我们就知道 它应该以真正的印刷形式呈现给我们
103:25 它应该以真正的印刷形式呈现给我们 它被打印为 true，即：
103:28 它被打印为 true，即： 逻辑运算符的工作方式
103:30 逻辑运算符的工作方式 这些是实际的逻辑运算符
103:32 这些是实际的逻辑运算符 这很重要，不是吗？我们进入下一章
103:34 这很重要，不是吗？我们进入下一章 我们将在其中学习条件语句。
103:36 我们将在其中学习条件语句。 只要有 if else 条件，我们就会讨论
103:38 只要有 if else 条件，我们就会讨论 当我们在其中写入语句时
103:39 当我们在其中写入语句时 必须输入条件为真
103:41 必须输入条件为真 如果是或否，则有这些表达式
103:44 如果是或否，则有这些表达式 我们现在将最常使用它
103:45 我们现在将最常使用它 这里我们有一个问题，
103:47 这里我们有一个问题， 在单个表达式中，我们可以找到一些算术
103:49 在单个表达式中，我们可以找到一些算术 运算符也可以用 Aeryth 来编写
103:51 运算符也可以用 Aeryth 来编写 在单个表达式中，我们使用如下运算符
103:53 在单个表达式中，我们使用如下运算符 我们可以这样写 a + b - c + d * e
103:58 我们可以这样写 a + b - c + d * e 从一个表达式中我们可以
104:01 从一个表达式中我们可以 您还可以比较这个值
104:04 您还可以比较这个值 大于4*3*5是这个方法的价值
104:11 大于4*3*5是这个方法的价值 然后我们可以做 end end 4 > 2 所以
104:14 然后我们可以做 end end 4 > 2 所以 我们可以写一个表达式，
104:16 我们可以写一个表达式， 里面的红斑
104:23 我们的关系运算符即将到来 那么他们之间如何决定总统
104:25 那么他们之间如何决定总统 所以他们也有自己的运营商总裁
104:28 所以他们也有自己的运营商总裁 优先顺序
104:30 优先顺序 总统是最高总统
104:32 总统是最高总统 给予的是给予我们的不是
104:34 给予的是给予我们的不是 无论运算符在哪里遇到 NOT 运算符，最
104:37 无论运算符在哪里遇到 NOT 运算符，最 首先你必须打结，然后其他一切
104:40 首先你必须打结，然后其他一切 先做后乘除
104:42 先做后乘除 然后是模块，然后是加减
104:44 然后是模块，然后是加减 我们的关系运算符又来了
104:46 我们的关系运算符又来了 关系运算符中的等于
104:48 关系运算符中的等于 并且不等于我们的逻辑
104:50 并且不等于我们的逻辑 首先看到的运算符
104:52 首先看到的运算符 最终结果如何，我们拭目以待。
104:54 最终结果如何，我们拭目以待。 然后等于即
104:56 然后等于即 赋值运算符是第一个
104:58 赋值运算符是第一个 事情将发生在左边
105:00 事情将发生在左边 我们将去分配那里写的任何内容
105:02 我们将去分配那里写的任何内容 如果你赋予价值，那么就这样做
105:05 如果你赋予价值，那么就这样做 总统也来这里是为了记住这一点
105:07 总统也来这里是为了记住这一点 没有必要记住其中的主要内容
105:09 没有必要记住其中的主要内容 你必须记住的是，首先结
105:11 你必须记住的是，首先结 关系优先，逻辑优先
105:15 关系优先，逻辑优先 如果我们下来那么我们将保持
105:18 如果我们下来那么我们将保持 参考计算时休息
105:20 参考计算时休息 您可以参考这些相同的注释
105:22 您可以参考这些相同的注释 能
105:23 能 现在我们可以读取另一个运算符的类型
105:25 现在我们可以读取另一个运算符的类型 让我们来看看，这是一个非常简单的操作符，最
105:28 让我们来看看，这是一个非常简单的操作符，最 简单的操作符将成为我们的
105:29 简单的操作符将成为我们的 赋值运算符 赋值我们已经
105:32 赋值运算符 赋值我们已经 已经阅读了等于 a e b 的作用
105:35 已经阅读了等于 a e b 的作用 然后 c = 将把 b 的值放入 a
105:37 然后 c = 将把 b 的值放入 a d 然后 c 会将 d 的值放入 e
105:40 d 然后 c 会将 d 的值放入 e = f + g - h 那么这个完整表达式的结果就是
105:44 = f + g - h 那么这个完整表达式的结果就是 将值放入 e 中，这是发生的事情
105:46 将值放入 e 中，这是发生的事情 赋值运算符的工作之后我们的
105:48 赋值运算符的工作之后我们的 这是运算符加等于二
105:51 这是运算符加等于二 基本上我们的简写运算符是什么
105:53 基本上我们的简写运算符是什么 速记运算符做什么
105:58 速记运算符做什么 困难的长语句是
106:00 困难的长语句是 他们也没有告诉你如何让它变小
106:02 他们也没有告诉你如何让它变小 就像如果我们写了 a = a p b 如果我们
106:06 就像如果我们写了 a = a p b 如果我们 在你的代码中添加这个东西
106:08 在你的代码中添加这个东西 写入 int a =
106:12 写入 int a = 1 int b = 4 并且我们想要写入 int
106:17 1 int b = 4 并且我们想要写入 int 或者 a = a p b 那么这里应该是什么
106:22 或者 a = a p b 那么这里应该是什么 b 是 4 a 是 1 那么 4 将是 5 然后是 a 的
106:26 b 是 4 a 是 1 那么 4 将是 5 然后是 a 的 该值现在将变为 f，也打印它
106:29 该值现在将变为 f，也打印它 我们可以通过做
106:32 我们可以通过做 如果输出为 5，那么
106:35 如果输出为 5，那么 因为四加一，所以变成五
106:37 因为四加一，所以变成五 现在是五，我们会注意到左边
106:39 现在是五，我们会注意到左边 右边也写着 a 右边也写着 a
106:41 右边也写着 a 右边也写着 a 当左右有相同的表达式时
106:43 当左右有相同的表达式时 确实如此，这意味着写入了相同的变量
106:46 确实如此，这意味着写入了相同的变量 所以我们可以让它变小，我们怎样才能让它变小
106:48 所以我们可以让它变小，我们怎样才能让它变小 我们可以将 a = a + b 写为
106:51 我们可以将 a = a + b 写为 a p 等于 b 所以这里加等于
106:56 a p 等于 b 所以这里加等于 已取代等于
106:59 已取代等于 这样，每当我们
107:02 这样，每当我们 在左侧和右侧使用变量
107:04 在左侧和右侧使用变量 然后我们用以下方式替换等于
107:07 然后我们用以下方式替换等于 可以做加等于二这样的运算
107:08 可以做加等于二这样的运算 如果我们
107:11 如果我们 写出语句 a +
107:15 写出语句 a + = b 然后检查其值
107:18 = b 然后检查其值 我们将得到相同的输出，即
107:20 我们将得到相同的输出，即 我们对 Plus 也做了同样的事情
107:22 我们对 Plus 也做了同样的事情 你也可以在这里用乘法来实现
107:24 你也可以在这里用乘法来实现 如果我写乘以等于二，那么
107:27 如果我写乘以等于二，那么 将是 4 * 1 两者将相乘
107:29 将是 4 * 1 两者将相乘 输出将显示一个减号
107:31 输出将显示一个减号 如果给出，那么这个语句中的减号是什么
107:34 如果给出，那么这个语句中的减号是什么 意味着 a = a - b 那么 a 为 1 b 为 4 1
107:41 意味着 a = a - b 那么 a 为 1 b 为 4 1 - 4 - 3 将会到来，所以我们会有
107:44 - 4 - 3 将会到来，所以我们会有 应该打印-3 统计一下
107:47 应该打印-3 统计一下 如果输出为 -3，则执行此方法
107:50 如果输出为 -3，则执行此方法 每当你想缩短表达方式时
107:52 每当你想缩短表达方式时 因为我们左右都是同一个操作员
107:54 因为我们左右都是同一个操作员 如果你正在使用，那么你会减去什么
107:56 如果你正在使用，那么你会减去什么 我们将写成等于二乘以等于二
107:58 我们将写成等于二乘以等于二 对于除法同样对于模同样这些是
108:01 对于除法同样对于模同样这些是 我们最简单的操作员是我们的
108:03 我们最简单的操作员是我们的 赋值运算符，这样我们就有
108:06 赋值运算符，这样我们就有 这是操作员的基本指令
108:08 这是操作员的基本指令 我们已经完成了，现在我们正在做一些事情
108:11 我们已经完成了，现在我们正在做一些事情 解决这些问题将会产生问题
108:14 解决这些问题将会产生问题 在我们刚刚读完第二章之后
108:16 在我们刚刚读完第二章之后 并将在我们的心中扎根
108:18 并将在我们的心中扎根 第一个问题是编写程序
108:20 第一个问题是编写程序 检查一个数字是否可以被二整除或
108:22 检查一个数字是否可以被二整除或 不是
108:23 不是 现在这个数字可以被二整除，但不能被二整除
108:26 现在这个数字可以被二整除，但不能被二整除 我们必须编写一个程序，任何数值
108:28 我们必须编写一个程序，任何数值 取 x 我们给出 x 的值为 5
108:30 取 x 我们给出 x 的值为 5 可能是 6，也可能是 10，明白吗
108:32 可能是 6，也可能是 10，明白吗 它能被二整除吗
108:35 它能被二整除吗 任何数字都可以被另一个数字整除
108:37 任何数字都可以被另一个数字整除 假设它除以 4。
108:40 假设它除以 4。 10 除以 5
108:43 10 除以 5 提醒器给出零给出4d是什么意思
108:46 提醒器给出零给出4d是什么意思 Ba 2 的提醒也会给我们零，所以这里
108:49 Ba 2 的提醒也会给我们零，所以这里 但我们需要用我们的头脑来提醒
108:51 但我们需要用我们的头脑来提醒 给出任意一个能被另一个数整除的数字
108:53 给出任意一个能被另一个数整除的数字 所以在这里我们将使用我们的模型
108:55 所以在这里我们将使用我们的模型 你会用运算符做什么，然后任何数字
108:58 你会用运算符做什么，然后任何数字 在我们采取的输入中
109:01 在我们采取的输入中 现在我们将看到 x 与 u 的模型
109:04 现在我们将看到 x 与 u 的模型 如果这个模型变为零
109:07 如果这个模型变为零 它变为零意味着除以一
109:10 它变为零意味着除以一 它不是零，接受它为零以外的任何值
109:14 它不是零，接受它为零以外的任何值 在这里打印它是人类还是我的
109:17 在这里打印它是人类还是我的 如果结果不是零，则表示
109:20 如果结果不是零，则表示 如果分裂了，那么该怎么办呢？
109:23 如果分裂了，那么该怎么办呢？ 将从用户那里获取一个数字输入，然后
109:25 将从用户那里获取一个数字输入，然后 我们将使用以下方法检查模块是否
109:27 我们将使用以下方法检查模块是否 如果模块返回零，则意味着
109:29 如果模块返回零，则意味着 如果分裂的话，现在就不会发生这样的事了
109:32 如果分裂的话，现在就不会发生这样的事了 首先让我们编写代码
109:34 首先让我们编写代码 然后我们声明 X
109:37 然后我们声明 X 先扫描然后打印
109:39 先扫描然后打印 给予
109:40 给予 进入
109:43 进入 一个数字，我们将在这里输入数字
109:47 一个数字，我们将在这里输入数字 那么我们就会这么做
109:49 那么我们就会这么做 扫描百分比 D
109:53 扫描百分比 D 结束 x 现在我们将再次打印它
109:58 结束 x 现在我们将再次打印它 百分比
109:59 百分比 如何检查 D 是否被整除
110:02 如何检查 D 是否被整除 如果没有发生，我们将写 x
110:05 如果没有发生，我们将写 x 莫德洛
110:07 莫德洛 2 等于等于
110:09 2 等于等于 0 在这里我们结合了两个 Aerith
110:12 0 在这里我们结合了两个 Aerith 我把运营商与我的
110:15 我把运营商与我的 优先采用关系运算符的模块
110:18 优先采用关系运算符的模块 然后关系出现了。现在我们有了运算符
110:20 然后关系出现了。现在我们有了运算符 当我们看到总统时，里面有什么？
110:22 当我们看到总统时，里面有什么？ 红斑狼疮
110:24 红斑狼疮 运算符如下，所以这里第一个是 x
110:27 运算符如下，所以这里第一个是 x 的模块将会出现两个如果
110:30 的模块将会出现两个如果 如果值等于零，则打印
110:32 如果值等于零，则打印 这将是真实的，意味着它将被分裂
110:35 这将是真实的，意味着它将被分裂 如果不存在则打印零
110:37 如果不存在则打印零 意思是它不被分割，所以保存它
110:39 意思是它不被分割，所以保存它 让我们来做一下并看看我们的输出
110:42 让我们来做一下并看看我们的输出 让我们输入数字五代表五
110:44 让我们输入数字五代表五 打印零，因为五等于二
110:47 打印零，因为五等于二 它不会随之分裂，而是再次分裂
110:49 它不会随之分裂，而是再次分裂 运行它，这次我们输入 10
110:53 运行它，这次我们输入 10 10 中打印的是 1，因为 10 是我们的 2
110:55 10 中打印的是 1，因为 10 是我们的 2 每当输入 10
110:57 每当输入 10 Kiya 10 模块首次推出两个
111:00 Kiya 10 模块首次推出两个 然后什么模块来了，我们哭了那个哭
111:02 然后什么模块来了，我们哭了那个哭 当我将它与自身进行比较时，结果证明是真的
111:04 当我将它与自身进行比较时，结果证明是真的 返回 True 但这里是 5 k
111:07 返回 True 但这里是 5 k 五个模块中的第二个（假设一个模块附带两个）
111:10 五个模块中的第二个（假设一个模块附带两个） 因此我们将 One 与 Ro 进行了比较
111:12 因此我们将 One 与 Ro 进行了比较 这等于没有出现，所以它被打印出来
111:14 这等于没有出现，所以它被打印出来 Ro 的意思是 false，现在有另一个版本
111:17 Ro 的意思是 false，现在有另一个版本 恰巧是这个程序的那个版本
111:19 恰巧是这个程序的那个版本 嘿，判断一个数字是偶数还是奇数
111:24 嘿，判断一个数字是偶数还是奇数 除以二
111:26 除以二 与数字 2 匹配的偶数
111:28 与数字 2 匹配的偶数 没有被划分，即他们的模块是我们的
111:31 没有被划分，即他们的模块是我们的 零不会靠近我们，他们是我们的胜算
111:34 零不会靠近我们，他们是我们的胜算 每当你想检查偶数或奇数时
111:36 每当你想检查偶数或奇数时 无论你有没有号码，
111:38 无论你有没有号码， 检查分区，这是我们的下一个
111:40 检查分区，这是我们的下一个 练习写一个问题
111:42 练习写一个问题 检查数字是奇数还是偶数的程序
111:44 检查数字是奇数还是偶数的程序 每当我们有偶数情况时
111:47 每当我们有偶数情况时 这样我们就可以打印出一个奇数
111:50 这样我们就可以打印出一个奇数 有这样一种情况，那些打印出来的人将会
111:52 有这样一种情况，那些打印出来的人将会 如果是零，那么我们输入的数字相同
111:55 如果是零，那么我们输入的数字相同 我已经通过以下方式将其存储在 x 中
111:57 我已经通过以下方式将其存储在 x 中 你会从两个
111:59 你会从两个 如果模型中出现零，我们将采用该模块
112:02 如果模型中出现零，我们将采用该模块 所以这个数字是偶数，否则就是奇数
112:04 所以这个数字是偶数，否则就是奇数 首先再次运行程序
112:07 首先再次运行程序 让我们以 16 16 中打印的那个为例，即
112:11 让我们以 16 16 中打印的那个为例，即 16 是偶数，因为 2 是
112:13 16 是偶数，因为 2 是 去了
112:15 去了 如果我们谈论七，那么现在就划分
112:18 如果我们谈论七，那么现在就划分 如果数字为七，则打印零
112:20 如果数字为七，则打印零 因为七是奇数，所以接下来
112:23 因为七是奇数，所以接下来 问题说的是以下是否有效和
112:25 问题说的是以下是否有效和 第一个语句不是 int e 8，而是这个
112:29 第一个语句不是 int e 8，而是这个 符号 8 现在我们有
112:31 符号 8 现在我们有 人们对此已经有了期待
112:33 人们对此已经有了期待 我们已经讨论过了，我们期待
112:35 我们已经讨论过了，我们期待 8 的 8 次方，应该很大
112:38 8 的 8 次方，应该很大 碳
112:39 碳 该值不会在这里打印。
112:42 该值不会在这里打印。 但这里会打印零，怎么才能
112:44 但这里会打印零，怎么才能 一旦你查看代码，就会打印零
112:46 一旦你查看代码，就会打印零 让我们把这整个东西删除并打印在这里
112:50 让我们把这整个东西删除并打印在这里 让我们完成它 8
112:53 让我们完成它 8 打印零是因为编译器有
112:55 打印零是因为编译器有 你做了什么，它不像 8 的 8 次方
112:57 你做了什么，它不像 8 的 8 次方 我选了这8个大8，当相同的数字
113:01 我选了这8个大8，当相同的数字 如果你用相同的号码兑换，那么
113:03 如果你用相同的号码兑换，那么 输出始终为零，因此这里
113:05 输出始终为零，因此这里 但我们得到的输出为零。
113:06 但我们得到的输出为零。 位运算符就是我们所说的
113:08 位运算符就是我们所说的 我们已经讨论过了，我们稍后再谈
113:10 我们已经讨论过了，我们稍后再谈 如果我们这样做，我们将获得这种力量的输出
113:12 如果我们这样做，我们将获得这种力量的输出 PoE WP 供电功能不来
113:15 PoE WP 供电功能不来 但这句话必须用
113:17 但这句话必须用 有效，是的，这个说法有效，不是吗？
113:19 有效，是的，这个说法有效，不是吗？ 编译器没有返回任何错误
113:21 编译器没有返回任何错误 编译器没有返回任何错误
113:23 编译器没有返回任何错误 这就是为什么声明没有赋予我们权力
113:26 这就是为什么声明没有赋予我们权力 但这是一个有效的陈述，其次
113:30 但这是一个有效的陈述，其次 让我们讨论一下语句 int x
113:33 让我们讨论一下语句 int x 是我们的终止符，然后 int y = x，然后
113:36 是我们的终止符，然后 int y = x，然后 终结者这个声明现在有效吗
113:39 终结者这个声明现在有效吗 如果你仔细看第一句，
113:41 如果你仔细看第一句， 这是我们的第二个结局
113:44 这是我们的第二个结局 声明已开始第二条声明
113:46 声明已开始第二条声明 我们将 x 的值代入 y
113:49 我们将 x 的值代入 y 现在给出这个语句，同一行
113:52 现在给出这个语句，同一行 我已经写了，但因为终结者即将到来
113:54 我已经写了，但因为终结者即将到来 如果发生，则进行下一个语句，然后进行第一个
113:57 如果发生，则进行下一个语句，然后进行第一个 我们声明 x 并稍后使用它
113:58 我们声明 x 并稍后使用它 如果已经完成，那么这个说法也是有效的。
114:02 如果已经完成，那么这个说法也是有效的。 让我们解决它并看看
114:06 让我们解决它并看看 x 和 int y = x 现在如果我们保存
114:11 x 和 int y = x 现在如果我们保存 如果你这样做，就不会出现错误，因为
114:13 如果你这样做，就不会出现错误，因为 发生的事情是，首先声明 x，然后声明 y
114:16 发生的事情是，首先声明 x，然后声明 y 如果我们这样写或者这样写
114:19 如果我们这样写或者这样写 这样写，两者没有区别
114:21 这样写，两者没有区别 两者的语法都是正确且相同的，但是
114:24 两者的语法都是正确且相同的，但是 如果我们把这个终结器移除，
114:26 如果我们把这个终结器移除， 在此处输入逗号，然后保存
114:29 在此处输入逗号，然后保存 那么为什么这里会出现错误呢？发生错误
114:31 那么为什么这里会出现错误呢？发生错误 因为终止符被删除了，所以这意味着同样
114:33 因为终止符被删除了，所以这意味着同样 它在同一条线上，所以我们做了一个
114:36 它在同一条线上，所以我们做了一个 我在声明它的那一行中使用了它
114:38 我在声明它的那一行中使用了它 如果你在同一行，那么在这里输入
114:40 如果你在同一行，那么在这里输入 声明规则被打破了，这里
114:42 声明规则被打破了，这里 但我们的第三个问题出现了。
114:45 但我们的第三个问题出现了。 我们有什么问题
114:47 我们有什么问题 他正在排队，走到我们中间
114:49 他正在排队，走到我们中间 逗号，所以这是有效的，但发生了这种情况
114:53 逗号，所以这是有效的，但发生了这种情况 我们的无效声明是第四个声明。
114:56 我们的无效声明是第四个声明。 有一个角色我们已经定义了星星
114:58 有一个角色我们已经定义了星星 我们在里面存储了两颗星星，并分别命名
115:00 我们在里面存储了两颗星星，并分别命名 让我们看看它是否有效
115:03 让我们看看它是否有效 关爱之星写下他们的代码
115:06 关爱之星写下他们的代码 等于 star star 这样做
115:09 等于 star star 这样做 保存现在让我们编译这个语句
115:12 保存现在让我们编译这个语句 编译后我们会收到警告
115:14 编译后我们会收到警告 生成的警告告诉我们什么
115:17 生成的警告告诉我们什么 创建了一个多字符常量
115:19 创建了一个多字符常量 这意味着我们在这里放了多个字符
115:21 这意味着我们在这里放了多个字符 如果你给那么这是一个错误的事情，这不是我们
115:23 如果你给那么这是一个错误的事情，这不是我们 如果我们还插入空格字符
115:25 如果我们还插入空格字符 里面甚至不会编译相同的
115:28 里面甚至不会编译相同的 它会问你为什么添加空格
115:30 它会问你为什么添加空格 所以这就是为什么每当我们创造角色时
115:32 所以这就是为什么每当我们创造角色时 我们必须赋予它们单一的价值
115:34 我们必须赋予它们单一的价值 这样才能编译成功
115:37 这样才能编译成功 如果我们在这里写森林那么它就意味着森林
115:40 如果我们在这里写森林那么它就意味着森林 无论发生什么，它都会被编译，但对于一个
115:42 无论发生什么，它都会被编译，但对于一个 另外，如果你写两个，那么请在这里给出
115:43 另外，如果你写两个，那么请在这里给出 角色以某种方式出现，所以这是我们的
115:46 角色以某种方式出现，所以这是我们的 它不会编译，它会给我们隐式的
115:49 它不会编译，它会给我们隐式的 转换警告 为什么这些警告
115:51 转换警告 为什么这些警告 因为如果我们有多个
115:53 因为如果我们有多个 如果我们是明星，为什么还要放人物呢？
115:54 如果我们是明星，为什么还要放人物呢？ 即使你放了一颗星，它也留在记忆里
115:56 即使你放了一颗星，它也留在记忆里 它占用的空间与字符一样多
115:58 它占用的空间与字符一样多 如果空间大于分配给它的空间，那么它
116:00 如果空间大于分配给它的空间，那么它 我们应该把它放在更大的容器里吗
116:02 我们应该把它放在更大的容器里吗 他认为小容器有特色
116:04 他认为小容器有特色 我不会让这个人做这件事，那砖头怎么办
116:06 我不会让这个人做这件事，那砖头怎么办 我可能把它放在容器里但它会自动实现它。
116:09 我可能把它放在容器里但它会自动实现它。 他不能这样做，因为角色
116:11 他不能这样做，因为角色 它不会自动将其转换为整数。
116:13 它不会自动将其转换为整数。 这就是此处生成此警告的原因
116:15 这就是此处生成此警告的原因 所以当你扮演角色时你不应该这样做
116:17 所以当你扮演角色时你不应该这样做 定义单个值
116:18 定义单个值 我们必须定义角色
116:20 我们必须定义角色 我们将称该声明无效，因为
116:23 我们将称该声明无效，因为 这里编译器会抛出一个警告
116:25 这里编译器会抛出一个警告 接下来是练习题
116:26 接下来是练习题 在那里，我们必须告诉它打印 true
116:29 在那里，我们必须告诉它打印 true 或首先对以下语句为假
116:31 或首先对以下语句为假 这句话是，如果是星期天，并且知道
116:35 这句话是，如果是星期天，并且知道 如果是星期日则打印 true
116:38 如果是星期日则打印 true 下雪了，然后真打印
116:41 下雪了，然后真打印 如何以程序形式实现
116:43 如何以程序形式实现 如何转换前两个
116:45 如何转换前两个 让我们以变量为例，第一个变量是 int
116:49 让我们以变量为例，第一个变量是 int 是星期日第二个变量是 int
116:53 是星期日第二个变量是 int 下雪了，所以如果我们是真的，现在是星期天
116:56 下雪了，所以如果我们是真的，现在是星期天 把它放进去，如果我们是真的，也会下雪
116:59 把它放进去，如果我们是真的，也会下雪 放进去然后执行 printf
117:03 放进去然后执行 printf 这个周日，真相将终结，
117:07 这个周日，真相将终结， 当雪是真的时，我们才会有真正的
117:11 当雪是真的时，我们才会有真正的 应该打印出来，也就是说这也应该是真的，而且这也
117:13 应该打印出来，也就是说这也应该是真的，而且这也 仅当是周日且下雪时才为真
117:15 仅当是周日且下雪时才为真 我们将进行真正的印刷，所以我们已经有了这些
117:18 我们将进行真正的印刷，所以我们已经有了这些 我已经让它们都成真了，让我们看看
117:19 我已经让它们都成真了，让我们看看 我们的产出是否实现了
117:23 我们的产出是否实现了 所以在输出中我们得到了 True
117:26 所以在输出中我们得到了 True 假设没有星期天
117:27 假设没有星期天 如果还有另一天，那么这个星期天将会是
117:30 如果还有另一天，那么这个星期天将会是 现在如果我们运行这个，输出将是
117:32 现在如果我们运行这个，输出将是 我们将得到零，因为在两者中
117:35 我们将得到零，因为在两者中 一个条件变为假，结果会怎样？
117:37 一个条件变为假，结果会怎样？ 如果一个条件为假，那么整个
117:39 如果一个条件为假，那么整个 现在第二个问题将使它成为假
117:42 现在第二个问题将使它成为假 他说如果是星期一下雨
117:46 他说如果是星期一下雨 所以要么是星期一要么是下雨
117:48 所以要么是星期一要么是下雨 如果有的话，那么它应该在这里打印出来，并且
117:51 如果有的话，那么它应该在这里打印出来，并且 代替现有的，我们将采取合乎逻辑的和
117:54 代替现有的，我们将采取合乎逻辑的和 运营商将把“本周日”改为“本周一”
117:57 运营商将把“本周日”改为“本周一” 我们知道这里正在下雨
118:02 我们知道这里正在下雨 如果不是星期一，那么我们将把它设为零，因为正在下雨
118:04 如果不是星期一，那么我们将把它设为零，因为正在下雨 所以我们就在这里做，开始吧
118:07 所以我们就在这里做，开始吧 我们周一就在这里吧
118:09 我们周一就在这里吧 现在正在下雨，有一种情况正在下降
118:12 现在正在下雨，有一种情况正在下降 一个条件为真，则两个条件之一
118:15 一个条件为真，则两个条件之一 如果是，那么我们需要将其打印出来
118:17 如果是，那么我们需要将其打印出来 如果为真，那么我们将使用逻辑和
118:20 如果为真，那么我们将使用逻辑和 让我们运行它，看看会打印什么
118:21 让我们运行它，看看会打印什么 我们有第三个条件，即如果
118:25 我们有第三个条件，即如果 数字大于 na 表示存在数字 x
118:28 数字大于 na 表示存在数字 x 如果大于 9 且小于 100
118:31 如果大于 9 且小于 100 如果少于 100，我们就会将其打印出来
118:35 如果少于 100，我们就会将其打印出来 如果你认为它是真的，那么你必须检查一个数字
118:37 如果你认为它是真的，那么你必须检查一个数字 它大于九，并且是同一个数字
118:42 它大于九，并且是同一个数字 这两个条件是小于 100
118:44 这两个条件是小于 100 条件应该为真，我们将其放在中间
118:46 条件应该为真，我们将其放在中间 你的逻辑与运算符然后打印
118:49 你的逻辑与运算符然后打印 我们会完成它而不是真正的现在这就是我们
118:52 我们会完成它而不是真正的现在这就是我们 声明撰写人 条件撰写人
118:54 声明撰写人 条件撰写人 我们可以这样说
118:56 我们可以这样说 让我们检查一下它是否是两位数
118:58 让我们检查一下它是否是两位数 大于 9 小于 100 的数字
119:01 大于 9 小于 100 的数字 较小的那个总是两位数
119:03 较小的那个总是两位数 所以每当我们有两位数的条件时
119:05 所以每当我们有两位数的条件时 我们必须在代码中检查这个语句
119:07 我们必须在代码中检查这个语句 因此，每当出现这样的问题时，请将其写下来
119:10 因此，每当出现这样的问题时，请将其写下来 我们必须打印相同的声明
119:12 我们必须打印相同的声明 在问题中写下这个代码
119:15 在问题中写下这个代码 首先，我们定义一个变量
119:17 首先，我们定义一个变量 然后将其打印在屏幕上并按 Enter
119:20 然后将其打印在屏幕上并按 Enter 数字
119:22 数字 输入号码，然后
119:25 输入号码，然后 您现在可以查看百分比 D&X
119:30 您现在可以查看百分比 D&X 我们假设 x 大于 9，并且
119:34 我们假设 x 大于 9，并且 如果这两个条件都成立，则 x 为 100
119:39 如果这两个条件都成立，则 x 为 100 如果该数字是两位数，那么
119:41 如果该数字是两位数，那么 将会打印一个，如果没有则打印
119:43 将会打印一个，如果没有则打印 它将是零，让我们先运行它，谁
119:47 它将是零，让我们先运行它，谁 我们会输入号码，他们会这样做 78 78
119:49 我们会输入号码，他们会这样做 78 78 如果你运行相同的代码，就会打印出一个
119:52 如果你运行相同的代码，就会打印出一个 执行此操作并输入数字
119:55 执行此操作并输入数字 101 将被打印为零，因为这是两个
119:58 101 将被打印为零，因为这是两个 如果数字尚未在 C 内，则
120:00 如果数字尚未在 C 内，则 正如我们所读到的，不同的
120:02 正如我们所读到的，不同的 通过结合操作符，我们看起来非常漂亮
120:04 通过结合操作符，我们看起来非常漂亮 逻辑程序可以创造世界
120:06 逻辑程序可以创造世界 这里面是否存在逻辑
120:09 这里面是否存在逻辑 这是否意味着数学之类的东西非常
120:11 这是否意味着数学之类的东西非常 物理学之类的东西更合乎逻辑，
120:13 物理学之类的东西更合乎逻辑， 如果逻辑在任何地方都是合乎逻辑的
120:15 如果逻辑在任何地方都是合乎逻辑的 它存在，我们可以为其制定一个公式
120:17 它存在，我们可以为其制定一个公式 你能为那件事制定一个流程吗
120:19 你能为那件事制定一个流程吗 总是可以转换成代码
120:22 总是可以转换成代码 如果有任何问题，我们会把东西放在这里
120:24 如果有任何问题，我们会把东西放在这里 其中很多已经转换成代码
120:26 其中很多已经转换成代码 关于美丽的程序，我们学到了什么？
120:27 关于美丽的程序，我们学到了什么？ 学会了如何很好地检查奇偶
120:29 学会了如何很好地检查奇偶 基础课程和许多学期中期课程
120:31 基础课程和许多学期中期课程 大学会问你是否
120:34 大学会问你是否 首轮结果与 TCS 类似
120:36 首轮结果与 TCS 类似 对于公司来说，他们也可以先询问
120:38 对于公司来说，他们也可以先询问 如果不是你，那么它将出现在你的 MCQ 轮次中
120:40 如果不是你，那么它将出现在你的 MCQ 轮次中 如果我们必须检查，就会出现这样的问题
120:42 如果我们必须检查，就会出现这样的问题 有没有两位数，那么它的
120:43 有没有两位数，那么它的 我们已经看到了除了接下来的情况
120:46 我们已经看到了除了接下来的情况 章节中有很多这样的逻辑论证
120:48 章节中有很多这样的逻辑论证 我们将发现更多问题
120:50 我们将发现更多问题 你将解决更多问题，这很简单
120:52 你将解决更多问题，这很简单 此后我们有一个家庭作业
120:54 此后我们有一个家庭作业 问题是我们会收到一份家庭作业表
120:57 问题是我们会收到一份家庭作业表 我们必须暂停并自己解决这个问题
120:59 我们必须暂停并自己解决这个问题 如果你无法解决，则会发生任何错误
121:01 如果你无法解决，则会发生任何错误 如果是，请在您的笔记中向我们发送解决方案。
121:03 如果是，请在您的笔记中向我们发送解决方案。 我们将去寻找这些问题的解决方案
121:05 我们将去寻找这些问题的解决方案 你可以看看它并问自己一个问题
121:07 你可以看看它并问自己一个问题 如果你可以练习，那么这里是我们的
121:08 如果你可以练习，那么这里是我们的 第二章结束，下一章开始
121:10 第二章结束，下一章开始 这是条件运算符
121:12 这是条件运算符 大家好，现在我们开始
121:15 大家好，现在我们开始 第三章名为
121:17 第三章名为 C 语言中条件语句内的条件
121:19 C 语言中条件语句内的条件 声明非常重要，
121:21 声明非常重要， 这构成了我们的编程基础
121:23 这构成了我们的编程基础 现在让我们阅读条件语句
121:26 现在让我们阅读条件语句 在此之前，先简单介绍一下她的真实生活
121:27 在此之前，先简单介绍一下她的真实生活 让我们看一些例子，例如，假设
121:30 让我们看一些例子，例如，假设 我们将被赋予一个角色
121:33 我们将被赋予一个角色 例如 M 代表星期一，T 代表星期二，或者 A
121:36 例如 M 代表星期一，T 代表星期二，或者 A W 代表星期三，所以我们
121:39 W 代表星期三，所以我们 无论他扮演哪个角色
121:41 无论他扮演哪个角色 无论哪一天我们都会打印它
121:43 无论哪一天我们都会打印它 我们需要完成它吗？或者除此之外，我们还需要成绩单
121:46 我们需要完成它吗？或者除此之外，我们还需要成绩单 我们在学校里见面，发生了什么
121:47 我们在学校里见面，发生了什么 我们被给予一些等级，例如
121:49 我们被给予一些等级，例如 如果你得到 90 分以上，那么你将获得 A 加
121:52 如果你得到 90 分以上，那么你将获得 A 加 加分 diya 会给 80 到 90 分
121:54 加分 diya 会给 80 到 90 分 会是 70 到 80 会给你 60 到
121:58 会是 70 到 80 会给你 60 到 在 70 年，你会以这种方式获得 B
122:00 在 70 年，你会以这种方式获得 B 如果评分制度继续存在，那么整个
122:02 如果评分制度继续存在，那么整个 如果我们必须编写整个评分系统
122:04 如果我们必须编写整个评分系统 如果我们想写成这样，那么我们需要使用条件
122:06 如果我们想写成这样，那么我们需要使用条件 如果值
122:08 如果值 假设正在创建这样的场景：
122:11 假设正在创建这样的场景： 如果我们有自己的光，那么我们需要把它打印出来
122:13 如果我们有自己的光，那么我们需要把它打印出来 如果有早晨和黑暗，就把它打印出来
122:16 如果有早晨和黑暗，就把它打印出来 嘿晚安，有些事情就是这样发生的
122:18 嘿晚安，有些事情就是这样发生的 有时需要用代码编写或
122:20 有时需要用代码编写或 那么如果我们去市场买东西
122:22 那么如果我们去市场买东西 假设你穿着衣服
122:23 假设你穿着衣服 如果你购买小工具，那么他们的
122:25 如果你购买小工具，那么他们的 你还得缴纳一些税，但是
122:28 你还得缴纳一些税，但是 如果你从市场上买书
122:30 如果你从市场上买书 那么谁不需要为它们纳税呢？
122:32 那么谁不需要为它们纳税呢？ 你是根据这个来买东西的
122:34 你是根据这个来买东西的 您拥有的软件将决定
122:36 您拥有的软件将决定 这样你会被征收多少税
122:38 这样你会被征收多少税 有条件的计划
122:40 有条件的计划 您的检查是根据物品的状况进行的
122:44 您的检查是根据物品的状况进行的 计算上述税额的条件
122:46 计算上述税额的条件 系统会检查它是哪件物品，然后告知
122:48 系统会检查它是哪件物品，然后告知 首先看看要征多少税
122:50 首先看看要征多少税 天会变黑或者天会变亮，然后
122:53 天会变黑或者天会变亮，然后 您将被告知首先要打印什么。
122:55 您将被告知首先要打印什么。 它将会看到它是哪个字符，然后它将被打印出来
122:58 它将会看到它是哪个字符，然后它将被打印出来 将在一周中的哪一天完成
123:00 将在一周中的哪一天完成 我们正在谈论你将首先被看到
123:02 我们正在谈论你将首先被看到 那么你对这门学科的了解有多少呢？
123:04 那么你对这门学科的了解有多少呢？ 打印出来的内容是你的
123:06 打印出来的内容是你的 在这种情况下有多少个等级
123:08 在这种情况下有多少个等级 我们观察情况并采取相应行动
123:11 我们观察情况并采取相应行动 一切都按照这个进行
123:14 一切都按照这个进行 如果我们完成了，我们会有条件地把它交给他们
123:16 如果我们完成了，我们会有条件地把它交给他们 条件运算符语句的关键
123:19 条件运算符语句的关键 现在，每当我们将其归入 C 类
123:21 现在，每当我们将其归入 C 类 谈论内部条件语句
123:23 谈论内部条件语句 那么我们可以区分两种类型的语句
123:25 那么我们可以区分两种类型的语句 第一个是我们的 FL
123:27 第一个是我们的 FL 语句，另一个是我们的 switch
123:30 语句，另一个是我们的 switch if 语句在英语中的意思
123:33 if 语句在英语中的意思 if and else 表示如果
123:36 if and else 表示如果 如果那件事没有发生，那就做这件事
123:38 如果那件事没有发生，那就做这件事 如何形成我们的FFL声明
123:40 如何形成我们的FFL声明 现在我们看一下语法，
123:43 现在我们看一下语法， 如何写声明是最重要的
123:45 如何写声明是最重要的 首先我们写 if 关键字，这是一个 C 关键字。
123:48 首先我们写 if 关键字，这是一个 C 关键字。 关键字已经是C编译器
123:50 关键字已经是C编译器 你知道“如果”是什么意思吗？
123:52 你知道“如果”是什么意思吗？ 然后我们把括号放在里面
123:54 然后我们把括号放在里面 我们现在写任何条件，我们写条件
123:57 我们现在写任何条件，我们写条件 我们已经读过关于这种类型的
123:59 我们已经读过关于这种类型的 我会写下我们的关系
124:01 我会写下我们的关系 在这种情况下，字符等于 m
124:04 在这种情况下，字符等于 m 周一或 Marks 打印
124:07 周一或 Marks 打印 如果我们必须写下条件，那么分数将由我们给出
124:10 如果我们必须写下条件，那么分数将由我们给出 大于 80 是结束标记，如果
124:13 大于 80 是结束标记，如果 我们的小于等于 90，所以在这种情况下
124:17 我们的小于等于 90，所以在这种情况下 我们要打印的等级
124:19 我们要打印的等级 假设它是 a+ 那么像这样
124:21 假设它是 a+ 那么像这样 我们在这里写下条件。
124:24 我们在这里写下条件。 我应该检查哪些条件
124:27 我应该检查哪些条件 如果这是真的，那就做这件事
124:30 如果这是真的，那就做这件事 如果它变成假的，那么就做这件事
124:33 如果它变成假的，那么就做这件事 这是我们的 if 语句，这是我们的
124:36 这是我们的 if 语句，这是我们的 Else 语句有自己的 Else 块
124:38 Else 语句有自己的 Else 块 else 也是一个关键字，如果它
124:41 else 也是一个关键字，如果它 如果条件成立，那么它里面的内容
124:43 如果条件成立，那么它里面的内容 这两个花括号的含义也会被写出来
124:46 这两个花括号的含义也会被写出来 里面写的内容必须执行
124:48 里面写的内容必须执行 但如果这个说法是错误的
124:50 但如果这个说法是错误的 如果成功，那么这是 Else 块
124:53 如果成功，那么这是 Else 块 没有这两个花括号，不管它里面是什么
124:55 没有这两个花括号，不管它里面是什么 任何写出来的东西都会被打印出来，或者
124:59 任何写出来的东西都会被打印出来，或者 我们会把工作交给编译器去做
125:01 我们会把工作交给编译器去做 现在这将在 if else 条件下发生
125:03 现在这将在 if else 条件下发生 里面的东西不是强制性的
125:06 里面的东西不是强制性的 如果这显然是强制性的，否则
125:08 如果这显然是强制性的，否则 这是我们的选择，这是我们的选择
125:10 这是我们的选择，这是我们的选择 否则，我们想完成更多的工作，如果
125:12 否则，我们想完成更多的工作，如果 条件是否为假
125:14 条件是否为假 如果我们愿意，我们可以彻底消除所有其他
125:17 如果我们愿意，我们可以彻底消除所有其他 现在让我们看一些例子
125:19 现在让我们看一些例子 首先在代码中创建一个变量
125:21 首先在代码中创建一个变量 让我们定义边缘，假设我们有 19
125:24 让我们定义边缘，假设我们有 19 存储甚至更好的边缘
125:28 存储甚至更好的边缘 我们首先从用户那里获取输入并打印它
125:30 我们首先从用户那里获取输入并打印它 让我们进入
125:36 然后它会扫描边缘 百分比 D 结束
125:40 百分比 D 结束 这里是声明中的赋值
125:43 这里是声明中的赋值 会删除这个
125:44 会删除这个 现在我们一到达边缘，
125:47 现在我们一到达边缘， 首先我们将在 Edge 中检查我们知道
125:50 首先我们将在 Edge 中检查我们知道 年龄超过 18 岁的人是
125:52 年龄超过 18 岁的人是 成年人是指年龄未满 18 岁的人
125:54 成年人是指年龄未满 18 岁的人 如果他还不是成年人那么
125:56 如果他还不是成年人那么 我们可以在这里用代码写出语句。
125:58 我们可以在这里用代码写出语句。 如果我们的年龄大于
126:01 如果我们的年龄大于 18
126:02 18 在这种情况下，我们想要打印
126:08 在这种情况下，我们想要打印 成年人应该谨慎对待这句话。
126:11 成年人应该谨慎对待这句话。 首先，我们将检查 if 条件
126:14 首先，我们将检查 if 条件 为此，我们在里面写了 if 关键字
126:16 为此，我们在里面写了 if 关键字 我写了我的条件，我们的条件是什么
126:19 我写了我的条件，我们的条件是什么 我们的年龄必须大于 18 岁，然后任何人
126:22 我们的年龄必须大于 18 岁，然后任何人 我们已经领先了，她是一个成年人，所以我们
126:25 我们已经领先了，她是一个成年人，所以我们 我已经阅读了如何使用关系运算符
126:27 我已经阅读了如何使用关系运算符 使用变量比较
126:29 使用变量比较 我们将把这个常数设为我们的边缘
126:31 我们将把这个常数设为我们的边缘 变量 18 是我们的常数
126:34 变量 18 是我们的常数 是否大，以及这个说法是否正确
126:36 是否大，以及这个说法是否正确 如果条件为真，就会发生这种情况
126:38 如果条件为真，就会发生这种情况 如果发生这种情况，我们将在此处写下
126:40 如果发生这种情况，我们将在此处写下 如果发生任何事情我们将在这里执行
126:42 如果发生任何事情我们将在这里执行 上面写着“成人”，所以如果这个条件成立
126:44 上面写着“成人”，所以如果这个条件成立 完成后，我们将打印一份
126:46 完成后，我们将打印一份 屏幕上的成年人但接受这个条件
126:48 屏幕上的成年人但接受这个条件 返回 false，在这种情况下我们打印
126:52 返回 false，在这种情况下我们打印 如果你想以非成年人的身份完成这件事，那么我们应该怎么做
126:54 如果你想以非成年人的身份完成这件事，那么我们应该怎么做 我们会做其他事情然后我们会像这样写
126:56 我们会做其他事情然后我们会像这样写 我们也将为此制作一个花括号块。
126:58 我们也将为此制作一个花括号块。 花括号之间的内容
127:00 花括号之间的内容 有線吧？我们称之为区块。
127:02 有線吧？我们称之为区块。 如果我们这里有自己的花括号版本，
127:05 如果我们这里有自己的花括号版本， 如果你完成打印 f 那么它将被写入其中
127:07 如果你完成打印 f 那么它将被写入其中 不是
127:08 不是 成人下一行并将保存它
127:12 成人下一行并将保存它 现在我们也可以在这里写多行。
127:14 现在我们也可以在这里写多行。 现在，如果她已经成年，那么显然我们
127:17 现在，如果她已经成年，那么显然我们 你知道如果他们年满 18 岁就可以投票
127:21 你知道如果他们年满 18 岁就可以投票 如果你年满 18 岁，你可以投票，也可以开车
127:26 如果你年满 18 岁，你可以投票，也可以开车 如果你能做到，那么让我把它写在这里，你可以
127:28 如果你能做到，那么让我把它写在这里，你可以 如果这个也以这种方式驾驶
127:32 如果这个也以这种方式驾驶 如果条件为真，那么这三个
127:34 如果条件为真，那么这三个 语句将被打印，并且如果条件
127:36 语句将被打印，并且如果条件 如果不是这样那么在这个块中
127:38 如果不是这样那么在这个块中 现在这两个卷曲的
127:40 现在这两个卷曲的 在支架的中间，完成了整个
127:43 在支架的中间，完成了整个 一大堆声明来了，这群人来了
127:45 一大堆声明来了，这群人来了 我们称这些块在 C 中或
127:47 我们称这些块在 C 中或 任何编程语言
127:49 任何编程语言 块是
127:51 块是 有一些声明中我们有很多
127:52 有一些声明中我们有很多 如果你插入语句，那么这三个就是一个
127:54 如果你插入语句，那么这三个就是一个 你们必须一起执行，你应该这样做
127:57 你们必须一起执行，你应该这样做 让我们保存它、编译它并运行它。
128:00 让我们保存它、编译它并运行它。 我们跑一跑吧，我们先进去
128:04 我们跑一跑吧，我们先进去 15 我们的年龄是 15 岁，在这种情况下打印
128:06 15 我们的年龄是 15 岁，在这种情况下打印 现在如果你再运行它，你就不再是成年人了
128:10 现在如果你再运行它，你就不再是成年人了 这次我们将进入22岁，这次
128:13 这次我们将进入22岁，这次 打印他们已成年他们可以投票
128:16 打印他们已成年他们可以投票 可以开车，所以如果我们有
128:19 可以开车，所以如果我们有 我发表了一个不真实的声明
128:22 我发表了一个不真实的声明 如果这里为假那么其他
128:24 如果这里为假那么其他 当他进去的时候他打印了一份不成人
128:26 当他进去的时候他打印了一份不成人 但是我们把 22 放在哪里
128:28 但是我们把 22 放在哪里 如果条件为真，那么所有这些
128:30 如果条件为真，那么所有这些 语句已执行，但
128:33 语句已执行，但 没有发生 表示该语句没有发生
128:35 没有发生 表示该语句没有发生 现在如果我们在最后写点什么
128:38 现在如果我们在最后写点什么 谢谢
128:40 谢谢 这显然会被执行吗？
128:43 这显然会被执行吗？ 是的，在任何情况下都应如此声明
128:45 是的，在任何情况下都应如此声明 它将被执行，因为除此之外没有
128:47 它将被执行，因为除此之外没有 如果它被应用，否则意味着任何
128:49 如果它被应用，否则意味着任何 有一个必须执行的条件
128:51 有一个必须执行的条件 让我们也看一个例子。
128:54 让我们也看一个例子。 让我们编译并运行。现在如果我们输入
128:58 让我们编译并运行。现在如果我们输入 如果你做 19 那么在这种情况下所有这些条件都是
129:01 如果你做 19 那么在这种情况下所有这些条件都是 所有这些声明都与
129:04 所有这些声明都与 最后的感谢也将永远被打印出来
129:06 最后的感谢也将永远被打印出来 无论我们进入年龄是 18 岁以下还是 18 岁以上
129:08 无论我们进入年龄是 18 岁以下还是 18 岁以上 现在把它放大，其他都是强制性的
129:11 现在把它放大，其他都是强制性的 即使我们删除这个，我们假设
129:13 即使我们删除这个，我们假设 我们只需要检查他是否大于 18 岁
129:15 我们只需要检查他是否大于 18 岁 不，如果它很小那么在这种情况下就没什么
129:17 不，如果它很小那么在这种情况下就没什么 即使我们不想打印，我们的程序也是
129:19 即使我们不想打印，我们的程序也是 编译成功后会变成这样
129:22 编译成功后会变成这样 如果我们进入 15 次，就说谢谢
129:24 如果我们进入 15 次，就说谢谢 您将打印其他内容
129:26 您将打印其他内容 没有，因为没有别的，只有这个
129:28 没有，因为没有别的，只有这个 将检查该声明是否属实
129:30 将检查该声明是否属实 这就是我们的 If Else 的工作原理
129:33 这就是我们的 If Else 的工作原理 现在如果否则里面有一个特殊的东西
129:35 现在如果否则里面有一个特殊的东西 我们已经写了多个语句，如果
129:37 我们已经写了多个语句，如果 里面，否则我们就必须做卷曲
129:39 里面，否则我们就必须做卷曲 我必须戴牙套，但这些是卷曲的
129:41 我必须戴牙套，但这些是卷曲的 如果我们
129:44 如果我们 假设你必须写一个语句
129:46 假设你必须写一个语句 就像在 if 的情况下写一个语句
129:48 就像在 if 的情况下写一个语句 在其他情况下也必须写入相同的状态
129:51 在其他情况下也必须写入相同的状态 这是最后一个了，谢谢，我们离开这里了
129:53 这是最后一个了，谢谢，我们离开这里了 现在就尝试一下并保存它
129:55 现在就尝试一下并保存它 因此，即使没有花括号，这个程序
129:58 因此，即使没有花括号，这个程序 它必须正在编译并运行 23
130:02 它必须正在编译并运行 23 如果你插入它，看到成人印着
130:04 如果你插入它，看到成人印着 并且没有发生错误，那么如果我们有
130:07 并且没有发生错误，那么如果我们有 有一句话说，我们可以不用卷发
130:10 有一句话说，我们可以不用卷发 牙套也可以起作用，对吗？
130:12 牙套也可以起作用，对吗？ 那些优秀的程序员，他们
130:14 那些优秀的程序员，他们 为项目带来一致性
130:16 为项目带来一致性 如果我们想成为一名优秀的程序员，那么
130:18 如果我们想成为一名优秀的程序员，那么 如果我每次都要加上花括号，那么我
130:19 如果我每次都要加上花括号，那么我 我每次都戴花括号，因为
130:22 我每次都戴花括号，因为 让我们看一个使用花括号的例子
130:24 让我们看一个使用花括号的例子 没有申请并写了多份声明
130:26 没有申请并写了多份声明 那么会发生什么呢？
130:29 那么会发生什么呢？ 您可以投票，我们已在此处写下您的投票
130:32 您可以投票，我们已在此处写下您的投票 现在让我们把它保存在这里
130:35 现在让我们把它保存在这里 我已经收到一条错误信息，提示其他东西总是存在
130:38 我已经收到一条错误信息，提示其他东西总是存在 应该在 if 之后出现，这做了什么
130:41 应该在 if 之后出现，这做了什么 这首单曲如果是那首
130:44 这首单曲如果是那首 有一份打印的声明，所以我把它混淆了
130:46 有一份打印的声明，所以我把它混淆了 但第二个是打印的声明
130:48 但第二个是打印的声明 他没有用if来计算
130:50 他没有用if来计算 单独计算
130:51 单独计算 然后这个人来到 Else Else 并思考了
130:54 然后这个人来到 Else Else 并思考了 如果在哪里，因为上面有一个如果
130:56 如果在哪里，因为上面有一个如果 不，上面写的是正常语句
130:59 不，上面写的是正常语句 指令是这样写的
131:01 指令是这样写的 不要让方法混淆
131:03 不要让方法混淆 我们总是要写一个程序，
131:04 我们总是要写一个程序， 无论有多少个花括号都必须佩戴
131:07 无论有多少个花括号都必须佩戴 现在，只要我们的 if 不成立
131:09 现在，只要我们的 if 不成立 之后，如果我们要检查
131:11 之后，如果我们要检查 除上述情况外，还有其他条件成立吗？
131:14 除上述情况外，还有其他条件成立吗？ 如果没有发生，那么下面的是真的，那么我们
131:16 如果没有发生，那么下面的是真的，那么我们 我们写 else if else 那如何写 else if
131:19 我们写 else if else 那如何写 else if 如果格式与我们上面写的相同
131:21 如果格式与我们上面写的相同 所以我们可以把条件一放在里面。
131:23 所以我们可以把条件一放在里面。 那么如果有事需要做，那就先做吧
131:26 那么如果有事需要做，那就先做吧 把它放在块中然后写 else if then
131:29 把它放在块中然后写 else if then 将条件 true 放在类似标记内
131:31 将条件 true 放在类似标记内 举个例子，如果我们的分数
131:34 举个例子，如果我们的分数 是的，它大于 90，所以你可以打印它
131:37 是的，它大于 90，所以你可以打印它 给出 + + 并在此处检查分数
131:40 给出 + + 并在此处检查分数 我有一个小于 90 但大于 80
131:43 我有一个小于 90 但大于 80 在这种情况下只需打印 a+ 和
131:46 在这种情况下只需打印 a+ 和 该条件成立时的输出将是
131:49 该条件成立时的输出将是 之后我们会以这种方式进来
131:51 之后我们会以这种方式进来 我们可以写另一个 LCF 另一个 LCF
131:53 我们可以写另一个 LCF 另一个 LCF 你可以根据需要编写任意数量的 LCF
131:55 你可以根据需要编写任意数量的 LCF 最后如果我们必须做
131:58 最后如果我们必须做 如果以上都不成立，则
132:00 如果以上都不成立，则 每当我们的流量中断时就这样做
132:02 每当我们的流量中断时就这样做 如果我们尽力而为，这个项目就成功了
132:05 如果我们尽力而为，这个项目就成功了 然后，创建你的
132:07 然后，创建你的 使用 LCF 创建一个块，然后
132:10 使用 LCF 创建一个块，然后 我们想写任意数量的 LCF
132:12 我们想写任意数量的 LCF 最后我们写一些其他的东西，如果
132:14 最后我们写一些其他的东西，如果 如果你想使用所有这些，那么使用这个
132:16 如果你想使用所有这些，那么使用这个 将会有一个流程，其中最常发生的事情
132:18 将会有一个流程，其中最常发生的事情 首先检查条件是否为真
132:20 首先检查条件是否为真 如果不是，则检查第二个条件
132:23 如果不是，则检查第二个条件 这不是真的，那么将检查第三个条件
132:26 这不是真的，那么将检查第三个条件 如果事实证明是真的，就假设它是真的
132:28 如果事实证明是真的，就假设它是真的 如果通过，之后将不再进行检查
132:31 如果通过，之后将不再进行检查 如果以上都是错误的，那么
132:34 如果以上都是错误的，那么 最后一个 else 没有检查
132:36 最后一个 else 没有检查 以上所有瀑布都在施舍中，因此
132:38 以上所有瀑布都在施舍中，因此 写好的作品无需检查即可完成
132:40 写好的作品无需检查即可完成 现在如果我们想要我们所有的
132:43 现在如果我们想要我们所有的 应检查所有条件，这意味着如果这也
132:45 应检查所有条件，这意味着如果这也 即使这是真的，这件事也应该检查一下
132:47 即使这是真的，这件事也应该检查一下 如果是，那么在这种情况下我们写如果
132:49 如果是，那么在这种情况下我们写如果 很多 一个接一个 一个接一个
132:52 很多 一个接一个 一个接一个 这将被检查，如果是真的，那么就不会发生
132:54 这将被检查，如果是真的，那么就不会发生 那么它就不会发生，然后会检查它是否为真
132:56 那么它就不会发生，然后会检查它是否为真 这不会发生，这不会发生在他身上
132:59 这不会发生，这不会发生在他身上 真假都无所谓
133:01 真假都无所谓 如果下面的条件受到上面的条件的影响，那么
133:04 如果下面的条件受到上面的条件的影响，那么 如果条件不重要，则重复
133:06 如果条件不重要，则重复 继续写，如果上述
133:08 继续写，如果上述 条件正在产生影响，就像标记一样
133:10 条件正在产生影响，就像标记一样 如果我们检查一下，我们会在上面看到一个 +
133:13 如果我们检查一下，我们会在上面看到一个 + 打印后，点击下方的 + 即可重新打印
133:15 打印后，点击下方的 + 即可重新打印 这就是为什么我们必须注意不要发生这种情况
133:17 这就是为什么我们必须注意不要发生这种情况 如果我们在其中使用 LCF，那么 LCF 的结果是
133:20 如果我们在其中使用 LCF，那么 LCF 的结果是 我们也会为此编写一个格式
133:22 我们也会为此编写一个格式 让我们用一个例子来解决这个问题
133:24 让我们用一个例子来解决这个问题 让我们看看是否只在极端情况下这样做
133:26 让我们看看是否只在极端情况下这样做 如果年龄大于 18 岁，则写为成人
133:29 如果年龄大于 18 岁，则写为成人 现在我们可以在其中添加一个 else if 条件
133:31 现在我们可以在其中添加一个 else if 条件 年龄大于 13 岁
133:35 年龄大于 13 岁 且年龄小于等于 18 岁
133:41 且年龄小于等于 18 岁 那么这里应该等于 18，并且这个
133:44 那么这里应该等于 18，并且这个 应该小于 18，所以我们在这里
133:47 应该小于 18，所以我们在这里 会写
133:49 会写 青少年，并将在最后写
133:53 青少年，并将在最后写 否则打印
133:56 否则打印 F
133:58 F 孩子，谢谢你，我们现在就把它移除
134:01 孩子，谢谢你，我们现在就把它移除 如果我们仔细观察，我们做了什么
134:02 如果我们仔细观察，我们做了什么 询问用户的年龄，我们的年龄是 18 岁还是 18 岁
134:06 询问用户的年龄，我们的年龄是 18 岁还是 18 岁 在这种情况下，女孩的年龄超过 18 岁就被认为是成年人
134:07 在这种情况下，女孩的年龄超过 18 岁就被认为是成年人 年龄超过 13 岁则需打印
134:10 年龄超过 13 岁则需打印 未满 18 岁，在这种情况下，任何人
134:12 未满 18 岁，在这种情况下，任何人 根据他的年龄，他是一名青少年，
134:14 根据他的年龄，他是一名青少年， 如果你让青少年打印出来，那么
134:16 如果你让青少年打印出来，那么 如果检查此条件并且任何
134:19 如果检查此条件并且任何 如果上述情况均不存在，则
134:21 如果上述情况均不存在，则 将会打印带有的情况，即 child
134:23 将会打印带有的情况，即 child 他现在还不到18岁，在13到18岁之间
134:25 他现在还不到18岁，在13到18岁之间 如果不在中间，那么显然它来自 13
134:27 如果不在中间，那么显然它来自 13 如果低于则无需检查
134:28 如果低于则无需检查 只需让孩子打印出来并执行此操作
134:31 只需让孩子打印出来并执行此操作 让我们保存并编译它
134:34 让我们保存并编译它 先跑我们把年龄放进去我们是五岁
134:37 先跑我们把年龄放进去我们是五岁 所以在这种情况下，孩子在那之后被打印出来
134:39 所以在这种情况下，孩子在那之后被打印出来 再次添加边，假设为 16，我们有
134:42 再次添加边，假设为 16，我们有 把它放在这个例子中，青少年被打印出来，
134:45 把它放在这个例子中，青少年被打印出来， 在这种情况下，我们再次将优势定为 22
134:48 在这种情况下，我们再次将优势定为 22 我以这种方式打印成人
134:50 我以这种方式打印成人 根据不同情况
134:52 根据不同情况 我们应该拥有什么
134:54 我们应该拥有什么 现在你可以在代码中借助 fs 来实现
134:57 现在你可以在代码中借助 fs 来实现 我们将要讨论的下一种语句
134:59 我们将要讨论的下一种语句 在我们交换之前我们会谈谈
135:01 在我们交换之前我们会谈谈 第二章中有条件运算符
135:04 第二章中有条件运算符 我们读到有五种类型的五
135:06 我们读到有五种类型的五 有以下类型的运算符
135:08 有以下类型的运算符 我们在接下来的章节中读到了一些内容
135:09 我们在接下来的章节中读到了一些内容 现在我们将阅读其中的一些非常重要的类型
135:12 现在我们将阅读其中的一些非常重要的类型 我们的三元运算符用于放置
135:15 我们的三元运算符用于放置 大量 MCQ 问题按时完成
135:17 大量 MCQ 问题按时完成 有很多公司是三元运算符
135:19 有很多公司是三元运算符 这位特纳操作员询问了这个问题
135:22 这位特纳操作员询问了这个问题 你的 C+ 既是 P 又是 Java
135:24 你的 C+ 既是 P 又是 Java 它确实发生了，而且语法完全相同
135:27 它确实发生了，而且语法完全相同 两种语言看起来都一样，
135:29 两种语言看起来都一样， 事实上那些曾经学过 C 的学生
135:31 事实上那些曾经学过 C 的学生 让我们把它们转移到 C++ 或 Java
135:33 让我们把它们转移到 C++ 或 Java 绝对没有问题，因为
135:34 绝对没有问题，因为 大多数情况下语法都相同
135:36 大多数情况下语法都相同 这只是输入和输出之间的区别
135:39 这只是输入和输出之间的区别 现在该如何编写 Turner 运算符
135:41 现在该如何编写 Turner 运算符 首先了解 Turner 运算符的用法很重要
135:44 首先了解 Turner 运算符的用法很重要 每当我们没有很多线路时，我们就选择
135:46 每当我们没有很多线路时，我们就选择 它发生在简单的 if else 中
135:48 它发生在简单的 if else 中 意味着你正在检查 if then 中的条件
135:51 意味着你正在检查 if then 中的条件 如果我们可以缩短它，我们正在做一些事情
135:53 如果我们可以缩短它，我们正在做一些事情 例如假设我们有变量的值
135:55 例如假设我们有变量的值 我需要检查我的年龄是否大于 18 岁
135:58 我需要检查我的年龄是否大于 18 岁 所以这里年龄成为一个变量，所以成年人
136:00 所以这里年龄成为一个变量，所以成年人 打印出来，否则会显示“未成年”
136:02 打印出来，否则会显示“未成年” 我们注意到我们写了很多行。
136:04 我们注意到我们写了很多行。 我已经给出了，这意味着如果你也看到了前一个 1 2
136:06 我已经给出了，这意味着如果你也看到了前一个 1 2 Three or Else 的六行左右
136:09 Three or Else 的六行左右 我们的代码将是那六行代码
136:11 我们的代码将是那六行代码 有一种方法可以在一行中完成
136:13 有一种方法可以在一行中完成 三元运算符 三元运算符的语法
136:16 三元运算符 三元运算符的语法 你首先告诉我你的病情
136:18 你首先告诉我你的病情 给出条件，然后问问题
136:20 给出条件，然后问问题 打上“Q”标记，相当于问号
136:22 打上“Q”标记，相当于问号 碰巧他会检查并提出问题
136:24 碰巧他会检查并提出问题 您的条件是否正确，如果您的
136:27 您的条件是否正确，如果您的 如果条件返回 true，则此处
136:31 如果条件返回 true，则此处 但凡写下的，都必须执行
136:34 但凡写下的，都必须执行 如果不是这个冒号那么之后我们
136:38 如果不是这个冒号那么之后我们 如果我们把它放那么它意味着否则它
136:42 如果我们把它放那么它意味着否则它 它会检查条件是否为真，然后就会发生这种情况
136:47 它会检查条件是否为真，然后就会发生这种情况 否则，此后所写的一切都会发生
136:50 否则，此后所写的一切都会发生 如果条件变为假，那么我们的
136:53 如果条件变为假，那么我们的 语法保持不变，我们可以称之为三元一次
136:56 语法保持不变，我们可以称之为三元一次 让我们写下一个运算符的例子并看看
136:58 让我们写下一个运算符的例子并看看 就像我们现在进入了边缘
137:00 就像我们现在进入了边缘 如何执行这个三元运算符
137:03 如何执行这个三元运算符 如果我们的年龄大于等于
137:06 如果我们的年龄大于等于 如果他18岁，这是真的
137:10 如果他18岁，这是真的 在这种情况下，我们将打印
137:14 在这种情况下，我们将打印 如果不是成人，那么我们将把它打印出来
137:19 如果不是成人，那么我们将把它打印出来 未成年
137:25 现在有一件事需要特别注意 它要做的是这个 print f 语句
137:27 它要做的是这个 print f 语句 此后我们不再应用半微积分
137:30 此后我们不再应用半微积分 我的意思是为什么我没有安装终结者，因为
137:32 我的意思是为什么我没有安装终结者，因为 我们尚未完成声明。
137:34 我们尚未完成声明。 如果我们想把这个语句放在最后，那么即使
137:37 如果我们想把这个语句放在最后，那么即使 如果返回 true，否则打印 f 写信给我们
137:39 如果返回 true，否则打印 f 写信给我们 在页面中间写任何内容或扫描它
137:40 在页面中间写任何内容或扫描它 如果你读到这篇文章，我们不是终结者
137:42 如果你读到这篇文章，我们不是终结者 我们将安装它，因为如果安装了终结器
137:44 我们将安装它，因为如果安装了终结器 我们的状况到此结束。
137:46 我们的状况到此结束。 我们的声明将像这样发送到
137:49 我们的声明将像这样发送到 会先跑
137:52 会先跑 编译并运行后，如果
137:54 编译并运行后，如果 输入 15，它会打印“Not Adult”
137:59 输入 15，它会打印“Not Adult” 你做了什么？首先，我检查了情况，然后
138:01 你做了什么？首先，我检查了情况，然后 如果这是真的，那么就应该这么做，但如果这是真的
138:03 如果这是真的，那么就应该这么做，但如果这是真的 如果它不存在，那么它就会满足后一个条件
138:06 如果它不存在，那么它就会满足后一个条件 现在我已经打印了《非成人》
138:09 现在我已经打印了《非成人》 如果我们在这里放一个终结者，
138:12 如果我们在这里放一个终结者， 首先会发生错误，因为
138:14 首先会发生错误，因为 终结者之后我们就没再学过半微积分
138:16 终结者之后我们就没再学过半微积分 因此将终止符放在这里是正确的
138:19 因此将终止符放在这里是正确的 只有在那时，转弯操作符才会被使用
138:22 只有在那时，转弯操作符才会被使用 当我们有一行东西时
138:24 当我们有一行东西时 因为这里还没有安装终结者
138:26 因为这里还没有安装终结者 如果可以的话，每当我得到一个
138:28 如果可以的话，每当我得到一个 如果你想写一个语句，那么我们可以使用三元
138:30 如果你想写一个语句，那么我们可以使用三元 操作员可以很容易地使用它
138:32 操作员可以很容易地使用它 这很重要，语法很好
138:34 这很重要，语法很好 操作员的实际使用情况更多
138:36 操作员的实际使用情况更多 并非主要在于你的展示位置或
138:38 并非主要在于你的展示位置或 如果考试中问到这个问题，我们就会
138:40 如果考试中问到这个问题，我们就会 现在你可以记住下一个条件
138:43 现在你可以记住下一个条件 我们将讨论操作员，他的名字是
138:46 我们将讨论操作员，他的名字是 就像我们在家里打开灯一样
138:48 就像我们在家里打开灯一样 你一定见过风扇开关，你一定见过电视
138:50 你一定见过风扇开关，你一定见过电视 你一定见过开关的作用是什么
138:52 你一定见过开关的作用是什么 如果你打开它，它会做一些工作
138:56 如果你打开它，它会做一些工作 如果你把它关掉，那么一切都不会再以同样的方式运作
138:59 如果你把它关掉，那么一切都不会再以同样的方式运作 从我们的 switch 内部编码
139:01 从我们的 switch 内部编码 你打开谁的条件，那么它
139:04 你打开谁的条件，那么它 他会为你做这项工作，如果他不做，那么
139:06 他会为你做这项工作，如果他不做，那么 您将不再需要编写开关
139:09 您将不再需要编写开关 语法是这样的
139:11 语法是这样的 首先，让我们写一下关键字 switch
139:13 首先，让我们写一下关键字 switch 我们在里面写一些数字或
139:16 我们在里面写一些数字或 字符和开关的基本作用
139:19 字符和开关的基本作用 该数字或字符的一些常量
139:21 该数字或字符的一些常量 与您给出的数字相匹配
139:24 与您给出的数字相匹配 那么常数就变成我们的1 2 3 4 5 6 7
139:28 那么常数就变成我们的1 2 3 4 5 6 7 8 9 10 Ld 这是一个非常不切实际的案例
139:30 8 9 10 Ld 这是一个非常不切实际的案例 这样，对于开关，我们有很多
139:32 这样，对于开关，我们有很多 如果数字是恒定的，那么它们将表明你的年龄
139:35 如果数字是恒定的，那么它们将表明你的年龄 无论哪种情况匹配，都意味着一个
139:37 无论哪种情况匹配，都意味着一个 此外，如果他/她与你年龄相仿，那么你
139:39 此外，如果他/她与你年龄相仿，那么你 他在边缘放了一片森林，然后把它和森林放在一起
139:41 他在边缘放了一片森林，然后把它和森林放在一起 如果匹配，则其旁边写的内容
139:44 如果匹配，则其旁边写的内容 他会做那项工作并把它交给你，然后这个
139:46 他会做那项工作并把它交给你，然后这个 你打开它的方式
139:48 你打开它的方式 比赛结束后，他会把工作做完并交给你
139:51 比赛结束后，他会把工作做完并交给你 现在我们在里面写入 switch
139:53 现在我们在里面写入 switch 任何具有数字或
139:55 任何具有数字或 您只能在此处输入字符我们需要匹配
139:58 您只能在此处输入字符我们需要匹配 必须这样做，然后他检查这里的案件
140:00 必须这样做，然后他检查这里的案件 但是我们写了一些常量，比如
140:02 但是我们写了一些常量，比如 完成后我们会这样做
140:04 完成后我们会这样做 撰写案例
140:06 撰写案例 具体情况具体分析
140:12 具体情况具体分析 字符如果假设具有字符
140:14 字符如果假设具有字符 如果你想完成它，那么案例 A 案例 B 案例
140:21 如果你想完成它，那么案例 A 案例 B 案例 案例之后，写下常数，然后
140:23 案例之后，写下常数，然后 我们必须加上冒号，然后无论我们的
140:25 我们必须加上冒号，然后无论我们的 任何数量的语句都是
140:27 任何数量的语句都是 把它写下来，这样我们就可以写出下一个案例
140:29 把它写下来，这样我们就可以写出下一个案例 最后还有一个声明和一个中断
140:31 最后还有一个声明和一个中断 你必须把这个案子写成刹车
140:34 你必须把这个案子写成刹车 把你从开关上拉出来后，如果
140:37 把你从开关上拉出来后，如果 如果这个开关没有被打破，那么这一切都会发生
140:40 如果这个开关没有被打破，那么这一切都会发生 所有语句都将被执行
140:42 所有语句都将被执行 如果打开开关并踩下刹车
140:45 如果打开开关并踩下刹车 如果没有写，所有开关都会打开
140:47 如果没有写，所有开关都会打开 之后就意味着休息
140:49 之后就意味着休息 如果你不打开所有开关
140:51 如果你不打开所有开关 如果你想这样做，那么这是默认的
140:53 如果你想这样做，那么这是默认的 如果所有开关均未打开，则会出现行为
140:55 如果所有开关均未打开，则会出现行为 因此，在第一个开关后立即刹车，
140:59 因此，在第一个开关后立即刹车， 在最后一种情况下，我们有一个默认值
141:00 在最后一种情况下，我们有一个默认值 如果以上都不属实
141:03 如果以上都不属实 现在做这件事就像我们的啤酒一样
141:06 现在做这件事就像我们的啤酒一样 如果发生上述任何情况，则
141:08 如果发生上述任何情况，则 否则，如果这不是真的，那么说你的其他
141:11 否则，如果这不是真的，那么说你的其他 执行 switch 执行其他操作
141:13 执行 switch 执行其他操作 默认现在让我们举个例子
141:16 默认现在让我们举个例子 我们将如何处理示例中的用户
141:18 我们将如何处理示例中的用户 一天是接受输入的一天
141:21 一天是接受输入的一天 所以
141:22 所以 我们将在第二天接受用户的输入
141:26 我们将在第二天接受用户的输入 se day 是什么意思？这里的一个意思是
141:31 se day 是什么意思？这里的一个意思是 星期一意味着
141:33 星期一意味着 星期二三意味着星期三等等
141:38 星期二三意味着星期三等等 告诉用户还剩多少天
141:41 告诉用户还剩多少天 要进入这里我们可以写
141:43 要进入这里我们可以写 你必须输入从一到七，然后在这里
141:45 你必须输入从一到七，然后在这里 我会写下结束日，然后我会写下我的转变
141:50 我会写下结束日，然后我会写下我的转变 这是您可以在 VS Code 中的开关内使用的唯一选项。
141:53 这是您可以在 VS Code 中的开关内使用的唯一选项。 如果你正在里面编码，那么一旦你点击进入
141:55 如果你正在里面编码，那么一旦你点击进入 压制所有写的东西
141:57 压制所有写的东西 我会去，但因为这是我第一次写信
141:59 我会去，但因为这是我第一次写信 我们从一开始
142:00 我们从一开始 括号放在 switch 后面
142:03 括号放在 switch 后面 无论我们需要检查父母内部的情况
142:05 无论我们需要检查父母内部的情况 我们将把变量写入我们需要做的事情
142:07 我们将把变量写入我们需要做的事情 我必须检查一下日期，然后我会涂卷发
142:09 我必须检查一下日期，然后我会涂卷发 现在大括号都在这个块里面了
142:11 现在大括号都在这个块里面了 写语句，先写它们
142:13 写语句，先写它们 案例一 案例一 我们的日子说明了什么
142:16 案例一 案例一 我们的日子说明了什么 WHO
142:18 WHO 是的，今天是星期一
142:21 是的，今天是星期一 所以我们周一写了，现在之后我们会做
142:23 所以我们周一写了，现在之后我们会做 我们将给予
142:25 我们将给予 我们可以用同样的方式写出另外六个案例。
142:29 我们可以用同样的方式写出另外六个案例。 一
142:36 如果是，那么我们将就此提起诉讼 把你的一天写在里面
142:39 把你的一天写在里面 星期二，让我们把下一行放进去
142:41 星期二，让我们把下一行放进去 我们也把下一行放在这里
142:43 我们也把下一行放在这里 但是我们的案例三也在这个里面，下一个
142:46 但是我们的案例三也在这个里面，下一个 这种情况将是
142:51 这种情况将是 案例 fi 是
142:57 星期五现在我们假设我们的用户有 输入后我们得到了 29，所以在这种情况下
143:00 输入后我们得到了 29，所以在这种情况下 所以我们无法打印任何东西
143:02 所以我们无法打印任何东西 在这种情况下，我们将在此处写入默认值。
143:05 在这种情况下，我们将在此处写入默认值。 这意味着我们的 else 情况现在处于默认状态
143:07 这意味着我们的 else 情况现在处于默认状态 我们将把它打印为无效
143:17 如今，违约后我们仍未得到喘息 必须写，因为在默认之后任何
143:19 必须写，因为在默认之后任何 此后我们无法打开任何开关
143:21 此后我们无法打开任何开关 现在让我们保存一下这个代码
143:24 现在让我们保存一下这个代码 如果我们运行它，我们就能更好地理解它
143:26 如果我们运行它，我们就能更好地理解它 编译运行是如何执行的
143:29 编译运行是如何执行的 首先，我们必须输入日期
143:32 首先，我们必须输入日期 让我们输入假设三三我们有
143:34 让我们输入假设三三我们有 如果我输入，那么星期三就会为我们打印。
143:36 如果我输入，那么星期三就会为我们打印。 当日价值上涨后，三家商店被出售
143:38 当日价值上涨后，三家商店被出售 发生了什么事 开关做了三场比赛
143:41 发生了什么事 开关做了三场比赛 开始寻找常数
143:43 开始寻找常数 首先检查了 One Falls
143:45 首先检查了 One Falls 我检查了两个，但秋天来了三个
143:48 我检查了两个，但秋天来了三个 三场比赛一结束就发生了
143:50 三场比赛一结束就发生了 他执行了那个条件
143:52 他执行了那个条件 休息了一会儿之后，现在出现了这个
143:55 休息了一会儿之后，现在出现了这个 假设这里没有发生中断
143:57 假设这里没有发生中断 或者让我们把这个注释掉
144:00 或者让我们把这个注释掉 我们也来评论一下刹车
144:03 我们也来评论一下刹车 如果我们取消所有这些休息
144:07 如果我们取消所有这些休息 注释掉
144:10 注释掉 给予并保存，然后做另一个
144:12 给予并保存，然后做另一个 编译一次然后运行
144:15 编译一次然后运行 如果我们输入三，我们输入三
144:17 如果我们输入三，我们输入三 那么首先为我们打印的是什么
144:19 那么首先为我们打印的是什么 所以打印星期三意味着星期一，
144:22 所以打印星期三意味着星期一， 星期二没有印刷，因为
144:23 星期二没有印刷，因为 根本不匹配，只要三个
144:25 根本不匹配，只要三个 匹配了它，意味着我们打开了开关
144:27 匹配了它，意味着我们打开了开关 diya now Wednesday 之后打印
144:29 diya now Wednesday 之后打印 所有的印刷品都已完成，星期四也已印刷
144:31 所有的印刷品都已完成，星期四也已印刷 星期五也印刷，星期六和星期日也印刷
144:33 星期五也印刷，星期六和星期日也印刷 然后还会打印“不是有效日期”
144:35 然后还会打印“不是有效日期” 这意味着之后的所有开关
144:37 这意味着之后的所有开关 不，从现在开始，它们全都打开了
144:40 不，从现在开始，它们全都打开了 这就是为什么休息对我们有用，因为
144:41 这就是为什么休息对我们有用，因为 我们不需要打开所有开关，只需打开一个
144:43 我们不需要打开所有开关，只需打开一个 你必须打开开关，一旦它到达你
144:45 你必须打开开关，一旦它到达你 离开这里，继续前进
144:52 这就是为什么每当你输入开关时，这非常重要 现在我们必须对默认设置踩刹车
144:54 现在我们必须对默认设置踩刹车 会检查一下
144:56 会检查一下 如果我们输入 19，那么 19
145:00 如果我们输入 19，那么 19 不会为我们打印有效日期
145:03 不会为我们打印有效日期 这就是我们的开关的工作原理
145:05 这就是我们的开关的工作原理 现在对于相同的代码我们
145:07 现在对于相同的代码我们 您还可以玩以下角色
145:09 您还可以玩以下角色 我们创建的这个day是整数类型
145:12 我们创建的这个day是整数类型 不，让我们把它变成一个角色类型
145:14 不，让我们把它变成一个角色类型 星期一的 M 代表星期二
145:17 星期一的 M 代表星期二 我们的 T 恤将是周三的小号
145:19 我们的 T 恤将是周三的小号 我们将在星期四保留大写的“T”
145:22 我们将在星期四保留大写的“T” 让我们把 F 保留为星期五星期六
145:25 让我们把 F 保留为星期五星期六 小写 S 代表星期日，大写 S 代表星期日
145:27 小写 S 代表星期日，大写 S 代表星期日 这就是我们度过每一天的方式，
145:30 这就是我们度过每一天的方式， 现在让我们把这里的情况改为
145:32 现在让我们把这里的情况改为 会写字符
145:38 让我们保存它，然后再次执行此操作 如果我们运行，那么我们必须在这里写
145:44 如果我们运行，那么我们必须在这里写 S如果我们进入我们的一天那么这次我们
145:47 S如果我们进入我们的一天那么这次我们 即将进入
145:49 即将进入 F 所以星期五是为我们打印的，
145:52 F 所以星期五是为我们打印的， 这次我们又添加了一个角色，比如 Maan
145:54 这次我们又添加了一个角色，比如 Maan 好的，在这种情况下我们输入了利率
145:57 好的，在这种情况下我们输入了利率 我被打印为无效日期，所以我们
146:00 我被打印为无效日期，所以我们 字符也可以用作常量
146:02 字符也可以用作常量 您还可以使用整数作为
146:03 您还可以使用整数作为 现在和之后都可以使用常量
146:05 现在和之后都可以使用常量 开关有其自身的一些属性
146:07 开关有其自身的一些属性 关于两个属性，例如
146:09 关于两个属性，例如 我们主要先讨论一下案例
146:11 我们主要先讨论一下案例 可以按照我们写的任意顺序
146:14 可以按照我们写的任意顺序 A 是第一个在那个星期一为森林写信的人
146:16 A 是第一个在那个星期一为森林写信的人 将于周二印刷 打印两份
146:18 将于周二印刷 打印两份 如果我们愿意，我们可以上下移动它们
146:20 如果我们愿意，我们可以上下移动它们 周二可能会有一个条件，即两个
146:23 周二可能会有一个条件，即两个 如果是的话那么就是周二印刷的，即将出版
146:24 如果是的话那么就是周二印刷的，即将出版 如果有的话，那就是星期一印刷的，它正在下降
146:26 如果有的话，那就是星期一印刷的，它正在下降 其中的开关不会给出类似的错误
146:29 其中的开关不会给出类似的错误 我们现在在这里配音
146:31 我们现在在这里配音 在我们的字符中它位于 F 之后，但是
146:34 在我们的字符中它位于 F 之后，但是 上面的 da 案例是 a
146:36 上面的 da 案例是 a 如果这个星期五也上涨的话，
146:38 如果这个星期五也上涨的话， 如果你写了它那么就不会出现错误
146:40 如果你写了它那么就不会出现错误 第二件事是嵌套开关意味着开关
146:43 第二件事是嵌套开关意味着开关 允许内部开关，我们可能
146:47 允许内部开关，我们可能 在 switch 内部我们可以
146:50 在 switch 内部我们可以 在里面像外面一样写一个单独的开关
146:53 在里面像外面一样写一个单独的开关 我们已经确定了哪一天是
146:56 我们已经确定了哪一天是 并且假设数字三为真
146:59 并且假设数字三为真 然后放置另一个开关
147:02 然后放置另一个开关 我们会告诉你哪一年
147:05 我们会告诉你哪一年 或者我们会把月份的日期写成哪个月
147:08 或者我们会把月份的日期写成哪个月 如果存在，那么也考虑我们的第四种情况。
147:11 如果存在，那么也考虑我们的第四种情况。 如果结果为真，则按此方式点击开关
147:13 如果结果为真，则按此方式点击开关 在里面我们可以插入向上的开关，
147:16 在里面我们可以插入向上的开关， 我们必须读到即使在里面，如果我们
147:19 我们必须读到即使在里面，如果我们 如果有差异，可以输入一次
147:22 如果有差异，可以输入一次 如果在 if 中表示如果条件一是
147:27 如果在 if 中表示如果条件一是 变为真，则第二个 if 为
147:29 变为真，则第二个 if 为 里面有条件二，打印出来
147:33 里面有条件二，打印出来 这样我们就可以使用嵌套的 if 语句。
147:38 这样我们就可以使用嵌套的 if 语句。 筑巢，一个在另一个里面
147:40 筑巢，一个在另一个里面 所以我们称之为嵌套 if
147:43 所以我们称之为嵌套 if 让我们再看一个例子，假设
147:45 让我们再看一个例子，假设 我们需要要求用户输入一个数字。
147:49 我们需要要求用户输入一个数字。 数字
147:59 您将输入号码然后扫描 号码
148:00 号码 因此，我们先写一些条件。
148:03 因此，我们先写一些条件。 我们将检查我们的数字是否为正数
148:06 我们将检查我们的数字是否为正数 如果是负数，那么正数呢
148:08 如果是负数，那么正数呢 我们将检查数字是否大于
148:11 我们将检查数字是否大于 然后等于
148:14 然后等于 0 在这种情况下，我们将得到打印的数字
148:17 0 在这种情况下，我们将得到打印的数字 是
148:18 是 将是积极的
148:21 将是积极的 如果这不意味着其他任何事情，那么这
148:24 如果这不意味着其他任何事情，那么这 我们通常也可以在这里写 else
148:26 我们通常也可以在这里写 else 我更喜欢把它写在同一行
148:28 我更喜欢把它写在同一行 所以我们会把它打印出来给其他人看
148:37 现在在这个里面一旦数字 如果结果呈阳性，那么我们必须检查
148:38 如果结果呈阳性，那么我们必须检查 无论我们的数字是奇数还是偶数，
148:41 无论我们的数字是奇数还是偶数， 如果你打印出来了，那么在这里写另一个 f
148:43 如果你打印出来了，那么在这里写另一个 f 如果我们的那个数字模型可以
148:48 如果我们的那个数字模型可以 等于零成为迟钝的条件
148:51 等于零成为迟钝的条件 我们已经为第二章的练习做好了准备。
148:53 我们已经为第二章的练习做好了准备。 如果你已经读过它，那么它应该很容易
148:55 如果你已经读过它，那么它应该很容易 我们有必要明白
148:57 我们有必要明白 我们如何检查该数字是否为偶数？
148:59 我们如何检查该数字是否为偶数？ 我们将在这里打印它
149:03 我们将在这里打印它 如果没有，那么它可以有自己的别名
149:06 如果没有，那么它可以有自己的别名 我们要把它打印出来
149:11 我们要把它打印出来 很有可能我们会这么做
149:13 很有可能我们会这么做 立即保存运行一次
149:22 无论我们输入什么数字，都是 24 24 打印出来这也是一个正数
149:24 打印出来这也是一个正数 如果是偶数，那么这个做了什么
149:26 如果是偶数，那么这个做了什么 条件变为真后，它又做了第二次
149:28 条件变为真后，它又做了第二次 我也检查了情况，我也需要看看
149:31 我也检查了情况，我也需要看看 这些相同的条件是否正确？
149:33 这些相同的条件是否正确？ 我们也可以在这里写入 else
149:35 我们也可以在这里写入 else 我们可以创建自己的 if 条件
149:37 我们可以创建自己的 if 条件 然后否则条件所以以这种方式每当如果
149:40 然后否则条件所以以这种方式每当如果 条件写在第二个 if 里面
149:43 条件写在第二个 if 里面 我们可以使用嵌套的 if 或嵌套的 else 子句来描述情况。
149:46 我们可以使用嵌套的 if 或嵌套的 else 子句来描述情况。 情况表明现在有一些问题
149:48 情况表明现在有一些问题 实践你的概念
149:50 实践你的概念 把它牢牢地记在心里
149:53 把它牢牢地记在心里 所以我们的第一个问题是，什么是正确的
149:55 所以我们的第一个问题是，什么是正确的 检查学生是否通过的程序
149:58 检查学生是否通过的程序 我们有学生的成绩
150:00 我们有学生的成绩 那些将获得 100 分的人
150:02 那些将获得 100 分的人 如果我们的分数低于30分，我们将被扣分
150:05 如果我们的分数低于30分，我们将被扣分 如果超过 30，那么孩子就通过了。
150:08 如果超过 30，那么孩子就通过了。 如果少于这个数字，我们的孩子就会失败
150:10 如果少于这个数字，我们的孩子就会失败 我们需要将情况转换成代码
150:13 我们需要将情况转换成代码 那么首先，你会如何处理分数
150:15 那么首先，你会如何处理分数 我们将在这里输入并创建这个变量
150:18 我们将在这里输入并创建这个变量 将给出分数 输入分数键
150:21 将给出分数 输入分数键 有些孩子给出的范围是从 0 到 100
150:24 有些孩子给出的范围是从 0 到 100 缺席者也得零分
150:27 缺席者也得零分 论文写作的日子到了，我会在这里写
150:29 论文写作的日子到了，我会在这里写 我们
150:32 我们 马克思现在我们必须写两个条件
150:35 马克思现在我们必须写两个条件 因此，应该先给出通过的和失败的
150:37 因此，应该先给出通过的和失败的 让我们试着把它写得笨拙一些
150:40 让我们试着把它写得笨拙一些 如果我们把我们的分数
150:42 如果我们把我们的分数 它们小于
150:50 30 或我们问题中给出的那个 小于等于 30，所以在这种情况下我们有
150:53 小于等于 30，所以在这种情况下我们有 获取打印件
151:03 失败，如果不是这样，那么在这种情况下 如果您想打印通行证，请前往此处的航站楼
151:08 如果您想打印通行证，请前往此处的航站楼 将打开编译运行标记将由您输入
151:12 将打开编译运行标记将由您输入 我们56岁了，我们又一次通过了
151:16 我们56岁了，我们又一次通过了 假设我们打出 105 分，因为我们
151:19 假设我们打出 105 分，因为我们 班里淘气的孩子要把105
151:22 班里淘气的孩子要把105 甚至后来，通行证才被打印出来，而我们却不得不提交
151:24 甚至后来，通行证才被打印出来，而我们却不得不提交 最多 100，我们有自己的条件
151:27 最多 100，我们有自己的条件 可以猜出麦芽酒
151:29 可以猜出麦芽酒 如果标记
151:33 如果标记 大于 30 是结束标记
151:38 大于 30 是结束标记 我们的课程等于 100，所以在这种情况下
151:42 我们的课程等于 100，所以在这种情况下 然后打印通行证，或者打印另一个
151:45 然后打印通行证，或者打印另一个 我们将在其中打印
151:49 我们将在其中打印 颜色标记也可以在其中应用条件
151:52 颜色标记也可以在其中应用条件 马克思才是他们应该做的更伟大的
151:55 马克思才是他们应该做的更伟大的 则等于 0 且小于
151:59 则等于 0 且小于 等于 30，这样当所有
152:02 等于 30，这样当所有 我们将报道发生的案例
152:03 我们将报道发生的案例 如果我们写语句那么我们的代码就是
152:05 如果我们写语句那么我们的代码就是 这样比较安全，现在也编译一下
152:09 这样比较安全，现在也编译一下 这次如果我们认为我们可以得到105
152:12 这次如果我们认为我们可以得到105 如果你把它放进去，那么这次它就会为我们打印出来。
152:14 如果你把它放进去，那么这次它就会为我们打印出来。 会出错
152:15 会出错 这样，标记就是安全的案例
152:18 这样，标记就是安全的案例 现在我们必须把这个 bean 放进去
152:22 现在我们必须把这个 bean 放进去 我们也可以借助三元语句来实现这一点
152:24 我们也可以借助三元语句来实现这一点 你可以做到这一点，也就是说，如果你对此发表评论
152:27 你可以做到这一点，也就是说，如果你对此发表评论 一次性注释掉所有这些行
152:30 一次性注释掉所有这些行 打印给我们 印刷给我们
152:32 打印给我们 印刷给我们 它需要命令和削减，所以如果你
152:35 它需要命令和削减，所以如果你 再次，任何多数块
152:38 再次，任何多数块 这些是语句，将其转换为注释
152:40 这些是语句，将其转换为注释 如果你想这样做，你必须按下命令斜线
152:43 如果你想这样做，你必须按下命令斜线 或者如果我们在 Windows 系统上
152:53 如果我们在这方面取得更多分数 我们将无法检查报表
152:55 我们将无法检查报表 因为三元组基于非常简单的条件
152:57 因为三元组基于非常简单的条件 如果我们的成绩低于
153:00 如果我们的成绩低于 在这种情况下，等于 30 就是问号
153:03 在这种情况下，等于 30 就是问号 我们将打印它
153:05 我们将打印它 如果我们不失败，我们就会把它印出来
153:09 如果我们不失败，我们就会把它印出来 我们将给予
153:12 我们将给予 所以我们明白了魔法
153:15 所以我们明白了魔法 三元运算符，在一行中
153:19 三元运算符，在一行中 这四到五行代码被转换为
153:21 这四到五行代码被转换为 完成了，现在我们来做个标记
153:24 完成了，现在我们来做个标记 我们已经进入第 23 个年头了，所以我们已经完成了
153:27 我们已经进入第 23 个年头了，所以我们已经完成了 我们失败了，如果我们进入89
153:31 我们失败了，如果我们进入89 那么在这种情况下我们现在将通过第二
153:34 那么在这种情况下我们现在将通过第二 谈谈练习题
153:37 谈谈练习题 因此在这种情况下我们会得到更多案例
153:40 因此在这种情况下我们会得到更多案例 就像编写一个程序来给出评分
153:42 就像编写一个程序来给出评分 成为一名学生是这个的首要条件
153:44 成为一名学生是这个的首要条件 如果分数低于 30，则为 C 级
153:46 如果分数低于 30，则为 C 级 如果你想支付 30 到 70 卢比，那么支付 B
153:49 如果你想支付 30 到 70 卢比，那么支付 B 介于 70 和 90 之间，然后给出一个和
153:51 介于 70 和 90 之间，然后给出一个和 现在你必须给出 90 到 100 之间的 APS
153:54 现在你必须给出 90 到 100 之间的 APS 我们需要把这四个条件以代码的形式
153:56 我们需要把这四个条件以代码的形式 如果你想写，那就一个接一个地开始
153:58 如果你想写，那就一个接一个地开始 让我们看看在这种情况下我们会给出的分数
154:00 让我们看看在这种情况下我们会给出的分数 我不能使用三元，因为三元
154:02 我不能使用三元，因为三元 非常
154:08 分数将根据复杂程度进行检查 如果
154:09 如果 我们的 Les Deen 30
154:13 我们的 Les Deen 30 如果是，那么在这种情况下我们将打印
154:18 如果是，那么在这种情况下我们将打印 现在会给我们 C 级，否则
154:23 现在会给我们 C 级，否则 如果上述条件为假，则应用
154:25 如果上述条件为假，则应用 如果是，则检查下面给出的标记
154:29 如果是，则检查下面给出的标记 我们的分数大于等于30
154:34 我们的分数大于等于30 并且结束标记小于我们的条件
154:38 并且结束标记小于我们的条件 70 是多少
154:41 70 是多少 现在每当我问有标记的问题时
154:44 现在每当我问有标记的问题时 我接受，我会尽力
154:47 我接受，我会尽力 我应该给更高的分数，这样就不会有人
154:48 我应该给更高的分数，这样就不会有人 即使孩子成绩不好，他们也会感到难过
154:50 即使孩子成绩不好，他们也会感到难过 不要看视频
154:52 不要看视频 如果发生这种情况，那么在这种情况下这个等级就会出现
154:56 如果发生这种情况，那么在这种情况下这个等级就会出现 否则会写
154:57 否则会写 如果这次标记大于等于
155:02 如果这次标记大于等于 到我们70年代末
155:04 到我们70年代末 70 多岁，成绩低于
155:10 70 多岁，成绩低于 90，所以在这种情况下，我们要打印
155:14 90，所以在这种情况下，我们要打印 我们将打印相同的条件
155:22 最后，我们的 else 情况是 我们将为您打印 A Plus Plus
155:26 我们将为您打印 A Plus Plus 或加号不要给更多加号
155:29 或加号不要给更多加号 老师们，这是我们的四个条件
155:33 老师们，这是我们的四个条件 已经以 fff else 的形式写入了终端
155:35 已经以 fff else 的形式写入了终端 我们将打开窗口并编译代码
155:38 我们将打开窗口并编译代码 你会跑，现在你必须输入你的分数
155:40 你会跑，现在你必须输入你的分数 假设我们是物理学专家
155:43 假设我们是物理学专家 98分，哇，我得了A+
155:48 98分，哇，我得了A+ 如果你想发布其他主题的帖子
155:50 如果你想发布其他主题的帖子 我们也可以把它放进去，例如，假设
155:51 我们也可以把它放进去，例如，假设 如果我们任何科目得了40分，那么
155:53 如果我们任何科目得了40分，那么 如果我们的成绩是 B，那么
155:55 如果我们的成绩是 B，那么 你可以制作自己的小迷你
155:57 你可以制作自己的小迷你 您可以创建一个项目，其中
155:59 您可以创建一个项目，其中 您可以根据您的分数获得成绩
156:01 您可以根据您的分数获得成绩 可以使用公式计算
156:03 可以使用公式计算 您所在的学院或学校
156:06 您所在的学院或学校 有一份课程表定义了
156:08 有一份课程表定义了 他有多少分能得到多少分
156:10 他有多少分能得到多少分 根据您的要求，或者即使您购买超市
156:13 根据您的要求，或者即使您购买超市 如果你想制作一个应用程序，那么你应该使用其中的哪个部分
156:15 如果你想制作一个应用程序，那么你应该使用其中的哪个部分 该项目应征税额及税率
156:17 该项目应征税额及税率 应用后将得到的最终值
156:19 应用后将得到的最终值 您也可以为此编写一个程序。
156:21 您也可以为此编写一个程序。 有很多这样的程序是家庭作业
156:23 有很多这样的程序是家庭作业 你肯定也遇到了一些问题，现在让我们继续
156:25 你肯定也遇到了一些问题，现在让我们继续 接下来是你的下一个问题，下一个问题是
156:27 接下来是你的下一个问题，下一个问题是 我们得到了一个实用的代码
156:31 我们得到了一个实用的代码 这段代码在这里会有问号吗
156:33 这段代码在这里会有问号吗 现在我们得到了一个代码
156:36 现在我们得到了一个代码 其中 int x 是我们的变量
156:38 其中 int x 是我们的变量 我们输入值 2，然后写为 x =
156:42 我们输入值 2，然后写为 x = 1 如果这个陈述成立，那么
156:46 1 如果这个陈述成立，那么 将打印 x = 1 否则打印
156:48 将打印 x = 1 否则打印 会做 x 不等于 1 所以在这个
156:51 会做 x 不等于 1 所以在这个 选择权在我们手中，这些项目是否允许我们
156:53 选择权在我们手中，这些项目是否允许我们 如果在这里打印 x = 1 会出错吗
156:56 如果在这里打印 x = 1 会出错吗 或 x 不等于 1 将被打印
156:59 或 x 不等于 1 将被打印 如果
157:01 如果 我们会记得一件小事
157:04 我们会记得一件小事 你学过赋值运算符或关系运算符吗
157:06 你学过赋值运算符或关系运算符吗 当读取运算符时，c 中的任何时候
157:10 当读取运算符时，c 中的任何时候 你哭着写，它就掉下来了，有时
157:14 你哭着写，它就掉下来了，有时 也写入非零值，即写入一
157:17 也写入非零值，即写入一 写下来 - 写下 1 - 写下 2 写下所有这些
157:20 写下来 - 写下 1 - 写下 2 写下所有这些 当我们听到这个事情时，我们的价值观就变得真实
157:24 当我们听到这个事情时，我们的价值观就变得真实 我们将首先在这里使用你停下来
157:26 我们将首先在这里使用你停下来 自己逻辑地猜一次
157:28 自己逻辑地猜一次 猜猜，别猜，基本上我会说
157:31 猜猜，别猜，基本上我会说 分析答案应该是什么
157:33 分析答案应该是什么 我们想要这三个中的任何一个
157:36 我们想要这三个中的任何一个 自己思考答案并找到原因，但你却不明白
157:39 自己思考答案并找到原因，但你却不明白 或者即使已经到达，然后检查该地区
157:42 或者即使已经到达，然后检查该地区 你必须先做这个
157:44 你必须先做这个 让我们执行它并看看它的
157:45 让我们执行它并看看它的 我们称之为 int x 的输出是什么
157:49 我们称之为 int x 的输出是什么 已经写好了，如果我们有一个平等的，那么我们
157:53 已经写好了，如果我们有一个平等的，那么我们 你想说的是没有必要
157:55 你想说的是没有必要 如果你说你必须打印 x 等于
158:01 如果你说你必须打印 x 等于 tov 否则打印 x 不是
158:07 tov 否则打印 x 不是 平等的
158:09 平等的 tov 让我们这样做 让我们保存它
158:18 先运行然后在这里生成警告 已经发生了，不过没关系，我们会忽略这件事
158:19 已经发生了，不过没关系，我们会忽略这件事 那些做
158:20 那些做 为我们打印 x = 1 现在这个
158:24 为我们打印 x = 1 现在这个 为什么打印出来是因为 x 等于 2
158:27 为什么打印出来是因为 x 等于 2 发生这种情况是因为如果我们检查
158:30 发生这种情况是因为如果我们检查 需要做的是，如果 x 等于 2，那么
158:32 需要做的是，如果 x 等于 2，那么 我们把二等于二，但在这里我们
158:35 我们把二等于二，但在这里我们 如果您已应用单等于那么这是单
158:37 如果您已应用单等于那么这是单 这个单一的等于两个相等的
158:39 这个单一的等于两个相等的 两个基本上首先里面有一个内存
158:42 两个基本上首先里面有一个内存 变量是 x ，它存储在这个
158:44 变量是 x ，它存储在这个 单等于二从那里到二做了什么
158:48 单等于二从那里到二做了什么 我把 P 放在那里
158:50 我把 P 放在那里 所以现在这个 if 条件中的 x 的值
158:53 所以现在这个 if 条件中的 x 的值 这意味着任何一现在都是一，一非零
158:56 这意味着任何一现在都是一，一非零 如果有价值，那么它就会成为现实，这里
158:58 如果有价值，那么它就会成为现实，这里 如果这里
159:03 如果这里 假设我们在这里写“fur”而不是“van”。
159:05 假设我们在这里写“fur”而不是“van”。 即使它已经存在，那么同样的打印也会像
159:09 即使它已经存在，那么同样的打印也会像 我们用 s4 替换了代码中的 x
159:12 我们用 s4 替换了代码中的 x 让我们保存它并执行此操作
159:14 让我们保存它并执行此操作 如果你运行它，你将忽略警告
159:17 如果你运行它，你将忽略警告 所以现在如果我们打印
159:22 所以现在如果我们打印 如果他想完成这件事，那么他就没有
159:27 如果他想完成这件事，那么他就没有 此处的值已修复
159:30 此处的值已修复 将会写 x
159:32 将会写 x 让我们保存它并再次执行
159:35 让我们保存它并再次执行 编译
159:37 编译 运行 x = 1，则我们有
159:41 运行 x = 1，则我们有 后来打印出来没有空格
159:43 后来打印出来没有空格 看起来接下来是 14 日
159:45 看起来接下来是 14 日 应该把这条线放在 x = 1 然后
159:48 应该把这条线放在 x = 1 然后 打印了 4，那么基本上发生了什么
159:51 打印了 4，那么基本上发生了什么 逻辑是什么逻辑是这一行
159:55 逻辑是什么逻辑是这一行 通过从 x 的值中移除 't' 并在那里添加一个
159:58 通过从 x 的值中移除 't' 并在那里添加一个 储存，然后在里面犯罪
160:01 储存，然后在里面犯罪 我们有一个非零值，因此
160:03 我们有一个非零值，因此 他会认为这是真的 他会认为这是真的
160:06 他会认为这是真的 他会认为这是真的 因此，无论该声明中写什么
160:07 因此，无论该声明中写什么 如果
160:10 如果 如果我们写了 x = 0 那么它就不会执行
160:13 如果我们写了 x = 0 那么它就不会执行 如果发生这种情况，那么这个条件就会被执行
160:16 如果发生这种情况，那么这个条件就会被执行 例如，如果我们在这里写 x = 0
160:20 例如，如果我们在这里写 x = 0 现在编译并运行它
160:25 现在编译并运行它 将打印 x 不等于 1，因为
160:27 将打印 x 不等于 1，因为 如果 x 的值变为零，那么这里
160:30 如果 x 的值变为零，那么这里 它出现在 if 里面，这是一个假值
160:32 它出现在 if 里面，这是一个假值 如果它变为假，那么总是与 Else
160:34 如果它变为假，那么总是与 Else 然后运行这个语句
160:36 然后运行这个语句 这个问题的正确答案应该是
160:39 这个问题的正确答案应该是 它不会给出任何错误，如果有任何错误，那么我们就没有
160:41 它不会给出任何错误，如果有任何错误，那么我们就没有 它没有来，是的，警告肯定来了，因为
160:44 它没有来，是的，警告肯定来了，因为 编译器怀疑你做错了什么。
160:47 编译器怀疑你做错了什么。 因为你没有检查平等
160:49 因为你没有检查平等 如果你正在做作业
160:50 如果你正在做作业 在逻辑上被认为是错误的，但是
160:53 在逻辑上被认为是错误的，但是 如果根据编译器规则正确
160:55 如果根据编译器规则正确 这里正确的输出应该是 print x e 1
160:58 这里正确的输出应该是 print x e 1 因为 x = 1 将被打印，因为 x
161:00 因为 x = 1 将被打印，因为 x 通过执行 = 1，我们的 if 将得到一个
161:02 通过执行 = 1，我们的 if 将得到一个 有一个真正的变量，现在下一个问题
161:06 有一个真正的变量，现在下一个问题 这是我们要问的最后一个问题
161:08 这是我们要问的最后一个问题 在我们的实践中，
161:10 在我们的实践中， 查找是否输入字符的程序
161:12 查找是否输入字符的程序 用户是否大写
161:15 用户是否大写 角色 a b kapil a kapil 是什么
161:17 角色 a b kapil a kapil 是什么 b Kapil c 以这种方式
161:19 b Kapil c 以这种方式 小写字母 a 小写 b 是什么
161:21 小写字母 a 小写 b 是什么 这样我们就可以使用它们
161:25 这样我们就可以使用它们 这叫大小写，我们叫小写
161:29 这叫大小写，我们叫小写 我们必须检查我们作为用户的性格
161:31 我们必须检查我们作为用户的性格 输入的字符是否为大写
161:33 输入的字符是否为大写 为此，让我们看看我们使用了什么技术
161:35 为此，让我们看看我们使用了什么技术 首先，编写一个程序
161:37 首先，编写一个程序 服用
161:38 服用 我们必须输入哪个字符
161:41 我们必须输入哪个字符 来自用户
161:43 来自用户 进入
161:49 该角色将在此 F 中被扫描 百分比
161:51 百分比 C 端
161:59 C 现在我们将检查我们的 C 是 大于等于 a 是我们没有的
162:02 大于等于 a 是我们没有的 您一定已经看到过它，因为我们总是谈论整数。
162:04 您一定已经看到过它，因为我们总是谈论整数。 让我们将它与 float 进行比较
162:06 让我们将它与 float 进行比较 我们第一次看到这个角色
162:08 我们第一次看到这个角色 比较价值与性格
162:10 比较价值与性格 如果它是一个关系运算符，那么这也是可能的
162:13 如果它是一个关系运算符，那么这也是可能的 因为一切事物的内部运作都是如此。
162:16 因为一切事物的内部运作都是如此。 角色不具备这样的价值
162:19 角色不具备这样的价值 因此 a 的 s 值可能是 97。
162:22 因此 a 的 s 值可能是 97。 这样，我们的许多数字直到 z
162:25 这样，我们的许多数字直到 z 有不同的值，那么如果我们必须转换为小写
162:27 有不同的值，那么如果我们必须转换为小写 如果你想检查，你可以用
162:30 如果你想检查，你可以用 这是我们的一个值也打印出来了
162:33 这是我们的一个值也打印出来了 如果我们在这里做的话，它是 97
162:37 如果我们在这里做的话，它是 97 如果我们接受它，那么它的 S-C 值是多少？98
162:39 如果我们接受它，那么它的 S-C 值是多少？98 如果我们以同样的方式做 c 那么我们会得到 99，然后 s
162:42 如果我们以同样的方式做 c 那么我们会得到 99，然后 s 有很多价值观，其中一个价值观是
162:44 有很多价值观，其中一个价值观是 基本上每个角色都有自己的身份
162:47 基本上每个角色都有自己的身份 有一种物质与之相关
162:49 有一种物质与之相关 编译器知道这个整数是
162:51 编译器知道这个整数是 我们可以直接看到角色
162:53 我们可以直接看到角色 可以与价值进行比较
162:57 可以与价值进行比较 Like 字符大于等于 97
163:01 Like 字符大于等于 97 写作和字符大于等于
163:05 写作和字符大于等于 写这个，这意味着相同的编译器
163:09 写这个，这意味着相同的编译器 为此，您可以写下这一行或
163:11 为此，您可以写下这一行或 写下这一行，不会有什么区别
163:13 写下这一行，不会有什么区别 在这里，我们将比较 Kapil 和
163:16 在这里，我们将比较 Kapil 和 所以大写字母 a 的单位值为 65
163:18 所以大写字母 a 的单位值为 65 并且看到小于等于资本
163:23 并且看到小于等于资本 Zee Capital Zee 的 S 值为 90，则
163:26 Zee Capital Zee 的 S 值为 90，则 它不断增加，即它必须是大写 A
163:29 它不断增加，即它必须是大写 A 是 65，那么大写字母 B 是 66，大写字母 C 是 67
163:33 是 65，那么大写字母 B 是 66，大写字母 C 是 67 以这种方式增加
163:35 以这种方式增加 如果我们的性格比这更伟大
163:38 如果我们的性格比这更伟大 等于它并且小于g，并且它的
163:41 等于它并且小于g，并且它的 现在我的编辑问我
163:44 现在我的编辑问我 为什么英式英语说成“Jadd”？
163:46 为什么英式英语说成“Jadd”？ 贾德用美式英语说“G”
163:48 贾德用美式英语说“G” 他们说话
163:50 他们说话 所以我们必须打印 f。
163:53 所以我们必须打印 f。 在这种情况下，我们将写大写
163:56 在这种情况下，我们将写大写 否则我将在其他情况下检查另一个案例
164:00 否则我将在其他情况下检查另一个案例 让我们这样做
164:03 让我们这样做 如果查找我们的大于等于工具
164:07 如果查找我们的大于等于工具 是，看看我们的教训等于泥泞
164:12 是，看看我们的教训等于泥泞 所以在这种情况下我们要打印
164:16 所以在这种情况下我们要打印 是小写
164:23 除此之外，我们最大的风险是什么 是的，百分之 m 也是这个标签
164:26 是的，百分之 m 也是这个标签 哈希字符就是所有这些字符
164:29 哈希字符就是所有这些字符 在此我们将不打印
164:37 英文字母不是英文字母 您已与我们一起打印了其他字符
164:39 您已与我们一起打印了其他字符 经过这一切，我觉得他已经把它给了我们
164:42 经过这一切，我觉得他已经把它给了我们 让我们看下一行
164:45 让我们看下一行 保存并运行此现在字符我们
164:47 保存并运行此现在字符我们 你必须进入，假设每个人都先进入
164:49 你必须进入，假设每个人都先进入 他告诉我，我们是为了 GG 而做这件事
164:52 他告诉我，我们是为了 GG 而做这件事 这是大写字符，但如果我们使用小写 g
164:55 这是大写字符，但如果我们使用小写 g 如果你输入它，它会说它是小写的，如果
164:58 如果你输入它，它会说它是小写的，如果 让我们在这里输入百分号
165:00 让我们在这里输入百分号 字符会告诉你，而不是英文字母
165:03 字符会告诉你，而不是英文字母 这样我们就可以创建完整的程序。
165:04 这样我们就可以创建完整的程序。 检查是否为大写
165:06 检查是否为大写 或者里面有很多小写字母
165:08 或者里面有很多小写字母 我们可以制作优秀的程序
165:10 我们可以制作优秀的程序 练习了一些问题
165:12 练习了一些问题 安置中有标准问题
165:13 安置中有标准问题 这些都是你在大学问题中问到的。
165:15 这些都是你在大学问题中问到的。 你也有家庭作业问题
165:17 你也有家庭作业问题 你本来可以给他们，但你必须自己解决
165:19 你本来可以给他们，但你必须自己解决 如果你无法解决问题，请参考你的笔记
165:21 如果你无法解决问题，请参考你的笔记 我需要一点帮助，这很容易
165:24 我需要一点帮助，这很容易 我们有非常重要、非常关键
165:26 我们有非常重要、非常关键 我已经完成了本章及其
165:28 我已经完成了本章及其 稍后我们将进入第四章
165:30 稍后我们将进入第四章 我们将在其中介绍 Hi to Loops
165:32 我们将在其中介绍 Hi to Loops 各位，现在我们开始
165:34 各位，现在我们开始 第四章名为“循环”
165:36 第四章名为“循环” 我们来读一下里面的控制指令。
165:38 我们来读一下里面的控制指令。 将会做什么 for 循环 while
165:40 将会做什么 for 循环 while 什么是循环 什么是 do while 循环
165:41 什么是循环 什么是 do while 循环 我们将共同讨论两个
165:43 我们将共同讨论两个 如何使用关键字 break 和 continue
165:46 如何使用关键字 break 和 continue 如何使用它们？
165:48 如何使用它们？ 现在在你的代码中你必须循环控制
165:50 现在在你的代码中你必须循环控制 什么是指令以及我们为什么需要它们
165:52 什么是指令以及我们为什么需要它们 他为什么需要一个例子？
165:54 他为什么需要一个例子？ 我们一起来了解一下。假设我们必须编写代码
165:57 我们一起来了解一下。假设我们必须编写代码 如果你想把它打印在里面，我们会说你好世界
165:59 如果你想把它打印在里面，我们会说你好世界 我能做些什么？只需打印一个 f
166:01 我能做些什么？只需打印一个 f 会写一个声明，其中会写你好
166:03 会写一个声明，其中会写你好 世界现在向我们问好五次
166:05 世界现在向我们问好五次 如果你想让世界印刷出来，你会说
166:08 如果你想让世界印刷出来，你会说 没问题，只需读一遍这一行
166:10 没问题，只需读一遍这一行 我会复制粘贴并再次粘贴
166:12 我会复制粘贴并再次粘贴 会再做一次然后这样做
166:15 会再做一次然后这样做 我们在屏幕上看到五次“你好”
166:18 我们在屏幕上看到五次“你好” 我会把世界印刷出来，但如果我
166:20 我会把世界印刷出来，但如果我 我想对世界说一千遍你好
166:23 我想对世界说一千遍你好 你想打印它还是打印10000次
166:25 你想打印它还是打印10000次 你想把它完成还是打印十万次
166:27 你想把它完成还是打印十万次 那么在这种情况下会发生什么呢？在这种情况下，我们
166:29 那么在这种情况下会发生什么呢？在这种情况下，我们 手动坐下并控制 c 控制 v 然后
166:32 手动坐下并控制 c 控制 v 然后 你不会这样做，即复制粘贴
166:34 你不会这样做，即复制粘贴 该方法将会非常缓慢，并且
166:36 该方法将会非常缓慢，并且 这会花掉我们几天的时间，如果我告诉你
166:38 这会花掉我们几天的时间，如果我告诉你 我应该说这是同一件作品 Haj Line Hello
166:41 我应该说这是同一件作品 Haj Line Hello 让世界印刷是我们的三大原则
166:44 让世界印刷是我们的三大原则 这样你就可以在我体内射精
166:45 这样你就可以在我体内射精 他们会问，姐姐，这是什么伎俩？
166:47 他们会问，姐姐，这是什么伎俩？ 在编码内部，所以在编码内部任何
166:50 在编码内部，所以在编码内部任何 如果我们必须一遍又一遍地做这项工作
166:52 如果我们必须一遍又一遍地做这项工作 如果必须一次又一次地这样做，那么我们
166:54 如果必须一次又一次地这样做，那么我们 使用循环，例如五个
166:57 使用循环，例如五个 有一行代码，需要一遍又一遍地写
166:59 有一行代码，需要一遍又一遍地写 这里有一个简单的小说明
167:02 这里有一个简单的小说明 我们使用这些说明
167:05 我们使用这些说明 循环控制指令称为循环
167:07 循环控制指令称为循环 英语中有些东西是有意义的
167:10 英语中有些东西是有意义的 像我们小时候那样一遍又一遍地做
167:13 像我们小时候那样一遍又一遍地做 如果你以前用手机听歌
167:15 如果你以前用手机听歌 你做了什么？制作自己的播放列表
167:17 你做了什么？制作自己的播放列表 他过去常常听他最喜欢的歌曲，
167:19 他过去常常听他最喜欢的歌曲， 这意味着同样的四五首歌曲会一遍又一遍地播放
167:21 这意味着同样的四五首歌曲会一遍又一遍地播放 或者有些人仍然有 spotify.com
167:50 我们需要记住的一件基本事情 这就是无论我们用 for 循环做什么
167:52 这就是无论我们用 for 循环做什么 我们可以用 while 循环完成所有这些事情
167:55 我们可以用 while 循环完成所有这些事情 我们也可以做所有这些事情
167:58 我们也可以做所有这些事情 可以用循环来完成，即这三个
168:00 可以用循环来完成，即这三个 循环的工作原理相同，但它们的
168:03 循环的工作原理相同，但它们的 我的语法现在会有些不同。
168:05 我的语法现在会有些不同。 我最喜欢的语法是 for 循环，所以我
168:07 我最喜欢的语法是 for 循环，所以我 如果你需要在代码中使用它那么
168:09 如果你需要在代码中使用它那么 我主要使用 for 循环
168:11 我主要使用 for 循环 我们需要这三个人都来，但无论你想要什么
168:14 我们需要这三个人都来，但无论你想要什么 你似乎就是其中之一，这更容易学习
168:16 你似乎就是其中之一，这更容易学习 您可以在代码中重复使用它
168:18 您可以在代码中重复使用它 不会有问题
168:20 不会有问题 这项工作可以用这三个循环中的任何一个来完成
168:22 这项工作可以用这三个循环中的任何一个来完成 有三个，所以我们必须先记住它们
168:25 有三个，所以我们必须先记住它们 因为如果在大学考试中
168:27 因为如果在大学考试中 老师让你回答这个问题
168:30 老师让你回答这个问题 给出并仅使用 for 循环或仅使用 while
168:33 给出并仅使用 for 循环或仅使用 while 如果你必须通过循环来实现，那么那时就会出现问题
168:35 如果你必须通过循环来实现，那么那时就会出现问题 如果可能的话，那么在这种情况下，所有三个
168:36 如果可能的话，那么在这种情况下，所有三个 我们应该先了解语法，我们来讨论一下
168:39 我们应该先了解语法，我们来讨论一下 现在 for 循环的语法是
168:42 现在 for 循环的语法是 首先，我们
168:44 首先，我们 写下 for 后面跟着的关键字
168:46 写下 for 后面跟着的关键字 让我们把括号和花括号放在一起
168:49 让我们把括号和花括号放在一起 正如我们在 If 时所观察到的
168:51 正如我们在 If 时所观察到的 有一些条件，那么我们的
168:53 有一些条件，那么我们的 花括号来了，不管怎样
168:54 花括号来了，不管怎样 它必须在我们写作之间完成
168:56 它必须在我们写作之间完成 类似的事情也发生在 for 循环中
168:59 类似的事情也发生在 for 循环中 循环中出现的第一个条件
169:00 循环中出现的第一个条件 在括号中我们称之为首字母
169:03 在括号中我们称之为首字母 点火初始点火条件是指任何
169:07 点火初始点火条件是指任何 我们将从这里开始我们的工作
169:10 我们将从这里开始我们的工作 例如，如果我们必须输入五次 hello world
169:12 例如，如果我们必须输入五次 hello world 如果你想打印它，那么我们可以使用一些变量
169:15 如果你想打印它，那么我们可以使用一些变量 它会记录我们说“你好”的次数
169:17 它会记录我们说“你好”的次数 如果打印了 world，那么该变量的值
169:19 如果打印了 world，那么该变量的值 价值可以从我们的根源开始
169:22 价值可以从我们的根源开始 最多可以是四个或该变量的值
169:24 最多可以是四个或该变量的值 可以从一开始到最多五
169:26 可以从一开始到最多五 到那时，该变量将做什么
169:29 到那时，该变量将做什么 我们可以取一个变量 i，这个 i 会做什么？
169:31 我们可以取一个变量 i，这个 i 会做什么？ 它的第一个值将是 1，所以这个
169:33 它的第一个值将是 1，所以这个 他会数二，然后数二，然后数三，然后数三
169:36 他会数二，然后数二，然后数三，然后数三 四个，五个，很快就变成了一个
169:38 四个，五个，很快就变成了一个 你好，世界，它被打印出来了，所以它发生了
169:40 你好，世界，它被打印出来了，所以它发生了 他打印了三个 hello world
169:42 他打印了三个 hello world 你好，世界，打印了四个你好
169:44 你好，世界，打印了四个你好 他还把《世界报》印刷了五版
169:46 他还把《世界报》印刷了五版 你好世界现在打印出来了什么
169:48 你好世界现在打印出来了什么 是初始值，即 i = 1，这是
169:53 是初始值，即 i = 1，这是 语句这是初始化语句
169:56 语句这是初始化语句 能来这里的人是我们的第二个
169:59 能来这里的人是我们的第二个 条件 条件告诉何时运行此 for 循环
170:02 条件 条件告诉何时运行此 for 循环 我们必须完成这意味着我们的工作是什么时候
170:04 我们必须完成这意味着我们的工作是什么时候 完整的将会像我们这里一样完成
170:07 完整的将会像我们这里一样完成 上面写着 int 接受一个变量 i
170:10 上面写着 int 接受一个变量 i 我们从其值开始
170:12 我们从其值开始 每个循环中的每个任务都有自己的循环
170:16 每个循环中的每个任务都有自己的循环 我们将在这里打印
170:18 我们将在这里打印 你完成了吗你好，世界，这里
170:22 你完成了吗你好，世界，这里 但是我们将写成以下条件
170:24 但是我们将写成以下条件 在这种情况下我们的循环应该运行
170:26 在这种情况下我们的循环应该运行 我们希望循环在以下情况下运行
170:29 我们希望循环在以下情况下运行 我们的 i 的值小于等于 5
170:32 我们的 i 的值小于等于 5 所以如果我们小于 5 或等于 5
170:35 所以如果我们小于 5 或等于 5 直到那时继续打印 hello world
170:37 直到那时继续打印 hello world 一旦数字大于 5，那么
170:40 一旦数字大于 5，那么 不再打印 hello world
170:41 不再打印 hello world 因为它被印刷了五次，
170:43 因为它被印刷了五次， 在更新语句中，我们将更新变量
170:46 在更新语句中，我们将更新变量 或者如果我们想在循环中进行任何更新
170:48 或者如果我们想在循环中进行任何更新 他们正在撰写类似这样的更新
170:50 他们正在撰写类似这样的更新 这里我们可以每次都写成 i = i + 1
170:54 这里我们可以每次都写成 i = i + 1 将使 i 的值增加 1
170:56 将使 i 的值增加 1 如果我们增加它，那么这个循环的控制将是什么
170:58 如果我们增加它，那么这个循环的控制将是什么 首先，我将保持这种方式
171:00 首先，我将保持这种方式 会发生在森林里，然后发生在那片森林里
171:03 会发生在森林里，然后发生在那片森林里 如果 i <= 5 为是，则检查条件
171:07 如果 i <= 5 为是，则检查条件 然后它会进入循环，无论
171:10 然后它会进入循环，无论 有工作，他会去做，然后他会来这里
171:12 有工作，他会去做，然后他会来这里 将会更新现在 i 的值已经变成了 2
171:15 将会更新现在 i 的值已经变成了 2 i 的值变为 2 再次检查条件
171:17 i 的值变为 2 再次检查条件 条件是 i <= 5 为是
171:20 条件是 i <= 5 为是 因为二的值小于五，所以
171:23 因为二的值小于五，所以 永远不会回到启蒙
171:25 永远不会回到启蒙 因此，再次检查此条件后
171:27 因此，再次检查此条件后 它会起作用，然后它会再次更新
171:29 它会起作用，然后它会再次更新 将进行两到三次，然后再次进行调理
171:32 将进行两到三次，然后再次进行调理 我会检查一下然后它就会再次工作
171:34 我会检查一下然后它就会再次工作 三点到四点会再更新
171:36 三点到四点会再更新 如果您再次检查条件，请按照以下方式操作
171:38 如果您再次检查条件，请按照以下方式操作 我们的 for 循环像这样循环运行
171:41 我们的 for 循环像这样循环运行 一旦实际编码后就会继续这样做
171:43 一旦实际编码后就会继续这样做 我把它写下来，看到并理解这一点
171:44 我把它写下来，看到并理解这一点 怎么做，然后先写下来
171:47 怎么做，然后先写下来 for for 是我们的 for 循环的关键字
171:49 for for 是我们的 for 循环的关键字 之后我们将写 Inish Eei Jashan Wali
171:51 之后我们将写 Inish Eei Jashan Wali 语句即 int i = 1 y 以某种方式
171:56 语句即 int i = 1 y 以某种方式 我们为自己写了一份简短的声明
171:58 我们为自己写了一份简短的声明 if 循环内的三个小语句
172:00 if 循环内的三个小语句 组合发生时，for 循环将首先出现
172:03 组合发生时，for 循环将首先出现 我们用来分配 i 的初始化语句
172:05 我们用来分配 i 的初始化语句 我已经启动了，之后我会写我的
172:08 我已经启动了，之后我会写我的 在什么条件下我们的循环
172:10 在什么条件下我们的循环 如果我们继续，那么条件是 i < = 5，那么我们将写
172:13 如果我们继续，那么条件是 i < = 5，那么我们将写 在更新语句中我们可以写 i = i + 1
172:19 在更新语句中我们可以写 i = i + 1 现在我们可以这样做：打印
172:21 现在我们可以这样做：打印 我会完成F
172:24 我会完成F 你好，世界，让我们保存这个并添加另一个
172:27 你好，世界，让我们保存这个并添加另一个 再次运行并查看输出结果
172:29 再次运行并查看输出结果 我们得到的输出是
172:32 我们得到的输出是 再次向世界问好，之后我们的
172:35 再次向世界问好，之后我们的 现在我们想要的是
172:37 现在我们想要的是 大家都在下一行 Hello World
172:38 大家都在下一行 Hello World 如果打印了也保存
172:41 如果打印了也保存 再次编译并运行，这次五次
172:43 再次编译并运行，这次五次 为我们打印的酒吧 hello world
172:45 为我们打印的酒吧 hello world 假设我们必须打印 1000 次
172:47 假设我们必须打印 1000 次 如果我必须完成这件事，那么什么也不会发生，只有这五个
172:49 如果我必须完成这件事，那么什么也不会发生，只有这五个 做一个简单的改变，你就可以赚1000卢比
172:52 做一个简单的改变，你就可以赚1000卢比 我们可以在 for 循环内做任何其他工作
172:55 我们可以在 for 循环内做任何其他工作 你可以重复多次，你会看到
172:57 你可以重复多次，你会看到 如果我滚动，它会向上滚动
172:59 如果我滚动，它会向上滚动 实际上，你好世界
173:02 实际上，你好世界 它已经在屏幕上打印了一千次
173:05 它已经在屏幕上打印了一千次 多次完成任何工作
173:07 多次完成任何工作 然后我们可以使用 for 循环
173:09 然后我们可以使用 for 循环 现在假设我必须计算从 1 到 100
173:11 现在假设我必须计算从 1 到 100 如果你想打印数字，那么该怎么做
173:13 如果你想打印数字，那么该怎么做 现在我们将借助循环来计算数字
173:15 现在我们将借助循环来计算数字 如果我想打印它，那么做这样的事情
173:18 如果我想打印它，那么做这样的事情 时尚将盛行，先有“一”，后有“二”。
173:20 时尚将盛行，先有“一”，后有“二”。 然后是 3，然后是 5，然后是 6，如此类推，100
173:24 然后是 3，然后是 5，然后是 6，如此类推，100 我们的数字到目前为止我们已经做了什么
173:27 我们的数字到目前为止我们已经做了什么 它采用了一个变量，其中
173:29 它采用了一个变量，其中 哪些值正在更新
173:31 哪些值正在更新 我们为什么不改变这个变量的值呢
173:33 我们为什么不改变这个变量的值呢 如果你一次又一次地打印它，那么如果这个
173:35 如果你一次又一次地打印它，那么如果这个 如果打印变量的值
173:37 如果打印变量的值 这里我们写百分比 d，然后
173:40 这里我们写百分比 d，然后 我们将把这1000变成100我希望
173:44 我们将把这1000变成100我希望 这意味着我们所有人都越来越清楚
173:47 这意味着我们所有人都越来越清楚 变量 i 的值从 1 开始
173:49 变量 i 的值从 1 开始 并将上升到 100，每次 i 的值都会增加 1
173:52 并将上升到 100，每次 i 的值都会增加 1 如果情况继续恶化，我们该怎么办？
173:55 如果情况继续恶化，我们该怎么办？ 打印从 1 到 100 的值
173:57 打印从 1 到 100 的值 一
173:58 一 所以所有这些价值观都是我们的
174:01 所以所有这些价值观都是我们的 输出已从 到 100 打印
174:04 输出已从 到 100 打印 现在我们可以在屏幕上看到这个变量
174:07 现在我们可以在屏幕上看到这个变量 您也可以拒绝，这意味着更新
174:09 您也可以拒绝，这意味着更新 总是表示变量的值
174:11 总是表示变量的值 没有必要增加更新，我们
174:13 没有必要增加更新，我们 您还可以减少变量的值，例如
174:15 您还可以减少变量的值，例如 如果我得到 100 的范围或者假设 10
174:18 如果我得到 100 的范围或者假设 10 如果我必须打印从一到
174:21 如果我必须打印从一到 我将 i 的值从 10 开始，
174:24 我将 i 的值从 10 开始， 然后继续增加 i 的值，直到
174:27 然后继续增加 i 的值，直到 直到从 10 减少到 1
174:30 直到从 10 减少到 1 每次 i = i - 1 时都会更新
174:33 每次 i = i - 1 时都会更新 以表格形式运行循环，直到我
174:35 以表格形式运行循环，直到我 我们的大于等于 t 不是 1 意思
174:38 我们的大于等于 t 不是 1 意思 即使 i 的值为 1，循环也会运行到
174:41 即使 i 的值为 1，循环也会运行到 即使有三个，循环也会运行
174:43 即使有三个，循环也会运行 将运行，循环如何运行，首先我
174:45 将运行，循环如何运行，首先我 的值是10，之后会变成9
174:47 的值是10，之后会变成9 那么它将变成八七654321一
174:51 那么它将变成八七654321一 一旦值一个接一个地更新
174:53 一旦值一个接一个地更新 将变为零，此后此循环将不会运行
174:55 将变为零，此后此循环将不会运行 现在让我们保存一次并运行它。
174:58 现在让我们保存一次并运行它。 这次我们将要打印的值是
175:01 这次我们将要打印的值是 它们一定从 10 开始就被打印出来了，即
175:03 它们一定从 10 开始就被打印出来了，即 10 9
175:04 10 9 87654321 所以我们的
175:09 87654321 所以我们的 这是一个变量，在更新时我们将
175:11 这是一个变量，在更新时我们将 您现在可以增加或减少它
175:13 您现在可以增加或减少它 无需在此发起任何操作
175:16 无需在此发起任何操作 它必须始终是一个整数值，这里
175:18 它必须始终是一个整数值，这里 我们也可以将字符写为字符串
175:20 我们也可以将字符写为字符串 您还可以编写自己的逻辑构建
175:22 您还可以编写自己的逻辑构建 我们根据问题做任何事情
175:24 我们根据问题做任何事情 需要启动，但我们会做
175:27 需要启动，但我们会做 大部分收入都来自这里
175:31 大部分收入都来自这里 我们要么称迭代器为 item
175:35 我们要么称迭代器为 item 我们也可以称之为物质，或者我们可以称之为
175:37 我们也可以称之为物质，或者我们可以称之为 是反变量，这意味着
175:40 是反变量，这意味着 一个变量，借助它我们可以测量任何
175:42 一个变量，借助它我们可以测量任何 如果你一次又一次地完成工作，那么这就叫做逐项化
175:45 如果你一次又一次地完成工作，那么这就叫做逐项化 指任何用英语创作的作品
175:46 指任何用英语创作的作品 一遍又一遍地这样做会抵消
175:49 一遍又一遍地这样做会抵消 我们把柜台放在商店上方
175:51 我们把柜台放在商店上方 我们在柜台记录，而不是数量
175:53 我们在柜台记录，而不是数量 就在顾客们来到这里的时候，这一个来了
175:55 就在顾客们来到这里的时候，这一个来了 是否有计数器或物品计量器可以跟踪
175:58 是否有计数器或物品计量器可以跟踪 如果在这里，工作已经完成了多少次
176:01 如果在这里，工作已经完成了多少次 我写了 10，这里的条件是
176:03 我写了 10，这里的条件是 只要数量大于一，工作就会继续，
176:05 只要数量大于一，工作就会继续， 更新条件说少一个
176:08 更新条件说少一个 如果是，我们知道我们的柜台，告诉我们
176:10 如果是，我们知道我们的柜台，告诉我们 我们的迭代器是否告诉我们
176:11 我们的迭代器是否告诉我们 我们的循环将运行 10 次。现在有一个问题
176:14 我们的循环将运行 10 次。现在有一个问题 让我们问一下关于 for 循环的问题
176:17 让我们问一下关于 for 循环的问题 这将打印从 0 到 10 的数字。
176:19 这将打印从 0 到 10 的数字。 你必须打印从 1 到 10 的数字
176:22 你必须打印从 1 到 10 的数字 我们将仔细研究这个问题，因为
176:24 我们将仔细研究这个问题，因为 到目前为止，我们打印的数字都是从一个
176:26 到目前为止，我们打印的数字都是从一个 最多 10 个，这次零也是额外的，
176:29 最多 10 个，这次零也是额外的， 如果我们计算所有这些数字，那么总数
176:31 如果我们计算所有这些数字，那么总数 这里有 11 个数字，这是一个小的
176:33 这里有 11 个数字，这是一个小的 早期出现的混乱
176:35 早期出现的混乱 学生们开始明白
176:37 学生们开始明白 我们有 10 个数字，从 0 到 10
176:40 我们有 10 个数字，从 0 到 10 但实际上我们并没有 11
176:42 但实际上我们并没有 11 有从 0 到 10 的数字，所以现在
176:45 有从 0 到 10 的数字，所以现在 我们将首先为此编写代码。
176:48 我们将首先为此编写代码。 所以让我们让物品变得重要，物品重要是
176:52 所以让我们让物品变得重要，物品重要是 我们现在开始使用的 Aa 值
176:54 我们现在开始使用的 Aa 值 我们将从零开始 我们将从零开始
176:56 我们将从零开始 我们将从零开始 Diya，现在我们将把条件放在这里
176:59 Diya，现在我们将把条件放在这里 直到小于等于我们的 10
177:01 直到小于等于我们的 10 等于 i 的值意味着每当
177:03 等于 i 的值意味着每当 小于 10 或等于 10，那么我们的
177:06 小于 10 或等于 10，那么我们的 循环将运行，为了更新我们将写入 i = i +
177:10 循环将运行，为了更新我们将写入 i = i + 1 每次都必须增加 1，并且
177:13 1 每次都必须增加 1，并且 这里我们将打印百分比 d
177:17 这里我们将打印百分比 d 我把这个放在下一行
177:20 我把这个放在下一行 让我们保存并运行它
177:24 让我们保存并运行它 这里我们的输出显示了行
177:26 这里我们的输出显示了行 从到我们所有的价值高达10
177:29 从到我们所有的价值高达10 如果将其打印出来，那么我们就可以这样
177:31 如果将其打印出来，那么我们就可以这样 总共打印了 11 个数字，现在这个 i =
177:34 总共打印了 11 个数字，现在这个 i = i + 1 是这个的简写
177:37 i + 1 是这个的简写 这意味着我们也可以将其写成 i + p
177:39 这意味着我们也可以将其写成 i + p 正如我们所学到的，对于 i = i + 1
177:43 正如我们所学到的，对于 i = i + 1 如果我们想写，我们就能写
177:46 如果我们想写，我们就能写 我 + e
177:48 我 + e 1 我们用赋值运算符来简写
177:51 1 我们用赋值运算符来简写 我们在做 i + = 1 时学到了，现在我们可以将 i + = 1 转换为 i +
177:56 我们在做 i + = 1 时学到了，现在我们可以将 i + = 1 转换为 i + 你也可以用简写来写
177:57 你也可以用简写来写 它变成了简写，只是一个 + 和
178:00 它变成了简写，只是一个 + 和 意思是如果这里有两个，并且
178:02 意思是如果这里有两个，并且 如果这里有 2，那么我会回答“是”。
178:06 如果这里有 2，那么我会回答“是”。 加上我们不能我pl加手段
178:08 加上我们不能我pl加手段 每次向 i 添加一个时都会发生
178:12 每次向 i 添加一个时都会发生 同样，还有 a plus p a plus p
178:15 同样，还有 a plus p a plus p aa p p aa 除此之外还有不同的含义
178:18 aa p p aa 除此之外还有不同的含义 还有减 aa 和 i 减
178:20 还有减 aa 和 i 减 还有一个减号，现在一旦这个加号加
178:22 还有一个减号，现在一旦这个加号加 还有一点点
178:24 还有一点点 我们将详细讨论
178:26 我们将详细讨论 什么是增量和减量运算符？
178:28 什么是增量和减量运算符？ 首先我们来谈谈你的
178:30 首先我们来谈谈你的 增加增量运算符
178:32 增加增量运算符 意思是英语中的某件事
178:34 意思是英语中的某件事 增加意味着增加，因此增加
178:37 增加意味着增加，因此增加 有两种类型的运算符，一种是
178:39 有两种类型的运算符，一种是 我们的 p pa 是我们的 i+ p 如果
178:43 我们的 p pa 是我们的 i+ p 如果 我们取一个变量 i，然后计算它的值
178:45 我们取一个变量 i，然后计算它的值 首字母缩略词
178:48 首字母缩略词 再次编写打印语句，它将
178:50 再次编写打印语句，它将 在里面我们要打印 i 键
178:51 在里面我们要打印 i 键 现在我们可以写入任意百分比 dsn 的值
178:56 现在我们可以写入任意百分比 dsn 的值 首先是 i plus
178:59 首先是 i plus 另外，让我们保存它并点击“新建”
179:02 另外，让我们保存它并点击“新建” 在终端中，我们的输出是
179:04 在终端中，我们的输出是 aaya 一个接一个 aa 每当我们加加
179:08 aaya 一个接一个 aa 每当我们加加 这意味着
179:10 这意味着 先使用该值，然后按 i
179:13 先使用该值，然后按 i 增加值，即加加
179:17 增加值，即加加 以后每次使用时，都意味着使用
179:20 以后每次使用时，都意味着使用 然后增加首先使用任意值
179:23 然后增加首先使用任意值 并增加 aa 的值
179:26 并增加 aa 的值 森林现在是什么？首先使用它的意义是什么
179:29 森林现在是什么？首先使用它的意义是什么 如果你想打印出来，我们就必须打印出来
179:32 如果你想打印出来，我们就必须打印出来 我把它打印出来了，但现在是内部的
179:34 我把它打印出来了，但现在是内部的 编译器已经增加了这个
179:36 编译器已经增加了这个 值，也就是说，如果我们再次输入 i
179:39 值，也就是说，如果我们再次输入 i 这次我们要打印值
179:42 这次我们要打印值 这次我不会做加法，只是我
179:44 这次我不会做加法，只是我 如果我们这样写，那么这里的 i 值就是 1
179:47 如果我们这样写，那么这里的 i 值就是 1 现在内部打印为 plus plus
179:49 现在内部打印为 plus plus 这个值已经变成了两个，当我们
179:52 这个值已经变成了两个，当我们 如果我们再次打印 i，我们就会知道
179:54 如果我们再次打印 i，我们就会知道 它将如何工作，它已经变成了两个，编译它
179:56 它将如何工作，它已经变成了两个，编译它 让我们来运行一下，这意味着之前它是一个，现在它是内部的
180:00 让我们来运行一下，这意味着之前它是一个，现在它是内部的 增加了，之后我就没用过
180:03 增加了，之后我就没用过 我在第二行再次使用了它
180:05 我在第二行再次使用了它 如果我们这样做了，它的价值就是 2，它就是我们的
180:07 如果我们这样做了，它的价值就是 2，它就是我们的 通行证已打印出来，如果我们
180:10 通行证已打印出来，如果我们 同一变量
180:11 同一变量 如果你把 + 当作 + 那么在这种情况下会发生什么
180:15 如果你把 + 当作 + 那么在这种情况下会发生什么 它是+aa说
180:19 它是+aa说 先增加后使用意味着先增加
180:22 先增加后使用意味着先增加 增加值，所以先加加
180:24 增加值，所以先加加 我跟你说了，加加就是先增加
180:27 我跟你说了，加加就是先增加 然后使用 i 的值
180:29 然后使用 i 的值 将增加并稍后使用 i 的值
180:31 将增加并稍后使用 i 的值 它会发生，让我们将其注释掉。
180:34 它会发生，让我们将其注释掉。 保存并再次运行并查看输出
180:37 保存并再次运行并查看输出 如果是，则打印第一个，然后打印第二个
180:40 如果是，则打印第一个，然后打印第二个 时间也打印到为什么因为我
180:42 时间也打印到为什么因为我 值最初为一加一
180:44 值最初为一加一 你首先做了什么来增加它然后又做了什么
180:46 你首先做了什么来增加它然后又做了什么 之后我们打印了
180:49 之后我们打印了 这意味着如果打印了两次，那么第二次
180:51 这意味着如果打印了两次，那么第二次 我们正在打印 i 的值
180:53 我们正在打印 i 的值 已经有两个了，所以才有
180:54 已经有两个了，所以才有 如果打印了两个，那么这就是为什么 plus p aa jo
180:57 如果打印了两个，那么这就是为什么 plus p aa jo 发生这种情况，我们称之为预增量
181:00 发生这种情况，我们称之为预增量 运算符，而 i + p 称为后置运算符
181:05 运算符，而 i + p 称为后置运算符 增量运算符加 p a 意味着 pre
181:09 增量运算符加 p a 意味着 pre 增量意味着首先发生增量，并且
181:11 增量意味着首先发生增量，并且 稍后使用并后增量
181:13 稍后使用并后增量 这意味着它首先被使用，然后被增加
181:17 这意味着它首先被使用，然后被增加 这就是我们可以写速记的方法
181:19 这就是我们可以写速记的方法 现在以同样的方式对 p 和 -1
181:22 现在以同样的方式对 p 和 -1 我们有减量运算符
181:24 我们有减量运算符 减量运算符起什么作用？减少
181:26 减量运算符起什么作用？减少 给出值，即如果我们的
181:30 给出值，即如果我们的 如果你通过了，但得了减分，我们会称之为
181:33 如果你通过了，但得了减分，我们会称之为 预减，并且有一个减号
181:37 预减，并且有一个减号 减去，所以我们称之为后减
181:40 减去，所以我们称之为后减 现在举个例子
181:43 现在举个例子 让我们注释掉，然后注释就会出现
181:47 让我们注释掉，然后注释就会出现 值最初为 1，现在我们可以这样做
181:50 值最初为 1，现在我们可以这样做 如果我们给 i 减去 - 那么输出是什么
181:53 如果我们给 i 减去 - 那么输出是什么 我们得到了输出一，然后排
181:57 我们得到了输出一，然后排 这意味着将使用 i 的第一个值
181:59 这意味着将使用 i 的第一个值 如果打印则有一个，因此只应打印一个
182:01 如果打印则有一个，因此只应打印一个 此后，如果森林面积减少，
182:03 此后，如果森林面积减少， 值将减少到行和第二
182:05 值将减少到行和第二 当我们打印出来时然后打印
182:07 当我们打印出来时然后打印 我们现在肯定已经对此发表了评论
182:09 我们现在肯定已经对此发表了评论 如果我们运行第二部分，即
182:12 如果我们运行第二部分，即 减法-来吧，首先在这种情况下
182:14 减法-来吧，首先在这种情况下 我们将打印零，因为首先
182:16 我们将打印零，因为首先 它很快就会减少，然后会被打印出来
182:19 它很快就会减少，然后会被打印出来 所以这里也是零 这里也是零 因为
182:21 所以这里也是零 这里也是零 因为 这个数字首次从 1 降至 0
182:23 这个数字首次从 1 降至 0 然后打印
182:25 然后打印 这意味着它被打印为零，
182:27 这意味着它被打印为零， 当你第二次打印时，
182:28 当你第二次打印时， 值已经变为零，因此
182:30 值已经变为零，因此 如果打印零，则以这种方式 c
182:33 如果打印零，则以这种方式 c 我们的 post 减少 pre 里面
182:35 我们的 post 减少 pre 里面 后减量 前增量
182:36 后减量 前增量 增量运算符在以下情况下有效：
182:38 增量运算符在以下情况下有效： 我们在这里也使用循环
182:40 我们在这里也使用循环 增量减量运算符
182:42 增量减量运算符 它们非常有用，因为大多数情况下你
182:44 它们非常有用，因为大多数情况下你 你会在任何地方看到这些语法
182:46 你会在任何地方看到这些语法 如果它们正在被使用，那么我们应该始终
182:48 如果它们正在被使用，那么我们应该始终 这是标准的方式
182:50 这是标准的方式 大多数人要么
182:52 大多数人要么 我们使用变量 aa 还是 j
182:54 我们使用变量 aa 还是 j 有吗或者你会用它吗，无论你想要什么
182:57 有吗或者你会用它吗，无论你想要什么 您可以随意使用 x vaz
183:00 您可以随意使用 x vaz 标准方法是，每当我编码时
183:02 标准方法是，每当我编码时 你肯定在写，大部分肯定在看
183:04 你肯定在写，大部分肯定在看 存在嵌套循环，即循环内循环
183:06 存在嵌套循环，即循环内循环 所以你接下来会看到 JK
183:09 所以你接下来会看到 JK 我们会谈论一些特别的事情
183:12 我们会谈论一些特别的事情 是的，我们已经讨论过了
183:14 是的，我们已经讨论过了 增量运算符是什么？
183:16 增量运算符是什么？ 我们已经讨论了减量运算符
183:18 我们已经讨论了减量运算符 进入循环后会发生什么
183:20 进入循环后会发生什么 计数器可以是浮点数，甚至是字符。
183:23 计数器可以是浮点数，甚至是字符。 到目前为止，我们已经写了 for 循环
183:25 到目前为止，我们已经写了 for 循环 我们的循环计数器是计数器
183:27 我们的循环计数器是计数器 它是一个变量，也可以是一个浮点数
183:30 它是一个变量，也可以是一个浮点数 我们的性格怎么也会这样
183:32 我们的性格怎么也会这样 编写一个循环，将系列从一个系列带到另一个系列。
183:34 编写一个循环，将系列从一个系列带到另一个系列。 我想打印最多 5 个数字
183:36 我想打印最多 5 个数字 但这次我们要讨论的是浮点数
183:37 但这次我们要讨论的是浮点数 当你打印它时，i 的值将开始
183:39 当你打印它时，i 的值将开始 将对 i 执行 1.0，直到我们的车道等于
183:43 将对 i 执行 1.0，直到我们的车道等于 5.0 不存在，我们将把 i 变成 plus
183:46 5.0 不存在，我们将把 i 变成 plus 每次我们都会打印它
183:49 每次我们都会打印它 百分比 f s n aa 的值通过以下公式计算
183:53 百分比 f s n aa 的值通过以下公式计算 保存并打开一个新终端
183:57 保存并打开一个新终端 那么我们在印刷品中得到了什么
184:00 那么我们在印刷品中得到了什么 1.00 2.00 3.0 4.0 等等直到 5.0
184:06 1.00 2.00 3.0 4.0 等等直到 5.0 这意味着这次所有的值都会打印在插槽中
184:08 这意味着这次所有的值都会打印在插槽中 这次我们添加了迭代器
184:10 这次我们添加了迭代器 我已经使用了我的计数器变量
184:13 我已经使用了我的计数器变量 我们的值是浮动的，其值为
184:15 我们的值是浮动的，其值为 带我们从 a 到 z 的字符
184:17 带我们从 a 到 z 的字符 如果你想打印它，那么它的循环是什么
184:18 如果你想打印它，那么它的循环是什么 我们将首先采用字符迭代器
184:21 我们将首先采用字符迭代器 我们将取 i = a 那么条件是什么
184:25 我们将取 i = a 那么条件是什么 或者这次你会把它放在这里而不是我
184:28 或者这次你会把它放在这里而不是我 如果我们把变量分开，那么我们就把它
184:30 如果我们把变量分开，那么我们就把它 i 的值存储在字符
184:33 i 的值存储在字符 将继续增加，直到
184:35 将继续增加，直到 小于等于 z 的值不会保持不变
184:39 小于等于 z 的值不会保持不变 每次我们都会这样做，而且我们知道
184:41 每次我们都会这样做，而且我们知道 角色们在内心深处是他们自己的
184:43 角色们在内心深处是他们自己的 当转换成数值时，这些数字
184:45 当转换成数值时，这些数字 如果你滚动到这个然后
184:47 如果你滚动到这个然后 97 是其正弦值在 z 轴上滚动
184:50 97 是其正弦值在 z 轴上滚动 如果我们这样做，那么它的值是 122，那么 b 的值是多少
184:54 如果我们这样做，那么它的值是 122，那么 b 的值是多少 a 将是 97 b 将是 98 因此这样
184:57 a 将是 97 b 将是 98 因此这样 所以每当角色
184:58 所以每当角色 我们正在增加，即我们从 a 到 b
185:00 我们正在增加，即我们从 a 到 b 从 b 到 c 从 c 到 d
185:02 从 b 到 c 从 c 到 d 所以每次我们打印它时
185:04 所以每次我们打印它时 你会把你的角色赋予谁？
185:09 你会把你的角色赋予谁？ 都得救了，所以这次我们将看到
185:12 都得救了，所以这次我们将看到 我们英语字母表中的所有内容
185:14 我们英语字母表中的所有内容 我们有从 A 到结尾的字母
185:17 我们有从 A 到结尾的字母 如果打印出来的话它看起来会像这样
185:19 如果打印出来的话它看起来会像这样 让我们的物品也漂浮起来
185:21 让我们的物品也漂浮起来 你也可以选择那个角色
185:23 你也可以选择那个角色 你也可以将其视为 int 或 double
185:25 你也可以将其视为 int 或 double 这取决于我们解决哪个问题
185:28 这取决于我们解决哪个问题 我们接下来要讨论的是
185:30 我们接下来要讨论的是 我们将会进行内斗
185:46 当 int i = 1 时，我们的条件就满足了 这就是我们的解雇发生的地方
185:48 这就是我们的解雇发生的地方 条件，你想来这里
185:50 条件，你想来这里 将其留空意味着这里不会有任何声明
185:52 将其留空意味着这里不会有任何声明 我不会写任何可以终止这个循环的东西
185:54 我不会写任何可以终止这个循环的东西 您将在这里写下您的更新
185:57 您将在这里写下您的更新 语句，即 i + p 以及每次要做什么
186:00 语句，即 i + p 以及每次要做什么 这个循环每次都会打印这个循环
186:02 这个循环每次都会打印这个循环 我们有 hello world 来做这件事
186:06 我们有 hello world 来做这件事 那么这个循环说明了什么？
186:09 那么这个循环说明了什么？ i 的值从 1 开始
186:11 i 的值从 1 开始 条形 aa 的值正在增加，即
186:13 条形 aa 的值正在增加，即 先是一个，然后变成两个，然后是三个
186:15 先是一个，然后变成两个，然后是三个 它会变成四，然后会变成五
186:17 它会变成四，然后会变成五 它会消失，但是我们在这里将这个声明留空
186:19 它会消失，但是我们在这里将这个声明留空 把我们的遗嘱留给我们三个人中的任何一个人
186:21 把我们的遗嘱留给我们三个人中的任何一个人 你也可以留空，问题是这个
186:23 你也可以留空，问题是这个 出现错误，现在还出现错误吗？
186:25 出现错误，现在还出现错误吗？ 我们将看到此声明我们将其留空
186:27 我们将看到此声明我们将其留空 如果我离开它，这个循环甚至不会知道
186:29 如果我离开它，这个循环甚至不会知道 C 编译器无法检测到它
186:31 C 编译器无法检测到它 何时结束此循环此循环运行
186:33 何时结束此循环此循环运行 它会继续下去，它会继续下去，它会如何继续下去
186:36 它会继续下去，它会继续下去，它会如何继续下去 如果我们运行这个，那么这个循环将持续到你好
186:39 如果我们运行这个，那么这个循环将持续到你好 全世界都会把它印出来，直到我们的
186:40 全世界都会把它印出来，直到我们的 如果计算机内存未满
186:43 如果计算机内存未满 这就是我关闭它的原因
186:45 这就是我关闭它的原因 重要的是我们始终
186:47 重要的是我们始终 在我们了解情况之前不要错过
186:50 在我们了解情况之前不要错过 我们的代码运行正确并且工作正常
186:53 我们的代码运行正确并且工作正常 注意什么条件会做什么
186:55 注意什么条件会做什么 这是一种永无止境的循环
186:57 这是一种永无止境的循环 这件事不会发生，我会一直跑下去
186:59 这件事不会发生，我会一直跑下去 我们和他有内讧
187:15 与 Web 开发相关或任何其他事物 我会在自己开发应用程序还是去公司
187:17 我会在自己开发应用程序还是去公司 如果你真的去开发那么
187:19 如果你真的去开发那么 但是当你必须编码时
187:21 但是当你必须编码时 错误是你犯的非常基本的错误
187:23 错误是你犯的非常基本的错误 当谈到循环时，绝对没有什么可做的
187:25 当谈到循环时，绝对没有什么可做的 始终注意你是一个
187:27 始终注意你是一个 你的程序内部发生内斗，所以
187:30 你的程序内部发生内斗，所以 我们的内斗已经结束
187:41 这就是我们的 while 循环，现在调用 while 循环 语法更容易写
187:43 语法更容易写 一开始我们从最轻的东西开始
187:46 一开始我们从最轻的东西开始 这是一个语法复杂的代码，我已经做到了
187:48 这是一个语法复杂的代码，我已经做到了 现在有了 for 循环，所有的循环对我们来说都很容易
187:50 现在有了 for 循环，所有的循环对我们来说都很容易 其余一切似乎都很容易
187:52 其余一切似乎都很容易 但如果在 for 循环中你仍然得到轻微的
187:54 但如果在 for 循环中你仍然得到轻微的 如果你有任何疑问，你可以稍微倒回去一下
187:56 如果你有任何疑问，你可以稍微倒回去一下 让我们进一步看看我们提出的问题。
187:59 让我们进一步看看我们提出的问题。 如果有任何疑问，我们已经讨论过了
188:01 如果有任何疑问，我们已经讨论过了 也看看它们，否则做笔记
188:03 也看看它们，否则做笔记 看一下就明白了
188:05 看一下就明白了 现在让我们来学习一下 while 循环
188:07 现在让我们来学习一下 while 循环 Weil 的语法是，我们首先
188:09 Weil 的语法是，我们首先 写下你的关键词
188:12 写下你的关键词 写下你的病情，然后写在里面
188:14 写下你的病情，然后写在里面 这些言论对我们毫无意义
188:16 这些言论对我们毫无意义 如果你愿意为我们做任何工作那么无论我们现在做了什么
188:19 如果你愿意为我们做任何工作那么无论我们现在做了什么 代码中写道，从 1 到 f 的数字
188:22 代码中写道，从 1 到 f 的数字 如果你想打印它，那么在 for 循环中
188:24 如果你想打印它，那么在 for 循环中 我们已经写好了代码，现在再一次
188:26 我们已经写好了代码，现在再一次 让我们比较一下 vile 的语法
188:28 让我们比较一下 vile 的语法 for 循环中 int 的代码是如何编写的
188:32 for 循环中 int 的代码是如何编写的 i = 1 aa 只要 lane 等于 5 aa ps ps
188:38 i = 1 aa 只要 lane 等于 5 aa ps ps 这里我们打印了百分比
188:40 这里我们打印了百分比 D 我们的我现在在 while 循环中它的值是多少
188:44 D 我们的我现在在 while 循环中它的值是多少 当您再次输入关键字时将发生转换
188:48 当您再次输入关键字时将发生转换 我们会写下我们的条件，我们的条件是什么
188:51 我们会写下我们的条件，我们的条件是什么 在这里省略变量
188:53 在这里省略变量 你必须在代码中声明它
188:56 你必须在代码中声明它 在 for 中，我们将变量保留在里面
188:59 在 for 中，我们将变量保留在里面 我已经以父母的身份声明了，但是这次
189:01 我已经以父母的身份声明了，但是这次 我们需要在这里声明外部变量。
189:03 我们需要在这里声明外部变量。 必须这样做，因为小瓶里没有空间
189:05 必须这样做，因为小瓶里没有空间 不管你是在小瓶里做，这都不会发生
189:07 不管你是在小瓶里做，这都不会发生 不能再在这里使用它，条件
189:09 不能再在这里使用它，条件 我会在外面宣布
189:11 我会在外面宣布 我们的条件是，直到教训平等
189:14 我们的条件是，直到教训平等 打印直到变成 25
189:18 打印直到变成 25 百分比 d 代表我们现在的 i 值
189:21 百分比 d 代表我们现在的 i 值 但是你会问，我们已经涵盖了两件事
189:24 但是你会问，我们已经涵盖了两件事 我们在这里讨论了一件事
189:26 我们在这里讨论了一件事 填写您的声明声明
189:28 填写您的声明声明 如果我们把它写在while循环之外，那么它将是
189:30 如果我们把它写在while循环之外，那么它将是 宣言取代本宣言
189:32 宣言取代本宣言 这是我们的终止条件
189:35 这是我们的终止条件 在这种情况下我们的循环结束
189:37 在这种情况下我们的循环结束 在什么情况下它会运行？
189:39 在什么情况下它会运行？ 终止条件在这里输入，在这里输入
189:42 终止条件在这里输入，在这里输入 已经到了，但是更新条件还没到
189:44 已经到了，但是更新条件还没到 您将在 while 循环内的哪里写入更新
189:47 您将在 while 循环内的哪里写入更新 我们必须将更新写入其内部，即
189:49 我们必须将更新写入其内部，即 在此处写入结束语句中的更新
189:51 在此处写入结束语句中的更新 将在循环结束前结束收入
189:54 将在循环结束前结束收入 我出去的时候也做了加加
189:56 我出去的时候也做了加加 如果你给予，那么下次它将会加加
189:59 如果你给予，那么下次它将会加加 语句将变为 + 然后再次
190:01 语句将变为 + 然后再次 将会回来并再次工作
190:04 将会回来并再次工作 这将是加分项，然后工作将再次回来
190:06 这将是加分项，然后工作将再次回来 会这样做然后它会再次成为加号
190:08 会这样做然后它会再次成为加号 如果它再次回来，它就会像这样
190:10 如果它再次回来，它就会像这样 我们的循环在 while 循环 c 内运行
190:13 我们的循环在 while 循环 c 内运行 现在尝试实际运行您的代码。
190:15 现在尝试实际运行您的代码。 我们将变量声明为 int aa
190:17 我们将变量声明为 int aa e 1 只要 i < eq 5 那么我们有
190:23 e 1 只要 i < eq 5 那么我们有 让我们打印五个 Hello World
190:26 让我们打印五个 Hello World 次，每次我都会把 i 变成加号
190:30 次，每次我都会把 i 变成加号 现在需要注意的是，这是卷曲的
190:31 现在需要注意的是，这是卷曲的 有时这些后面有括号，甚至在 c 之后
190:34 有时这些后面有括号，甚至在 c 之后 我们没有把这个放在里面，即声明
190:37 我们没有把这个放在里面，即声明 终止符，因为花括号意味着
190:39 终止符，因为花括号意味着 恰巧这里有一段代码
190:41 恰巧这里有一段代码 之后，我们知道了
190:42 之后，我们知道了 如果即将结束，则语句终止符
190:44 如果即将结束，则语句终止符 无需申请，立即申请
190:46 无需申请，立即申请 让我们运行新的终端，这样我们就有了
190:50 让我们运行新的终端，这样我们就有了 Hello World 被打印了五次
190:52 Hello World 被打印了五次 现在我们来谈谈它的问题，这个问题是我们的
190:55 现在我们来谈谈它的问题，这个问题是我们的 如果 n 是，则打印从 0 到 n 的数字
190:58 如果 n 是，则打印从 0 到 n 的数字 用户给出的我们到目前为止所做的事情
191:00 用户给出的我们到目前为止所做的事情 打印从行到五的数字
191:02 打印从行到五的数字 你想把它做完还是想从一到五把它做完
191:05 你想把它做完还是想从一到五把它做完 所以我们自己放了一个终止语句
191:06 所以我们自己放了一个终止语句 i 的值只要小于等于
191:08 i 的值只要小于等于 剩下两个 5，但这次用户会告诉
191:11 剩下两个 5，但这次用户会告诉 直到我想打印这样的值
191:13 直到我想打印这样的值 示例用户给我们发送了 4，所以我们
191:16 示例用户给我们发送了 4，所以我们 如果用户
191:19 如果用户 发送了 10，所以我们必须打印 0 1 2 3 4
191:23 发送了 10，所以我们必须打印 0 1 2 3 4 5 6 直到 10 到来，现在这样做
191:27 5 6 直到 10 到来，现在这样做 首先从用户的角度
191:29 首先从用户的角度 值输入将从用户处获取值
191:32 值输入将从用户处获取值 接受输入并将其放入变量 n
191:34 接受输入并将其放入变量 n 已存储 将数字存储在 n 中
191:37 已存储 将数字存储在 n 中 现在，每当我们写 for 条件或这个
191:40 现在，每当我们写 for 条件或这个 如果遇到有关墙环的问题该怎么办
191:42 如果遇到有关墙环的问题该怎么办 每当我们要解决卑鄙的问题时，我们都会首先解决它。
191:44 每当我们要解决卑鄙的问题时，我们都会首先解决它。 如果你曾经写过条件，那么小瓶里是什么
191:46 如果你曾经写过条件，那么小瓶里是什么 除非我们的 i < 等于 n
191:50 除非我们的 i < 等于 n 它会更早发生，我们过去常常写课程等于5
191:53 它会更早发生，我们过去常常写课程等于5 如果 n 是一个变化的数字，它总是 5
191:55 如果 n 是一个变化的数字，它总是 5 不可能是 4 个，可能是 10 个
191:57 不可能是 4 个，可能是 10 个 也可以是 10000，所以车道等于
192:00 也可以是 10000，所以车道等于 我们会把它打印出来
192:03 我们会把它打印出来 我们将在稍后结束 i + p 然后某事
192:07 我们将在稍后结束 i + p 然后某事 这就是我们的流程的编码方式
192:09 这就是我们的流程的编码方式 如果你尝试了，那么就写在上面
192:11 如果你尝试了，那么就写在上面 打印 f 输入数字并点赞
192:14 打印 f 输入数字并点赞 让我们定义 int n，然后我们可以这样做
192:16 让我们定义 int n，然后我们可以这样做 进行扫描
192:18 进行扫描 现在我们将编写 while 循环，当一个项目
192:22 现在我们将编写 while 循环，当一个项目 int i 只要我们的 i < 等于 n 那么
192:26 int i 只要我们的 i < 等于 n 那么 我们的 while 循环将运行到
192:29 我们的 while 循环将运行到 你会在里面做什么，每次都把它打印出来
192:30 你会在里面做什么，每次都把它打印出来 将给出它的值，即它的 i 和
192:35 将给出它的值，即它的 i 和 之后我们将做 i + 那么发生了什么
192:37 之后我们将做 i + 那么发生了什么 首先，我们向用户询问他的号码
192:39 首先，我们向用户询问他的号码 当他输入数字时，我们将其改为 n
192:41 当他输入数字时，我们将其改为 n 存储然后 i 的值
192:44 存储然后 i 的值 我从一行开始直到小于等于
192:46 我从一行开始直到小于等于 只要 n 保持不变，每次我们
192:49 只要 n 保持不变，每次我们 我会把它打印出来然后做
192:51 我会把它打印出来然后做 我们将逐一更新，让我们保存它
192:54 我们将逐一更新，让我们保存它 如果你运行这个，首先按回车键
192:57 如果你运行这个，首先按回车键 我必须这样做，我们要输入数字
192:59 我必须这样做，我们要输入数字 我们进入了七七，所以对我们来说
193:01 我们进入了七七，所以对我们来说 应打印从行到七的所有数字
193:03 应打印从行到七的所有数字 现在我们已经到了这里，我们甚至没有得到任何大的数字
193:06 现在我们已经到了这里，我们甚至没有得到任何大的数字 例如，假设我们输入 55
193:10 例如，假设我们输入 55 如果我输入从第 55 行开始的所有数字
193:13 如果我输入从第 55 行开始的所有数字 我们已将所有数字打印出来。
193:15 我们已将所有数字打印出来。 因此，对于循环或 C 中的任何其他循环
193:18 因此，对于循环或 C 中的任何其他循环 只有一种方法可以很好地学习这个概念
193:20 只有一种方法可以很好地学习这个概念 方法是问很多关于它的问题
193:22 方法是问很多关于它的问题 我们正在练习的事情
193:24 我们正在练习的事情 如果我们清楚的话，那么任何
193:26 如果我们清楚的话，那么任何 没问题，我们使用相同的代码
193:29 没问题，我们使用相同的代码 我们如何使用 for 代替 while
193:32 我们如何使用 for 代替 while 让我们在这里评论一下
193:35 让我们在这里评论一下 让我们在 for 中写入相同的代码：for int aa = 0
193:40 让我们在 for 中写入相同的代码：for int aa = 0 aa 的值小于等于我们的
193:42 aa 的值小于等于我们的 我不住在你附近，而你在这里
193:47 我不住在你附近，而你在这里 撰写打印声明
193:49 撰写打印声明 百分比 d n aa 所以像这里 aa ki
193:55 百分比 d n aa 所以像这里 aa ki 值是第一行，条件检查在这里
193:57 值是第一行，条件检查在这里 同样的情况也发生在 for 循环中
193:59 同样的情况也发生在 for 循环中 该值是第一行，我们将条件设置为
194:01 该值是第一行，我们将条件设置为 i <= n 不成立，需要 i+ 进行更新
194:05 i <= n 不成立，需要 i+ 进行更新 每次我们打印时
194:07 每次我们打印时 保存一次值然后运行它
194:09 保存一次值然后运行它 开始吧，下次我们输入号码
194:12 开始吧，下次我们输入号码 所以从这一行开始到所有行都是六
194:15 所以从这一行开始到所有行都是六 我们现在已经打印了所有数字。
194:17 我们现在已经打印了所有数字。 假设我们不从零开始，而是从一开始
194:19 假设我们不从零开始，而是从一开始 我必须在六点之前把它打印出来，没问题
194:20 我必须在六点之前把它打印出来，没问题 i 的值称为
194:26 将首字母缩略词从三个增加到六个 从三点到七点或从三点到
194:28 从三点到七点或从三点到 如果要打印到 n，则从初始化开始
194:31 如果要打印到 n，则从初始化开始 从三到n做出陈述
194:32 从三到n做出陈述 以这种方式给出任何类型的代码
194:35 以这种方式给出任何类型的代码 我们将以这种方式采取并克服它
194:37 我们将以这种方式采取并克服它 我们接下来要讨论的是
194:39 我们接下来要讨论的是 我们的 do while 循环绝对是 do while 循环
194:42 我们的 do while 循环绝对是 do while 循环 它就像一个小瓶环，现在小瓶环
194:45 它就像一个小瓶环，现在小瓶环 内部条件已经检查过，即
194:47 内部条件已经检查过，即 如果我们谈论邪恶循环，那么邪恶
194:49 如果我们谈论邪恶循环，那么邪恶 曾经最卑鄙的东西被写下来
194:52 曾经最卑鄙的东西被写下来 那么我们的条件就会被写成这样
194:54 那么我们的条件就会被写成这样 如果条件为假，则任何时候都不会删除该块。
194:58 如果条件为假，则任何时候都不会删除该块。 我们不会像被砖头砸到一样走进去
195:02 我们不会像被砖头砸到一样走进去 e 等于我们写的一个和条件
195:05 e 等于我们写的一个和条件 我正在检查，如果你接受的话就来，否则
195:08 我正在检查，如果你接受的话就来，否则 这不是真的，这就是为什么里面的
195:10 这不是真的，这就是为什么里面的 语句将永远被执行
195:12 语句将永远被执行 否则我们的恶意循环将不会运行一次
195:15 否则我们的恶意循环将不会运行一次 它会这样做，但如果我们写一个 while 循环
195:18 它会这样做，但如果我们写一个 while 循环 至少总是运行一次，我们会这样做
195:21 至少总是运行一次，我们会这样做 如果你说 while 那么也做 while 循环
195:24 如果你说 while 那么也做 while 循环 在不同情况下使用它
195:26 在不同情况下使用它 使用语法是否更有意义
195:28 使用语法是否更有意义 如果我们谈论 do while，那么首先我们
195:30 如果我们谈论 do while，那么首先我们 写成 do，意思是这里的条件先行
195:32 写成 do，意思是这里的条件先行 没有检查，先做工作，做
195:35 没有检查，先做工作，做 先做工作，然后写下你所做的一切
195:38 先做工作，然后写下你所做的一切 工作完成了，我们在这里写下我们的台词
195:40 工作完成了，我们在这里写下我们的台词 然后最后检查条件
195:43 然后最后检查条件 这意味着你必须继续做这项工作，直到
195:47 这意味着你必须继续做这项工作，直到 必须一直这样做，直到工作完成，然后
195:51 必须一直这样做，直到工作完成，然后 将检查条件，然后完成工作，然后检查条件
195:53 将检查条件，然后完成工作，然后检查条件 我会检查一下，最后再写，然后我会写
195:55 我会检查一下，最后再写，然后我会写 把你的条件放在括号里，我们在这里
195:58 把你的条件放在括号里，我们在这里 一定是语句终止符，因为
196:00 一定是语句终止符，因为 这里没有块，只有括号
196:02 这里没有块，只有括号 语句终止符可以位于
196:04 语句终止符可以位于 这就是他来这里的原因，所以这是我们的
196:06 这就是他来这里的原因，所以这是我们的 现在如果我们编写代码
196:09 现在如果我们编写代码 打印从一到五的数字
196:11 打印从一到五的数字 为了完成它，将变量放在顶部
196:13 为了完成它，将变量放在顶部 我们将定义 i = 5，然后写入
196:16 我们将定义 i = 5，然后写入 你必须在 do do 中告诉你的工作，你的工作是什么
196:19 你必须在 do do 中告诉你的工作，你的工作是什么 将 i 的值打印为该变量
196:21 将 i 的值打印为该变量 您将在打印中写入值
196:23 您将在打印中写入值 语句打印 f 百分比 d b n i 和
196:30 语句打印 f 百分比 d b n i 和 现在我必须告诉你条件，条件是这样的，直到
196:33 现在我必须告诉你条件，条件是这样的，直到 我们的 i 的值不再等于 5
196:36 我们的 i 的值不再等于 5 到那时，这项工作必须完成，在中间
196:39 到那时，这项工作必须完成，在中间 我们将设置更新条件，即 i + p
196:42 我们将设置更新条件，即 i + p 所以我们写成 i = 1 到 2 3 4
196:46 所以我们写成 i = 1 到 2 3 4 5 要打印这五个数字
196:49 5 要打印这五个数字 让我们运行一次此代码
196:51 让我们运行一次此代码 首先写“do do”它会做什么
196:54 首先写“do do”它会做什么 现在我们有工作要做
196:56 现在我们有工作要做 变量应该已经存在，因此请初始化它
196:58 变量应该已经存在，因此请初始化它 让我们一起保护森林
197:00 让我们一起保护森林 打印变量然后打印
197:02 打印变量然后打印 为了完成它，我会写百分比 d n i
197:07 为了完成它，我会写百分比 d n i 然后我会再次用卑鄙的方式写下我的卑鄙
197:10 然后我会再次用卑鄙的方式写下我的卑鄙 我们会写条件，我们的条件是什么
197:12 我们会写条件，我们的条件是什么 除非 i 的值不等于 5
197:15 除非 i 的值不等于 5 然后是我们的语句终止符
197:18 然后是我们的语句终止符 到那时我们将继续印刷 i 和每一个
197:20 到那时我们将继续印刷 i 和每一个 次我会做加加，因为我 +
197:23 次我会做加加，因为我 + 如果它没有得到加分，那么这对我们又有什么意义呢
197:25 如果它没有得到加分，那么这对我们又有什么意义呢 将会演变成内讧
197:32 那么 i 的值将始终小于 f 因此，每次条件成立时，循环就会运行
197:34 因此，每次条件成立时，循环就会运行 每次条件成立时循环就会运行
197:36 每次条件成立时循环就会运行 内讧
197:45 我去运行它并得到了输出 1 2 3 4 5 从 f 到此处打印
197:48 1 2 3 4 5 从 f 到此处打印 如果我必须实现价值观那么我会怎么做？
197:50 如果我必须实现价值观那么我会怎么做？ 我在 Fav i 的帮助下开始在这里写作
197:53 我在 Fav i 的帮助下开始在这里写作 我的减法终止语句变成
197:56 我的减法终止语句变成 i 只要大于等于 1 就这样做
197:59 i 只要大于等于 1 就这样做 我们保存并运行，现在它被打印出来了
198:02 我们保存并运行，现在它被打印出来了 54321 然后以这种方式递增
198:04 54321 然后以这种方式递增 我可以从哪里获得减量？
198:06 我可以从哪里获得减量？ 我们可以理解我们要去哪里的代码
198:08 我们可以理解我们要去哪里的代码 这就是我们的“为什么循环”问题。
198:10 这就是我们的“为什么循环”问题。 说打印前 n 个自然数的和
198:13 说打印前 n 个自然数的和 数字，所以首先这是第一部分
198:15 数字，所以首先这是第一部分 之后我们会做，你会看第二部分
198:17 之后我们会做，你会看第二部分 然后我们必须计算前 n 个自然数
198:20 然后我们必须计算前 n 个自然数 用户必须像每次一样打印总数
198:23 用户必须像每次一样打印总数 这将给我们 n 然后我们将打印它们的总和
198:25 这将给我们 n 然后我们将打印它们的总和 假设用户给出 n = 4，那么
198:28 假设用户给出 n = 4，那么 无论数字从一到四，
198:33 无论数字从一到四， 我们必须打印所有这些的总和，这将完成
198:35 我们必须打印所有这些的总和，这将完成 如果用户给出 5 分，我们就有 10 分。
198:39 如果用户给出 5 分，我们就有 10 分。 我们知道从一到五的所有数字。
198:42 我们知道从一到五的所有数字。 如果给出 3，则必须打印总和
198:45 如果给出 3，则必须打印总和 所以 1 + 2 + 3 = 6 那么怎么做呢
198:49 所以 1 + 2 + 3 = 6 那么怎么做呢 首先要知道
198:51 首先要知道 最基本的是，用户可以扫描
198:54 最基本的是，用户可以扫描 接受输入 n，然后一旦 n
198:57 接受输入 n，然后一旦 n 输入完成后，我们必须运行
198:59 输入完成后，我们必须运行 for 循环假设我们运行
199:02 for 循环假设我们运行 其中 aa 的值以 1 开头
199:05 其中 aa 的值以 1 开头 并上升到我们的四个或最多 n 个
199:09 并上升到我们的四个或最多 n 个 为此我们现在将做更多工作
199:12 为此我们现在将做更多工作 我们要做的就是在循环中编写工作
199:14 我们要做的就是在循环中编写工作 我们的工作是计算总和，所以
199:17 我们的工作是计算总和，所以 我们将创建一个名为 sum 的变量，以及这个 sum 的值
199:19 我们将创建一个名为 sum 的变量，以及这个 sum 的值 将从哭声开始，即
199:22 将从哭声开始，即 一开始是我们的行，之后是
199:24 一开始是我们的行，之后是 如果我们继续添加 i 的值，那么 i
199:28 如果我们继续添加 i 的值，那么 i = 1 则在和 i = 2 内加一
199:31 = 1 则在和 i = 2 内加一 然后将 2 添加到和中，如果 i = 3，则
199:34 然后将 2 添加到和中，如果 i = 3，则 如果总数中加了 3，那么这样做
199:37 如果总数中加了 3，那么这样做 我们拥有一切
199:39 我们拥有一切 这些值的总和将像 i 的值
199:41 这些值的总和将像 i 的值 一开始，偶数的值是 1
199:44 一开始，偶数的值是 1 进入循环后会发生什么
199:47 进入循环后会发生什么 sam 的值将变成 sam + aa，即
199:52 sam 的值将变成 sam + aa，即 那么 i 的值就会更新为
199:55 那么 i 的值就会更新为 为了总结我们现在使用的一个循环
199:59 为了总结我们现在使用的一个循环 sum i 等于 sum + i 时会发生什么
200:02 sum i 等于 sum + i 时会发生什么 这意味着 1 + 2 即 3 现在 i 的值变成
200:07 这意味着 1 + 2 即 3 现在 i 的值变成 sum 的值将成为 through 循环的值
200:10 sum 的值将成为 through 循环的值 sum = sum + i = 1 + 2 + 内部会发生什么
200:15 sum = sum + i = 1 + 2 + 内部会发生什么 3 = 6
200:17 3 = 6 所以我们的流程将是这样的
200:19 所以我们的流程将是这样的 一旦你写好了代码，那么
200:21 一旦你写好了代码，那么 我们将再次讨论一开始该做什么
200:23 我们将再次讨论一开始该做什么 首先会要求用户输入一个号码
200:25 首先会要求用户输入一个号码 然后输入数字成为变量
200:29 然后输入数字成为变量 让我们在 int n n 内完成这个
200:32 让我们在 int n n 内完成这个 如果百分比 d 和 n 为
200:35 如果百分比 d 和 n 为 之后，让我们创建另一个名为 sum key 的变量
200:38 之后，让我们创建另一个名为 sum key 的变量 我们将用零初始化该值，
200:40 我们将用零初始化该值， 让我们创建一个 for 循环并将其写入 for
200:42 让我们创建一个 for 循环并将其写入 for 在 i = 0 或 i = 1 中，直到我们的 le 方程
200:47 在 i = 0 或 i = 1 中，直到我们的 le 方程 n 不再是 i + p 和此循环内的和
200:51 n 不再是 i + p 和此循环内的和 我会得到 sum + i 的和，或者我们会得到它
200:55 我会得到 sum + i 的和，或者我们会得到它 我们可以写 sam + i 吗？最后是什么
200:59 我们可以写 sam + i 吗？最后是什么 我会按你的尺寸打印
201:01 我会按你的尺寸打印 这个总和的值是百分比 d，这是
201:06 这个总和的值是百分比 d，这是 让我们保存并在这里运行它
201:09 让我们保存并在这里运行它 我们将打印 sum 的值而不是 aa
201:11 我们将打印 sum 的值而不是 aa 如果你要完成它，请在最后按 Enter
201:14 如果你要完成它，请在最后按 Enter 我们输入三号所以我们的
201:16 我们输入三号所以我们的 如果我们打印了传递总数，则会出现六个
201:19 如果我们打印了传递总数，则会出现六个 假设我们输入的是五，那么这次
201:21 假设我们输入的是五，那么这次 我输入了 5，结果打印出来的总数是 15
201:23 我输入了 5，结果打印出来的总数是 15 那么最好的流程是什么
201:26 那么最好的流程是什么 首先输入 n，然后输入总和
201:28 首先输入 n，然后输入总和 我们创建了一个变量，其值
201:30 我们创建了一个变量，其值 Inish 和 Ro 结束后，我们
201:33 Inish 和 Ro 结束后，我们 每次我们运行从 1 到 n 的循环
201:36 每次我们运行从 1 到 n 的循环 用于执行该 aa 到项目事项的循环
201:38 用于执行该 aa 到项目事项的循环 我们以前都是打印出来的，但这次我们
201:41 我们以前都是打印出来的，但这次我们 除了项目事项之外，还做了一些其他工作，即我自己的工作
201:43 除了项目事项之外，还做了一些其他工作，即我自己的工作 如何计算总和
201:46 如何计算总和 Sum = Sum + i，即每次 Sum 中添加 i
201:49 Sum = Sum + i，即每次 Sum 中添加 i 当我不断添加时，所有的 i 都总结起来了
201:52 当我不断添加时，所有的 i 都总结起来了 然后打印了我的最终金额
201:54 然后打印了我的最终金额 如果
201:58 如果 我是 1，偶数是行，那么第一个偶数 = 偶数 +
202:01 我是 1，偶数是行，那么第一个偶数 = 偶数 + 我们的总数从我变成了 1，然后我是 2，所以总数
202:05 我们的总数从我变成了 1，然后我是 2，所以总数 进入循环后就会变得均匀
202:07 进入循环后就会变得均匀 值变成了三，然后我增加了
202:09 值变成了三，然后我增加了 现在总数已经是三了
202:12 现在总数已经是三了 如果将三加到和中，那么和就是
202:14 如果将三加到和中，那么和就是 如果最终答案是 6，那么答案就是
202:17 如果最终答案是 6，那么答案就是 我们的 n = 3 现在这个问题的第二部分是
202:22 我们的 n = 3 现在这个问题的第二部分是 它还说以相反的方式打印它们，即
202:25 它还说以相反的方式打印它们，即 我们有从 1 到 n 的数字
202:28 我们有从 1 到 n 的数字 我们总结的数字
202:30 我们总结的数字 反向打印
202:32 反向打印 另一部分关于如何打印
202:34 另一部分关于如何打印 让我们创建一个循环。假设我们有
202:37 让我们创建一个循环。假设我们有 现在对于 int i = n i 时
202:43 现在对于 int i = n i 时 直到我们的大于等于 1 不再存在
202:46 直到我们的大于等于 1 不再存在 i - 减去每次我们都会打印 f
202:50 i - 减去每次我们都会打印 f 百分比 d n 你的 i 现在第一个注释
202:55 百分比 d n 你的 i 现在第一个注释 我们要做的是使用我们的 i
202:58 我们要做的是使用我们的 i 这里也声明了 int i = 1
203:00 这里也声明了 int i = 1 这里还声明 int i = 1
203:02 这里还声明 int i = 1 编译器会报两次错误吗？
203:05 编译器会报两次错误吗？ 你声明了相同的变量
203:06 你声明了相同的变量 我们已经知道这是错误的，所以在这里
203:08 我们已经知道这是错误的，所以在这里 但不会出现错误，因为在 for 循环中
203:11 但不会出现错误，因为在 for 循环中 我们在这里声明的任何变量
203:13 我们在这里声明的任何变量 无论它在 for 循环中的值是什么
203:17 无论它在 for 循环中的值是什么 它只持续到这意味着你一看到
203:19 它只持续到这意味着你一看到 不是一开始我就把
203:21 不是一开始我就把 我尝试在 Pay I 上打印它，但是
203:23 我尝试在 Pay I 上打印它，但是 我的 i 的值仅在此块内
203:25 我的 i 的值仅在此块内 我会用我的A走出这个困境
203:27 我会用我的A走出这个困境 如果不能，那么编译器就会删除这个块
203:30 如果不能，那么编译器就会删除这个块 我不知道发生了什么，所以我来这里
203:32 我不知道发生了什么，所以我来这里 我不能只在这里使用
203:34 我不能只在这里使用 只能使用偶数，因此 i 的数量
203:37 只能使用偶数，因此 i 的数量 生命就此结束
203:39 生命就此结束 所以编译器甚至不知道
203:41 所以编译器甚至不知道 那么这是什么？因此我们要再次引入一个新变量。
203:43 那么这是什么？因此我们要再次引入一个新变量。 可以声明我们所做的
203:45 可以声明我们所做的 i 的值初始化为
203:47 i 的值初始化为 和 n 即 n 将是 thi，然后 i 在开头
203:49 和 n 即 n 将是 thi，然后 i 在开头 会有三个，然后会有 n5，所以一开始会有 n5
203:53 会有三个，然后会有 n5，所以一开始会有 n5 那么我们的条件语句是这样的，直到 i >
203:56 那么我们的条件语句是这样的，直到 i > = 1 不再是 i 减 - 然后
203:58 = 1 不再是 i 减 - 然后 我们正在打印 i 所以保存它
204:00 我们正在打印 i 所以保存它 如果我们这样做并得分，那么这次
204:03 如果我们这样做并得分，那么这次 我们给出了三个，所以首先是
204:05 我们给出了三个，所以首先是 它将打印在六上，然后是三上。
204:08 它将打印在六上，然后是三上。 从一到一反向倒计时意味着反向
204:10 从一到一反向倒计时意味着反向 我们已将所有数字排序
204:12 我们已将所有数字排序 现在所有这些都将被打印出来
204:14 现在所有这些都将被打印出来 我们要做的工作是在 for 循环中完成
204:17 我们要做的工作是在 for 循环中完成 我们可以在单个 for 循环中做到这一点吗？
204:19 我们可以在单个 for 循环中做到这一点吗？ 你怎么能让它变得普遍
204:22 你怎么能让它变得普遍 怀疑，你在这里做什么另一个新的
204:25 怀疑，你在这里做什么另一个新的 让我们以这种方式创建变量 j = n
204:29 让我们以这种方式创建变量 j = n 我们可以在 for 循环中使用多个变量
204:31 我们可以在 for 循环中使用多个变量 如果 i = 1 且 j = n，则可以初始化 ei
204:36 如果 i = 1 且 j = n，则可以初始化 ei 现在这里 i < eq n 除非
204:39 现在这里 i < eq n 除非 并且我们的 j 大于等于 1
204:44 并且我们的 j 大于等于 1 只要有，并且每次都加上 i
204:47 只要有，并且每次都加上 i 然后 j 将被减去至负数，并且每个
204:50 然后 j 将被减去至负数，并且每个 我们将在打印 J 之后再次打印它
204:53 我们将在打印 J 之后再次打印它 这个里面的 for 循环已经完成，现在可以删除了。
204:56 这个里面的 for 循环已经完成，现在可以删除了。 现在让我们仔细听听，这里面是什么
204:59 现在让我们仔细听听，这里面是什么 发生的事情是我们已经有一个变量 i
205:01 发生的事情是我们已经有一个变量 i 这次其值从一开始
205:03 这次其值从一开始 我们输入一个新变量并将其命名为
205:05 我们输入一个新变量并将其命名为 给定 j 的值，我们从 n 开始
205:07 给定 j 的值，我们从 n 开始 这个 aa 的工作是计算总和
205:11 这个 aa 的工作是计算总和 j 的工作是将数字按相反的顺序排列
205:13 j 的工作是将数字按相反的顺序排列 打印出来是我的条件，每当我
205:16 打印出来是我的条件，每当我 j 没有限制，条件是 j
205:19 j 没有限制，条件是 j 逆转，直到没有更伟大的一天
205:21 逆转，直到没有更伟大的一天 如果事情继续按顺序打印，那么我们
205:23 如果事情继续按顺序打印，那么我们 知道只要我是我们的一对一
205:26 知道只要我是我们的一对一 到那时我们的 j 将从 n 变为 1
205:29 到那时我们的 j 将从 n 变为 1 所以需要同样的时间，所以我们
205:31 所以需要同样的时间，所以我们 在这里我结束了这两种情况
205:33 在这里我结束了这两种情况 中间意味着我们的两个都应该是真的
205:36 中间意味着我们的两个都应该是真的 每次我们将 i 添加到 plus 中
205:38 每次我们将 i 添加到 plus 中 因为每次我们计算总和
205:40 因为每次我们计算总和 我们也可以从负数中减去 j
205:42 我们也可以从负数中减去 j 因为我们按相反的顺序排列数字
205:44 因为我们按相反的顺序排列数字 我正在打印，现在让我们这样做
205:46 我正在打印，现在让我们这样做 现在让我们保存并运行它。
205:51 现在让我们保存并运行它。 我们将其打印为 3 2 1 并结束
205:55 我们将其打印为 3 2 1 并结束 我打印了一些是六个应该首先
205:57 我打印了一些是六个应该首先 之前被印刷为《Some is Six》
205:59 之前被印刷为《Some is Six》 这次的数字印刷得比较晚
206:01 这次的数字印刷得比较晚 首先打印这些数字是因为
206:04 首先打印这些数字是因为 直到整个计算完成，然后
206:05 直到整个计算完成，然后 正在打印，因为正在打印总数
206:07 正在打印，因为正在打印总数 打印第一个数字的语句
206:09 打印第一个数字的语句 我们可以用这笔收入做什么
206:12 我们可以用这笔收入做什么 我们也可以完全取消收入，如果我们
206:14 我们也可以完全取消收入，如果我们 如果我们消除完整性，那么会发生什么？
206:18 如果我们消除完整性，那么会发生什么？ 它的值可以从 n 到 1
206:20 它的值可以从 n 到 1 现在我们取 1 2 3 的和，还是取 3 的和
206:24 现在我们取 1 2 3 的和，还是取 3 的和 将 21 相加，两者之和最终为 6
206:27 将 21 相加，两者之和最终为 6 如果有人来找我们，那么对他们两个来说都是平等的
206:29 如果有人来找我们，那么对他们两个来说都是平等的 这些值将相等，因此我们可以从一开始循环
206:32 这些值将相等，因此我们可以从一开始循环 从 到 n 或从 n 到 v
206:34 从 到 n 或从 n 到 v 我们要走了，明白就好
206:35 我们要走了，明白就好 所以这里我们计算总和
206:38 所以这里我们计算总和 将使 sum = sum + j，因此它是 1 + 2 + 3
206:41 将使 sum = sum + j，因此它是 1 + 2 + 3 而不是这样，它会变成 3 + 2 + 1，所以
206:45 而不是这样，它会变成 3 + 2 + 1，所以 保存后
206:47 保存后 然后运行这个
206:48 然后运行这个 那么我们将得到相同的输出
206:52 那么我们将得到相同的输出 3比1，总和我们将得到正确的计算
206:54 3比1，总和我们将得到正确的计算 那是六个，所以这就是我们的
206:57 那是六个，所以这就是我们的 循环的工作原理以及我们可以用它做的不同的事情
207:00 循环的工作原理以及我们可以用它做的不同的事情 现在你可以进去了如果你有任何问题
207:02 现在你可以进去了如果你有任何问题 说到它，下一个问题是打印
207:05 说到它，下一个问题是打印 用户输入的数字表
207:07 用户输入的数字表 他肯定给了我们一个数字，他的桌子也肯定给了我们一个数字
207:09 他肯定给了我们一个数字，他的桌子也肯定给了我们一个数字 我想打印它，就像用户给我的一样
207:11 我想打印它，就像用户给我的一样 我们将如何打印表格
207:13 我们将如何打印表格 首先我们将打印两个，然后是四个，然后是六个
207:16 首先我们将打印两个，然后是四个，然后是六个 然后是 8 10 12 14 16 18 和 20，如果用户
207:24 然后是 8 10 12 14 16 18 和 20，如果用户 因为我们有 42 个，所以我们必须打印 42 个的表格
207:27 因为我们有 42 个，所以我们必须打印 42 个的表格 显然我必须尽快完成
207:29 显然我必须尽快完成 如果我做不到，那么我们迄今为止做了什么
207:31 如果我做不到，那么我们迄今为止做了什么 我们写了一个 for 循环，其中
207:33 我们写了一个 for 循环，其中 我已经说明了我的条件 i = 1 i < = n i +
207:38 我已经说明了我的条件 i = 1 i < = n i + 我们在里面对我们的眼睛做了什么
207:41 我们在里面对我们的眼睛做了什么 我以前用 print i 来打印，但是这个
207:43 我以前用 print i 来打印，但是这个 这次我们不会打印 aa
207:45 这次我们不会打印 aa 他肯定在履行其他一些职责，
207:48 他肯定在履行其他一些职责， 2 ko hum 2 malla ba 的功能是什么样的
207:51 2 ko hum 2 malla ba 的功能是什么样的 也可以写1 也可以写4 可以写成2
207:53 也可以写1 也可以写4 可以写成2 malla ba 2 6 我们可以写成 2 m ba 3
207:56 malla ba 2 6 我们可以写成 2 m ba 3 因为这一切对于
207:58 因为这一切对于 这是一张表格，现在让我们看看这里
208:00 这是一张表格，现在让我们看看这里 它是两个，它保持不变，但是这
208:04 它是两个，它保持不变，但是这 这是我们的变量，它正在增加
208:06 这是我们的变量，它正在增加 首先有一个，然后有两个，然后是 3、4、5，接下来
208:09 首先有一个，然后有两个，然后是 3、4、5，接下来 6 7 8 9 10 所以这个值增加
208:12 6 7 8 9 10 所以这个值增加 如果她要去，那么显然这个号码是我们的
208:16 如果她要去，那么显然这个号码是我们的 迭代器不会是这个数字我们的项目a
208:19 迭代器不会是这个数字我们的项目a 物品是有价值的
208:21 物品是有价值的 变化不断发生，更新不断发生
208:23 变化不断发生，更新不断发生 这个数字将是我们的项目事项，然后是这个代码
208:27 这个数字将是我们的项目事项，然后是这个代码 我该如何处理我的IT价值
208:29 我该如何处理我的IT价值 从 1 开始，一直到 10
208:32 从 1 开始，一直到 10 每次都会去把它提高到 10
208:34 每次都会去把它提高到 10 我们将打印您的号码
208:37 我们将打印您的号码 这很重要，所以首先将数字乘以 2*1
208:40 这很重要，所以首先将数字乘以 2*1 它将被打印出来然后乘以 2 * 2
208:42 它将被打印出来然后乘以 2 * 2 它将被打印然后乘以 2*3
208:44 它将被打印然后乘以 2*3 它将打印出来，这样你
208:46 它将打印出来，这样你 我们将打印完整的数字表
208:48 我们将打印完整的数字表 我们先来写一下代码
208:51 我们先来写一下代码 我们将输入我们的号码，我们已经输入了
208:53 我们将输入我们的号码，我们已经输入了 之后我们写一个循环
208:57 之后我们写一个循环 int i = 1 aa 直到我们的课程等于 10
209:02 int i = 1 aa 直到我们的课程等于 10 i + 10 没有保留，因为我们试图使表格成为一
209:05 i + 10 没有保留，因为我们试图使表格成为一 每次只能到 10
209:07 每次只能到 10 我们将打印百分比 d b n
209:12 我们将打印百分比 d b n n * aa 数字 * aa 让我们保存它并运行
209:18 n * aa 数字 * aa 让我们保存它并运行 首先，如果我们输入数字 2，那么它将是两个键
209:21 首先，如果我们输入数字 2，那么它将是两个键 整个表格将被打印。
209:24 整个表格将被打印。 现在我无法完成的工作可以通过电脑完成
209:28 现在我无法完成的工作可以通过电脑完成 他会为我们做这件事，即 42 号桌
209:30 他会为我们做这件事，即 42 号桌 如果你打印出来给我，这就是全部的42
209:33 如果你打印出来给我，这就是全部的42 完整的表格已打印出来并寄给我们。
209:35 完整的表格已打印出来并寄给我们。 那么很快这样如果
209:38 那么很快这样如果 从我们这里打印任意数量的表格
209:40 从我们这里打印任意数量的表格 如果有的话，我们可以借助 C 将其打印出来
209:42 如果有的话，我们可以借助 C 将其打印出来 随时在屏幕上方
209:44 随时在屏幕上方 数学计算正在进行，计算器
209:47 数学计算正在进行，计算器 你不在身边，无法动脑
210:18 我以前常带他出去，就是那个曾经走遍整个街区的人 他会让我们离开
210:20 他会让我们离开 正是因为所有案件都是
210:23 正是因为所有案件都是 这就是为什么他们的条件无法开启
210:26 这就是为什么他们的条件无法开启 break 语句意味着无论我们
210:28 break 语句意味着无论我们 我已经写了，它的主要意思是我们必须退出
210:31 我已经写了，它的主要意思是我们必须退出 现在我们必须从我们想要开始循环的地方开始循环
210:33 现在我们必须从我们想要开始循环的地方开始循环 如果你想出去，我们在那里写休息
210:36 如果你想出去，我们在那里写休息 例如如果我们编写了一个代码
210:38 例如如果我们编写了一个代码 里面有一个 for 循环，我们正在写一个
210:41 里面有一个 for 循环，我们正在写一个 打印出从一到五的数字
210:42 打印出从一到五的数字 对于 int i = 1 i 小于 5 a p
210:49 对于 int i = 1 i 小于 5 a p 另外现在我们可以将其打印出来
210:53 另外现在我们可以将其打印出来 将给予百分比 DBSA
210:59 将给予百分比 DBSA 现在如果我们把条件写在中间
211:03 现在如果我们把条件写在中间 如果 aa 等于 i 等于 3，则意味着像 aa
211:08 如果 aa 等于 i 等于 3，则意味着像 aa 这是 if 条件的作用，它变成了三个
211:10 这是 if 条件的作用，它变成了三个 i3 一到就检查一下
211:12 i3 一到就检查一下 所以让我们休息一下，这意味着整个
211:15 所以让我们休息一下，这意味着整个 让我们跳出这个循环
211:18 让我们跳出这个循环 最后，让我们把它打印出来并这样做
211:21 最后，让我们把它打印出来并这样做 让我们保存它并运行一次并查看输出
211:23 让我们保存它并运行一次并查看输出 让我们分析一下我们打印的
211:26 让我们分析一下我们打印的 2 和结束这是如何打印出来的首先我键
211:30 2 和结束这是如何打印出来的首先我键 我们的价值是 1，当我
211:33 我们的价值是 1，当我 这个值是我们进入循环获取的
211:35 这个值是我们进入循环获取的 值是三 不不不 不是三
211:37 值是三 不不不 不是三 如果它存在那么它就不是真的，我们把它打印出来了
211:39 如果它存在那么它就不是真的，我们把它打印出来了 给定一个 i，更新的是 i 的值
211:42 给定一个 i，更新的是 i 的值 如果 i2 发生，则此条件将再次为假
211:45 如果 i2 发生，则此条件将再次为假 所以我把它打印在这里然后我
211:48 所以我把它打印在这里然后我 一旦 i 的值就会更新为三
211:51 一旦 i 的值就会更新为三 的值为三，这是 if 条件
211:53 的值为三，这是 if 条件 是的，然后我们就休息了
211:56 是的，然后我们就休息了 break 起什么作用？退出循环
211:58 break 起什么作用？退出循环 所以我们完全脱离了这个for循环
212:01 所以我们完全脱离了这个for循环 出去来到这里我们打印了
212:02 出去来到这里我们打印了 完成了，这意味着剩下的条件
212:05 完成了，这意味着剩下的条件 或者我们当时所做的任何其他更新
212:08 或者我们当时所做的任何其他更新 没有看到这个语句条件
212:10 没有看到这个语句条件 我们没有看到终止，我们看到的是更新
212:12 我们没有看到终止，我们看到的是更新 由于失明，我们什么也没看见
212:15 由于失明，我们什么也没看见 完全脱离了循环，然后
212:17 完全脱离了循环，然后 无论外面写了什么，然后执行它
212:19 无论外面写了什么，然后执行它 如果你这样做，那么当你
212:22 如果你这样做，那么当你 到你的 for 循环或 do 循环执行 while 循环
212:25 到你的 for 循环或 do 循环执行 while 循环 或者每当 Y 环正好位于中心时
212:27 或者每当 Y 环正好位于中心时 我必须切断它，我必须摆脱它
212:29 我必须切断它，我必须摆脱它 当它完成时，我们在那里写下 break。
212:32 当它完成时，我们在那里写下 break。 所以我们将彻底摆脱它
212:33 所以我们将彻底摆脱它 你将退出，所以问一个问题
212:35 你将退出，所以问一个问题 问题的名称是继续占据数字优势
212:38 问题的名称是继续占据数字优势 那么用户输入的是奇数
212:41 那么用户输入的是奇数 我们需要用户做什么？
212:43 我们需要用户做什么？ 我们必须不断输入一些数字
212:45 我们必须不断输入一些数字 就像用户输入 2 4 10 16 18 和
212:51 就像用户输入 2 4 10 16 18 和 继续从用户那里获取数字输入，直到
212:53 继续从用户那里获取数字输入，直到 直到用户输入一个奇数，即
212:56 直到用户输入一个奇数，即 如果他进入七，我们就在这里
212:59 如果他进入七，我们就在这里 你会停下来还是刹车
213:03 你会停下来还是刹车 所以到那时我们必须接受用户输入的数字
213:05 所以到那时我们必须接受用户输入的数字 除非他现在输入奇数
213:09 除非他现在输入奇数 为此，每当我们从用户那里获取一些输入时
213:11 为此，每当我们从用户那里获取一些输入时 它会发生，但必须满足一个条件
213:13 它会发生，但必须满足一个条件 我们总是更喜欢循环
213:15 我们总是更喜欢循环 为什么 wa 循环，因为现在我们的任务是
213:18 为什么 wa 循环，因为现在我们的任务是 最重要的是获取用户的输入
213:21 最重要的是获取用户的输入 只要我们接受一次输入，我们就可以做任何事
213:23 只要我们接受一次输入，我们就可以做任何事 您可以通过应用条件来检查，所以首先
213:25 您可以通过应用条件来检查，所以首先 完成工作然后设置条件，这就是为什么这里
213:27 完成工作然后设置条件，这就是为什么这里 但 Per Du Vile 的逻辑构建略显低沉
213:29 但 Per Du Vile 的逻辑构建略显低沉 尝试做剩下的
213:32 尝试做剩下的 您可以在循环内解决同样的问题
213:34 您可以在循环内解决同样的问题 我们要做的第一件事就是做一个
213:36 我们要做的第一件事就是做一个 如果我们创建一个循环，那么我们将编写 do，然后稍后
213:40 如果我们创建一个循环，那么我们将编写 do，然后稍后 现在在这个 do while 循环中我们必须完成工作
213:43 现在在这个 do while 循环中我们必须完成工作 我必须工作一次，该怎么办
213:45 我必须工作一次，该怎么办 要重复输入，有一个
213:48 要重复输入，有一个 让我们定义一个变量 int n
213:50 让我们定义一个变量 int n 我们的数字，每次在你的 do 循环中
213:53 我们的数字，每次在你的 do 循环中 我们从 do 循环中的 scanf 中获取数字
213:55 我们从 do 循环中的 scanf 中获取数字 将输入百分比 d 逗号和 n 然后这个
214:01 将输入百分比 d 逗号和 n 然后这个 每次输入数字时的方法
214:03 每次输入数字时的方法 为了好玩，我们也可以输出这个数字。
214:06 为了好玩，我们也可以输出这个数字。 让我们给你我们所拥有的百分比 D
214:09 让我们给你我们所拥有的百分比 D 号码已到，我们应该保留什么条件
214:14 号码已到，我们应该保留什么条件 在这种情况下有一个条件，我们可以保留这个
214:17 在这种情况下有一个条件，我们可以保留这个 一旦我们的 n 是我们的 n
214:19 一旦我们的 n 是我们的 n 一旦情况变得异常，我们就会出去。
214:22 一旦情况变得异常，我们就会出去。 在这种情况下，我们只需写
214:24 在这种情况下，我们只需写 在条件 'are one' 中写 one 是什么意思
214:26 在条件 'are one' 中写 one 是什么意思 我们每次写的都是真实的情况
214:28 我们每次写的都是真实的情况 无论数字是多少，这都是正确的
214:30 无论数字是多少，这都是正确的 始终将 true 放在你的条件中
214:33 始终将 true 放在你的条件中 这是我们目前为止所做的循环
214:36 这是我们目前为止所做的循环 y 循环内讧
214:42 直到我们的条件变为假 条件永远不会为假，因为
214:44 条件永远不会为假，因为 我们在那里种了一片森林
214:46 我们在那里种了一片森林 但有一种方法可以摆脱它
214:48 但有一种方法可以摆脱它 我们应该分解，我们该怎么做
214:51 我们应该分解，我们该怎么做 当我们的情况出现时，我们就会崩溃，也就是说
214:53 当我们的情况出现时，我们就会崩溃，也就是说 一旦用户输入 n
214:56 一旦用户输入 n 是奇数 如何检查 n 是否是奇数
214:59 是奇数 如何检查 n 是否是奇数 百分比模 2 = = 0 将到达这里
215:03 百分比模 2 = = 0 将到达这里 不等于 0，在这种情况下我们会这样做
215:06 不等于 0，在这种情况下我们会这样做
Chrome Extension