1
00:00:00,000 --> 00:00:07,170

2
00:00:07,170 --> 00:00:09,100
>> LUCAS FREITAS：好吧，我猜
現在我們的現場。

3
00:00:09,100 --> 00:00:11,220
歡迎來到CS50 Supersection。

4
00:00:11,220 --> 00:00:12,880
我們是不太舒服。

5
00:00:12,880 --> 00:00:13,870
我的名字是盧卡斯塔斯。

6
00:00:13,870 --> 00:00:16,230
我算是CS50頭轉錄因子。

7
00:00:16,230 --> 00:00:17,523
這是勞倫。

8
00:00:17,523 --> 00:00:19,002
>> LAUREN卡瓦略：嗨，我是勞倫。

9
00:00:19,002 --> 00:00:21,330
我也頭TF的CS50。

10
00:00:21,330 --> 00:00:24,730
>> LUCAS FREITAS：今天我們只是
讓公眾知道你的概述

11
00:00:24,730 --> 00:00:28,440
傢伙已經學會了在一個星期內，有希望
給你們一個好

12
00:00:28,440 --> 00:00:32,580
意義是什麼你應該知道
對於問題集之一。

13
00:00:32,580 --> 00:00:34,120
>> 只是一對夫婦的公告。

14
00:00:34,120 --> 00:00:36,490
首先，辦公時間。

15
00:00:36,490 --> 00:00:41,580
辦公時間是從週一發生
週四在不同的房子

16
00:00:41,580 --> 00:00:43,450
嫩伯格的每一天。

17
00:00:43,450 --> 00:00:46,680
他們是為你一個非常好的資源
人來問問題，

18
00:00:46,680 --> 00:00:49,470
聊到TFS，甚至交換
想法與其他同學。

19
00:00:49,470 --> 00:00:55,420
所以一定要使用該資源
對你有利。

20
00:00:55,420 --> 00:00:59,790
>> 第二件事是
CS50電器。

21
00:00:59,790 --> 00:01:01,390
在過去的[聽不清]

22
00:01:01,390 --> 00:01:04,180
你們沒有真正
有一個設備。

23
00:01:04,180 --> 00:01:06,910
你只是在做的一切
你的個人電腦。

24
00:01:06,910 --> 00:01:10,330
但對於這個問題，你實際上有
有一個虛擬機，因此

25
00:01:10,330 --> 00:01:14,680
一定要下載CS50
電器和設置它。

26
00:01:14,680 --> 00:01:18,670
>> 而第三件事是一定要
啟動設置問題盡快公正

27
00:01:18,670 --> 00:01:22,740
因為它更容易找到
幫助時，你在

28
00:01:22,740 --> 00:01:23,730
開始的一周。

29
00:01:23,730 --> 00:01:27,540
因為人們往往要等到
最後一秒啟動問題集，

30
00:01:27,540 --> 00:01:29,730
然後你去辦公時間，
而且也有很多人。

31
00:01:29,730 --> 00:01:33,020
在那裡，如果你去週一，你會
一看就知道你可以傾訴的轉錄因子

32
00:01:33,020 --> 00:01:35,870
幾乎整個晚上，
他們打算超過

33
00:01:35,870 --> 00:01:37,790
竭誠為您服務。

34
00:01:37,790 --> 00:01:40,720
>> LAUREN卡瓦略：我可以只是停止
您只需一秒？

35
00:01:40,720 --> 00:01:43,330
人人都能夠下載
在CS50電器？

36
00:01:43,330 --> 00:01:44,255
人們已經嘗試過？

37
00:01:44,255 --> 00:01:47,120
>> LUCAS FREITAS：要下載，由
這樣，就可以在得到指令

38
00:01:47,120 --> 00:01:48,045
cs50.net/appliance。

39
00:01:48,045 --> 00:01:48,817
>> LAUREN卡瓦略：對。

40
00:01:48,817 --> 00:01:53,120
而它確實需要一些時間，我們的
系統管理員以獲得您的許可

41
00:01:53,120 --> 00:01:55,450
鍵，所以報名參加
免費試用第一。

42
00:01:55,450 --> 00:01:59,080
這樣，你將擁有它30天，
然後等待您的許可證密鑰

43
00:01:59,080 --> 00:02:02,650
這應該給它
你一年。

44
00:02:02,650 --> 00:02:04,100
>> LUCAS FREITAS：首先，
讓我們來談談一點點

45
00:02:04,100 --> 00:02:06,180
關於CS50電器。

46
00:02:06,180 --> 00:02:10,770
該CS50設備實際上是一個虛擬的
機器，你要

47
00:02:10,770 --> 00:02:15,040
在你自己的電腦是運行
基本上運行另一台電腦

48
00:02:15,040 --> 00:02:16,010
在你自己的電腦。

49
00:02:16,010 --> 00:02:16,800
這是很酷。

50
00:02:16,800 --> 00:02:19,420
而實際上它的使用無處不在。

51
00:02:19,420 --> 00:02:23,150
人誰到高科技的都知道
這是所使用的所有的時間。

52
00:02:23,150 --> 00:02:23,250
你呢？

53
00:02:23,250 --> 00:02:26,200
可以有多個電腦
在一個設備中。

54
00:02:26,200 --> 00:02:27,760
>> 讓我們來實際看看
在電器。

55
00:02:27,760 --> 00:02:32,680

56
00:02:32,680 --> 00:02:36,640
當你以後去的電器
註冊後，你將不得不

57
00:02:36,640 --> 00:02:42,035
把你的名字和登錄哈佛
所以我們可以讓你所有註冊。

58
00:02:42,035 --> 00:02:46,570
你會看到基本上是一個
壁紙，然後家庭和垃圾桶，

59
00:02:46,570 --> 00:02:48,980
然後這些小圖標。

60
00:02:48,980 --> 00:02:51,930
這三個圖標實際上是最
您可以在重要的事情

61
00:02:51,930 --> 00:02:53,000
您的設備。

62
00:02:53,000 --> 00:03:00,270
>> 第一個是gedit的，這是一個文本
編輯器，就像記事本或類似

63
00:03:00,270 --> 00:03:01,440
任何類型的文本編輯器。

64
00:03:01,440 --> 00:03:09,750
這是我們用它來寫東西只是
代碼，然後做的東西吧。

65
00:03:09,750 --> 00:03:11,770
>> 第二件事，我們
這裡是Chrome瀏覽器。

66
00:03:11,770 --> 00:03:13,910
所以，如果你需要使用互聯網
在家電，這是

67
00:03:13,910 --> 00:03:15,030
你可以使用的東西。

68
00:03:15,030 --> 00:03:22,000
>> 而第三件事是終端，
這其實是很甜蜜的。

69
00:03:22,000 --> 00:03:26,420
這類人通常都害怕
終端，因為它是這個非常

70
00:03:26,420 --> 00:03:32,320
在老式的應用程序，您
只是基本型與一切

71
00:03:32,320 --> 00:03:32,940
您的鍵盤。

72
00:03:32,940 --> 00:03:34,730
有沒有很多的互動
用你的鼠標。

73
00:03:34,730 --> 00:03:39,780
但實際上終端
確實很不錯的東西。

74
00:03:39,780 --> 00:03:43,990
>> 首先，讓我們剛剛經歷
一些命令，你

75
00:03:43,990 --> 00:03:48,765
可以在終端中使用。

76
00:03:48,765 --> 00:03:51,995
>> LAUREN卡瓦略：而且隨時停止
我們，如果您有任何問題。

77
00:03:51,995 --> 00:03:52,830
>> LUCAS FREITAS：是啊。

78
00:03:52,830 --> 00:04:01,950
因此，我們有第一個命令
對於終端是LS。

79
00:04:01,950 --> 00:04:06,450
LS的基本含義列表的一切，都是
文件及全體董事，

80
00:04:06,450 --> 00:04:09,540
那我在，我在這個地方。

81
00:04:09,540 --> 00:04:15,200
所以，如果我在這裡做的LS，我要去看看
我有一些目錄。

82
00:04:15,200 --> 00:04:18,670
我的桌面上，下載，
日誌和虛擬主機。

83
00:04:18,670 --> 00:04:21,260
這些都是藍色，因為他們
是所有的目錄。

84
00:04:21,260 --> 00:04:24,160
>> 那麼你有一些其他文件。

85
00:04:24,160 --> 00:04:27,840
你有像打招呼，hello.c中，這
只是文件，而他們在

86
00:04:27,840 --> 00:04:28,910
不同的顏色。

87
00:04:28,910 --> 00:04:33,960
所以這是一個非常重要的命令只是
你可以看到哪些文件

88
00:04:33,960 --> 00:04:37,690
並且您有目錄
在該目錄中

89
00:04:37,690 --> 00:04:39,410
你在終端正處於。

90
00:04:39,410 --> 00:04:44,580
當你看到jharvard @家電和
接著小符號那裡，

91
00:04:44,580 --> 00:04:49,185
波浪，那只是意味著這就是
你是在目前的目錄。

92
00:04:49,185 --> 00:04:52,970
>> LAUREN卡瓦略：所以輸入ls幾乎是
如單擊該文件夾

93
00:04:52,970 --> 00:04:57,380
列出在那裡，在它表演
你們凡內容

94
00:04:57,380 --> 00:04:58,886
在該文件夾。

95
00:04:58,886 --> 00:05:04,232
>> 觀眾：是否有文字
在hello.c中呢？

96
00:05:04,232 --> 00:05:10,070
>> LAUREN卡瓦略：哦，你不能
看到，因為它是藍色的。

97
00:05:10,070 --> 00:05:12,490
>> LUCAS FREITAS：它說
日誌和虛擬主機。

98
00:05:12,490 --> 00:05:14,450
>> LAUREN卡瓦略：這些都是
只是其他文件夾。

99
00:05:14,450 --> 00:05:16,890
我很抱歉，這真的很難看到的。

100
00:05:16,890 --> 00:05:19,090
也許如果我們關掉燈？

101
00:05:19,090 --> 00:05:23,002
科爾頓，你想嘗試和
找到燈的開關？

102
00:05:23,002 --> 00:05:24,960
我們對此深感抱歉。

103
00:05:24,960 --> 00:05:25,675
我沒有去想它。

104
00:05:25,675 --> 00:05:27,340
>> LUCAS FREITAS：但它基本上是 - 

105
00:05:27,340 --> 00:05:30,310
是啊，如果你能 - 

106
00:05:30,310 --> 00:05:32,278
>> LAUREN卡瓦略：放大屏幕。

107
00:05:32,278 --> 00:05:34,738
>> LUCAS FREITAS：我不知道
具有該功能。

108
00:05:34,738 --> 00:05:35,988
>> LAUREN卡瓦略：[聽不清]。

109
00:05:35,988 --> 00:05:39,528

110
00:05:39,528 --> 00:05:40,001
確定。

111
00:05:40,001 --> 00:05:44,270
嗯，有只是很多自然
光在這個房間也是如此。

112
00:05:44,270 --> 00:05:48,726
>> LUCAS FREITAS：讓我們姑且認為
還有另外兩個沒有目錄。

113
00:05:48,726 --> 00:05:49,780
>> LAUREN卡瓦略：剛才我們一起承擔。

114
00:05:49,780 --> 00:05:54,200
這是唯一的一部分，你會
要著眼於終端。

115
00:05:54,200 --> 00:06:00,160
>> LUCAS FREITAS：下一個命令
基本上，也許你想組織

116
00:06:00,160 --> 00:06:01,080
你的文件 - 

117
00:06:01,080 --> 00:06:05,015
例如，所有的在一個C文件
目錄，但是你沒有一個

118
00:06:05,015 --> 00:06:07,180
只是對於C目錄​​中的文件呢。

119
00:06:07,180 --> 00:06:11,590
你基本上可以創建一個目錄
使用終端以及，這是

120
00:06:11,590 --> 00:06:15,670
同樣的事情，右擊
並說新文件夾。

121
00:06:15,670 --> 00:06:20,640
該命令創建目錄，其中
是MKDIR，所以基本上“製造”和

122
00:06:20,640 --> 00:06:21,260
“目錄”。

123
00:06:21,260 --> 00:06:22,680
>> 然後你可以把
該目錄的名稱。

124
00:06:22,680 --> 00:06:32,490
比方說，我想叫，
我不知道，讓我們說做PSET1

125
00:06:32,490 --> 00:06:33,900
這一點，我剛剛創建的目錄。

126
00:06:33,900 --> 00:06:35,910
讓我們只檢查它的存在。

127
00:06:35,910 --> 00:06:40,870
所以，如果我做的LS，現在我看日誌，
然後PSET1，然後虛擬主機。

128
00:06:40,870 --> 00:06:44,360
所以，我有沒有新的目錄。

129
00:06:44,360 --> 00:06:46,670
>> 然後經過你有一個新的目錄，
也許你想瀏覽

130
00:06:46,670 --> 00:06:51,760
進去，所以下一個命令這張CD，
這只是基本上意味著去

131
00:06:51,760 --> 00:06:53,400
特定的目錄。

132
00:06:53,400 --> 00:06:58,377
所以，如果我想去PSET1，
我可以做CD PSET1。

133
00:06:58,377 --> 00:07:01,550
>> LAUREN卡瓦略：CD代表變更
目錄[聽不清]能

134
00:07:01,550 --> 00:07:02,230
記住這一點。

135
00:07:02,230 --> 00:07:05,460
>> LUCAS FREITAS：現在你看到，
而不是僅僅有jharvard

136
00:07:05,460 --> 00:07:09,150
家電，我已經jharvard家電，
然後PSET1，因為它示出

137
00:07:09,150 --> 00:07:14,150
我在哪裡，我在這台電腦。

138
00:07:14,150 --> 00:07:17,510
>> 現在，如果我想回去
目錄是這樣的人之前，我

139
00:07:17,510 --> 00:07:22,950
可以做一個CD點點，這只是意味著去
到我之前所在的目錄，

140
00:07:22,950 --> 00:07:26,290
像這樣的父
目錄中，基本上是這樣。

141
00:07:26,290 --> 00:07:30,460
現在我看到我
回jharvard。

142
00:07:30,460 --> 00:07:36,050
>> 接下來的事情，我可以做到這一點
為rm，這是刪除一個文件。

143
00:07:36,050 --> 00:07:39,590
例如，讓我們先做LS
看看我這裡有。

144
00:07:39,590 --> 00:07:41,790
我有打招呼，hello.c中。

145
00:07:41,790 --> 00:07:43,780
比方說，我想刪除它們。

146
00:07:43,780 --> 00:07:48,280
我能做的RM打招呼。

147
00:07:48,280 --> 00:07:52,770
它會說“刪除普通文件
你好？“我說：”是的。“現在，如果我

148
00:07:52,770 --> 00:07:56,410
做LS，我看到它的
不存在了。

149
00:07:56,410 --> 00:07:59,700
>> 如果我嘗試使用rm等的目錄，
不過，它不會

150
00:07:59,700 --> 00:08:00,800
讓你做任何事情。

151
00:08:00,800 --> 00:08:02,960
它會說，哎，你
不能刪除一個目錄。

152
00:08:02,960 --> 00:08:08,100
因此，我們有這個其他都稱為RMDIR，
這只是基本含義

153
00:08:08,100 --> 00:08:09,800
刪除目錄。

154
00:08:09,800 --> 00:08:12,842
我可以，例如，刪除PSET1。

155
00:08:12,842 --> 00:08:15,770
如果我做LS，我不
擁有它了。

156
00:08:15,770 --> 00:08:18,430
>> 這方面有任何問題嗎？

157
00:08:18,430 --> 00:08:20,200
沒有？

158
00:08:20,200 --> 00:08:20,595
是嗎？

159
00:08:20,595 --> 00:08:23,954
>> 觀眾：你離開是很重要
一個空格之後 - 當你

160
00:08:23,954 --> 00:08:26,540
開始輸入的東西？

161
00:08:26,540 --> 00:08:26,830
>> LUCAS FREITAS：是啊。

162
00:08:26,830 --> 00:08:32,080
如果我做喜歡的CD和目錄，
我要加一個空格。

163
00:08:32,080 --> 00:08:33,350
什麼空間你在說什麼？

164
00:08:33,350 --> 00:08:34,979
>> LAUREN卡瓦略：之間的空間
CD和[聽不清]。

165
00:08:34,979 --> 00:08:37,710
>> LUCAS FREITAS：是啊，你要
放空間，因為CD是

166
00:08:37,710 --> 00:08:42,770
命令，然後在接下來的字符串
你的類型是基本的目錄。

167
00:08:42,770 --> 00:08:45,020
所以它就像一個參數。

168
00:08:45,020 --> 00:08:45,360
是嗎？

169
00:08:45,360 --> 00:08:47,952
>> 觀眾：當你列出，所有這些
在不同的目錄，對不對？

170
00:08:47,952 --> 00:08:50,125
>> LUCAS FREITAS：是的，他們
在目錄中。

171
00:08:50,125 --> 00:08:53,524
>> 觀眾：什麼是差異
目錄中？

172
00:08:53,524 --> 00:08:55,390
>> LUCAS FREITAS：他們只是
不同的文件夾。

173
00:08:55,390 --> 00:08:57,366
目錄是一個文件夾
在您的計算機。

174
00:08:57,366 --> 00:08:58,120
>> 觀眾：打開文件夾。

175
00:08:58,120 --> 00:09:00,140
>> LUCAS FREITAS：是的，這是
剛打開的文件夾。

176
00:09:00,140 --> 00:09:03,400
>> LAUREN卡瓦略：在這裡，那些
那是藍色的是實際的

177
00:09:03,400 --> 00:09:07,107
您可以進入和目錄
然後看到一堆東西，是

178
00:09:07,107 --> 00:09:10,248
內，這是不幸
因為你不能真正閱讀

179
00:09:10,248 --> 00:09:11,290
那些藍色。

180
00:09:11,290 --> 00:09:16,166
和那些在白色的只是文件
是當前目錄內。

181
00:09:16,166 --> 00:09:17,870
>> LUCAS FREITAS：所以目錄
是文件夾。

182
00:09:17,870 --> 00:09:18,810
其他的都是文件。

183
00:09:18,810 --> 00:09:22,810
>> 觀眾：什麼是命令
重設或清除呢？

184
00:09:22,810 --> 00:09:23,650
LUCAS FREITAS：要清除？

185
00:09:23,650 --> 00:09:24,362
LAUREN卡瓦略：要清除？

186
00:09:24,362 --> 00:09:27,985
LUCAS FREITAS：我覺得
這是“清”。是啊。

187
00:09:27,985 --> 00:09:32,370
所以，你只需要輸入不清楚
你的屏幕是太亂了。

188
00:09:32,370 --> 00:09:33,700
還有沒有其他問題？

189
00:09:33,700 --> 00:09:36,720
你會學到一堆其他的
在命令只是自然的

190
00:09:36,720 --> 00:09:38,405
學期，因為他們是非常有用的。

191
00:09:38,405 --> 00:09:42,380

192
00:09:42,380 --> 00:09:46,155
>> 所以，現在讓我們來談談編譯。

193
00:09:46,155 --> 00:09:51,510

194
00:09:51,510 --> 00:09:54,730
我們談到偽代碼和
源代碼和目標代碼。

195
00:09:54,730 --> 00:09:59,020
並且有很多代碼，也許
你們是困惑的。

196
00:09:59,020 --> 00:10:02,190
讓我們說一下什麼
當你寫一個程序發生，

197
00:10:02,190 --> 00:10:06,620
而你編譯它，並成為
一個可執行文件。

198
00:10:06,620 --> 00:10:10,190
這些都是的話，你的傢伙
可能聽說過，也許你不

199
00:10:10,190 --> 00:10:12,130
真的知道是怎麼回事。

200
00:10:12,130 --> 00:10:15,540
>> 比方說，例如，我想
編寫一個程序，說：“你好。”該

201
00:10:15,540 --> 00:10:19,670
，在你的頭腦的第一件事就是
有種你再想想你是怎樣

202
00:10:19,670 --> 00:10:23,000
要做到這一點在你的心中，並
你可能在想用英語或

203
00:10:23,000 --> 00:10:25,550
其他一些語言，如自然
語言，大概。

204
00:10:25,550 --> 00:10:28,770
然後你想，好吧，如果我想，
例如，編寫一個程序，

205
00:10:28,770 --> 00:10:32,630
說：“你好，”我會啟動一個程序，
我將打印打招呼，然後我會

206
00:10:32,630 --> 00:10:35,270
退出程序。

207
00:10:35,270 --> 00:10:36,350
這是偽代碼。

208
00:10:36,350 --> 00:10:41,740
這只是基本上你想
想出的事件序列

209
00:10:41,740 --> 00:10:46,510
你要做的是
能寫一個程序。

210
00:10:46,510 --> 00:10:49,610
>> 那麼你的源代碼，並
源代碼不必

211
00:10:49,610 --> 00:10:53,240
特別是C。我們談論
C語言有關的源代碼，因為這是

212
00:10:53,240 --> 00:10:56,760
我們正在學習的語言，但當然
代碼可以是幾乎任何

213
00:10:56,760 --> 00:10:59,160
你有編程語言。

214
00:10:59,160 --> 00:11:01,230
在學期過去了，你會
學習其他語言。

215
00:11:01,230 --> 00:11:03,230
這也是源代碼。

216
00:11:03,230 --> 00:11:07,380
>> 例如，在這裡，這是我的源
代碼，然後我包括一個

217
00:11:07,380 --> 00:11:10,170
庫，然後我開始
主要的，然後我打印。

218
00:11:10,170 --> 00:11:14,510
和勞拉是要談一點
所有的這一點。

219
00:11:14,510 --> 00:11:16,190
因此，這是源代碼。

220
00:11:16,190 --> 00:11:19,590
>> 什麼是目標代碼？

221
00:11:19,590 --> 00:11:22,500
對象是一堆零
和的，基本上是這樣。

222
00:11:22,500 --> 00:11:27,680
什麼情況是你一開始有
偽代碼，這是全英文的。

223
00:11:27,680 --> 00:11:29,020
我的意思是，你了解它。

224
00:11:29,020 --> 00:11:31,260
可能是你的朋友了解
它，大多數人會

225
00:11:31,260 --> 00:11:32,560
理解的想法。

226
00:11:32,560 --> 00:11:36,770
但電腦是非常愚蠢的，他們
不懂英語，所以你

227
00:11:36,770 --> 00:11:41,320
已翻譯的到的東西，
通常譯成

228
00:11:41,320 --> 00:11:42,460
編程語言。

229
00:11:42,460 --> 00:11:46,840
>> 和你能想到一個編程
語言那種作為一門語言

230
00:11:46,840 --> 00:11:50,970
那你告訴你的電腦怎麼
說話和理解。

231
00:11:50,970 --> 00:11:54,160
你基本上寫的東西在
一種語言，你們倆和你

232
00:11:54,160 --> 00:11:55,190
計算機理解。

233
00:11:55,190 --> 00:11:56,470
這是源代碼。

234
00:11:56,470 --> 00:12:00,580
那麼回事形式的偽代碼源
代碼，它是由你決定。

235
00:12:00,580 --> 00:12:03,130
它基本上是你做你的方案。

236
00:12:03,130 --> 00:12:06,740
>> 但問題是，
電腦甚至不

237
00:12:06,740 --> 00:12:08,360
了解編程語言。

238
00:12:08,360 --> 00:12:10,320
它不明白
源代碼中。

239
00:12:10,320 --> 00:12:12,520
它實際上只是理解
零和一。

240
00:12:12,520 --> 00:12:16,570
因此，我們有這個非常神奇的東西叫做
一個編譯器，這基本上是

241
00:12:16,570 --> 00:12:19,755
要得到所謂的源，你
寫在你倆的語言

242
00:12:19,755 --> 00:12:25,320
和你的電腦說話，現在你
要改造，在

243
00:12:25,320 --> 00:12:26,270
零和一。

244
00:12:26,270 --> 00:12:30,860
所以基本上什麼樣的編譯器是
它得到的源代碼，在這種情況下，C，

245
00:12:30,860 --> 00:12:34,100
它是將它改造成零
和那些在計算機

246
00:12:34,100 --> 00:12:37,440
理解並可以使一個
可執行文件出來。

247
00:12:37,440 --> 00:12:40,900
>> 這是否有道理？

248
00:12:40,900 --> 00:12:45,300
你可以認為編譯器作為
一些翻譯的是

249
00:12:45,300 --> 00:12:50,280
幫助您講解到電腦
究竟什麼是應該做的。

250
00:12:50,280 --> 00:12:52,310
>> 但我怎麼編譯。

251
00:12:52,310 --> 00:12:59,680
讓我們回到設備，並
讓我們說，我做了計劃。

252
00:12:59,680 --> 00:13:04,220
首先我要創建一個目錄
在這裡，我要叫它

253
00:13:04,220 --> 00:13:11,130
“實踐”。現在，我要瀏覽
到該目錄，所以CD的做法。

254
00:13:11,130 --> 00:13:13,210
現在，我在裡面練習。

255
00:13:13,210 --> 00:13:16,860
>> 現在，我要開始gedit的，
讓我怎麼做呢？

256
00:13:16,860 --> 00:13:21,920
我可以點擊這裡，或者我可以只
逐字輸入“gedit的，”它是怎麼回事

257
00:13:21,920 --> 00:13:24,290
打開我。

258
00:13:24,290 --> 00:13:28,100
>> 現在，我要輸入我的程序，所以
正是我寫在幻燈片。

259
00:13:28,100 --> 00:13:30,360
我宣布一個圖書館。

260
00:13:30,360 --> 00:13:35,440
我做整型為主，無效。

261
00:13:35,440 --> 00:13:39,180
現在我做的printf，你好。

262
00:13:39,180 --> 00:13:46,530

263
00:13:46,530 --> 00:13:50,170
現在，我要救這一點。

264
00:13:50,170 --> 00:13:53,665
讓我把它付諸實踐，並
我要調用這個hello.c中。

265
00:13:53,665 --> 00:13:57,710

266
00:13:57,710 --> 00:13:59,590
所以，現在它的保存。

267
00:13:59,590 --> 00:14:03,250
>> 如果我想編譯它，其實我
可以在兩個不同的地方做。

268
00:14:03,250 --> 00:14:07,090
我可以做一個終端窗口，
所以這個大的，或者您也可以

269
00:14:07,090 --> 00:14:09,860
用gedit，實際上有一個
終端窗口就在這裡。

270
00:14:09,860 --> 00:14:17,890
所以，你可以很方便地就去做
你的代碼，那麼你可以只輸入

271
00:14:17,890 --> 00:14:20,670
無論在這裡，並嘗試編譯它。

272
00:14:20,670 --> 00:14:23,450
>> 讓我怎麼編譯的代碼？

273
00:14:23,450 --> 00:14:27,495
我們有最簡單的方法是使用
作，這是一個函數，它

274
00:14:27,495 --> 00:14:29,590
基本上要
編譯你的代碼。

275
00:14:29,590 --> 00:14:34,170
你只需要說做招呼，所以
“使”和該程序的名稱。

276
00:14:34,170 --> 00:14:35,420
>> 哎呀。

277
00:14:35,420 --> 00:14:38,250

278
00:14:38,250 --> 00:14:39,280
這是尷尬的。

279
00:14:39,280 --> 00:14:41,738
>> LAUREN卡瓦略：你能[聽不清]？

280
00:14:41,738 --> 00:14:45,182

281
00:14:45,182 --> 00:14:45,990
>> LUCAS FREITAS：對不起。

282
00:14:45,990 --> 00:14:49,960
我沒有把它保存在
正確的目錄。

283
00:14:49,960 --> 00:14:52,130
來練習，現在
將其保存為hello.c中。

284
00:14:52,130 --> 00:14:54,750
對不起。

285
00:14:54,750 --> 00:14:56,250
現在它的保存。

286
00:14:56,250 --> 00:14:58,300
>> 我只是做ls和被
確保它在這裡。

287
00:14:58,300 --> 00:14:59,460
好了，現在就在這裡。

288
00:14:59,460 --> 00:15:05,930
所以，現在如果我這樣做讓你好，它吐出一個
很多東西，但當時它只是給

289
00:15:05,930 --> 00:15:08,870
我的另一條線的終端，它
也就是說，它是成功的。

290
00:15:08,870 --> 00:15:13,160
現在如果我再這樣做了LS，我竟如此
看到此文件為綠色，這是

291
00:15:13,160 --> 00:15:15,470
可執行文件。

292
00:15:15,470 --> 00:15:21,700
>> 然後如果我要運行它，所有的
我所要做的就是點斜線打招呼。

293
00:15:21,700 --> 00:15:25,830
它會跟你打招呼就在這裡，所以
這正是我要問它。

294
00:15:25,830 --> 00:15:29,620
>> 有編制的一種方式，
這是使用鐺。

295
00:15:29,620 --> 00:15:35,740
鐺只是一個編譯器，我們有，
和它的更詳細一點點

296
00:15:35,740 --> 00:15:36,390
編譯它。

297
00:15:36,390 --> 00:15:40,180
但它的作品一樣好。

298
00:15:40,180 --> 00:15:46,810
所以，如果我做鐺，然後鄰，然後
我想給的名字

299
00:15:46,810 --> 00:15:50,400
可執行文件，所以讓我們說
“你好。”然後我想要的文件

300
00:15:50,400 --> 00:15:53,460
編譯，hello.c中。

301
00:15:53,460 --> 00:15:55,900
它也將進行編譯。

302
00:15:55,900 --> 00:15:59,020
和你在這裡的文件，
我可以執行它。

303
00:15:59,020 --> 00:16:00,610
所以他們兩個人的工作。

304
00:16:00,610 --> 00:16:03,270
>> 這是否有道理？

305
00:16:03,270 --> 00:16:06,020
有問題嗎？

306
00:16:06,020 --> 00:16:09,020
>> 觀眾：你能否放大
在一點點？

307
00:16:09,020 --> 00:16:09,913
>> LUCAS FREITAS：對不起？

308
00:16:09,913 --> 00:16:11,135
>> 觀眾：放大？

309
00:16:11,135 --> 00:16:13,310
>> LAUREN卡瓦略：我想你
只需命令加。

310
00:16:13,310 --> 00:16:14,295
>> LUCAS FREITAS：命令是什麼？

311
00:16:14,295 --> 00:16:16,060
>> LAUREN卡瓦略：命令加。

312
00:16:16,060 --> 00:16:17,000
>> LUCAS FREITAS：號

313
00:16:17,000 --> 00:16:19,350
>> LAUREN卡瓦略：哦，那不是
去上班，因為 - 

314
00:16:19,350 --> 00:16:25,548
這是因為我們設置的分辨率
對於這件事情。

315
00:16:25,548 --> 00:16:27,450
>> LUCAS FREITAS：我不知道
認為我們可以放大。

316
00:16:27,450 --> 00:16:30,852

317
00:16:30,852 --> 00:16:34,130
是啊，我們不能放大。

318
00:16:34,130 --> 00:16:36,200
你有別的問題？

319
00:16:36,200 --> 00:16:36,680
抱歉。

320
00:16:36,680 --> 00:16:39,170
>> 觀眾：你能重複鐺？

321
00:16:39,170 --> 00:16:40,630
>> LUCAS FREITAS：該鐺？

322
00:16:40,630 --> 00:16:44,190
鐺的是同樣的事情化妝，但
不同的是，第一次我要去

323
00:16:44,190 --> 00:16:48,460
寫鐺，這是命令，
那麼我該怎麼辦-0，所有的，這是

324
00:16:48,460 --> 00:16:51,680
只是我們要什麼
後來作為一個標誌學習。

325
00:16:51,680 --> 00:16:54,440
所以，只是覺得你總是
必須把鄰。

326
00:16:54,440 --> 00:16:58,690
>> 然後首先，你要放
該可執行文件的文件名，

327
00:16:58,690 --> 00:17:00,680
基本上，你是該文件
要創建。

328
00:17:00,680 --> 00:17:06,430
所以我可以說，舉例來說，的Hello2和
然後，我要編譯的文件，

329
00:17:06,430 --> 00:17:07,800
這是c文件。

330
00:17:07,800 --> 00:17:09,240
所以這是hello.c中。

331
00:17:09,240 --> 00:17:10,871
這是否有道理？

332
00:17:10,871 --> 00:17:12,635
>> 觀眾：你好是什麼？

333
00:17:12,635 --> 00:17:13,076
那是什麼？

334
00:17:13,076 --> 00:17:15,960
>> LUCAS FREITAS：HELLO.C。

335
00:17:15,960 --> 00:17:19,849
如果我編譯它，而如果
我LS，我也有一個

336
00:17:19,849 --> 00:17:22,010
的Hello2，我只是編譯。

337
00:17:22,010 --> 00:17:26,339
如果我嘗試運行它，它會
做同樣的事情為hello，

338
00:17:26,339 --> 00:17:27,089
只是打印打招呼。

339
00:17:27,089 --> 00:17:31,660
>> 觀眾：怎麼來化妝
你可以穿上後的hello.c？

340
00:17:31,660 --> 00:17:33,880
>> LUCAS FREITAS：在化妝，你
不必把。角

341
00:17:33,880 --> 00:17:36,140
在化妝，你剛才說的
該程序的名稱。

342
00:17:36,140 --> 00:17:37,750
你不必說了。角

343
00:17:37,750 --> 00:17:39,020
但對於鐺，你應該。

344
00:17:39,020 --> 00:17:44,040
>> 觀眾：隨著鐺做的，你也
必須添加[聽不清]

345
00:17:44,040 --> 00:17:44,480
>> LAUREN卡瓦略：是啊。

346
00:17:44,480 --> 00:17:46,180
所以，你也有圖書館。

347
00:17:46,180 --> 00:17:51,170
>> LUCAS FREITAS：是啊，這東西
我們打算以後使用。

348
00:17:51,170 --> 00:17:54,850
這就是所謂的連接，並且我認為我們
後來去談論它。

349
00:17:54,850 --> 00:17:55,930
另一個問題？

350
00:17:55,930 --> 00:17:59,927
>> 觀眾：你放
點斜線鐺？

351
00:17:59,927 --> 00:18:01,060
>> LUCAS FREITAS：號

352
00:18:01,060 --> 00:18:06,040
點斜線只是開
可執行文件。

353
00:18:06,040 --> 00:18:09,440
所以，鐺，你只寫“鐺”，並
那麼，如果你想打開

354
00:18:09,440 --> 00:18:12,640
可執行文件，你只是
編譯，那麼你就點

355
00:18:12,640 --> 00:18:13,780
削減而得名。

356
00:18:13,780 --> 00:18:15,100
這是否有道理？

357
00:18:15,100 --> 00:18:18,635

358
00:18:18,635 --> 00:18:22,435
>> 觀眾：如果你只是改變
[聽不清]為Hello World，你

359
00:18:22,435 --> 00:18:23,870
必須重新編譯它？

360
00:18:23,870 --> 00:18:24,750
>> LUCAS FREITAS：是啊。

361
00:18:24,750 --> 00:18:36,650
如果我想要說，例如，“你好
在那裡，“我可以只保存了，我

362
00:18:36,650 --> 00:18:38,020
只是重新編譯它。

363
00:18:38,020 --> 00:18:41,910
因此，讓我做一個make打招呼。

364
00:18:41,910 --> 00:18:48,490
如果我做你好，這將
說“你好”。有道理？

365
00:18:48,490 --> 00:18:50,280
還有沒有其他問題？

366
00:18:50,280 --> 00:18:54,384
>> 觀眾：你一定要包括
標準I / O的協調工作？

367
00:18:54,384 --> 00:18:55,480
>> LUCAS FREITAS：是啊。

368
00:18:55,480 --> 00:18:58,050
標準I / O的基本
具有一個庫

369
00:18:58,050 --> 00:19:00,050
實現printf的。

370
00:19:00,050 --> 00:19:03,450

371
00:19:03,450 --> 00:19:06,910
所以，在那件事權利
頂部包括標準輸入輸出。

372
00:19:06,910 --> 00:19:11,920
這是包括一個庫，
基本上有一堆不同

373
00:19:11,920 --> 00:19:13,260
工具，你可以使用。

374
00:19:13,260 --> 00:19:13,480
呢？

375
00:19:13,480 --> 00:19:17,820
其中printf的是那是一個函數
基本上版畫

376
00:19:17,820 --> 00:19:21,290
消息到屏幕上。

377
00:19:21,290 --> 00:19:23,200
>> 還有沒有其他問題？

378
00:19:23,200 --> 00:19:24,700
沒有？

379
00:19:24,700 --> 00:19:25,060
確定。

380
00:19:25,060 --> 00:19:31,620
所以，現在讓我們來談談 - 

381
00:19:31,620 --> 00:19:33,948
>> LAUREN卡瓦略：我們只是
去的風格指南。

382
00:19:33,948 --> 00:19:35,896
你想只找到它在這裡？

383
00:19:35,896 --> 00:19:37,880
>> LUCAS FREITAS：所以我們要
談風格。

384
00:19:37,880 --> 00:19:47,006

385
00:19:47,006 --> 00:19:50,430
>> LAUREN卡瓦略：哦，大衛
沒有完成。

386
00:19:50,430 --> 00:19:51,230
確定。

387
00:19:51,230 --> 00:19:53,870
我們為什麼不回來
風格在最後？

388
00:19:53,870 --> 00:19:56,220
它實際上已更新
因為我們說話。

389
00:19:56,220 --> 00:19:56,810
>> LUCAS FREITAS：是啊。

390
00:19:56,810 --> 00:19:58,300
讓我們的方式為大衛完成了。

391
00:19:58,300 --> 00:20:07,150

392
00:20:07,150 --> 00:20:08,600
>> LAUREN卡瓦略：能
我們改用什麼呢？

393
00:20:08,600 --> 00:20:14,920

394
00:20:14,920 --> 00:20:17,200
>> 所以我希望每個人都對
享受划痕。

395
00:20:17,200 --> 00:20:21,950
不幸的是，它的時間
遠離本 - 

396
00:20:21,950 --> 00:20:25,280
不幸的是它的時間離開
從這些漂亮的編程塊

397
00:20:25,280 --> 00:20:28,530
到C。但幸運的是，所有的
編程構造，你已經

398
00:20:28,530 --> 00:20:32,370
在划痕一直與有
直接翻譯到C，和我們

399
00:20:32,370 --> 00:20:35,130
要開始學習
他們中的一些現在。

400
00:20:35,130 --> 00:20:39,200
讓我們談條件先說說
在布爾表達式。

401
00:20:39,200 --> 00:20:41,944
>> 這是在運行儲備
電池電量。

402
00:20:41,944 --> 00:20:43,912
>> LUCAS FREITAS：如何是
那不工作？

403
00:20:43,912 --> 00:20:47,850

404
00:20:47,850 --> 00:20:48,010
確定。

405
00:20:48,010 --> 00:20:50,256
你去那裡，我會得到 - 

406
00:20:50,256 --> 00:20:53,700

407
00:20:53,700 --> 00:20:57,390
>> LAUREN卡瓦略：所以條件
重要的，因為它們使我們能夠

408
00:20:57,390 --> 00:21:00,588
邏輯引入到我們的節目。

409
00:21:00,588 --> 00:21:04,620
這裡有一個條件的例子
在一個C程序。

410
00:21:04,620 --> 00:21:06,130
讓我們注意如何 - 

411
00:21:06,130 --> 00:21:11,324
所以這種情況下塊就在這裡，這
printf語句將不會執行

412
00:21:11,324 --> 00:21:14,860
除非內的條件
括號中，n大於0，則

413
00:21:14,860 --> 00:21:16,800
計算結果為true。

414
00:21:16,800 --> 00:21:20,780
>> 現在，所有的F內的條件
語句是布爾表達式，

415
00:21:20,780 --> 00:21:22,970
這意味著有
只有兩個選項。

416
00:21:22,970 --> 00:21:26,856
他們既可以評估為true，
或者他們可以評估為false。

417
00:21:26,856 --> 00:21:33,174
所以在這裡，所以這是有道理的，對不對？ Ñ
大於0時，意味著它是一個正

418
00:21:33,174 --> 00:21:41,160
數，這意味著它將打印
出“你選擇了一個正數。”

419
00:21:41,160 --> 00:21:44,630
>> 有很多的布爾表達式
能夠形成的條件與

420
00:21:44,630 --> 00:21:47,190
初始化語句。

421
00:21:47,190 --> 00:21:48,520
我們具有比少。

422
00:21:48,520 --> 00:21:50,950
這是小於或等於。

423
00:21:50,950 --> 00:21:52,200
這僅僅是一個有趣的[聽不清]。

424
00:21:52,200 --> 00:21:54,800

425
00:21:54,800 --> 00:22:01,630
如果你想，如果它是printf的發生
大於或等於0，則

426
00:22:01,630 --> 00:22:03,345
你會選擇這個。

427
00:22:03,345 --> 00:22:07,750
因此，平等公正的權利附加
後大於號。

428
00:22:07,750 --> 00:22:12,030
>> 相等相等，這是從不同
只是一個等號，平等平等

429
00:22:12,030 --> 00:22:16,430
實際上意味著，凡是在
本左手邊是一樣

430
00:22:16,430 --> 00:22:20,610
什麼在這個右手側
其中一個等號是什麼？

431
00:22:20,610 --> 00:22:23,333
什麼是只是一個等號？

432
00:22:23,333 --> 00:22:24,275
分配。

433
00:22:24,275 --> 00:22:25,985
>> LUCAS FREITAS：誰說的？

434
00:22:25,985 --> 00:22:27,170
是糖果？

435
00:22:27,170 --> 00:22:27,370
哦，不。

436
00:22:27,370 --> 00:22:27,885
抱歉。

437
00:22:27,885 --> 00:22:28,210
抱歉。

438
00:22:28,210 --> 00:22:30,400
你都得到糖果。

439
00:22:30,400 --> 00:22:31,510
哦，好吧！

440
00:22:31,510 --> 00:22:33,046
三個人得到的糖果！

441
00:22:33,046 --> 00:22:37,393
>> LAUREN卡瓦略：所以這一塊就在這裡
是前爆炸運營商

442
00:22:37,393 --> 00:22:40,240
等號，所以這
不等於。

443
00:22:40,240 --> 00:22:46,560
因此，如果這是在我的情況下，
病情的身體會

444
00:22:46,560 --> 00:22:49,615
執行只有當一切在
左邊是不一樣的

445
00:22:49,615 --> 00:22:52,540
什麼是右側。

446
00:22:52,540 --> 00:22:57,680
>> 我也可以有剛
感嘆號。

447
00:22:57,680 --> 00:23:01,250
實際上，我們將在一個功能看
滑動如何做到這一點可以使用。

448
00:23:01,250 --> 00:23:03,830
>> LUCAS FREITAS：有問題嗎？

449
00:23:03,830 --> 00:23:06,450
沒有？

450
00:23:06,450 --> 00:23:10,460
>> LAUREN卡瓦略：我們可以結合這些
布爾表達式構建更

451
00:23:10,460 --> 00:23:12,500
複雜的條件語句。

452
00:23:12,500 --> 00:23:19,680
所以在這裡，如果凡是在左邊
雙桿的右手邊，或

453
00:23:19,680 --> 00:23:23,160
無論是在右手側
雙桿計算結果為true，

454
00:23:23,160 --> 00:23:25,700
然後我們再打印出來無效。

455
00:23:25,700 --> 00:23:29,503
然後到這裡，如果不管的
對2的左手側

456
00:23:29,503 --> 00:23:33,480
＆符號和任何的右側
兩個＆符號的右手邊

457
00:23:33,480 --> 00:23:37,470
計算結果為true，則
我們將打印出有效的。

458
00:23:37,470 --> 00:23:42,195
雙條被稱為邏輯
OR運算符的雙連字號

459
00:23:42,195 --> 00:23:44,190
所謂邏輯AND運算。

460
00:23:44,190 --> 00:23:44,648
是嗎？

461
00:23:44,648 --> 00:23:47,850
>> 觀眾：是那些剛
小寫l的？

462
00:23:47,850 --> 00:23:48,620
>> LAUREN卡瓦略：號

463
00:23:48,620 --> 00:23:50,890
它們實際上是 - 

464
00:23:50,890 --> 00:23:55,134
你知道的反彈，像
上面的回車鍵？

465
00:23:55,134 --> 00:23:56,585
你看到了嗎？

466
00:23:56,585 --> 00:23:57,940
>> LUCAS FREITAS：它實際上是一個酒吧。

467
00:23:57,940 --> 00:24:02,100
>> LAUREN卡瓦略：它實際上是
只是兩間酒吧。

468
00:24:02,100 --> 00:24:05,724
>> 觀眾：你可以使用
字符串相等相等？

469
00:24:05,724 --> 00:24:07,000
>> LUCAS FREITAS：號

470
00:24:07,000 --> 00:24:09,130
我們打算以後學習
一些事。

471
00:24:09,130 --> 00:24:10,735
>> LAUREN卡瓦略：有一個函數
您可以使用。

472
00:24:10,735 --> 00:24:12,644
但你不必
擔心，只是還沒有。

473
00:24:12,644 --> 00:24:15,530

474
00:24:15,530 --> 00:24:18,270
>> 如果我給這個程序
數字5？

475
00:24:18,270 --> 00:24:20,850
什麼會打印出來嗎？

476
00:24:20,850 --> 00:24:22,100
>> 觀眾：[聽不清]

477
00:24:22,100 --> 00:24:27,780

478
00:24:27,780 --> 00:24:28,275
有效。

479
00:24:28,275 --> 00:24:29,770
>> LAUREN卡瓦略：有效？

480
00:24:29,770 --> 00:24:30,135
是啊。

481
00:24:30,135 --> 00:24:34,092
我不知道誰得到了這一點。

482
00:24:34,092 --> 00:24:35,036
>> [笑]

483
00:24:35,036 --> 00:24:37,990
>> LAUREN卡瓦略：這是一種
嚇人[聽不清]。

484
00:24:37,990 --> 00:24:40,900
>> 觀眾：所以，雙和，
這只是意味著和？

485
00:24:40,900 --> 00:24:41,740
>> LAUREN卡瓦略：是啊。

486
00:24:41,740 --> 00:24:46,160
因此，5號是兩個較大
比大於100 0及以下。

487
00:24:46,160 --> 00:24:48,970
>> 觀眾：它為什麼會呢？

488
00:24:48,970 --> 00:24:51,350
>> LAUREN卡瓦略：一個是符號
其實不同的東西，它是

489
00:24:51,350 --> 00:24:53,390
按位運算符，你會
後來了解。

490
00:24:53,390 --> 00:24:58,250
但它的東西，實際工作
與一個給定數目的位。

491
00:24:58,250 --> 00:25:00,872
>> LUCAS FREITAS：試想他們不
不用擔心它現在。

492
00:25:00,872 --> 00:25:04,590
>> LAUREN卡瓦略：我覺得它可能
下週就要到了。

493
00:25:04,590 --> 00:25:06,420
>> LUCAS FREITAS：還有沒有其他問題？

494
00:25:06,420 --> 00:25:07,990
沒有？

495
00:25:07,990 --> 00:25:12,480
>> LAUREN卡瓦略：因此，我們已經看到了一個
它阻止可單獨存在，但它可以

496
00:25:12,480 --> 00:25:15,370
也可以搭配和else塊。

497
00:25:15,370 --> 00:25:18,880
因此，在這種情況下，如果n大於
0，我們要打印出“你

498
00:25:18,880 --> 00:25:23,855
拾取的正數。“一樣，意味著
如果是0，或者如果它的不足

499
00:25:23,855 --> 00:25:27,170
大於0，我們要打印出來，
“你挑一個負數。”

500
00:25:27,170 --> 00:25:30,390
>> 這裡有趣的是，這些
是互相排斥的。

501
00:25:30,390 --> 00:25:33,940
還有的永遠不會是一個案例
其中這與本

502
00:25:33,940 --> 00:25:35,544
既可以打印出來。

503
00:25:35,544 --> 00:25:38,190

504
00:25:38,190 --> 00:25:41,030
>> 我敢肯定，你曾與if / else語句
方塊在刮，所以這應該是

505
00:25:41,030 --> 00:25:42,392
相當熟悉。

506
00:25:42,392 --> 00:25:42,874
是嗎？

507
00:25:42,874 --> 00:25:48,522
>> 觀眾：我們是否需要之間的空間
整數n等於調用getInt然後在空間

508
00:25:48,522 --> 00:25:49,460
if語句？

509
00:25:49,460 --> 00:25:51,565
就像我們使用一個線[聽不清]

510
00:25:51,565 --> 00:25:52,790
>> LAUREN卡瓦略：哦，這裡的空間？

511
00:25:52,790 --> 00:25:56,742
>> 觀眾：這樣，但
你雙倍的空間。

512
00:25:56,742 --> 00:25:58,718
沒有，上去了。

513
00:25:58,718 --> 00:25:59,706
上去了。

514
00:25:59,706 --> 00:26:00,610
>> LUCAS FREITAS：只是行了？

515
00:26:00,610 --> 00:26:01,140
>> 觀眾：是啊。

516
00:26:01,140 --> 00:26:02,870
>> LUCAS FREITAS：就在空行？

517
00:26:02,870 --> 00:26:03,270
>> 觀眾：是啊。

518
00:26:03,270 --> 00:26:04,070
>> LAUREN卡瓦略：空行？

519
00:26:04,070 --> 00:26:04,470
號

520
00:26:04,470 --> 00:26:06,320
這只是一個風格的東西。

521
00:26:06,320 --> 00:26:09,360
>> LUCAS FREITAS：這就像有時
你只是跳過一些行，以便

522
00:26:09,360 --> 00:26:12,330
該代碼看起來並不像
文本塊巨大。

523
00:26:12,330 --> 00:26:15,800
>> LAUREN卡瓦略：我覺得發生了什麼
是，我們必須在這裡留言，但我

524
00:26:15,800 --> 00:26:18,220
拿出來，這樣你們將有
思考的代碼，而

525
00:26:18,220 --> 00:26:19,920
不只是看我的評論。

526
00:26:19,920 --> 00:26:24,170
一般來說，間距不會真的
影響程序的運行方式。

527
00:26:24,170 --> 00:26:26,070
它更多的是一種風格的東西。

528
00:26:26,070 --> 00:26:29,460
而當我們有風格指南更新
並準備去年底

529
00:26:29,460 --> 00:26:33,260
supersection，我們將討論
關於更多。

530
00:26:33,260 --> 00:26:34,660
>> 有什麼東西錯
這一方案，對不對？

531
00:26:34,660 --> 00:26:38,980
因為0是不是真的
一個負數。

532
00:26:38,980 --> 00:26:40,270
因此，讓我們看看我們是否能夠解決這個問題。

533
00:26:40,270 --> 00:26:45,710

534
00:26:45,710 --> 00:26:48,370
>> 你大概可以想像
與此說，對不對？

535
00:26:48,370 --> 00:26:52,850
如果n大於0，我們打印，“你
挑一個正數。“THEN ELSE

536
00:26:52,850 --> 00:26:57,340
如果n小於0，“你挑了個
負數。“一樣，”你挑

537
00:26:57,340 --> 00:27:01,040
0。“

538
00:27:01,040 --> 00:27:06,030
>> 現在，有趣的是，
這可能會永遠持續下去。

539
00:27:06,030 --> 00:27:10,020
你可以有一個if塊中，否則，如果
塊，另一否則，如果塊，否則，如果，

540
00:27:10,020 --> 00:27:14,790
否則，如果，否則，如果，否則，基本上
只要你想要的。

541
00:27:14,790 --> 00:27:17,110
而當這樣的構造，
這些都將是

542
00:27:17,110 --> 00:27:19,206
互相排斥的。

543
00:27:19,206 --> 00:27:19,650
是嗎？

544
00:27:19,650 --> 00:27:24,130
>> 觀眾：那麼，為什麼你就不能使用
另外，如果代替[聽不清]？

545
00:27:24,130 --> 00:27:26,990
>> LAUREN卡瓦略：在這種情況下，是的，我
如果可以使用另一個，這將是

546
00:27:26,990 --> 00:27:29,190
精絕，因為
條件本身是

547
00:27:29,190 --> 00:27:30,600
互相排斥的。

548
00:27:30,600 --> 00:27:33,560
但如果條件不是唯一
相互的，這將

549
00:27:33,560 --> 00:27:37,596
迫使他們從來沒有兩個評價，
如果是有道理的。

550
00:27:37,596 --> 00:27:44,195
>> 觀眾：在這種情況下，我們能否巢
第二，如果在第一，如果？

551
00:27:44,195 --> 00:27:46,160
>> LAUREN卡瓦略：如果 - 
你是什​​麼意思？

552
00:27:46,160 --> 00:27:49,660
>> 觀眾：如果這兩個條件
並不相互排斥？

553
00:27:49,660 --> 00:27:54,700
>> LAUREN卡瓦略：如果條件
並不相互排斥？

554
00:27:54,700 --> 00:27:58,000
但是你只想要其中的一種來運行？

555
00:27:58,000 --> 00:28:00,260
>> 觀眾：你只想要
如果不是別的。

556
00:28:00,260 --> 00:28:01,020
>> LAUREN卡瓦略：是啊。

557
00:28:01,020 --> 00:28:03,630
有總是會很多
的方式，你可以做到這一點。

558
00:28:03,630 --> 00:28:06,600
你絕對可以嵌套它們。

559
00:28:06,600 --> 00:28:10,390
而且你會在將來的幻燈片看到，
你可以有多個如果，只有一個

560
00:28:10,390 --> 00:28:11,680
紛至沓來。

561
00:28:11,680 --> 00:28:14,840
但是，這是邏輯上的一種方法
組織你的程序的流程。

562
00:28:14,840 --> 00:28:18,000
>> LUCAS FREITAS：而且還有一
的事情，就是你問把

563
00:28:18,000 --> 00:28:20,110
如果再另外如果。

564
00:28:20,110 --> 00:28:25,240
這將很好地工作，但它的壞
設計，因為基本上，如果你

565
00:28:25,240 --> 00:28:29,320
第一，如果檢查，而且你注意到
的數目大於0，則

566
00:28:29,320 --> 00:28:30,660
可以只是完成該程序。

567
00:28:30,660 --> 00:28:33,080
你不必檢查
它是小於0的，對不對？

568
00:28:33,080 --> 00:28:37,510
>> 但是，如果你做，如果，如​​果，它要檢查
這兩個，而如果我做，如果其他人在，

569
00:28:37,510 --> 00:28:39,260
它會檢查是否
它是大於0。

570
00:28:39,260 --> 00:28:43,500
如果是，它不會連看
在其他行的代碼。

571
00:28:43,500 --> 00:28:48,560
所以你基本上是檢查它像
兩次不必要的，所以這就是為什麼我們

572
00:28:48,560 --> 00:28:50,750
如果做別的，如果。

573
00:28:50,750 --> 00:28:52,350
還有沒有其他問題？

574
00:28:52,350 --> 00:28:56,547
>> 觀眾：這樣的功能
在其他的，如果是相同的

575
00:28:56,547 --> 00:28:57,790
如果這只是如果？

576
00:28:57,790 --> 00:28:58,470
>> LAUREN卡瓦略：號

577
00:28:58,470 --> 00:29:02,720
你究竟要看到我的未來
滑動的示例，其中它可以

578
00:29:02,720 --> 00:29:03,270
是不同的。

579
00:29:03,270 --> 00:29:05,690
在這種情況下，它幾乎是相同的。

580
00:29:05,690 --> 00:29:10,190

581
00:29:10,190 --> 00:29:15,410
>> 所以在這裡，我們有多個的一個例子
if語句和

582
00:29:15,410 --> 00:29:20,020
功能是不一樣的
就好像我剛剛說，如果

583
00:29:20,020 --> 00:29:23,120
否則，如果其他人，如果其他人。

584
00:29:23,120 --> 00:29:26,970
讓我們只是想想將打印
，如果我輸入數字95

585
00:29:26,970 --> 00:29:27,715
到這個程序。

586
00:29:27,715 --> 00:29:29,764
>> 觀眾：[聽不清]

587
00:29:29,764 --> 00:29:31,102
>> LAUREN卡瓦略：然後呢？

588
00:29:31,102 --> 00:29:32,340
>> 觀眾：[聽不清]

589
00:29:32,340 --> 00:29:33,680
>> LAUREN卡瓦略：是啊。

590
00:29:33,680 --> 00:29:37,430
所以在這種情況下，這些條件是
不是相互排斥的。

591
00:29:37,430 --> 00:29:41,040
並且因為沒有什麼能阻止
從評估這種情況下，如果這

592
00:29:41,040 --> 00:29:44,730
1已經有了，他們只是
一切都將打印出來。

593
00:29:44,730 --> 00:29:46,222
所以，我怎麼能解決這個問題？

594
00:29:46,222 --> 00:29:47,608
>> 觀眾：還有IFS？

595
00:29:47,608 --> 00:29:48,910
>> LAUREN卡瓦略：您可以使用其他IFS。

596
00:29:48,910 --> 00:29:50,590
我可以改變順序
這些，對不對？

597
00:29:50,590 --> 00:29:53,800
如果我第一次做這個嗎？

598
00:29:53,800 --> 00:29:55,120
嗯，事實上，沒有。

599
00:29:55,120 --> 00:29:57,100
這不會對95工作。

600
00:29:57,100 --> 00:29:58,490
>> LUCAS FREITAS：沒有，只是在else IFS。

601
00:29:58,490 --> 00:30:01,720
>> LAUREN卡瓦略：在別的IFS
將固定的。

602
00:30:01,720 --> 00:30:07,050
這是否清理混亂
IFS之間和else IFS？

603
00:30:07,050 --> 00:30:11,480
>> 觀眾：我只是想問問你，如果
你沒有使用否則，如果，它會停下來？

604
00:30:11,480 --> 00:30:11,840
>> LAUREN卡瓦略：對。

605
00:30:11,840 --> 00:30:13,330
所以只有這第一個。

606
00:30:13,330 --> 00:30:16,535
如果我輸入的號碼95，僅此
將打印出來的，它從不

607
00:30:16,535 --> 00:30:17,934
會進展到別人。

608
00:30:17,934 --> 00:30:22,570
>> LUCAS FREITAS：剛才那種想到的
它作為如果發生這種情況，做到這一點。

609
00:30:22,570 --> 00:30:26,990
在else是一樣，如果沒有，檢查
對於這一點，然後做到這一點。

610
00:30:26,990 --> 00:30:28,690
因此，像他們都相互
排斥。

611
00:30:28,690 --> 00:30:30,270
你不能為兩個以上的。

612
00:30:30,270 --> 00:30:32,800

613
00:30:32,800 --> 00:30:37,630
>> 觀眾：你可以使用邏輯
而對於這種情況？

614
00:30:37,630 --> 00:30:39,370
>> LAUREN卡瓦略：是啊。

615
00:30:39,370 --> 00:30:41,400
這是另一種方式，我們可以
已經修正了這個問題。

616
00:30:41,400 --> 00:30:43,470
我們可以定義
範圍，對不對？

617
00:30:43,470 --> 00:30:49,410
所以我可以說，如果n大於
大於90且小於 - 

618
00:30:49,410 --> 00:30:52,135
嗯，我想這其中並沒有真正
無所謂，但在這裡我可以說，如果

619
00:30:52,135 --> 00:30:53,960
n大於80小於90。

620
00:30:53,960 --> 00:30:55,570
大於70，小於80更大。

621
00:30:55,570 --> 00:30:59,077
那會還努力。

622
00:30:59,077 --> 00:30:59,891
>> [笑]

623
00:30:59,891 --> 00:31:00,980
>> LUCAS FREITAS：她是害怕。

624
00:31:00,980 --> 00:31:02,070
>> LAUREN卡瓦略：不要怕。

625
00:31:02,070 --> 00:31:04,570
>> LUCAS FREITAS：這不是
這將是錯誤的。

626
00:31:04,570 --> 00:31:08,630
只是，它是不必要的
冗長。

627
00:31:08,630 --> 00:31:13,480
就像在計算機科學，人們應
要盡可能簡單，只要

628
00:31:13,480 --> 00:31:14,730
你具備的功能。

629
00:31:14,730 --> 00:31:16,725

630
00:31:16,725 --> 00:31:17,835
你想要的糖果？

631
00:31:17,835 --> 00:31:19,084
>> 觀眾：不需要它。

632
00:31:19,084 --> 00:31:20,340
>> LAUREN卡瓦略：你嚇到
每個人，盧卡斯。

633
00:31:20,340 --> 00:31:21,590
>> LUCAS FREITAS：對不起。

634
00:31:21,590 --> 00:31:24,650

635
00:31:24,650 --> 00:31:29,510
>> LAUREN卡瓦略：大衛還提到
在這些類switch語句。

636
00:31:29,510 --> 00:31:33,180
基本上，這是怎麼回事是開關
需要聲明一個變量。

637
00:31:33,180 --> 00:31:35,760
在這種情況下，我們正在採取一個整數。

638
00:31:35,760 --> 00:31:39,220
>> 如果整數是1，我們要
打印出來，“你挑一個小

639
00:31:39,220 --> 00:31:42,000
數。“如果整數為1，”你
挑了中等數量。“如果

640
00:31:42,000 --> 00:31:45,730
整數為3，“你挑了個高
號，“而且我也有一個默認的情況下，

641
00:31:45,730 --> 00:31:50,020
到這裡，但它沒有顯示
起來，這是太糟糕了。

642
00:31:50,020 --> 00:31:53,120

643
00:31:53,120 --> 00:31:55,360
>> 基本上，這僅僅是
另一種語法。

644
00:31:55,360 --> 00:31:58,640
我們也可以精確實現這一
同樣的事情，if和else if

645
00:31:58,640 --> 00:31:59,390
語句。

646
00:31:59,390 --> 00:32:05,530
但是，當有很多不同
條件和許多不同的

647
00:32:05,530 --> 00:32:10,350
變化你想要做什麼
每個輸入，這是一種選擇。

648
00:32:10,350 --> 00:32:13,262
所以它只是一個很好的語法就知道了。

649
00:32:13,262 --> 00:32:15,099
是嗎？

650
00:32:15,099 --> 00:32:21,380
>> 觀眾：為什麼不是一個反斜杠
N的第一個？

651
00:32:21,380 --> 00:32:23,340
>> LAUREN卡瓦略：對於在那裡？

652
00:32:23,340 --> 00:32:27,600
有沒有反斜線Ñ在那裡
因為調用getInt  - 

653
00:32:27,600 --> 00:32:30,140
如果你試試這個，它會
給你這樣的提示。

654
00:32:30,140 --> 00:32:32,290
給我1和3之間的整數。

655
00:32:32,290 --> 00:32:35,550
如果我把背隙N，它會
帶我到下一行，但我只是

656
00:32:35,550 --> 00:32:38,690
希望他們鍵入整數
後右結腸。

657
00:32:38,690 --> 00:32:40,120
你可能已經把反彈ñ。

658
00:32:40,120 --> 00:32:42,374
這不是什麼大不了的事。

659
00:32:42,374 --> 00:32:43,288
是嗎？

660
00:32:43,288 --> 00:32:50,525
>> 觀眾：對於此代碼，這是
情況1，是因為

661
00:32:50,525 --> 00:32:51,760
這是第一種情況？

662
00:32:51,760 --> 00:32:52,260
因為 - 

663
00:32:52,260 --> 00:32:53,400
>> LAUREN卡瓦略：不，不，不。

664
00:32:53,400 --> 00:32:56,480
因此，這是給我一個整數
1到3之間。

665
00:32:56,480 --> 00:32:59,070
如果n為1，我打印了。

666
00:32:59,070 --> 00:33:02,740
如果我問信，我可以有
說給我的一封信

667
00:33:02,740 --> 00:33:04,935
和C那麼這將是案件A.

668
00:33:04,935 --> 00:33:05,910
>> 觀眾：[聽不清]。

669
00:33:05,910 --> 00:33:08,090
的情況下也只是[聽不清]

670
00:33:08,090 --> 00:33:11,260
>> LAUREN卡瓦略：是的，沒錯。

671
00:33:11,260 --> 00:33:11,550
是嗎？

672
00:33:11,550 --> 00:33:14,861
>> 觀眾：如果你有什麼想有
更多的關係式的？

673
00:33:14,861 --> 00:33:17,645
所以不是說Ñ
等於1，[聽不清]

674
00:33:17,645 --> 00:33:21,050
n是大於1的第一種情況？

675
00:33:21,050 --> 00:33:26,630
>> LAUREN卡瓦略：其實，如果我不
定義其中的一些情況下，這將

676
00:33:26,630 --> 00:33:28,500
被帶下去。

677
00:33:28,500 --> 00:33:30,680
因此，實際上，也許這不是
你問什麼。

678
00:33:30,680 --> 00:33:36,240
>> LUCAS FREITAS：我認為她詢問
的情況下為：N比0，更大的情況下，

679
00:33:36,240 --> 00:33:37,150
小於0。

680
00:33:37,150 --> 00:33:39,210
>> LAUREN卡瓦略：也許開關
聲明是不是真的是你想要的東西

681
00:33:39,210 --> 00:33:39,880
在這種情況下使用。

682
00:33:39,880 --> 00:33:42,420
>> LUCAS FREITAS：switch語句是
只是值，所以你檢查

683
00:33:42,420 --> 00:33:45,370
該值是像這樣或那樣的。

684
00:33:45,370 --> 00:33:47,025
所以你不能真正
把條件。

685
00:33:47,025 --> 00:33:50,988

686
00:33:50,988 --> 00:33:55,920
>> 觀眾：如果什麼人
類型的[聽不清]？

687
00:33:55,920 --> 00:33:58,240
>> LAUREN卡瓦略：那將是
我的默認情況下，不幸的是

688
00:33:58,240 --> 00:33:58,910
你看不到。

689
00:33:58,910 --> 00:34:02,240
>> LUCAS FREITAS：[聽不清]
讓他們看到。

690
00:34:02,240 --> 00:34:03,690
>> LAUREN卡瓦略：其實，
你知道嗎？

691
00:34:03,690 --> 00:34:07,795
就讓我們去研究50，我會
只是放大在學習上的幻燈片

692
00:34:07,795 --> 00:34:10,610
50，因為這僅僅是煩人。

693
00:34:10,610 --> 00:34:14,938
所以讓我真正去條件。

694
00:34:14,938 --> 00:34:17,860
這只是要
取一小會兒。

695
00:34:17,860 --> 00:34:26,940

696
00:34:26,940 --> 00:34:27,840
>> 好的。

697
00:34:27,840 --> 00:34:29,590
所以，我很抱歉。

698
00:34:29,590 --> 00:34:33,625
至少現在，我們就可以看到
一切都沒有它切斷。

699
00:34:33,625 --> 00:34:36,230

700
00:34:36,230 --> 00:34:36,969
好的。

701
00:34:36,969 --> 00:34:43,800
>> 所以，如果他們把在10，我們將默認
這裡我默認情況下，我

702
00:34:43,800 --> 00:34:46,510
將只打印無效的，因為我
要求他們輸入一個整數

703
00:34:46,510 --> 00:34:49,460
1到3之間。

704
00:34:49,460 --> 00:34:50,650
還有沒有其他問題？

705
00:34:50,650 --> 00:34:51,081
是嗎？

706
00:34:51,081 --> 00:34:57,590
>> 觀眾：我們先來說說案例一，案例
3，說，你希望它是所有

707
00:34:57,590 --> 00:35:00,950
同樣的事情，所以你選擇了一個數
這不是一個中等數量。

708
00:35:00,950 --> 00:35:03,840
在這種情況下，會是多餘的？

709
00:35:03,840 --> 00:35:08,371
你只需要改變兩個文本
其中，或者會有一些

710
00:35:08,371 --> 00:35:08,617
冗餘？

711
00:35:08,617 --> 00:35:11,920
有什麼辦法來組合
[聽不清]？

712
00:35:11,920 --> 00:35:15,810
>> LAUREN卡瓦略：有辦法
結合他們，但我相信你可以

713
00:35:15,810 --> 00:35:18,730
只有結合相鄰。

714
00:35:18,730 --> 00:35:22,250
所以，如果我沒有什麼定義
對於案例二，這將

715
00:35:22,250 --> 00:35:24,130
適用於這兩種情況。

716
00:35:24,130 --> 00:35:28,110
哦，如果我沒有把任何東西的情況下
之一，這將同時適用於

717
00:35:28,110 --> 00:35:30,620
案例一和二。

718
00:35:30,620 --> 00:35:33,616
如果是有道理的。

719
00:35:33,616 --> 00:35:35,872
>> 觀眾：你能再說一遍嗎？

720
00:35:35,872 --> 00:35:36,670
>> LUCAS FREITAS：確定。

721
00:35:36,670 --> 00:35:39,950
如果你做了，基本上一樣，你有
同樣的事情，但你不把

722
00:35:39,950 --> 00:35:46,820
任何事情在這裡，你會無論是對
案例一案例二，做到這一點。

723
00:35:46,820 --> 00:35:47,930
對不對？

724
00:35:47,930 --> 00:35:54,010
如果你得到這個突破意味著
這個情況下，見好就收。

725
00:35:54,010 --> 00:35:55,030
所以，這就是剎車的意思。

726
00:35:55,030 --> 00:35:59,755
所以，如果我只是做了這個，你看，這是
情況之一，你只需做到這一點。

727
00:35:59,755 --> 00:36:02,110
如果是情況二，它也將
剛剛來這裡做。

728
00:36:02,110 --> 00:36:03,544
>> 觀眾：但是你能做到嗎？

729
00:36:03,544 --> 00:36:05,140
如果有東西
案例二[聽不清]

730
00:36:05,140 --> 00:36:07,095
>> LAUREN卡瓦略：我不相信
你可以做到這一點。

731
00:36:07,095 --> 00:36:09,380
我不認為你可以跳過左右。

732
00:36:09,380 --> 00:36:11,070
你可以做到這一點，羅布？

733
00:36:11,070 --> 00:36:13,300
我不認為如此。

734
00:36:13,300 --> 00:36:16,548
>> 觀眾：所以只有一個號碼
可以去一案之後，對不對？

735
00:36:16,548 --> 00:36:21,410
不能有案例一，逗號，二？

736
00:36:21,410 --> 00:36:21,970
>> LUCAS FREITAS：不，你不能。

737
00:36:21,970 --> 00:36:25,085
你絕對不能。

738
00:36:25,085 --> 00:36:28,770
>> LAUREN卡瓦略：我的意思是，問題是
這是一種選擇，而這可能不是

739
00:36:28,770 --> 00:36:31,940
適合你的使用情況，這樣，那麼你
在if條件會使用。

740
00:36:31,940 --> 00:36:33,906
>> 觀眾：那你為什麼還要這麼做？

741
00:36:33,906 --> 00:36:34,314
開關？

742
00:36:34,314 --> 00:36:38,540
>> LAUREN卡瓦略：我會用這
如果你很確定 - 

743
00:36:38,540 --> 00:36:39,730
實際上，盧卡斯，被你堵。

744
00:36:39,730 --> 00:36:40,982
>> LUCAS FREITAS：哦，對不起。

745
00:36:40,982 --> 00:36:44,200
>> LAUREN卡瓦略：如果你有非常
您要為定義的行為

746
00:36:44,200 --> 00:36:48,105
每一個輸入端，這可能是一個
小比寫出來更簡潔

747
00:36:48,105 --> 00:36:49,530
一個if語句為每一個。

748
00:36:49,530 --> 00:36:51,210
>> 觀眾：什麼的
再次突破是什麼意思？

749
00:36:51,210 --> 00:36:53,180
>> LAUREN卡瓦略：間隔意味著停止。

750
00:36:53,180 --> 00:36:56,860
請記住，如果我沒有這個破
在這裡，我們剛剛倒下

751
00:36:56,860 --> 00:36:58,110
進入下一個案例。

752
00:36:58,110 --> 00:37:00,820
>> LUCAS FREITAS：歇手段來獲得
出了switch語句。

753
00:37:00,820 --> 00:37:03,400
因為如果它是1，我想
打印該離開。

754
00:37:03,400 --> 00:37:04,640
我並不想檢查什麼。

755
00:37:04,640 --> 00:37:05,790
>> 觀眾：你不想
打印任何東西。

756
00:37:05,790 --> 00:37:06,730
>> LUCAS FREITAS：是啊。

757
00:37:06,730 --> 00:37:08,260
因為它是相互排斥的。

758
00:37:08,260 --> 00:37:11,378
>> 觀眾：而這是否只是進行
到下一個的情況下，如果第一種情況下

759
00:37:11,378 --> 00:37:11,850
是不是真的？

760
00:37:11,850 --> 00:37:14,120
抑或是測試所有的情況下，
在同一時間？

761
00:37:14,120 --> 00:37:16,300
>> LUCAS FREITAS：不，
檢查順序。

762
00:37:16,300 --> 00:37:18,070
按順序，是的。

763
00:37:18,070 --> 00:37:21,840
還有一個問題，那我們得
繼續前進，所以我們可以面面俱到。

764
00:37:21,840 --> 00:37:22,300
是嗎？

765
00:37:22,300 --> 00:37:25,280
>> 觀眾：所以對於的情況下，可以有
做了一些事情，除了只是一個？

766
00:37:25,280 --> 00:37:27,680
你可以給它一個範圍？

767
00:37:27,680 --> 00:37:28,580
>> LUCAS FREITAS：號

768
00:37:28,580 --> 00:37:29,900
>> LAUREN卡瓦略：我不認為
你可以給它一個範圍。

769
00:37:29,900 --> 00:37:31,430
>> LUCAS FREITAS：你不能你
不能給它一個範圍。

770
00:37:31,430 --> 00:37:33,190
>> 觀眾：此案是具體的
[聽不清]。

771
00:37:33,190 --> 00:37:34,840
>> LUCAS FREITAS：開關
是有點價值的。

772
00:37:34,840 --> 00:37:38,400
你在做不同的事情
上的值，為特定值。

773
00:37:38,400 --> 00:37:41,050
你不能做的範圍，你不能
做任何事情。

774
00:37:41,050 --> 00:37:43,055
它只是一個工具來查看。

775
00:37:43,055 --> 00:37:46,570
>> LAUREN卡瓦略：大多數人不使用
十分CS50 switch語句，

776
00:37:46,570 --> 00:37:48,760
但它的存在。

777
00:37:48,760 --> 00:37:49,920
>> 好的。

778
00:37:49,920 --> 00:37:53,870
因此，我們要談接下來的事情
大約是三元運算符。

779
00:37:53,870 --> 00:37:56,650
這只是另一種類型
有條件的。

780
00:37:56,650 --> 00:38:01,460
基本上，這是怎麼回事是我
尋求的整數，如果n為

781
00:38:01,460 --> 00:38:05,550
大於100，我要打印出來
“高”。如果不是的話，我要去

782
00:38:05,550 --> 00:38:07,010
打印出“低”。

783
00:38:07,010 --> 00:38:11,230
>> 所以它在做什麼是條件
在這裡，在括號和你

784
00:38:11,230 --> 00:38:13,550
一種能想到的問題
因為我問是否

785
00:38:13,550 --> 00:38:15,030
這是真的還是假的。

786
00:38:15,030 --> 00:38:18,485
如果這是真的，我要做到這一點首先
的事情，如果這不是真的，我

787
00:38:18,485 --> 00:38:20,020
要做到這第二件事。

788
00:38:20,020 --> 00:38:23,520

789
00:38:23,520 --> 00:38:27,960
>> 有關的任何問題
三元運算符？

790
00:38:27,960 --> 00:38:30,880
>> LUCAS FREITAS：只是想注意，從
大衛是，只要你有一個

791
00:38:30,880 --> 00:38:33,346
條件 - 

792
00:38:33,346 --> 00:38:35,690
>> LAUREN卡瓦略：我想大衛
通過實時流觀看。

793
00:38:35,690 --> 00:38:37,210
>> LUCAS FREITAS：他在幹什麼
生活流現在。

794
00:38:37,210 --> 00:38:41,730
所以，只要你有一個條件，你
應該把花括號，

795
00:38:41,730 --> 00:38:45,320
就像我們在一個開關
這裡聲明。

796
00:38:45,320 --> 00:38:46,750
我們在這裡有大括號。

797
00:38:46,750 --> 00:38:49,560
不管是什麼條件，你
應該也放了。

798
00:38:49,560 --> 00:38:50,820
>> LAUREN卡瓦略：你會看到
這在風格指南。

799
00:38:50,820 --> 00:38:52,900
我們實際上並不具備
風格指南現在。

800
00:38:52,900 --> 00:38:53,930
我覺得大衛還在工作。

801
00:38:53,930 --> 00:38:55,100
>> LUCAS FREITAS：他說，
它只是現在的工作。

802
00:38:55,100 --> 00:38:56,120
>> LAUREN卡瓦略：哦，原來是現在的工作？

803
00:38:56,120 --> 00:38:57,520
確定。

804
00:38:57,520 --> 00:39:02,060
因此很明顯，今年的風格
引導，即使你只是有一條線，

805
00:39:02,060 --> 00:39:06,040
你必須把那些
大括號英寸

806
00:39:06,040 --> 00:39:09,480
你不一定需要為
該程序的功能。

807
00:39:09,480 --> 00:39:12,210
也許我們應該休息一下
之後的條件和直行

808
00:39:12,210 --> 00:39:14,620
在風格指南來清除
一些這些東西？

809
00:39:14,620 --> 00:39:15,010
>> LUCAS FREITAS：是啊。

810
00:39:15,010 --> 00:39:15,775
你有問題嗎？

811
00:39:15,775 --> 00:39:17,580
>> 觀眾：不，我只是等待
直到風格指南。

812
00:39:17,580 --> 00:39:19,578
>> 觀眾：你能回去
以三元運算符？

813
00:39:19,578 --> 00:39:23,360
>> LAUREN卡瓦略：三元，是的。

814
00:39:23,360 --> 00:39:29,010
>> LUCAS FREITAS：三元運算符是
基本上是一個的if else語句，但

815
00:39:29,010 --> 00:39:33,590
而不必有兩條線
檢查了，如果再的

816
00:39:33,590 --> 00:39:36,600
否則，你只是有一條線。

817
00:39:36,600 --> 00:39:40,930
所以基本上，如果我想給一個字符串
高或低的，並且我的一個值

818
00:39:40,930 --> 00:39:46,270
想要做一個高，如果n大於
100還是低，如果是少，我能做些什麼

819
00:39:46,270 --> 00:39:47,730
這是[聽不清]

820
00:39:47,730 --> 00:39:53,060
該字符串將是，然後我
問該程序是n大於100？

821
00:39:53,060 --> 00:39:55,750
>> 所以這就是為什麼我有這樣的表達
在括號中，然後

822
00:39:55,750 --> 00:39:56,580
問號。

823
00:39:56,580 --> 00:39:59,110
我問的是它大於100？

824
00:39:59,110 --> 00:40:02,310
如果是這樣，這將是很高的。

825
00:40:02,310 --> 00:40:03,850
如果它不是，它要低。

826
00:40:03,850 --> 00:40:07,310
>> 所以基本上你認為是你問
一個問題，所以你把括號

827
00:40:07,310 --> 00:40:08,620
的條件。

828
00:40:08,620 --> 00:40:11,160
然後你把問號
因為你問吧。

829
00:40:11,160 --> 00:40:15,240
如果這是真的，這將是
在第一個值[聽不清]在這裡。

830
00:40:15,240 --> 00:40:18,176
如果不是的話，我打算把
值，冒號之後。

831
00:40:18,176 --> 00:40:21,580
這是否有意義？

832
00:40:21,580 --> 00:40:24,730
>> 這也是東西，就像是一個
工具在C，但你不必

833
00:40:24,730 --> 00:40:25,700
具體地使用它。

834
00:40:25,700 --> 00:40:29,890
但是CS的人通常喜歡
因為它只是節省了線。

835
00:40:29,890 --> 00:40:31,050
>> LAUREN卡瓦略：這是非常優雅。

836
00:40:31,050 --> 00:40:32,951
它做了很多，在短短一個語句。

837
00:40:32,951 --> 00:40:36,077
>> 觀眾：所以百分號是
只是無論對結果

838
00:40:36,077 --> 00:40:36,799
前行？

839
00:40:36,799 --> 00:40:38,260
>> LAUREN卡瓦略：哦，對不起。

840
00:40:38,260 --> 00:40:42,670
這百分號實際上是
一個佔位符，這個S。

841
00:40:42,670 --> 00:40:46,160
在printf語句，你有這個
串在這裡，這是怎麼回事，以

842
00:40:46,160 --> 00:40:48,440
打印出來，但你不能隨便
把這個在裡面。

843
00:40:48,440 --> 00:40:50,290
否則，將打印
出的S字面上。

844
00:40:50,290 --> 00:40:54,070
所以我們把一個百分點這裡，以保持
保持這個地方什麼

845
00:40:54,070 --> 00:40:57,590
談到在逗號後。

846
00:40:57,590 --> 00:40:59,470
>> 因此，對於一個字符串，你有百分之秒。

847
00:40:59,470 --> 00:41:00,950
對於一個整數，百分比我。

848
00:41:00,950 --> 00:41:03,330
對於浮動，百分比f。

849
00:41:03,330 --> 00:41:06,960
你會看到那些為我們
看到更多的例子。

850
00:41:06,960 --> 00:41:09,230
但也許你應該說說
風格指南一小會兒，現在

851
00:41:09,230 --> 00:41:10,480
它的了。

852
00:41:10,480 --> 00:41:21,040

853
00:41:21,040 --> 00:41:24,010
>> LUCAS FREITAS：如果你去
cs50.net/style，你會看到

854
00:41:24,010 --> 00:41:25,760
風格指南。

855
00:41:25,760 --> 00:41:32,420
對於習題集，你的分數為
習題集是由範圍，

856
00:41:32,420 --> 00:41:35,510
而如果你做了所有的基本含義
問題設置的部分，或者如果您

857
00:41:35,510 --> 00:41:37,170
嘗試一些東西。

858
00:41:37,170 --> 00:41:41,120
第二件事是正確，這
手段是你的程序在做什麼

859
00:41:41,120 --> 00:41:44,520
是應該做的，還是它
有錯誤，或者是它沒有做什麼

860
00:41:44,520 --> 00:41:45,620
它應該做的。

861
00:41:45,620 --> 00:41:51,420
>> 第三件事是設計，這意味著
你實現這口井，或者是

862
00:41:51,420 --> 00:41:54,520
您使用不必要的報表？

863
00:41:54,520 --> 00:41:59,400
因此，舉例來說，如果你想重複
一個數字的10倍，你在寫一個

864
00:41:59,400 --> 00:42:03,040
for循環還是你只是在做10次
相同的語句，只是在做

865
00:42:03,040 --> 00:42:04,060
複製和粘貼。

866
00:42:04,060 --> 00:42:05,760
這樣的設計對於那些。

867
00:42:05,760 --> 00:42:07,420
>> 最後，你有風格。

868
00:42:07,420 --> 00:42:12,000
風格就像判斷
如果你的代碼看起來

869
00:42:12,000 --> 00:42:14,050
可讀種漂亮，。

870
00:42:14,050 --> 00:42:16,520
這只是基本含義
是你的代碼可讀性？

871
00:42:16,520 --> 00:42:20,560
將別人誰一直在尋找有
你的代碼能夠了解什麼

872
00:42:20,560 --> 00:42:21,250
它在做什麼？

873
00:42:21,250 --> 00:42:25,360
它有意見之類的？

874
00:42:25,360 --> 00:42:30,430
>> 讓我們來談談的風格，
你應該使用。

875
00:42:30,430 --> 00:42:32,200
第一件事是註釋。

876
00:42:32,200 --> 00:42:35,280
註釋是非常重要的，你的
代碼，因為有時候你做

877
00:42:35,280 --> 00:42:38,750
你的程序，你知道到底是什麼
你想這樣做，你剛開始

878
00:42:38,750 --> 00:42:43,120
編碼，只要輸入了一堆C的，但
如果有人在看著你是

879
00:42:43,120 --> 00:42:47,500
代碼，他們不會要能夠
了解它，因為他們不知道

880
00:42:47,500 --> 00:42:51,420
是在你的腦袋的東西，比如
該pesudocode，所以也許他們會

881
00:42:51,420 --> 00:42:53,970
有一個很難理解
什麼代碼正在做什麼。

882
00:42:53,970 --> 00:42:57,900
>> 因此，註釋是真正有用的解釋
以人誰是在看

883
00:42:57,900 --> 00:43:00,880
你的代碼它在做什麼，和
實際上，即使對你來說，

884
00:43:00,880 --> 00:43:01,880
他們是非常有用的。

885
00:43:01,880 --> 00:43:05,740
當你去努力和辛勤pset時，
你會看到，代碼變得

886
00:43:05,740 --> 00:43:10,590
更長的時間，然後註釋是真的
所以你記住每一個重要的東西

887
00:43:10,590 --> 00:43:13,320
你的程序的一部分一樣。

888
00:43:13,320 --> 00:43:16,920
>> 把一個評論，你可以做一個
斜線斜線，然後寫一個評論。

889
00:43:16,920 --> 00:43:21,250
和整個行是註釋的一部分，
不管你寫下來，

890
00:43:21,250 --> 00:43:24,550
它不會是
用你的代碼。

891
00:43:24,550 --> 00:43:27,993
這基本上就像編譯器
將要忽略。

892
00:43:27,993 --> 00:43:29,290
這是否有道理？

893
00:43:29,290 --> 00:43:31,710
>> 觀眾：你又做了什麼
寫評論？

894
00:43:31,710 --> 00:43:33,260
>> LUCAS FREITAS：這個？

895
00:43:33,260 --> 00:43:36,020
斜線斜線？

896
00:43:36,020 --> 00:43:39,810
當您鍵入斜線斜線，無論
是在該行的是不會

897
00:43:39,810 --> 00:43:42,260
被認為是C。是嗎？

898
00:43:42,260 --> 00:43:45,910
>> 觀眾：所以註釋之後，你
剛剛進入並開始一個新行？

899
00:43:45,910 --> 00:43:47,120
>> LUCAS FREITAS：是的，沒錯。

900
00:43:47,120 --> 00:43:50,010
>> LAUREN卡瓦略：斜杠斜杠
是單行註釋。

901
00:43:50,010 --> 00:43:52,910
>> LUCAS FREITAS：例如，
在這裡，我們有 - 

902
00:43:52,910 --> 00:43:54,160
讓我放大 - 

903
00:43:54,160 --> 00:43:56,530

904
00:43:56,530 --> 00:44:01,180
例如，我在這裡聲明一個浮點數，
但也許，如果你只是把這個

905
00:44:01,180 --> 00:44:04,980
在你的代碼，就像你不知道
這是什麼在做什麼，其實像

906
00:44:04,980 --> 00:44:06,950
有人誰的看著這個代碼
將是一樣，什麼樣的

907
00:44:06,950 --> 00:44:09,190
到底是怎麼回事？

908
00:44:09,190 --> 00:44:12,890
>> 如果你把一個評論說“轉換
華氏攝氏度，這讓很多

909
00:44:12,890 --> 00:44:13,450
更有意義。

910
00:44:13,450 --> 00:44:15,480
你，想，好，你是
做一個轉換。

911
00:44:15,480 --> 00:44:16,730
這是否有道理？

912
00:44:16,730 --> 00:44:19,860

913
00:44:19,860 --> 00:44:24,960
所以它只是一些幫助人們
準備好你的代碼，也使

914
00:44:24,960 --> 00:44:28,290
你能夠組織
你的代碼更好。

915
00:44:28,290 --> 00:44:33,080
>> 第二件事是，你可以做
多行註釋，所以有一個

916
00:44:33,080 --> 00:44:34,850
對於一幫行的意見。

917
00:44:34,850 --> 00:44:38,880
相反，不必把斜線斜線
第一行註釋，斜線斜線，

918
00:44:38,880 --> 00:44:43,590
在第二行，依此類推，則
可以使用斜線明星。

919
00:44:43,590 --> 00:44:46,330
你做的方式是，對
註釋的第一行，你

920
00:44:46,330 --> 00:44:49,650
要做一個斜線明星明星，
所以就是這樣。

921
00:44:49,650 --> 00:44:56,900
就像我們這裡有初
一個程序，你通常把你們誰

922
00:44:56,900 --> 00:44:59,530
是，這是什麼節目呢，
和類似的東西。

923
00:44:59,530 --> 00:45:01,900
這有點像一個頭
對於該程序。

924
00:45:01,900 --> 00:45:04,540
>> 再次，它不是一個
編譯器會關心，但

925
00:45:04,540 --> 00:45:07,570
這是重要的，你知道這是什麼
程序執行或其他人

926
00:45:07,570 --> 00:45:09,960
知道你的程序在做什麼。

927
00:45:09,960 --> 00:45:17,480
這樣你就兇多吉少明星明星，然後
你要做明星最後一行

928
00:45:17,480 --> 00:45:22,250
削減到能夠關閉
這一評論。

929
00:45:22,250 --> 00:45:26,140
因此，基本上所有其它線路，
你可以只寫什麼，而這

930
00:45:26,140 --> 00:45:27,390
一切會被忽略。

931
00:45:27,390 --> 00:45:32,920

932
00:45:32,920 --> 00:45:37,780
>> 而且，正如風格，你看到
每一行都有一個明星，和所有

933
00:45:37,780 --> 00:45:39,380
星星是一致的。

934
00:45:39,380 --> 00:45:41,605
這些都是重要的東西，所以
你的代碼看起來很漂亮。

935
00:45:41,605 --> 00:45:42,855
聽起來不錯？

936
00:45:42,855 --> 00:45:45,320

937
00:45:45,320 --> 00:45:47,290
>> 現在，條件。

938
00:45:47,290 --> 00:45:52,240
什麼大衛說，我們應該
居然把這些幻燈片，是

939
00:45:52,240 --> 00:45:55,810
當你有任何形式的if語句
或任何種類的情況下，

940
00:45:55,810 --> 00:46:00,700
你應該使用大括號表明，
這是發生了什麼事情要發生

941
00:46:00,700 --> 00:46:02,730
當你具備的條件。

942
00:46:02,730 --> 00:46:07,560
從技術上講，當你有一個條件
然後下一行僅僅是一個

943
00:46:07,560 --> 00:46:12,110
行，你沒有在技術上有
把花括號。

944
00:46:12,110 --> 00:46:16,930
>> 基本上，編譯器會明白
反正是隱式的。

945
00:46:16,930 --> 00:46:21,100
但對於CS50，我們要求你們把
花括號只是讓你

946
00:46:21,100 --> 00:46:24,560
代碼更有條理
和更具可讀性。

947
00:46:24,560 --> 00:46:28,200
因為該代碼變得更長，如果你
沒有大括號和如此的。

948
00:46:28,200 --> 00:46:29,150
它變得非常凌亂。

949
00:46:29,150 --> 00:46:31,410
>> LAUREN卡瓦略：這正是
什麼大衛剛指出，

950
00:46:31,410 --> 00:46:33,000
在我以前的幻燈片。

951
00:46:33,000 --> 00:46:36,690
它絕對有效不帶花
括號，但對於文體的原因

952
00:46:36,690 --> 00:46:38,840
我們要問這個
你不要把那些英寸

953
00:46:38,840 --> 00:46:42,400
>> 而當你開始運行style50，
這是一種檢查50對

954
00:46:42,400 --> 00:46:44,860
風格，它會提醒你做到這一點。

955
00:46:44,860 --> 00:46:49,710
>> LUCAS FREITAS：還有一件事是
記得把花括號沿

956
00:46:49,710 --> 00:46:50,610
在每一行。

957
00:46:50,610 --> 00:46:52,490
所以你做什麼，例如，l的。

958
00:46:52,490 --> 00:46:56,910
轉到下一行，開大
撐，然後你去下一行。

959
00:46:56,910 --> 00:46:59,560
縮進，這是四個空格。

960
00:46:59,560 --> 00:47:03,570
那麼你就寫什麼，然後又
線，並關閉大括號。

961
00:47:03,570 --> 00:47:06,870
所以，要確保這兩個大
括號是在不同的線路。

962
00:47:06,870 --> 00:47:11,548
>> 觀眾：所以，如果這段代碼有一個像
10其他IFS，這應該

963
00:47:11,548 --> 00:47:13,040
有10套括號？

964
00:47:13,040 --> 00:47:14,610
>> LUCAS FREITAS：是的，為他們每個人。

965
00:47:14,610 --> 00:47:14,930
是啊。

966
00:47:14,930 --> 00:47:17,980
因此，如果，否則，如果，等等。

967
00:47:17,980 --> 00:47:21,990
>> 觀眾：你不能
按Tab鍵縮進？

968
00:47:21,990 --> 00:47:25,350
>> LUCAS FREITAS：我們要求您
你們用四個空格。

969
00:47:25,350 --> 00:47:30,060
一些文本編輯器翻譯標籤
作為四個空格自動。

970
00:47:30,060 --> 00:47:34,850
gedit中沒有，所以你必須
做空格空格空格空格。

971
00:47:34,850 --> 00:47:37,920
這也未嘗一些
程序員只能做標籤，有的

972
00:47:37,920 --> 00:47:40,560
程序員只能做四個空格，
和其他一些人甚至做

973
00:47:40,560 --> 00:47:41,900
2或3位。

974
00:47:41,900 --> 00:47:44,040
這只是我們在這裡問
你們做四個空格。

975
00:47:44,040 --> 00:47:47,556
>> 觀眾：有幾乎肯定
必須是一個方式的gedit來

976
00:47:47,556 --> 00:47:48,645
自動[聽不清]。

977
00:47:48,645 --> 00:47:50,480
像沒有[聽不清]這樣做的。

978
00:47:50,480 --> 00:47:51,150
>> LUCAS FREITAS：是啊。

979
00:47:51,150 --> 00:47:53,165
我覺得你可以去設置。

980
00:47:53,165 --> 00:47:55,270
>> 觀眾：它已經這樣做了這一切。

981
00:47:55,270 --> 00:47:56,410
>> LUCAS FREITAS：它已經這樣做？

982
00:47:56,410 --> 00:47:56,890
確定。

983
00:47:56,890 --> 00:48:00,854
因此，只要確保你
有4個空格。

984
00:48:00,854 --> 00:48:05,880
>> 觀眾：我們有沒有把捲髮
括號中的for循環呢？

985
00:48:05,880 --> 00:48:07,470
>> LUCAS FREITAS：是的。

986
00:48:07,470 --> 00:48:11,610
>> LAUREN卡瓦略：每當你的
封裝的代碼塊，就

987
00:48:11,610 --> 00:48:13,570
請使用大括號。

988
00:48:13,570 --> 00:48:18,040
而你認為我們只是之前
是拘泥於這個沒有很好的

989
00:48:18,040 --> 00:48:23,450
因此，如果你們幹什麼去了就搞定
高科技在實習的大公司，

990
00:48:23,450 --> 00:48:26,020
他們會給你一個風格指南，並
他們會告訴你，這是你的

991
00:48:26,020 --> 00:48:27,220
代碼需要的樣子。

992
00:48:27,220 --> 00:48:31,120
而且即使你學會了這樣的代碼
這一點，也許在你的實習

993
00:48:31,120 --> 00:48:32,680
你必須做一些事情
完全不同的。

994
00:48:32,680 --> 00:48:35,115
他們期望你符合
他們的風格。

995
00:48:35,115 --> 00:48:39,800
>> LUCAS FREITAS：還有一件事是
那你會注意我怎麼有這樣​​的x，

996
00:48:39,800 --> 00:48:42,290
空間少，空間，0？

997
00:48:42,290 --> 00:48:44,640
只要你有一個操作 - 

998
00:48:44,640 --> 00:48:50,490
它可以像加，減，時間，少，
更大，無論運營商 - 

999
00:48:50,490 --> 00:48:57,560
你必須把左邊的空間
和操作者的權利。

1000
00:48:57,560 --> 00:49:00,570
>> LAUREN卡瓦略：這些都是
稱為二進制操作數。

1001
00:49:00,570 --> 00:49:03,720
只要確保你總是空間
你的二進制操作數。

1002
00:49:03,720 --> 00:49:05,465
>> LUCAS FREITAS：這是
不是二元運算。

1003
00:49:05,465 --> 00:49:07,010
>> LAUREN卡瓦略：這是
因為它需要兩個。

1004
00:49:07,010 --> 00:49:08,260
>> LUCAS FREITAS：哦，是的。

1005
00:49:08,260 --> 00:49:13,340

1006
00:49:13,340 --> 00:49:14,590
>> OK，開關。

1007
00:49:14,590 --> 00:49:18,180

1008
00:49:18,180 --> 00:49:23,390
首先，你必須要看到，就像
在if或else語句，你有

1009
00:49:23,390 --> 00:49:28,280
把花括號在它自己的行
並根據這裡的大括號。

1010
00:49:28,280 --> 00:49:32,240
請注意，有一個空格
切換後，如果只是和其他人喜歡

1011
00:49:32,240 --> 00:49:35,360
我們之間有一個空格
這和括號。

1012
00:49:35,360 --> 00:49:36,610
所以，你必須把那個。

1013
00:49:36,610 --> 00:49:40,380

1014
00:49:40,380 --> 00:49:48,270
>> 而且也沒有空間，之後每
括號中或年底前

1015
00:49:48,270 --> 00:49:49,080
括號中。

1016
00:49:49,080 --> 00:49:52,612
所以你看，這一切都在一起，
也喜歡這裡了。

1017
00:49:52,612 --> 00:49:53,940
>> 是嗎？

1018
00:49:53,940 --> 00:49:58,040
>> LAUREN卡瓦略：我覺得
我們需要繼續前進。

1019
00:49:58,040 --> 00:50:02,340
>> LUCAS FREITAS：所以這是其中的一部分，
風格指南，你必須為CS50。

1020
00:50:02,340 --> 00:50:06,520
一定要到cs50.net/style
並看看這個。

1021
00:50:06,520 --> 00:50:09,250
這些都是非常重要的
為你的風格得分。

1022
00:50:09,250 --> 00:50:12,740

1023
00:50:12,740 --> 00:50:15,670
>> 讓我回去的語句。

1024
00:50:15,670 --> 00:50:17,070
>> LAUREN卡瓦略：我寧願
只需使用style50。

1025
00:50:17,070 --> 00:50:18,920
我們只是要去
直循環。

1026
00:50:18,920 --> 00:50:27,580

1027
00:50:27,580 --> 00:50:28,300
好的。

1028
00:50:28,300 --> 00:50:33,720
>> 因此，讓我們回到內容，現在
我們已經討論了在風格指南。

1029
00:50:33,720 --> 00:50:37,220
循環，你見過他們的划痕，並
我們要談論他們在

1030
00:50:37,220 --> 00:50:39,210
C.

1031
00:50:39,210 --> 00:50:44,400
>> 在fo​​r循環中，有
三個部分的

1032
00:50:44,400 --> 00:50:45,440
聲明這個for循環。

1033
00:50:45,440 --> 00:50:49,040
你有你的初始化中
您設置的變量。

1034
00:50:49,040 --> 00:50:52,160
你有你的條件，這是
檢查，看東西是否是

1035
00:50:52,160 --> 00:50:54,670
真或假，以及是否
循環應該繼續。

1036
00:50:54,670 --> 00:50:59,390
和你有你的更新，這
正在更新您的變數。

1037
00:50:59,390 --> 00:51:05,310
>> 就讓我們來簡單看看一些
這個C代碼的for循環在行動。

1038
00:51:05,310 --> 00:51:08,860
這是怎麼回事是在這裡的
初始化時，我們設置時i為0。

1039
00:51:08,860 --> 00:51:11,820
在此條件下，我們正在檢查
i是否小於10。

1040
00:51:11,820 --> 00:51:14,982
並在更新我們
i增加。

1041
00:51:14,982 --> 00:51:20,490
這樣會導致什麼
這個循環？

1042
00:51:20,490 --> 00:51:24,344
>> LUCAS FREITAS：其實，首先，
做你們知道我+ +是？

1043
00:51:24,344 --> 00:51:25,850
>> 觀眾：由1提高。

1044
00:51:25,850 --> 00:51:26,870
>> LUCAS FREITAS：增加1，是的。

1045
00:51:26,870 --> 00:51:30,020
因此，這是同樣的事情，
做我等於我加1。

1046
00:51:30,020 --> 00:51:35,890
並請注意，我們沒有一個空間
在i和+之間。

1047
00:51:35,890 --> 00:51:37,600
>> 所以，不要你們知道這是什麼會做什麼？

1048
00:51:37,600 --> 00:51:39,060
有人能告訴我嗎？

1049
00:51:39,060 --> 00:51:41,463
也許得到一些糖果
正因為如此？

1050
00:51:41,463 --> 00:51:42,912
>> 觀眾：[聽不清]

1051
00:51:42,912 --> 00:51:44,850
>> LUCAS FREITAS：確定。

1052
00:51:44,850 --> 00:51:45,400
[聽不清]

1053
00:51:45,400 --> 00:51:47,450
顯示大家以後[聽不清]。

1054
00:51:47,450 --> 00:51:49,565
是啊，它會顯示“此
是CS50“的10倍。

1055
00:51:49,565 --> 00:51:52,150
>> LAUREN卡瓦略：我想這是
在幻燈片的標題。

1056
00:51:52,150 --> 00:51:53,830
>> LUCAS FREITAS：哦，是的。

1057
00:51:53,830 --> 00:51:54,670
>> [笑]

1058
00:51:54,670 --> 00:51:56,790
>> LUCAS FREITAS：沒有什麼幫助。

1059
00:51:56,790 --> 00:51:58,370
>> LAUREN卡瓦略：那麼那些
對於循環。

1060
00:51:58,370 --> 00:52:03,200
我們將看到一些更多的例子
以後的循環。

1061
00:52:03,200 --> 00:52:06,510
但是，讓我們實際來看看的
第二種類型的循環，你會遇到

1062
00:52:06,510 --> 00:52:08,920
在C中，它就是所謂的while循環。

1063
00:52:08,920 --> 00:52:11,120
>> 在while循環中，你已經
剛剛得到一個條件。

1064
00:52:11,120 --> 00:52:14,790
條件是在檢查
開始，如果該條件

1065
00:52:14,790 --> 00:52:18,450
計算結果為true，那麼代碼中
而該塊體

1066
00:52:18,450 --> 00:52:20,380
將執行。

1067
00:52:20,380 --> 00:52:23,000
並且代碼將繼續
執行，只要該

1068
00:52:23,000 --> 00:52:24,450
條件保持為真。

1069
00:52:24,450 --> 00:52:28,350

1070
00:52:28,350 --> 00:52:33,320
>> 下面是C中的while循環的一個例子
我們將設置數為10〜

1071
00:52:33,320 --> 00:52:34,580
開始的時候。

1072
00:52:34,580 --> 00:52:41,800
只要計數值大於0時，
我們要保持打印出此

1073
00:52:41,800 --> 00:52:43,360
變量在這裡。

1074
00:52:43,360 --> 00:52:47,080
我們將遞減計數和
然後再檢查的條件。

1075
00:52:47,080 --> 00:52:51,370
打印，減量，檢查
的條件了。

1076
00:52:51,370 --> 00:52:54,530
>> 在這裡，我們有一個涉及一個例子
早期你的問題。

1077
00:52:54,530 --> 00:52:57,340
我們有百分之S當我們
打印出一個字符串，而現在

1078
00:52:57,340 --> 00:53:03,420
我們要打印出一個int，我們有一個
％的我作為我們的佔位符代替。

1079
00:53:03,420 --> 00:53:09,250
這些信件都應該是相當
直觀，s為字符串，i為整數。

1080
00:53:09,250 --> 00:53:15,400
>> 所以，如果這段代碼執行時，你應該
從10倒數到0時，打印出

1081
00:53:15,400 --> 00:53:15,925
每個整數。

1082
00:53:15,925 --> 00:53:19,460
>> LUCAS FREITAS：你能想到的
％，因為它感覺就像一個空白

1083
00:53:19,460 --> 00:53:23,960
空間，然後你把這個
這裡的變量在該空白。

1084
00:53:23,960 --> 00:53:27,640
因此，舉例來說，在這裡我將剛
一片空白，然後我把

1085
00:53:27,640 --> 00:53:30,262
算右那裡，
計數的值。

1086
00:53:30,262 --> 00:53:32,710
這是否有道理？

1087
00:53:32,710 --> 00:53:35,860
>> 難道我只是做如printf
然後報價，算什麼？

1088
00:53:35,860 --> 00:53:36,840
將這項工作？

1089
00:53:36,840 --> 00:53:37,980
>> 觀眾：號

1090
00:53:37,980 --> 00:53:41,190
>> LUCAS FREITAS：沒有，因為它會
實際打印的字“數”

1091
00:53:41,190 --> 00:53:42,850
而不是打印的值。

1092
00:53:42,850 --> 00:53:46,080
這是你如何讓它打印出值
朝向變量，而不是

1093
00:53:46,080 --> 00:53:47,670
可變的只是名稱。

1094
00:53:47,670 --> 00:53:48,530
有問題嗎？

1095
00:53:48,530 --> 00:53:53,060
>> 觀眾：你為什麼使用
作為反對一會兒？

1096
00:53:53,060 --> 00:53:56,130
>> LAUREN卡瓦略：我會用的
循環，如果我知道到底有多少

1097
00:53:56,130 --> 00:53:59,520
迭代我想我的循環運行。

1098
00:53:59,520 --> 00:54:02,810
在這種情況下，也沒有關係，因為
我的意思是，我只是想

1099
00:54:02,810 --> 00:54:05,310
想到一個非常簡單的
例如這個幻燈片。

1100
00:54:05,310 --> 00:54:09,990
但讓​​我們說，你想要的東西
堅持下去，而 - 

1101
00:54:09,990 --> 00:54:14,480
>> LUCAS FREITAS：例如，你
要求輸入，直到人

1102
00:54:14,480 --> 00:54:15,370
為您提供了正確的輸入。

1103
00:54:15,370 --> 00:54:19,720
所以像而輸入不
好了，一個勁兒地問它。

1104
00:54:19,720 --> 00:54:22,920
還是喜歡，而你父母不給
你的錢，不斷地問它。

1105
00:54:22,920 --> 00:54:23,430
>> [笑]

1106
00:54:23,430 --> 00:54:25,390
>> LAUREN卡瓦略：你不知道如何
很多時候，你就必須做到這一點。

1107
00:54:25,390 --> 00:54:27,292
>> LUCAS FREITAS：因為你不
知道多少倍的

1108
00:54:27,292 --> 00:54:28,010
要繼續下去。

1109
00:54:28,010 --> 00:54:30,397
>> LAUREN卡瓦略：但是，在一個for循環，
你需要知道多少倍。

1110
00:54:30,397 --> 00:54:33,640

1111
00:54:33,640 --> 00:54:33,860
是嗎？

1112
00:54:33,860 --> 00:54:38,520
>> 觀眾：我想弄清楚，百分比
說這是一些關於到

1113
00:54:38,520 --> 00:54:42,415
發生時，我的為整數，
和反斜線北 - 

1114
00:54:42,415 --> 00:54:43,910
>> LAUREN卡瓦略：什麼意思？

1115
00:54:43,910 --> 00:54:45,820
誰知道反斜杠n意思？

1116
00:54:45,820 --> 00:54:47,770
新的生產線，是的。

1117
00:54:47,770 --> 00:54:48,130
沒錯。

1118
00:54:48,130 --> 00:54:50,500
>> LUCAS FREITAS：你能想到的
n作為新行。

1119
00:54:50,500 --> 00:54:52,258
>> LAUREN卡瓦略：尼斯。

1120
00:54:52,258 --> 00:54:55,775
>> 觀眾：那是什麼數
短跑衝刺[聽不清]？

1121
00:54:55,775 --> 00:55:00,240
>> LUCAS FREITAS：減計數減為
同樣的事情，再加上加分，但

1122
00:55:00,240 --> 00:55:02,160
而不是增加，
它減少了1。

1123
00:55:02,160 --> 00:55:04,720

1124
00:55:04,720 --> 00:55:07,185
>> LAUREN卡瓦略：任何更多
while循環的問題？

1125
00:55:07,185 --> 00:55:09,460
沒有？

1126
00:55:09,460 --> 00:55:13,910
哦，我們應該
跳過了這一點。

1127
00:55:13,910 --> 00:55:14,950
>> 這是一個do while循環。

1128
00:55:14,950 --> 00:55:18,950
非常相似，除了在一個while循環
這種情況下，我們檢查的條件後，

1129
00:55:18,950 --> 00:55:23,430
中的主體的代碼
循環執行一次。

1130
00:55:23,430 --> 00:55:27,170
因此，我們執行的代碼
先不管。

1131
00:55:27,170 --> 00:55:31,956
然後我們檢查的情況下，執行
再次，如果條件為真。

1132
00:55:31,956 --> 00:55:35,450

1133
00:55:35,450 --> 00:55:38,950
>> 你會發現自己使用這個時
你要求用戶輸入。

1134
00:55:38,950 --> 00:55:42,080
因為你總是不得不
再問一次，然後根據什麼

1135
00:55:42,080 --> 00:55:46,570
用戶輸入的是，您可能需要
重新提示，如果再次問

1136
00:55:46,570 --> 00:55:50,670
輸入是不是你
希望它是。

1137
00:55:50,670 --> 00:55:53,610
>> 觀眾：所以它就像一個形式
供人填寫。

1138
00:55:53,610 --> 00:55:56,010
>> LAUREN卡瓦略：是的，沒錯。

1139
00:55:56,010 --> 00:55:59,720
你會發現，我想，在你的第一個
PSET，你將不得不

1140
00:55:59,720 --> 00:56:04,010
使用做好循環收集
來自用戶的輸入。

1141
00:56:04,010 --> 00:56:08,728
>> 觀眾：視情況而定，
您的while循環將傾向於運行更

1142
00:56:08,728 --> 00:56:12,805
往往比while循環，像
由一個或某事？

1143
00:56:12,805 --> 00:56:14,080
>> LAUREN卡瓦略：如果是準確的 - 

1144
00:56:14,080 --> 00:56:17,400
>> LUCAS FREITAS：他們應該始終運行
時代的確切數額，你

1145
00:56:17,400 --> 00:56:19,130
希望它運行。

1146
00:56:19,130 --> 00:56:23,860
就像我們用做的，而因為我們真的
想要得到的輸入至少一次。

1147
00:56:23,860 --> 00:56:27,220
在while循環，有時候你不想
執行它在所有，如果它不是

1148
00:56:27,220 --> 00:56:28,540
執行的情況。

1149
00:56:28,540 --> 00:56:31,300
因此它取決於設計。

1150
00:56:31,300 --> 00:56:35,900
我的意思是，你可以使用做，而或
而只要你的代碼做了

1151
00:56:35,900 --> 00:56:36,905
它應該做的。

1152
00:56:36,905 --> 00:56:38,470
>> LAUREN卡瓦略：但我
認為答案給你

1153
00:56:38,470 --> 00:56:40,540
問題很可能是肯定的。

1154
00:56:40,540 --> 00:56:42,190
假設條件是假的。

1155
00:56:42,190 --> 00:56:45,498
在一種情況下，它會運行一次，並
另一種情況下，它會運行零次。

1156
00:56:45,498 --> 00:56:47,370
所以，是的。

1157
00:56:47,370 --> 00:56:49,260
>> 還有什麼問題嗎？

1158
00:56:49,260 --> 00:56:50,320
是嗎？

1159
00:56:50,320 --> 00:56:56,443
>> 觀眾：可循環條件是
for循環中的變量其他條款

1160
00:56:56,443 --> 00:56:57,385
比[聽不清]。

1161
00:56:57,385 --> 00:57:01,700
>> LAUREN卡瓦略：是啊，
它可以是任何東西。

1162
00:57:01,700 --> 00:57:06,420
可能是開始pset時，你
不會遇到這種情況，但

1163
00:57:06,420 --> 00:57:09,878
肯定它可以是任何東西。

1164
00:57:09,878 --> 00:57:12,680
>> LUCAS FREITAS：我覺得
我們在這裡完成。

1165
00:57:12,680 --> 00:57:13,290
>> LAUREN卡瓦略：我們？

1166
00:57:13,290 --> 00:57:13,480
沒有？

1167
00:57:13,480 --> 00:57:13,870
>> LUCAS FREITAS：循環？

1168
00:57:13,870 --> 00:57:14,600
是啊。

1169
00:57:14,600 --> 00:57:16,280
>> LAUREN卡瓦略：我們不應該。

1170
00:57:16,280 --> 00:57:17,760
哦，我們已經完成了循環。

1171
00:57:17,760 --> 00:57:19,250
確定。

1172
00:57:19,250 --> 00:57:23,180
>> 事實上，因為我們一直在談論這樣
多，讓我們居然全部瀏覽

1173
00:57:23,180 --> 00:57:28,950
交給study.cs50.net/conditions。

1174
00:57:28,950 --> 00:57:34,460
而你要向下導航
對問題部件。

1175
00:57:34,460 --> 00:57:39,090
嗯，事實上，當人們越來越
這種設置中，CS50是研究

1176
00:57:39,090 --> 00:57:42,620
將是一個工具，你將轉錄因子
使用的部分，並且準備

1177
00:57:42,620 --> 00:57:45,230
你們可以使用，如果您錯過的部分。

1178
00:57:45,230 --> 00:57:48,980
這將包含一堆幻燈片，
一些提示和技巧對每個

1179
00:57:48,980 --> 00:57:54,030
的話題，和一些實際問題
的解決方案。

1180
00:57:54,030 --> 00:57:57,200
>> 為什麼不是每個人都只是來看看
這個問題就在這裡。

1181
00:57:57,200 --> 00:58:01,630

1182
00:58:01,630 --> 00:58:04,790
>> 對不起，我應該提醒
今天的人們帶來的筆記本電腦。

1183
00:58:04,790 --> 00:58:07,050
但是，如果你沒有
一台筆記本電腦，那也無妨。

1184
00:58:07,050 --> 00:58:10,140
你可以只記下來的
一張紙或查看

1185
00:58:10,140 --> 00:58:12,890
你的鄰居的肩膀。

1186
00:58:12,890 --> 00:58:16,380
>> 讓我們試著寫一個程序，
提示用戶採取了猜測，

1187
00:58:16,380 --> 00:58:19,250
每個家庭子女平均數
單元在美國。

1188
00:58:19,250 --> 00:58:22,265
這個數字是2，順便說一下，當你
從這些例子看。

1189
00:58:22,265 --> 00:58:24,770

1190
00:58:24,770 --> 00:58:29,030
>> 我們想打印出的平均數
在美國每個家庭的孩子，那麼我們

1191
00:58:29,030 --> 00:58:31,080
想什麼？

1192
00:58:31,080 --> 00:58:35,480
我們要收集的輸入
從用戶。

1193
00:58:35,480 --> 00:58:41,290
然後這取決於用戶的
輸入是，你要打印出

1194
00:58:41,290 --> 00:58:44,850
無論這是正確的
或者這是不正確的。

1195
00:58:44,850 --> 00:58:48,040
>> 而第一件事，你會
看，如果你點擊那個小箭頭

1196
00:58:48,040 --> 00:58:52,190
問題插件的底部是一個
當場記下一些偽代碼。

1197
00:58:52,190 --> 00:58:53,340
這樣你就不會編程呢。

1198
00:58:53,340 --> 00:58:56,740
你只是讓你的
思想秩序。

1199
00:58:56,740 --> 00:58:59,620
>> 有誰想幫助盧卡斯
想出正確的

1200
00:58:59,620 --> 00:59:01,270
偽代碼這個問題？

1201
00:59:01,270 --> 00:59:04,900
>> LUCAS FREITAS：什麼是第一件事情
我們也許應該在這裡做？

1202
00:59:04,900 --> 00:59:07,010
你們有什麼想法？

1203
00:59:07,010 --> 00:59:08,260
>> 觀眾：[聽不清]

1204
00:59:08,260 --> 00:59:12,060

1205
00:59:12,060 --> 00:59:13,290
>> LUCAS FREITAS：是的，確定。

1206
00:59:13,290 --> 00:59:16,610
因此，打印。

1207
00:59:16,610 --> 00:59:19,480
只是說在打印這個平均值
人數？

1208
00:59:19,480 --> 00:59:20,470
確定。

1209
00:59:20,470 --> 00:59:23,450
打印的問題，讓我們說。

1210
00:59:23,450 --> 00:59:25,951
之後我打印這個問題，
我該怎麼辦？

1211
00:59:25,951 --> 00:59:27,875
>> 觀眾：獲取輸入。

1212
00:59:27,875 --> 00:59:30,690
>> LUCAS FREITAS：獲取輸入。

1213
00:59:30,690 --> 00:59:32,864
還有別的嗎？

1214
00:59:32,864 --> 00:59:34,114
>> 觀眾：條件。

1215
00:59:34,114 --> 00:59:36,770

1216
00:59:36,770 --> 00:59:38,980
>> LUCAS FREITAS：條件。

1217
00:59:38,980 --> 00:59:41,325
>> LAUREN卡瓦略：那是什麼
情況會是什麼？

1218
00:59:41,325 --> 00:59:43,550
>> 觀眾：中[聽不清]的數量。

1219
00:59:43,550 --> 00:59:44,440
>> LAUREN卡瓦略：對。

1220
00:59:44,440 --> 00:59:46,945
>> LUCAS FREITAS：那麼我該怎麼
檢查的條件？

1221
00:59:46,945 --> 00:59:48,750
>> 觀眾：如果它等於2。

1222
00:59:48,750 --> 00:59:50,640
>> Lauren的CARVALHO：如果它等於2。

1223
00:59:50,640 --> 00:59:51,890
沒錯。

1224
00:59:51,890 --> 00:59:58,340

1225
00:59:58,340 --> 01:00:00,140
>> LUCAS FREITAS：這有什麼
否則，我應該怎麼辦？

1226
01:00:00,140 --> 01:00:01,390
>> 觀眾：計數。

1227
01:00:01,390 --> 01:00:05,184

1228
01:00:05,184 --> 01:00:08,110
>> LUCAS FREITAS：所以，如果它是
等於2，讓我們說 - 

1229
01:00:08,110 --> 01:00:14,250

1230
01:00:14,250 --> 01:00:17,960
讓我寫，如果輸入等於
2，然後我什麼都

1231
01:00:17,960 --> 01:00:23,665
需要做的就是正確的。

1232
01:00:23,665 --> 01:00:26,230

1233
01:00:26,230 --> 01:00:31,826
然後別人，我要去
打印不正確。

1234
01:00:31,826 --> 01:00:34,600

1235
01:00:34,600 --> 01:00:37,720
還有別的嗎？

1236
01:00:37,720 --> 01:00:38,670
沒有？

1237
01:00:38,670 --> 01:00:40,500
>> LAUREN卡瓦略：所以你
可以點擊 - 

1238
01:00:40,500 --> 01:00:42,290
每個人都擁有這樣下來？

1239
01:00:42,290 --> 01:00:44,680
>> LUCAS FREITAS：這是否有意義？

1240
01:00:44,680 --> 01:00:46,226
所以，現在讓我們嘗試編寫這一點。

1241
01:00:46,226 --> 01:00:50,140
>> LAUREN卡瓦略：如果您按一下小
箭頭，它實際上可以節省您的

1242
01:00:50,140 --> 01:00:51,900
偽代碼，這實在是令人振奮的。

1243
01:00:51,900 --> 01:00:56,480
你可以讓那些為註釋如果
你要只是為了提醒自己

1244
01:00:56,480 --> 01:00:57,075
該怎麼做。

1245
01:00:57,075 --> 01:01:01,555
>> LUCAS FREITAS：因此，例如，第一
我要打印的問題，所以

1246
01:01:01,555 --> 01:01:05,930
我應該如何去做到這一點，其實？

1247
01:01:05,930 --> 01:01:07,050
printf的。

1248
01:01:07,050 --> 01:01:12,130
所以printf的，問題是平均
每個兒童的數量

1249
01:01:12,130 --> 01:01:14,110
家人在美國。

1250
01:01:14,110 --> 01:01:19,070

1251
01:01:19,070 --> 01:01:21,790
>> 然後我會得到
來自用戶的輸入。

1252
01:01:21,790 --> 01:01:29,050

1253
01:01:29,050 --> 01:01:31,324
我那麼如何才能做到這一點？

1254
01:01:31,324 --> 01:01:32,200
>> 觀眾：找詮釋。

1255
01:01:32,200 --> 01:01:33,076
>> LAUREN卡瓦略：調用getInt。

1256
01:01:33,076 --> 01:01:33,890
>> LUCAS FREITAS：確定。

1257
01:01:33,890 --> 01:01:35,220
所以先聲明，對不對？

1258
01:01:35,220 --> 01:01:39,300
整型，姑且稱之為n等於調用getInt。

1259
01:01:39,300 --> 01:01:42,610

1260
01:01:42,610 --> 01:01:44,670
>> 而現在的情況。

1261
01:01:44,670 --> 01:01:49,250
所以，讓我說，我要去
來看看這裡的答案。

1262
01:01:49,250 --> 01:01:57,290
因此，首先，如果輸入，這為n，等於
到 - 我應該如何去寫呢？

1263
01:01:57,290 --> 01:01:58,480
>> 觀眾：平等相等。

1264
01:01:58,480 --> 01:02:00,000
>> LUCAS FREITAS：完美。

1265
01:02:00,000 --> 01:02:00,670
因此n。

1266
01:02:00,670 --> 01:02:04,600
並請注意，我做一個空間，
等於，等於，空間，真實的。

1267
01:02:04,600 --> 01:02:06,930
現在我該怎麼辦？

1268
01:02:06,930 --> 01:02:08,820
東西的風格很重要。

1269
01:02:08,820 --> 01:02:10,070
大括號。

1270
01:02:10,070 --> 01:02:16,570

1271
01:02:16,570 --> 01:02:17,795
>> 然後我去打印。

1272
01:02:17,795 --> 01:02:19,790
如何打印？

1273
01:02:19,790 --> 01:02:22,500
printf的。

1274
01:02:22,500 --> 01:02:24,568
>> 觀眾：難道資本化？

1275
01:02:24,568 --> 01:02:27,166

1276
01:02:27,166 --> 01:02:28,380
>> LUCAS FREITAS：號

1277
01:02:28,380 --> 01:02:31,000
它應該全部小寫。

1278
01:02:31,000 --> 01:02:32,250
所以這是正確的。

1279
01:02:32,250 --> 01:02:40,990

1280
01:02:40,990 --> 01:02:44,870
>> 請問這足以令的printf
語句，還是我缺少什麼？

1281
01:02:44,870 --> 01:02:46,265
>> 觀眾：新線。

1282
01:02:46,265 --> 01:02:50,220
>> LUCAS FREITAS：新線，是的。

1283
01:02:50,220 --> 01:02:51,250
現在別的。

1284
01:02:51,250 --> 01:02:57,290
>> 觀眾：是否有空間
中的printf後，還是沒有呢？

1285
01:02:57,290 --> 01:03:00,820
>> LAUREN卡瓦略：我們應該
檢查風格指南。

1286
01:03:00,820 --> 01:03:02,260
>> 觀眾：它不應該。

1287
01:03:02,260 --> 01:03:03,510
>> LUCAS FREITAS：應該不是，確定。

1288
01:03:03,510 --> 01:03:05,820

1289
01:03:05,820 --> 01:03:13,605
所以別的，printf的，“這是不正確的。”

1290
01:03:13,605 --> 01:03:17,105
>> LAUREN卡瓦略：哎呀，你的報價。

1291
01:03:17,105 --> 01:03:17,950
>> LUCAS FREITAS：確定。

1292
01:03:17,950 --> 01:03:18,600
還有別的嗎？

1293
01:03:18,600 --> 01:03:20,770
它是否好看？

1294
01:03:20,770 --> 01:03:21,890
>> LAUREN卡瓦略：大家試試吧？

1295
01:03:21,890 --> 01:03:23,190
>> LUCAS FREITAS：是啊，讓我們來運行它。

1296
01:03:23,190 --> 01:03:25,880

1297
01:03:25,880 --> 01:03:29,070
所以它的編譯，並將其
看來，它的工作原理。

1298
01:03:29,070 --> 01:03:31,465
讓我們嘗試兩個孩子。

1299
01:03:31,465 --> 01:03:34,110
這是正確的。

1300
01:03:34,110 --> 01:03:37,300
現在讓我們再次運行，但現在反而
把兩個孩子，讓我們的

1301
01:03:37,300 --> 01:03:40,990
說，我要去把像5。

1302
01:03:40,990 --> 01:03:41,515
這是不正確的。

1303
01:03:41,515 --> 01:03:42,670
如此看來，它的工作原理。

1304
01:03:42,670 --> 01:03:44,160
>> LAUREN卡瓦略：你為什麼不向他們展示
如果你把東西會發生什麼

1305
01:03:44,160 --> 01:03:45,055
奇怪，像一些字母。

1306
01:03:45,055 --> 01:03:45,790
>> LUCAS FREITAS：哦，是的。

1307
01:03:45,790 --> 01:03:47,430
讓我們也檢查。

1308
01:03:47,430 --> 01:03:51,170
如果什麼用戶試圖一塌糊塗
與你的程序，他們只是

1309
01:03:51,170 --> 01:03:57,430
寫的，我不知道兩。

1310
01:03:57,430 --> 01:03:58,320
它會說重試。

1311
01:03:58,320 --> 01:04:00,780
>> LAUREN卡瓦略：所以調用getInt
是要求他們重試。

1312
01:04:00,780 --> 01:04:02,115
我們沒有照顧
那我們自己。

1313
01:04:02,115 --> 01:04:02,750
>> LUCAS FREITAS：是啊。

1314
01:04:02,750 --> 01:04:06,853
所以，除非我居然把一個數字，它是
要不斷地問我重試。

1315
01:04:06,853 --> 01:04:08,330
>> 觀眾：你是怎麼運行呢？

1316
01:04:08,330 --> 01:04:10,570
>> LUCAS FREITAS：只要按一下
這個星號按鈕。

1317
01:04:10,570 --> 01:04:11,940
>> LAUREN卡瓦略：你應該上去。

1318
01:04:11,940 --> 01:04:13,320
你去那裡。

1319
01:04:13,320 --> 01:04:15,550
>> LUCAS FREITAS：星形
按鈕就在那裡。

1320
01:04:15,550 --> 01:04:16,040
是嗎？

1321
01:04:16,040 --> 01:04:19,960
>> 觀眾：是否提示[聽不清]
與十進制數嗎？

1322
01:04:19,960 --> 01:04:21,235
>> LAUREN卡瓦略：我相信會的。

1323
01:04:21,235 --> 01:04:22,660
>> LUCAS FREITAS：如果它做什麼？

1324
01:04:22,660 --> 01:04:24,990
>> LAUREN卡瓦略：如果他們輸入
在一個十進制數，我覺得

1325
01:04:24,990 --> 01:04:25,880
它會提示。

1326
01:04:25,880 --> 01:04:26,586
>> LUCAS FREITAS：讓我們來看看。

1327
01:04:26,586 --> 01:04:28,360
>> LAUREN卡瓦略：因為
它不是一個int。

1328
01:04:28,360 --> 01:04:32,056

1329
01:04:32,056 --> 01:04:33,442
>> LUCAS FREITAS：是啊。

1330
01:04:33,442 --> 01:04:37,370
>> LAUREN卡瓦略：所以它不是一個int，
得到詮釋將要求您重試。

1331
01:04:37,370 --> 01:04:40,795
>> 觀眾：那麼，在該代碼將
提示的小數位

1332
01:04:40,795 --> 01:04:46,005
用戶，他們必須輸入
一個整數，具體一點嗎？

1333
01:04:46,005 --> 01:04:48,480
>> LAUREN卡瓦略：調用getInt實際上是
這樣做，對我們來說。

1334
01:04:48,480 --> 01:04:50,600
>> 觀眾：不是，我的意思是，如果我們想
進入[聽不清]

1335
01:04:50,600 --> 01:04:55,070
>> LUCAS FREITAS：你可以說像平均
在美國的子女數。

1336
01:04:55,070 --> 01:04:56,120
我不知道。

1337
01:04:56,120 --> 01:05:01,761
我們可以說，例如，“請
輸入的整數。“

1338
01:05:01,761 --> 01:05:04,270
>> LAUREN卡瓦略：一個整數，等於
到的平均數目。

1339
01:05:04,270 --> 01:05:06,190
我的意思是，它只是如何
你話呢，對吧？

1340
01:05:06,190 --> 01:05:06,520
>> LUCAS FREITAS：是啊。

1341
01:05:06,520 --> 01:05:08,420
這實際上是不可能的編碼的一部分。

1342
01:05:08,420 --> 01:05:11,000
它是更多的像什麼
你會想

1343
01:05:11,000 --> 01:05:13,987
寫在你的程序。

1344
01:05:13,987 --> 01:05:17,723
>> 觀眾：怎麼會，我們已經運行它，如果它
實際上是在gedit中[聽不清]。

1345
01:05:17,723 --> 01:05:19,130
而不是壓著打？

1346
01:05:19,130 --> 01:05:21,180
>> LUCAS FREITAS：我們會
首先編譯它。

1347
01:05:21,180 --> 01:05:25,080
我們可以通過做湊合吧
和該文件的名稱。

1348
01:05:25,080 --> 01:05:29,896
然後運行它，我們會做點斜線
和該程序的名稱。

1349
01:05:29,896 --> 01:05:36,588
>> 觀眾：我想我的意思是，如果
我們希望該方案以應對

1350
01:05:36,588 --> 01:05:42,010
他們不正確，無效的條目，
你不應該把 - 

1351
01:05:42,010 --> 01:05:45,710
>> LUCAS FREITAS：我們將無法
做到這一點，因為這個代碼表示

1352
01:05:45,710 --> 01:05:50,350
重試來自獲取詮釋其是
一個已經實現的功能

1353
01:05:50,350 --> 01:05:55,790
我們通過CS50庫，並且由於
它已經實現在那裡，我們

1354
01:05:55,790 --> 01:05:58,340
不能隨便[聽不清]。

1355
01:05:58,340 --> 01:06:00,780
>> LAUREN卡瓦略：如果你不使用
調用getInt，那麼你就可以做到這一點。

1356
01:06:00,780 --> 01:06:01,490
>> LUCAS FREITAS：是啊。

1357
01:06:01,490 --> 01:06:03,750
但是，如果你使用的是調用getInt，你不能。

1358
01:06:03,750 --> 01:06:05,427
還有沒有其他問題？

1359
01:06:05,427 --> 01:06:12,938
>> 觀眾：請問您去與像
GetFloat然後能夠把

1360
01:06:12,938 --> 01:06:14,381
它在一個小數？

1361
01:06:14,381 --> 01:06:15,343
>> LUCAS FREITAS：是啊。

1362
01:06:15,343 --> 01:06:15,824
>> 觀眾：確定。

1363
01:06:15,824 --> 01:06:19,210
然後你只需輸入能
飄起了一個等號 - 

1364
01:06:19,210 --> 01:06:19,950
>> LAUREN卡瓦略：是啊。

1365
01:06:19,950 --> 01:06:22,740
除了一個完全相同的
浮而不是一個int。

1366
01:06:22,740 --> 01:06:27,372
>> LUCAS FREITAS：只要把它放在這裡
然後GetFloat那裡。

1367
01:06:27,372 --> 01:06:29,795
>> 觀眾：當你將
看到或已經看到 - 

1368
01:06:29,795 --> 01:06:31,327
>> LAUREN卡瓦略：我們有
沒有得到那裡。

1369
01:06:31,327 --> 01:06:36,490
>> 觀眾： - 做與不平等
花車不[聽不清]

1370
01:06:36,490 --> 01:06:40,290
>> 觀眾：是什麼分號是什麼意思？

1371
01:06:40,290 --> 01:06:43,220
>> LAUREN卡瓦略：分號剛
也就是說，這種說法是完整的，

1372
01:06:43,220 --> 01:06:45,030
我們打算去
到下一張幻燈片。

1373
01:06:45,030 --> 01:06:47,040
>> 觀眾：所以這是必要的
每一次？

1374
01:06:47,040 --> 01:06:48,330
>> LAUREN卡瓦略：是啊。

1375
01:06:48,330 --> 01:06:53,130
好了，好了，沒有這些條件，
因為他們是

1376
01:06:53,130 --> 01:06:54,090
封裝的東西。

1377
01:06:54,090 --> 01:07:00,290
所以基本上，如果事情是造成
你再創建一個大括號

1378
01:07:00,290 --> 01:07:03,000
塊，不要把一個分號
在末端。

1379
01:07:03,000 --> 01:07:04,200
>> LUCAS FREITAS：但是，一切都
否則，是的。

1380
01:07:04,200 --> 01:07:06,670
當你完成一項聲明，
把分號。

1381
01:07:06,670 --> 01:07:10,380
如果你忘了分號，則
編譯器會得到你生氣，

1382
01:07:10,380 --> 01:07:12,640
而你將不得不
以嘗試修復它。

1383
01:07:12,640 --> 01:07:16,520
>> LAUREN卡瓦略：如果我把一個分號
在這裡，將停止這一點，我

1384
01:07:16,520 --> 01:07:18,780
永遠不會得到執行什麼
內，通過的方式。

1385
01:07:18,780 --> 01:07:21,113
所以它的那些常見的錯誤之一。

1386
01:07:21,113 --> 01:07:22,390
>> 觀眾：始終執行。

1387
01:07:22,390 --> 01:07:22,950
>> LAUREN卡瓦略：是啊。

1388
01:07:22,950 --> 01:07:25,860
在這種情況下，我們總是
執行裡面有什麼。

1389
01:07:25,860 --> 01:07:29,050
>> 觀眾：你的風格[聽不清]
附加的你，想過。

1390
01:07:29,050 --> 01:07:29,802
>> LAUREN卡瓦略：哦，這是真的。

1391
01:07:29,802 --> 01:07:34,298
>> 觀眾：[聽不清]單
行的事[聽不清]

1392
01:07:34,298 --> 01:07:35,286
>> 觀眾：是的？

1393
01:07:35,286 --> 01:07:37,756
>> 觀眾：你可以有多個
在一個線路輸入？

1394
01:07:37,756 --> 01:07:41,214
所以像你可以問用戶
打印兩件事？

1395
01:07:41,214 --> 01:07:42,530
>> LAUREN卡瓦略：不使用 - 

1396
01:07:42,530 --> 01:07:44,520
>> LUCAS FREITAS：號

1397
01:07:44,520 --> 01:07:47,040
比方說，我也想
得到這個整數米。

1398
01:07:47,040 --> 01:07:49,558
我必須這樣做，在不同的線路。

1399
01:07:49,558 --> 01:07:54,992
>> 觀眾：如果你要運行
即，如何[聽不清]？

1400
01:07:54,992 --> 01:07:59,438
這將打印的提示
有[聽不清]

1401
01:07:59,438 --> 01:08:00,940
然後你會進入一個， - 

1402
01:08:00,940 --> 01:08:01,840
>> LAUREN卡瓦略：嗯，運行它。

1403
01:08:01,840 --> 01:08:04,365
我的意思是，沒有什麼從阻止我們
只需運行它，看到什麼

1404
01:08:04,365 --> 01:08:06,610
會發生什麼。

1405
01:08:06,610 --> 01:08:08,080
>> LUCAS FREITAS：我認為這是
要在抱怨我們

1406
01:08:08,080 --> 01:08:08,977
因為我們沒有使用 - 

1407
01:08:08,977 --> 01:08:09,751
>> LAUREN卡瓦略：哎呀。

1408
01:08:09,751 --> 01:08:12,580
>> LUCAS FREITAS：它在抱怨我們的權利
現在，因為我們沒有使用這個

1409
01:08:12,580 --> 01:08:21,640
可變的，但如果我這樣做，例如，
n是等於等於，和m等於

1410
01:08:21,640 --> 01:08:26,849
等於，那麼會出現什麼
發生這種情況？

1411
01:08:26,849 --> 01:08:28,830
什麼這個節目嗎？

1412
01:08:28,830 --> 01:08:30,330
>> 觀眾：我只是想知道
它怎麼會 - 

1413
01:08:30,330 --> 01:08:31,550
>> LAUREN卡瓦略：她只是想
要知道它的外觀

1414
01:08:31,550 --> 01:08:34,189
像，我想，對不對？

1415
01:08:34,189 --> 01:08:36,819
於是花了其中之一，然後
它採取了第二個。

1416
01:08:36,819 --> 01:08:41,279

1417
01:08:41,279 --> 01:08:43,069
>> 我認為我們應該繼續前進，
因為我們多了一個

1418
01:08:43,069 --> 01:08:44,689
幻燈片放映去之前 - 

1419
01:08:44,689 --> 01:08:46,269
你要拉起來的數學？

1420
01:08:46,269 --> 01:08:47,558
>> LUCAS FREITAS：是啊，數學。

1421
01:08:47,558 --> 01:09:00,033

1422
01:09:00,033 --> 01:09:02,206
>> LAUREN卡瓦略：給
我只是一秒鐘。

1423
01:09:02,206 --> 01:09:07,390

1424
01:09:07,390 --> 01:09:14,260
>> 有幾個不同的數值
在C C.數值數據變量

1425
01:09:14,260 --> 01:09:18,130
可以分為不同的類型，
而這些是那些你會

1426
01:09:18,130 --> 01:09:19,570
看到最頻繁。

1427
01:09:19,570 --> 01:09:20,910
>> 和int是整數。

1428
01:09:20,910 --> 01:09:23,189
你不能有任何小數。

1429
01:09:23,189 --> 01:09:27,754
在電器，它需要
32位來存儲一個int。

1430
01:09:27,754 --> 01:09:30,450
>> 一個浮點可以有小數。

1431
01:09:30,450 --> 01:09:34,330
它也需要32位來存儲
一個漂浮在電器。

1432
01:09:34,330 --> 01:09:42,270
>> 雙是一個數字帶小數
點需要64位來存儲它，

1433
01:09:42,270 --> 01:09:44,470
這意味著你可以有
更高的精確度，因為

1434
01:09:44,470 --> 01:09:46,426
你可以有更多的 - 

1435
01:09:46,426 --> 01:09:47,785
你怎麼稱呼它？

1436
01:09:47,785 --> 01:09:48,640
>> LUCAS FREITAS：是啊，這更多。

1437
01:09:48,640 --> 01:09:52,140
>> LAUREN卡瓦略：更多地方
小數點後。

1438
01:09:52,140 --> 01:09:57,140
和久長是一個整數
這需要64位

1439
01:09:57,140 --> 01:09:58,395
其疼痛的電器。

1440
01:09:58,395 --> 01:10:00,278
>> LUCAS FREITAS：所以它可以
比整數大即可。

1441
01:10:00,278 --> 01:10:03,320

1442
01:10:03,320 --> 01:10:08,380
>> LAUREN卡瓦略：關於數據的東西
C語言的類型是，他們告訴你什麼

1443
01:10:08,380 --> 01:10:11,050
樣的數據可以存儲
在您的變量。

1444
01:10:11,050 --> 01:10:15,860
他們會告訴你如何使用這個
變量在你的程序。

1445
01:10:15,860 --> 01:10:19,650
這是非常重要的，只是跟踪
什麼樣的數據類型，你正在使用的，如果

1446
01:10:19,650 --> 01:10:23,070
你需要轉換從一個數據類型
另一個，確保你知道

1447
01:10:23,070 --> 01:10:25,250
究竟發生了什麼時
鑄造發生。

1448
01:10:25,250 --> 01:10:28,520
你會看到一個例子後
在上一這些幻燈片

1449
01:10:28,520 --> 01:10:31,490
錯誤可能發生。

1450
01:10:31,490 --> 01:10:35,300
>> 讓我們來看看C語言的一些數學和
覺得真的很用心，我猜，

1451
01:10:35,300 --> 01:10:38,470
這是怎麼回事就當這
數學正在發生。

1452
01:10:38,470 --> 01:10:43,552
在第一行，有什麼
發生的事情時，我x聲明？

1453
01:10:43,552 --> 01:10:48,921
>> 觀眾：你讓
X要的東西？

1454
01:10:48,921 --> 01:10:49,700
>> LAUREN卡瓦略：是啊。

1455
01:10:49,700 --> 01:10:54,040
好吧，我真的問工作
系統為32位的內存，對不對？

1456
01:10:54,040 --> 01:10:57,890
我在其中可以存儲一個int，並
我要調用詮釋x。

1457
01:10:57,890 --> 01:11:01,370
>> LUCAS FREITAS：基本上會在內存中
並發現有32個地方

1458
01:11:01,370 --> 01:11:05,290
位和說法，哎，我想這個空間，
它的將是名為x。

1459
01:11:05,290 --> 01:11:08,590
所以，你只是相當多的發現
在你的記憶的盒子

1460
01:11:08,590 --> 01:11:10,440
存儲值對於x。

1461
01:11:10,440 --> 01:11:13,980
>> LAUREN卡瓦略：然後我初始化
x，它意味著，我只是存儲

1462
01:11:13,980 --> 01:11:20,270
2在那個地方，那個塊的價值
內存，我們問經營

1463
01:11:20,270 --> 01:11:21,860
制度。

1464
01:11:21,860 --> 01:11:25,090
而這兒正是我們正在做的是
我們實際上並聲明

1465
01:11:25,090 --> 01:11:29,060
在一行中初始化Ÿ代替
在兩行像我們一樣在這裡，

1466
01:11:29,060 --> 01:11:33,960
這也是一個完美的罰款，我們是
加1到x，和我們的存儲

1467
01:11:33,960 --> 01:11:34,950
在y值。

1468
01:11:34,950 --> 01:11:39,360
>> LUCAS FREITAS：所以基本上這是什麼
行呢，它現在發現一個盒子Y，

1469
01:11:39,360 --> 01:11:41,990
然後將其值，在東西
你打算把箱子裡面，是

1470
01:11:41,990 --> 01:11:43,800
將是x的值加1。

1471
01:11:43,800 --> 01:11:45,850
所以它有這個方塊年。

1472
01:11:45,850 --> 01:11:49,980
它得到x的值，看起來
在這裡，看看它的2。

1473
01:11:49,980 --> 01:11:53,035
把它放在那裡，加1，所以
它把一個3那裡。

1474
01:11:53,035 --> 01:11:54,290
這是否有道理？

1475
01:11:54,290 --> 01:11:55,780
所以y是2在這種情況下。

1476
01:11:55,780 --> 01:11:58,993

1477
01:11:58,993 --> 01:12:00,770
>> LAUREN卡瓦略：好吧，冷靜。

1478
01:12:00,770 --> 01:12:06,010
我們看到了一些另外，讓我們覺得現在
關於分工。這裡我

1479
01:12:06,010 --> 01:12:11,490
聲明和初始化一個浮點
所謂的答案，1除以10，

1480
01:12:11,490 --> 01:12:14,860
然後我打印出來的答案
到小數點後兩位。

1481
01:12:14,860 --> 01:12:18,800
並注意在這裡，在我的printf語句，
當我想打印的東西兩

1482
01:12:18,800 --> 01:12:25,600
小數位，％.2 f是
我想用。

1483
01:12:25,600 --> 01:12:28,880

1484
01:12:28,880 --> 01:12:31,760
因此，問題2只是說
我需要經過兩地

1485
01:12:31,760 --> 01:12:34,980
十進制打印出來。

1486
01:12:34,980 --> 01:12:38,740
>> 現在，什麼事情要發生
如果我運行這個代碼？

1487
01:12:38,740 --> 01:12:40,500
有沒有人有一個想法？

1488
01:12:40,500 --> 01:12:42,721
你會打印出來？

1489
01:12:42,721 --> 01:12:45,010
>> LUCAS FREITAS：什麼是
我們期望得到的。

1490
01:12:45,010 --> 01:12:46,810
>> LAUREN卡瓦略：做什麼
我們想，首先？

1491
01:12:46,810 --> 01:12:48,871
>> LUCAS FREITAS：[聽不清]

1492
01:12:48,871 --> 01:12:51,120
>> LAUREN卡瓦略：0.1，是的。

1493
01:12:51,120 --> 01:12:52,325
但是，會打印出？

1494
01:12:52,325 --> 01:12:53,275
>> 觀眾：[聽不清]

1495
01:12:53,275 --> 01:12:56,760
>> LAUREN卡瓦略：哦，不，其實。

1496
01:12:56,760 --> 01:13:01,400
這就是我說的是你為什麼
需要保持非常謹慎的軌道

1497
01:13:01,400 --> 01:13:02,550
您的數據類型。

1498
01:13:02,550 --> 01:13:05,000
那麼，什麼樣的數據類型是什麼？

1499
01:13:05,000 --> 01:13:06,250
是一個int，對不對？

1500
01:13:06,250 --> 01:13:07,600
有沒有小數位。

1501
01:13:07,600 --> 01:13:08,770
10也是一個int。

1502
01:13:08,770 --> 01:13:09,930
有沒有小數位。

1503
01:13:09,930 --> 01:13:15,770
>> 如果我把一個int一個int，我得到一個
INT這是不是0.1的，因為整型

1504
01:13:15,770 --> 01:13:18,630
不能有小數位，但只是0。

1505
01:13:18,630 --> 01:13:21,005
由於int只是截斷
關閉小數。

1506
01:13:21,005 --> 01:13:24,280
>> LUCAS FREITAS：所以每當你做
與整數運算，你要

1507
01:13:24,280 --> 01:13:25,990
得到一個int作為答案。

1508
01:13:25,990 --> 01:13:28,930
因此，基本上，什麼樣的電腦
是幹什麼的，它的劃分由1

1509
01:13:28,930 --> 01:13:31,520
10，連帶0.1。

1510
01:13:31,520 --> 01:13:34,870
但隨後的樣子，等待，這是
應該是一個整數，所以你只要

1511
01:13:34,870 --> 01:13:37,045
忽略了0.1，所以它現在只是0。

1512
01:13:37,045 --> 01:13:41,782
>> LAUREN卡瓦略：所以，當我打印這個
出來，我得到0.00，而不是0.10。

1513
01:13:41,782 --> 01:13:44,075
>> LUCAS FREITAS：這是否有道理？

1514
01:13:44,075 --> 01:13:45,530
>> LAUREN卡瓦略：這是一種
不幸的，對不對？

1515
01:13:45,530 --> 01:13:47,290
>> LUCAS FREITAS：我們那麼如何才能解決這個問題？

1516
01:13:47,290 --> 01:13:48,620
>> LAUREN卡瓦略：讓我們
嘗試解決這個問題。

1517
01:13:48,620 --> 01:13:51,570

1518
01:13:51,570 --> 01:13:54,810
這裡是哪裡，我的例子
實際上鑄造1

1519
01:13:54,810 --> 01:13:56,650
和10至浮動。

1520
01:13:56,650 --> 01:13:58,800
所以，現在，1已不再是一個int。

1521
01:13:58,800 --> 01:14:00,020
1是一個浮點數。

1522
01:14:00,020 --> 01:14:02,590
順便說一句，這僅僅是個語法
當你想投的一個用於

1523
01:14:02,590 --> 01:14:03,410
數據類型到另一個。

1524
01:14:03,410 --> 01:14:07,140
你可以把數據類型
括號和有剛剛之前

1525
01:14:07,140 --> 01:14:10,860
您正在鑄造的值。

1526
01:14:10,860 --> 01:14:15,800
>> 所以在這裡，我把一個浮點數由
花車得到一個浮動的答案。

1527
01:14:15,800 --> 01:14:19,535
是的，這將在
事實上打印0.10。

1528
01:14:19,535 --> 01:14:20,470
這是否有道理？

1529
01:14:20,470 --> 01:14:24,110
>> LUCAS FREITAS：所以類型轉換只是
從一種類型轉換到另一邊。

1530
01:14:24,110 --> 01:14:29,460
因此，浮動1實際上是1.000。

1531
01:14:29,460 --> 01:14:33,400
不完全是這樣，但是它的東西
帶小數位

1532
01:14:33,400 --> 01:14:34,715
這實際上是1。

1533
01:14:34,715 --> 01:14:35,960
這是否有道理？

1534
01:14:35,960 --> 01:14:36,260
是嗎？

1535
01:14:36,260 --> 01:14:40,990
>> 觀眾：如果你沒有浮答案
等於1.0除以10？

1536
01:14:40,990 --> 01:14:43,940
>> LAUREN卡瓦略：你究竟要
一看就知道下一張幻燈片。

1537
01:14:43,940 --> 01:14:47,150
這實際上是我們非常下一張幻燈片。

1538
01:14:47,150 --> 01:14:50,740
這實際上是一個更好的比
類型轉換，我想。

1539
01:14:50,740 --> 01:14:53,470
因此，這兩個是剛彩車通過
的事實性質，它們

1540
01:14:53,470 --> 01:14:54,926
有小數位。

1541
01:14:54,926 --> 01:14:55,300
是嗎？

1542
01:14:55,300 --> 01:14:57,670
>> 觀眾：如果你的所作所為[聽不清]

1543
01:14:57,670 --> 01:14:59,480
除以10？

1544
01:14:59,480 --> 01:15:02,270
>> LAUREN卡瓦略：其實一個浮動
一個int劃分實際上給你一個

1545
01:15:02,270 --> 01:15:03,670
浮動，這樣就會很好地工作。

1546
01:15:03,670 --> 01:15:08,070

1547
01:15:08,070 --> 01:15:09,120
>> 等待，每個人都明白這一點？

1548
01:15:09,120 --> 01:15:12,720
因為這將是一個非常
大不了在PS​​ET1，其實。

1549
01:15:12,720 --> 01:15:13,130
是嗎？

1550
01:15:13,130 --> 01:15:14,762
>> 觀眾：你能不能快
走在紅色的部分？

1551
01:15:14,762 --> 01:15:16,380
>> LAUREN卡瓦略：紅色部分，是啊。

1552
01:15:16,380 --> 01:15:17,250
盧卡斯，你想？

1553
01:15:17,250 --> 01:15:18,020
>> LUCAS FREITAS：確定。

1554
01:15:18,020 --> 01:15:20,570
因此請記住百分比
是一個佔位符。

1555
01:15:20,570 --> 01:15:22,150
這就像一個空格。

1556
01:15:22,150 --> 01:15:26,240
因此，讓我們試著去了解一切
這是怎麼回事。

1557
01:15:26,240 --> 01:15:28,170
百分比意味著它是一個佔位符。

1558
01:15:28,170 --> 01:15:33,640
然後，你必須在F，這意味著
這個佔位符是一個浮動。

1559
01:15:33,640 --> 01:15:38,870
我們在這裡的最後一件事是
2，這意味著我想有兩個

1560
01:15:38,870 --> 01:15:42,410
小數的浮點數。

1561
01:15:42,410 --> 01:15:48,510
>> 如果我剛％F，他們就會把
一堆小數。

1562
01:15:48,510 --> 01:15:54,170
這樣我就可以把0.2或0.1或0.5，或
什麼，以及它打算把那

1563
01:15:54,170 --> 01:15:55,950
小數位數。

1564
01:15:55,950 --> 01:15:59,950
唯一的一點是，如果你把喜歡
.100或.1,000，它實際上並不是

1565
01:15:59,950 --> 01:16:04,200
打算把所有這些小數
因為它不具有足夠的內存

1566
01:16:04,200 --> 01:16:06,432
有這種精度。

1567
01:16:06,432 --> 01:16:07,955
>> 還有沒有其他問題？

1568
01:16:07,955 --> 01:16:08,450
是嗎？

1569
01:16:08,450 --> 01:16:12,970
>> 觀眾：所以剛才浮動允許
你要超越的整數？

1570
01:16:12,970 --> 01:16:13,720
>> LUCAS FREITAS：是的。

1571
01:16:13,720 --> 01:16:17,345
>> LAUREN卡瓦略：好了，只是浮
可以讓你有小數位。

1572
01:16:17,345 --> 01:16:20,460
>> LUCAS FREITAS：它只是意味著你
現在可以有小數。

1573
01:16:20,460 --> 01:16:25,728
>> 觀眾：為什麼我們
用不完的整數？

1574
01:16:25,728 --> 01:16:27,870
>> LUCAS FREITAS：為什麼會
你使用整數？

1575
01:16:27,870 --> 01:16:31,810
也許，如果你是從0數到10，
你想實際使用一個整數。

1576
01:16:31,810 --> 01:16:33,370
你並不需要使用浮點數。

1577
01:16:33,370 --> 01:16:35,430
在某些情況下，你不
有實際 - 

1578
01:16:35,430 --> 01:16:37,040
>> LAUREN卡瓦略：也許你
不想小數。

1579
01:16:37,040 --> 01:16:38,600
>> LUCAS FREITAS：也許你不
想用一個浮點數。

1580
01:16:38,600 --> 01:16:42,660
>> LAUREN卡瓦略：另一件事是，
記住，無論是把一個float和int

1581
01:16:42,660 --> 01:16:46,170
需要32位來存儲它們，也許
你不想浪費比特的

1582
01:16:46,170 --> 01:16:48,062
小數位。

1583
01:16:48,062 --> 01:16:49,750
>> LUCAS FREITAS：是啊。

1584
01:16:49,750 --> 01:16:51,910
這麼喜歡，只是覺得這個問題。

1585
01:16:51,910 --> 01:16:55,200
你有32位為
一個int和float類型。

1586
01:16:55,200 --> 01:16:59,400
對於一個int，所有這些32位
去的整數部分。

1587
01:16:59,400 --> 01:17:03,460
如果您使用的是浮動32位，你
有正在使用這塊內存部分

1588
01:17:03,460 --> 01:17:06,820
對數，為整​​數，
和正在使用的其它部分

1589
01:17:06,820 --> 01:17:08,300
小數位。

1590
01:17:08,300 --> 01:17:12,370
因此，這意味著，你不能去
非常大的數字用浮漂，因為

1591
01:17:12,370 --> 01:17:16,020
浮動的已經使用了很多
內存為小數位。

1592
01:17:16,020 --> 01:17:17,014
是嗎？

1593
01:17:17,014 --> 01:17:21,487
>> 觀眾：那第一個答案，
它到底是什麼做的？

1594
01:17:21,487 --> 01:17:25,214
它是設置浮動平等的價值
該佔位符，你可以

1595
01:17:25,214 --> 01:17:26,954
記得在它的下一行？

1596
01:17:26,954 --> 01:17:28,942
它說，浮動的答案。

1597
01:17:28,942 --> 01:17:29,770
>> LUCAS FREITAS：是啊。

1598
01:17:29,770 --> 01:17:37,200
因此，浮動的答案意味著你得到
現在有點桶的內存

1599
01:17:37,200 --> 01:17:40,050
持有浮動，這是怎麼回事
被稱為應答。

1600
01:17:40,050 --> 01:17:42,040
所以，這就是浮動的答案呢。

1601
01:17:42,040 --> 01:17:44,720
>> 然後你說的內
這一點，你要放

1602
01:17:44,720 --> 01:17:46,470
這樣做的結果。

1603
01:17:46,470 --> 01:17:52,610
所以你要做1.0除以
10.0，你會得到0.1，然後你把

1604
01:17:52,610 --> 01:17:53,490
這裡面的答案。

1605
01:17:53,490 --> 01:17:57,540
>> LAUREN卡瓦略：那麼在一行中，我們
聲明和初始化這個浮動

1606
01:17:57,540 --> 01:18:00,070
所謂的答案。

1607
01:18:00,070 --> 01:18:04,470
>> LUCAS FREITAS：有趣的是，雖然
這只是一條線，它在做

1608
01:18:04,470 --> 01:18:05,570
多個操作。

1609
01:18:05,570 --> 01:18:08,800
這是Ç出租的只是一種方式
你用更少的代碼。

1610
01:18:08,800 --> 01:18:12,310
這是同樣的事情三元
運營商，你怎麼可以這樣做的

1611
01:18:12,310 --> 01:18:13,810
在一行[聽不清]。

1612
01:18:13,810 --> 01:18:18,860
它實際上在做同樣的事情，
做浮動答案，分號和

1613
01:18:18,860 --> 01:18:23,060
那麼答案等於代替這一點，但
讓你做兩線的，

1614
01:18:23,060 --> 01:18:24,160
它就像一個快捷方式。

1615
01:18:24,160 --> 01:18:24,520
是嗎？

1616
01:18:24,520 --> 01:18:27,929
>> 觀眾：所以，如果你跑了這一點，
這將是0.10？

1617
01:18:27,929 --> 01:18:30,120
>> LUCAS FREITAS：是的。

1618
01:18:30,120 --> 01:18:30,530
是嗎？

1619
01:18:30,530 --> 01:18:34,540
>> 觀眾：是回答居然代碼，
或者是它只是叫什麼名字？

1620
01:18:34,540 --> 01:18:36,010
>> LAUREN卡瓦略：這
實際上是代碼。

1621
01:18:36,010 --> 01:18:37,750
這就是我們要去
來命名我們的變量。

1622
01:18:37,750 --> 01:18:39,770
>> 觀眾：所以這只是
名稱[聽不清]。

1623
01:18:39,770 --> 01:18:40,270
>> LAUREN卡瓦略：是啊。

1624
01:18:40,270 --> 01:18:44,670
我可以說浮x等於1.0。

1625
01:18:44,670 --> 01:18:47,160
>> LUCAS FREITAS：問題是，
變量的名稱是

1626
01:18:47,160 --> 01:18:48,400
您使用的東西。

1627
01:18:48,400 --> 01:18:49,690
這是對你很重要。

1628
01:18:49,690 --> 01:18:52,660
對於實際的程序，唯一
該事項是價值，你

1629
01:18:52,660 --> 01:18:55,570
有桶的內部。

1630
01:18:55,570 --> 01:18:59,270
為什麼你有變量和的原因
變量名是這樣你就會知道

1631
01:18:59,270 --> 01:19:01,910
你處理的，像什麼
你是什​​麼樣的數據

1632
01:19:01,910 --> 01:19:03,040
訪問的時間。

1633
01:19:03,040 --> 01:19:07,580
但代碼本身，如果你調用
它回答或提問或任何東西，

1634
01:19:07,580 --> 01:19:09,530
漂亮多了，也沒關係。

1635
01:19:09,530 --> 01:19:10,060
不要緊

1636
01:19:10,060 --> 01:19:12,910
只要你在每一個一致
它的發生，所以你叫它

1637
01:19:12,910 --> 01:19:13,620
別的東西。

1638
01:19:13,620 --> 01:19:14,880
是嗎？

1639
01:19:14,880 --> 01:19:17,208
>> 觀眾：執行變量
超越函數？

1640
01:19:17,208 --> 01:19:20,902
就像如果你要創建一個支架
[聽不清]，可能你只是

1641
01:19:20,902 --> 01:19:21,806
[聽不清]再回答？

1642
01:19:21,806 --> 01:19:22,550
>> LAUREN卡瓦略：號

1643
01:19:22,550 --> 01:19:23,300
>> 觀眾：[聽不清]

1644
01:19:23,300 --> 01:19:24,200
>> LAUREN卡瓦略：號

1645
01:19:24,200 --> 01:19:26,930
這將是在範圍之外
這個特殊的變量。

1646
01:19:26,930 --> 01:19:29,940
而實際上，這是一種
有趣，因為當我們有

1647
01:19:29,940 --> 01:19:33,010
之類的東西循環或如果這些
條件下，如果你聲明一個變量

1648
01:19:33,010 --> 01:19:36,330
在另一組大括號，
它真的只存在

1649
01:19:36,330 --> 01:19:39,800
在這些大括號。

1650
01:19:39,800 --> 01:19:43,088
>> 觀眾：最後一個音符左右
在[聽不清]花車。

1651
01:19:43,088 --> 01:19:46,076
為什麼你想使用整數？

1652
01:19:46,076 --> 01:19:49,562
這更是一個側面說明比
任何事情，但你的電腦

1653
01:19:49,562 --> 01:19:53,048
顯著更好地處理整數
比它在處理浮點數。

1654
01:19:53,048 --> 01:19:55,040
這就像一個數量級
幅度更快。

1655
01:19:55,040 --> 01:20:00,360
因此，如果我們僅僅只處理了花車，
事情會是慢了很多。

1656
01:20:00,360 --> 01:20:03,080
>> LAUREN卡瓦略：其實，似乎有
要與花車的一個問題。

1657
01:20:03,080 --> 01:20:06,400
>> LUCAS FREITAS：類的原因
這一點，你能想到，就是如何以二進制

1658
01:20:06,400 --> 01:20:08,480
你可以表示整數
通過將0和1的。

1659
01:20:08,480 --> 01:20:09,980
>> LAUREN卡瓦略：這是
接下來的事情。

1660
01:20:09,980 --> 01:20:10,480
>> LUCAS FREITAS：確定。

1661
01:20:10,480 --> 01:20:10,740
真棒。

1662
01:20:10,740 --> 01:20:11,480
>> LAUREN卡瓦略：只是
持有這種想法。

1663
01:20:11,480 --> 01:20:13,800
>> LUCAS FREITAS：好的，我會
以後告訴你。

1664
01:20:13,800 --> 01:20:16,920
>> LAUREN卡瓦略：在我們到達什麼
盧卡斯只是說，運營商

1665
01:20:16,920 --> 01:20:17,420
優先。

1666
01:20:17,420 --> 01:20:18,220
這是常識。

1667
01:20:18,220 --> 01:20:20,830
你們這樣做就夠了。

1668
01:20:20,830 --> 01:20:24,705
所以，只要有什麼東西是在括號中，
它會先發生。

1669
01:20:24,705 --> 01:20:27,970
這是乘法的優先級
在此外，

1670
01:20:27,970 --> 01:20:30,330
減法，這樣的事情。

1671
01:20:30,330 --> 01:20:34,700
因此，實際上，只是沒有人要
告訴我什麼頭號實際

1672
01:20:34,700 --> 01:20:36,674
計算結果為？

1673
01:20:36,674 --> 01:20:37,638
>> 對象：27。

1674
01:20:37,638 --> 01:20:39,090
>> LAUREN卡瓦略：27？

1675
01:20:39,090 --> 01:20:39,550
是啊。

1676
01:20:39,550 --> 01:20:41,975
>> LUCAS FREITAS：我舉
糖果的人。

1677
01:20:41,975 --> 01:20:42,850
>> LAUREN卡瓦略：好吧。

1678
01:20:42,850 --> 01:20:44,100
怎麼樣二號嗎？

1679
01:20:44,100 --> 01:20:46,880

1680
01:20:46,880 --> 01:20:48,340
怎麼樣二號嗎？

1681
01:20:48,340 --> 01:20:49,280
>> 對象：22。

1682
01:20:49,280 --> 01:20:50,680
>> LAUREN卡瓦略：22，是的。

1683
01:20:50,680 --> 01:20:51,570
我不知道誰得到了這一點。

1684
01:20:51,570 --> 01:20:52,694
之三？

1685
01:20:52,694 --> 01:20:54,050
>> 對象：10。

1686
01:20:54,050 --> 01:20:55,300
>> LAUREN卡瓦略：10，是的。

1687
01:20:55,300 --> 01:20:58,150

1688
01:20:58,150 --> 01:20:58,490
涼爽。

1689
01:20:58,490 --> 01:21:01,280
所以模。

1690
01:21:01,280 --> 01:21:03,700
盧卡斯，你想解釋模？

1691
01:21:03,700 --> 01:21:07,150
>> LUCAS FREITAS：模數是這樣的運營商
這實際上是一個非常有用的

1692
01:21:07,150 --> 01:21:09,470
一堆問題。

1693
01:21:09,470 --> 01:21:15,270
如果我做55模數10，它做什麼
這讓我們說，我想

1694
01:21:15,270 --> 01:21:16,970
除以10 55。

1695
01:21:16,970 --> 01:21:18,240
我能得到什麼？

1696
01:21:18,240 --> 01:21:21,380
這感覺就像如果我實際上只是
這樣的劃分，什麼是

1697
01:21:21,380 --> 01:21:22,450
第一次，我得到了整數？

1698
01:21:22,450 --> 01:21:23,190
>> 對象：5。

1699
01:21:23,190 --> 01:21:24,080
>> LUCAS FREITAS：5。

1700
01:21:24,080 --> 01:21:26,230
然後餘數為5，對不對？

1701
01:21:26,230 --> 01:21:29,250
所以它就像5次10加5。

1702
01:21:29,250 --> 01:21:35,570
基本上，它，它會嘗試什麼模
這個數除以這一個，

1703
01:21:35,570 --> 01:21:37,440
它看到什麼是餘數
分工。

1704
01:21:37,440 --> 01:21:40,080
>> LAUREN卡瓦略：因此，它只是
返回餘數。

1705
01:21:40,080 --> 01:21:41,920
所以，排名第一的是什麼？

1706
01:21:41,920 --> 01:21:42,560
5。

1707
01:21:42,560 --> 01:21:43,336
第二？

1708
01:21:43,336 --> 01:21:44,150
>> 對象：3。

1709
01:21:44,150 --> 01:21:44,934
>> Lauren的CARVALHO：3。

1710
01:21:44,934 --> 01:21:46,240
之三？

1711
01:21:46,240 --> 01:21:47,190
0。

1712
01:21:47,190 --> 01:21:48,410
和4是1。

1713
01:21:48,410 --> 01:21:48,665
沒錯。

1714
01:21:48,665 --> 01:21:49,915
>> LUCAS FREITAS：簡單，對不對？

1715
01:21:49,915 --> 01:21:54,270

1716
01:21:54,270 --> 01:21:56,560
>> LAUREN卡瓦略：我們為什麼不跳過這
只是因為我們真的沒有

1717
01:21:56,560 --> 01:21:59,780
一次，人們似乎明白了。

1718
01:21:59,780 --> 01:22:03,330
因此，這裡就是盧卡斯
剛才講的。

1719
01:22:03,330 --> 01:22:08,030
>> LUCAS FREITAS：另一個原因，我
將使用整數而不是浮點數是

1720
01:22:08,030 --> 01:22:10,840
該花車非常不精確。

1721
01:22:10,840 --> 01:22:12,720
他們為什麼不精確？

1722
01:22:12,720 --> 01:22:17,140
大衛說，代表一個整數，
例如，我們使用0和

1723
01:22:17,140 --> 01:22:17,810
1的，對不對？

1724
01:22:17,810 --> 01:22:22,370
然後你基本上做
乘法，做所有這些

1725
01:22:22,370 --> 01:22:30,000
操作要知道什麼十進制數
你有代替二進制。

1726
01:22:30,000 --> 01:22:33,040
>> 現在會發生什麼，如果我嘗試
把小數點？

1727
01:22:33,040 --> 01:22:37,680
事實上，舉例來說，如果我有
像3.33333多少？

1728
01:22:37,680 --> 01:22:40,250
這感覺就像10超過3。

1729
01:22:40,250 --> 01:22:44,950
我怎麼來存儲所有的
3就是我以後有哪些？

1730
01:22:44,950 --> 01:22:47,120
這真的很難，對吧？

1731
01:22:47,120 --> 01:22:49,580
你不能只是告訴電腦，
哎，我有一個3，和

1732
01:22:49,580 --> 01:22:50,520
那麼你這樣做，直到永遠。

1733
01:22:50,520 --> 01:22:52,810
其實，電腦是不
足夠聰明這一點。

1734
01:22:52,810 --> 01:22:58,300
>> 所以基本上所有的計算機所做的就是
它試圖把盡可能多的數字作為

1735
01:22:58,300 --> 01:23:00,950
它可以達到，你有記憶。

1736
01:23:00,950 --> 01:23:05,890
因此，讓我們說，它要
說3.3333，就是這樣。

1737
01:23:05,890 --> 01:23:10,690
所以它不是能夠真正表達
正是浮動是什麼。

1738
01:23:10,690 --> 01:23:13,240
>> LAUREN卡瓦略：我們有一個有限的數量
比特，表示不

1739
01:23:13,240 --> 01:23:17,910
每一個十進制數將是
能夠被精確地表示。

1740
01:23:17,910 --> 01:23:24,910
所以在這個例子中，如果我們
打印出0.1，我們現在是印刷

1741
01:23:24,910 --> 01:23:26,475
出20個名額。

1742
01:23:26,475 --> 01:23:30,250
>> LUCAS FREITAS：就像我告訴
你們這些傢伙，你可以​​把任何數字。

1743
01:23:30,250 --> 01:23:36,520
但如果你只是做了兩個地方，
你會得到0.10，但如果你把20

1744
01:23:36,520 --> 01:23:43,630
的地方，它會告訴你一堆
的的，因為這是你可以把什麼

1745
01:23:43,630 --> 01:23:45,720
在記憶裡，對不對？

1746
01:23:45,720 --> 01:23:48,800
>> 但在這裡，直到0，
然後只是把它放在一個

1747
01:23:48,800 --> 01:23:50,030
一串隨機數。

1748
01:23:50,030 --> 01:23:52,590
這是一種像一些 - 

1749
01:23:52,590 --> 01:23:56,190
>> LAUREN卡瓦略：這是因為我們
不能夠代表這個十進制

1750
01:23:56,190 --> 01:23:58,320
精確地與數
位的，我們有。

1751
01:23:58,320 --> 01:23:59,730
>> LUCAS FREITAS：然後是
計算機基本上是

1752
01:23:59,730 --> 01:24:01,470
給你一個垃圾數量。

1753
01:24:01,470 --> 01:24:04,530
這實際上是不可能的
數的值。

1754
01:24:04,530 --> 01:24:08,242
>> 觀眾：這是親如
它可以得到[聽不清]

1755
01:24:08,242 --> 01:24:09,613
使用[聽不清]。

1756
01:24:09,613 --> 01:24:12,685

1757
01:24:12,685 --> 01:24:18,830
>> LAUREN卡瓦略：的言下之意
這是一個讓我們說，而不是

1758
01:24:18,830 --> 01:24:27,680
為0.100014，什麼的，
如果它是0.0999  - 

1759
01:24:27,680 --> 01:24:30,470
好，好。

1760
01:24:30,470 --> 01:24:38,280
讓我們假設實際的答案
到，這是0.9999999。

1761
01:24:38,280 --> 01:24:40,740
這是非常接近1，但
它不完全1。

1762
01:24:40,740 --> 01:24:42,840
這是0.99999。

1763
01:24:42,840 --> 01:24:48,140
>> 這意味著，如果我採取0.999，
我投它為int，我得到0。

1764
01:24:48,140 --> 01:24:49,460
我不明白1。

1765
01:24:49,460 --> 01:24:53,050
>> LUCAS FREITAS：因為記得，鑄造
從浮到整數，你只是

1766
01:24:53,050 --> 01:24:54,880
忽略所有的小數位。

1767
01:24:54,880 --> 01:24:56,400
你不理會他們。

1768
01:24:56,400 --> 01:25:00,170
有沒有這樣的東西作為圍捕
或向下運行時，強制轉換。

1769
01:25:00,170 --> 01:25:03,310
其實，有這個功能，
做四捨五入，這是非常

1770
01:25:03,310 --> 01:25:08,840
重要的，但你只是認為，當
你做類型轉換，它只是

1771
01:25:08,840 --> 01:25:09,720
要刪除一切。

1772
01:25:09,720 --> 01:25:13,970
所以，即使你有0.99999，這是怎麼回事
就這樣給0，如果你的類型轉換

1773
01:25:13,970 --> 01:25:14,800
[聽不清]的整數。

1774
01:25:14,800 --> 01:25:17,480
>> LAUREN卡瓦略：所以只是真正意識到
在精確的浮點

1775
01:25:17,480 --> 01:25:20,410
尤其是當你開始
使用花車在PSET1。

1776
01:25:20,410 --> 01:25:22,790
但通過應該走
提醒你這一點。

1777
01:25:22,790 --> 01:25:26,100
>> LUCAS FREITAS：實際上，它真的
難，例如，如果我這樣做

1778
01:25:26,100 --> 01:25:31,570
浮動答案1等於超過1.0
10，然後浮答案2

1779
01:25:31,570 --> 01:25:35,540
等於10.0比100.0。

1780
01:25:35,540 --> 01:25:36,890
它們是相同的號碼，對不對？

1781
01:25:36,890 --> 01:25:38,540
0.1，對不對？

1782
01:25:38,540 --> 01:25:41,700
1比10或10比100。

1783
01:25:41,700 --> 01:25:46,360
但現在，如果我嘗試看看的平等，
就像如果答案1等於回答2，

1784
01:25:46,360 --> 01:25:49,300
也許它不會實際去
是相同的東西。

1785
01:25:49,300 --> 01:25:50,720
所以彩車是有點像那個。

1786
01:25:50,720 --> 01:25:51,970
他們喜歡做的平等。

1787
01:25:51,970 --> 01:25:55,136