1
00:00:00,000 --> 00:00:05,140

2
00:00:05,140 --> 00:00:05,640
Все в порядке.

3
00:00:05,640 --> 00:00:08,330
Так что теперь давайте поговорим о чем-то
очень полезно в programming--

4
00:00:08,330 --> 00:00:09,914
условные операторы.

5
00:00:09,914 --> 00:00:11,830
Так условные выражения
позволяют ваши программы

6
00:00:11,830 --> 00:00:14,538
чтобы принимать решения и разные
вилки в дороге, то

7
00:00:14,538 --> 00:00:17,670
Я ссылался на немного раньше,
в зависимости от значений переменных,

8
00:00:17,670 --> 00:00:20,990
или на основе того, что пользователь вводит в
программист, в командной строке,

9
00:00:20,990 --> 00:00:23,130
или если у вас есть приглашение
или что-то вроде того.

10
00:00:23,130 --> 00:00:26,690
С имеет несколько различных способов
выразить условные выражения, которые

11
00:00:26,690 --> 00:00:29,911
мы также иногда будет вызывать
условный переход в ваших программах.

12
00:00:29,911 --> 00:00:32,910
И некоторые из них будут смотреть
очень знакомо вам с нуля,

13
00:00:32,910 --> 00:00:35,190
так что мы даже тянуть их
бок о бок, как раз

14
00:00:35,190 --> 00:00:38,170
Вы можете сделать эту аналогию в вашей голове.

15
00:00:38,170 --> 00:00:41,250
>> Так, если if-- довольно
просто условно.

16
00:00:41,250 --> 00:00:43,560
Если вы помните из
царапина на правом здесь

17
00:00:43,560 --> 00:00:50,000
Вы могли бы заполнить это шестиугольник
с синим выражения, если мышь вниз

18
00:00:50,000 --> 00:00:53,010
или если х меньше 10,
или что-то вроде того.

19
00:00:53,010 --> 00:00:57,390
И тогда, если х меньше 10,
или, если мышь на самом деле, вниз,

20
00:00:57,390 --> 00:01:01,140
весь код внутренней части
кусок головоломки будет выполнять.

21
00:01:01,140 --> 00:01:03,720
Все вещи, которые соответствуют
внутри этой формы C.

22
00:01:03,720 --> 00:01:07,200
>> Точно так же, у нас есть
если слева нет.

23
00:01:07,200 --> 00:01:09,210
Если логическое выражение,
который я только с помощью

24
00:01:09,210 --> 00:01:13,010
в качестве заменителя одного из Boolean
выражения мы ранее,

25
00:01:13,010 --> 00:01:15,240
открыт фигурная скобка, недалеко фигурная скобка.

26
00:01:15,240 --> 00:01:17,720
Так что думайте открытого кудрявых
скобка и закрытый фигурная скобка

27
00:01:17,720 --> 00:01:22,720
как своего рода аналогом бутерброд
эффект, если блок на правой

28
00:01:22,720 --> 00:01:24,070
с нуля.

29
00:01:24,070 --> 00:01:28,680
>> Если логическое выражение
в заявлении, если это правда,

30
00:01:28,680 --> 00:01:30,900
то все строки кода
между фигурными скобками

31
00:01:30,900 --> 00:01:33,870
будет выполняться в порядке
сверху вниз.

32
00:01:33,870 --> 00:01:35,700
Если логическое выражение
является ложным, мы будем

33
00:01:35,700 --> 00:01:38,610
пропустить все между
фигурные скобки, потому что мы только

34
00:01:38,610 --> 00:01:44,570
хочу пойти вниз, что вилка в дороге
если логическое выражение истинно.

35
00:01:44,570 --> 00:01:48,540
>> Мы можем принять это еще один шаг
далее с тем, если еще.

36
00:01:48,540 --> 00:01:50,820
Так что это царапинам блок
очень похож на тот,

37
00:01:50,820 --> 00:01:55,884
мы видели только секунду назад, за исключением
он принимает два различных пути, основанные

38
00:01:55,884 --> 00:01:56,550
о том, что происходит.

39
00:01:56,550 --> 00:02:00,420
Таким образом, если мышь была вниз,
или если х было меньше, чем 10,

40
00:02:00,420 --> 00:02:04,780
мы сделаем всё, что в период между
что в первую вилки, что в первую С.,

41
00:02:04,780 --> 00:02:08,430
>> В противном случае, если мышь
до, или х не меньше, чем 10,

42
00:02:08,430 --> 00:02:10,460
мы сделаем все, во втором сете.

43
00:02:10,460 --> 00:02:15,010
И это аналогично тому, что вы видите
здесь C. Если логическое выражение,

44
00:02:15,010 --> 00:02:17,910
сделать вещи между
первый набор фигурных скобках.

45
00:02:17,910 --> 00:02:20,550
В противном случае, сделать вещи между
второй набор фигурных скобок.

46
00:02:20,550 --> 00:02:22,080
Так что, если логическое
выражение истинно, мы будем

47
00:02:22,080 --> 00:02:23,580
делать все, что находится между первым набором.

48
00:02:23,580 --> 00:02:27,480
Если логическое выражение
ложь, что бы курок еще,

49
00:02:27,480 --> 00:02:30,100
и мы хотели бы сделать что бы ни в
второй набор фигурных скобках.

50
00:02:30,100 --> 00:02:34,190
Опять же, сверху вниз, все
линии в между скобками.

51
00:02:34,190 --> 00:02:38,130
>> В C, это возможно, чтобы создать
ПЧ-то еще, если-иначе цепь.

52
00:02:38,130 --> 00:02:42,000
На самом деле вы можете иметь, если-иначе, если-иначе
если-иначе, если, и так далее, и так далее, и так

53
00:02:42,000 --> 00:02:42,720
на.

54
00:02:42,720 --> 00:02:44,660
В пустом, для этого требуется
гнездования блоки.

55
00:02:44,660 --> 00:02:48,280
Вы добавьте, если-иначе, и вы должны были
положил еще один внутри еще,

56
00:02:48,280 --> 00:02:51,110
и так далее, и он получил вид
вложенных и сложным.

57
00:02:51,110 --> 00:02:52,450
Но С, мы не должны этого делать.

58
00:02:52,450 --> 00:02:55,300
Мы можем на самом деле просто
это будет цепочка, как это.

59
00:02:55,300 --> 00:02:58,350
Опять же, как вы могли бы ожидать, все
эти ветви являются взаимоисключающими.

60
00:02:58,350 --> 00:03:00,750
Вы можете только когда-нибудь
по одному из филиала.

61
00:03:00,750 --> 00:03:02,270
Если это правда.

62
00:03:02,270 --> 00:03:03,930
В противном случае, если это правда.

63
00:03:03,930 --> 00:03:05,700
В противном случае, если это правда.

64
00:03:05,700 --> 00:03:07,120
В противном случае, сделать это.

65
00:03:07,120 --> 00:03:11,010
Таким образом, все четыре ветви в этот
Пример являются взаимоисключающими.

66
00:03:11,010 --> 00:03:14,900
Это, если-иначе, если-иначе цепь.

67
00:03:14,900 --> 00:03:17,580
>> Возможно, хотя,
а иногда и очень полезно,

68
00:03:17,580 --> 00:03:20,950
создать цепочку не
взаимоисключающие филиалы.

69
00:03:20,950 --> 00:03:24,600
В этом примере, только третий и
четвертый филиалы являются взаимоисключающими.

70
00:03:24,600 --> 00:03:27,450
Это может быть, что вы могли бы
удовлетворяет первому условию,

71
00:03:27,450 --> 00:03:29,396
и вы могли бы удовлетворить
второе условие,

72
00:03:29,396 --> 00:03:31,770
и вы могли бы удовлетворить
третья condition-- в этом случае

73
00:03:31,770 --> 00:03:35,270
Вы бы пойти вниз первое отделение,
Затем вы спуститесь второй филиал,

74
00:03:35,270 --> 00:03:37,000
то вы бы спуститься третью ветвь.

75
00:03:37,000 --> 00:03:40,450
Или, возможно, вы удовлетворяете первым
состояние, а второе условие,

76
00:03:40,450 --> 00:03:42,770
но вы не удовлетворяют
третье условие.

77
00:03:42,770 --> 00:03:46,230
В этом случае вы спуститесь первым
Филиал и вторая ветвь,

78
00:03:46,230 --> 00:03:48,040
а затем четвертый филиал,

79
00:03:48,040 --> 00:03:51,392
>> Причина этого в том, что еще
будет связываться только с ближайшим если.

80
00:03:51,392 --> 00:03:53,100
Поэтому, даже если есть
еще здесь, что

81
00:03:53,100 --> 00:03:56,490
не обязательно создает взаимно
Эксклюзивный цепь все.

82
00:03:56,490 --> 00:04:00,890
Это только выражение
там с Boolean

83
00:04:00,890 --> 00:04:05,040
Выражение 3-- это
взаимоисключающими с еще.

84
00:04:05,040 --> 00:04:07,580
Так что, возможно, и
иногда весьма полезно,

85
00:04:07,580 --> 00:04:11,772
как я уже сказал, чтобы создать цепочку
не взаимоисключающие филиалы.

86
00:04:11,772 --> 00:04:14,230
Давайте взглянем на другой
вид условного, что

87
00:04:14,230 --> 00:04:17,392
Вы не видели прежде в царапина.

88
00:04:17,392 --> 00:04:19,369
Там что-то называется
переключатель заявлении.

89
00:04:19,369 --> 00:04:21,410
В заявлении переключатель
вид аккуратно, потому что это

90
00:04:21,410 --> 00:04:25,930
условный оператор, который позволяет
указать различные случаи,

91
00:04:25,930 --> 00:04:28,926
вместо того, чтобы полагаться на логическое
выражения для принятия решений для Вас.

92
00:04:28,926 --> 00:04:31,050
Так, например, скажем,
что у меня есть эта программа,

93
00:04:31,050 --> 00:04:34,110
и я прошу пользователю
внести вклад в меня.

94
00:04:34,110 --> 00:04:37,170
Поэтому я говорю, INT х = Получить Int (),
и если вы не знакомы еще,

95
00:04:37,170 --> 00:04:40,190
получить Int является функция,
также включены в библиотеке CS50,

96
00:04:40,190 --> 00:04:44,610
так что если вы #include CS50.H вы будете иметь
Получить доступ к Int () и все его

97
00:04:44,610 --> 00:04:46,840
cousins-- GetFloat,
GetString, и так далее.

98
00:04:46,840 --> 00:04:52,590
В основном одно получает функцию для каждого
тип данных, который мы уже обсуждали.

99
00:04:52,590 --> 00:04:53,970
>> Так Int х равен GetInt.

100
00:04:53,970 --> 00:04:56,390
В основном то, что происходит
это я на терминале.

101
00:04:56,390 --> 00:04:58,790
Я спрашиваю пользователю ввести номер.

102
00:04:58,790 --> 00:05:02,300
>> И вот я переключения
то, что я делаю, в зависимости

103
00:05:02,300 --> 00:05:05,060
на то, что пользователь ввел в командной строке.

104
00:05:05,060 --> 00:05:09,147
Так что, если они ввели один, я распечатать одно.

105
00:05:09,147 --> 00:05:09,855
И тогда я нарушу.

106
00:05:09,855 --> 00:05:12,590

107
00:05:12,590 --> 00:05:15,510
Если они типа два, я распечатать два.

108
00:05:15,510 --> 00:05:16,690
И тогда я нарушу.

109
00:05:16,690 --> 00:05:19,060
Важно
разрыв между каждом случае

110
00:05:19,060 --> 00:05:20,890
потому что иначе вы провалитесь.

111
00:05:20,890 --> 00:05:23,380
Так что, если у меня не было какой-либо
перерывы там, и пользователь

112
00:05:23,380 --> 00:05:31,380
типизированных одним, что случится это
будет печатать один, два, три, извините.

113
00:05:31,380 --> 00:05:33,099
Это своего рода странным поведением, верно?

114
00:05:33,099 --> 00:05:33,890
Вы могли бы так думать.

115
00:05:33,890 --> 00:05:36,480
Но на самом деле там некоторых случаях, когда
это может быть довольно полезная вещь.

116
00:05:36,480 --> 00:05:39,730
Так вот еще один пример переключателя
Заявление, где я опускаю перерывы.

117
00:05:39,730 --> 00:05:42,030
Но я делаю это нарочно.

118
00:05:42,030 --> 00:05:43,030
>> Так что здесь происходит?

119
00:05:43,030 --> 00:05:43,821
Задумайтесь на секунду.

120
00:05:43,821 --> 00:05:45,960
Вы даже можете приостановить видео.

121
00:05:45,960 --> 00:05:48,230
>> Что происходит здесь, если
пользователь вводит четыре?

122
00:05:48,230 --> 00:05:51,190

123
00:05:51,190 --> 00:05:53,860
Так что я спросил у пользователя ввод.

124
00:05:53,860 --> 00:05:56,560
И они обеспечивают значение 4.

125
00:05:56,560 --> 00:05:59,545
Что печатается, когда я это сделать?

126
00:05:59,545 --> 00:06:02,170
На предыдущем слайде, были
перерывы между всех случаях.

127
00:06:02,170 --> 00:06:04,750
И так бы просто
распечатать четырех, а затем остановиться.

128
00:06:04,750 --> 00:06:06,610
Но в данном случае, это не будет.

129
00:06:06,610 --> 00:06:10,700
Что случится, вам
провалится каждом случае.

130
00:06:10,700 --> 00:06:14,890
>> Таким образом, в этом случае я организовал моих дел
таким образом, что если пользователь 4,

131
00:06:14,890 --> 00:06:20,070
Я печатать четыре, три,
два, один, взлетать.

132
00:06:20,070 --> 00:06:22,780
И если они набрали 5, я хотел бы начать
в пять и делать то же самое.

133
00:06:22,780 --> 00:06:26,410
Если они набрали 1, я бы
просто сделать один, взлетать.

134
00:06:26,410 --> 00:06:28,715
>> Таким образом, в этом случае, я использую
переключатель вид ловко так

135
00:06:28,715 --> 00:06:30,804
что я намерен попасть
через всех случаях.

136
00:06:30,804 --> 00:06:33,720
Но в целом вы, вероятно, собирается
хотим сломать между всеми из них,

137
00:06:33,720 --> 00:06:36,090
если у вас есть ситуации,
как этот, где вы

138
00:06:36,090 --> 00:06:40,081
вид используя тот факт, что вы будете
провалиться случаях без перерыва.

139
00:06:40,081 --> 00:06:42,830
Так вот второй из важнейших
Типы условных операторов.

140
00:06:42,830 --> 00:06:47,139
Последний из которых является: Так что я
есть два фрагменты кода C здесь.

141
00:06:47,139 --> 00:06:48,680
Один слева и один справа.

142
00:06:48,680 --> 00:06:52,330
Тот слева должны
вероятно, будет довольно знакомым.

143
00:06:52,330 --> 00:06:55,110
>> У меня есть Int х.

144
00:06:55,110 --> 00:06:57,167
И я, вероятно, следует
попросили пользователя

145
00:06:57,167 --> 00:07:00,250
for-- это, вероятно, следует Int х
равна GetInt, или что-то подобное.

146
00:07:00,250 --> 00:07:03,030

147
00:07:03,030 --> 00:07:05,240
И тогда я принятия решения.

148
00:07:05,240 --> 00:07:11,700
Если некоторые логическое выражение является
правда, назначить х значение 5.

149
00:07:11,700 --> 00:07:13,590
В противном случае, назначить х значение 6.

150
00:07:13,590 --> 00:07:16,548
>> Это слева, вероятно, следует
довольно хорошо знакомы с нашей дискуссии

151
00:07:16,548 --> 00:07:18,160
Если в остальное просто мгновение назад.

152
00:07:18,160 --> 00:07:20,535
Вы были бы удивлены знать,
что линии справа

153
00:07:20,535 --> 00:07:22,310
делает ту же самую вещь?

154
00:07:22,310 --> 00:07:26,140
>> Итак, это называется: иногда
называется тройной оператор.

155
00:07:26,140 --> 00:07:27,450
И это очень здорово.

156
00:07:27,450 --> 00:07:29,110
Это, как правило, используется в качестве милый трюк.

157
00:07:29,110 --> 00:07:35,777
>> Но то, что он позволяет сделать, это
имитировать If Else с действительно небольшой,

158
00:07:35,777 --> 00:07:37,610
действительно тривиально короткий
условные переходы.

159
00:07:37,610 --> 00:07:41,470
Вы вообще не использовать: если вы
шесть строк кода между каждым набором

160
00:07:41,470 --> 00:07:42,569
из фигурные скобки.

161
00:07:42,569 --> 00:07:44,360
Но если вы просто
что делает быстрое решение,

162
00:07:44,360 --> 00:07:47,520
если вы собираетесь сделать одну вещь
или другой, и это очень просто,

163
00:07:47,520 --> 00:07:52,240
это может быть пример того, как
сделать это с: тройной оператор.

164
00:07:52,240 --> 00:07:56,940
Так Int х равен выражение?

165
00:07:56,940 --> 00:07:59,470
Дело после вопроса
знак того, что Х значение

166
00:07:59,470 --> 00:08:02,690
будет, если выражение истинно.

167
00:08:02,690 --> 00:08:05,330
>> Дело после
толстой кишки, что Х значение

168
00:08:05,330 --> 00:08:07,990
если бы выражение было ложным.

169
00:08:07,990 --> 00:08:11,510
Вот я и спрашиваю себя,
это выражение верно?

170
00:08:11,510 --> 00:08:13,870
Если это так, присвоить х значение 5.

171
00:08:13,870 --> 00:08:16,619
Если это не так, назначьте х значение 6.

172
00:08:16,619 --> 00:08:17,410
Опять же, как я сказал.

173
00:08:17,410 --> 00:08:18,670
Это, как правило, просто уловка.

174
00:08:18,670 --> 00:08:20,430
А иногда, если вы стали
действительно комфортно с ним,

175
00:08:20,430 --> 00:08:22,820
вы будете делать это, потому что это выглядит
круто в ваших программах.

176
00:08:22,820 --> 00:08:25,710
Вообще я представляю его
Вы сейчас так вы знакомы с ним

177
00:08:25,710 --> 00:08:26,990
если вы его видите.

178
00:08:26,990 --> 00:08:30,080
Но, конечно, знаю, что вы не должны
написать его в любой из вашего кода.

179
00:08:30,080 --> 00:08:33,246
Но это что-то, чтобы быть знакомы с,
потому что вы будете определенно сталкиваться

180
00:08:33,246 --> 00:08:36,130
фрагменты кода здесь и
там, где это? синтаксиса,

181
00:08:36,130 --> 00:08:39,120
АКА тройной оператор, используется.

182
00:08:39,120 --> 00:08:40,960
>> Так краткий обзор на
то, что условные являются,

183
00:08:40,960 --> 00:08:44,210
и то, что варианты
Вам в С вас, если, и если-иначе,

184
00:08:44,210 --> 00:08:46,860
и если еще, если, и так далее.

185
00:08:46,860 --> 00:08:50,880
Вы можете использовать логические выражения
для тех, для принятия решений.

186
00:08:50,880 --> 00:08:53,720
>> С переключателем заявления вы используете
дискретные случаи, чтобы принимать решения.

187
00:08:53,720 --> 00:08:57,540
Вы бы специально сказать, что если это
Один из них, или, если это два, или, если это три,

188
00:08:57,540 --> 00:09:00,870
Я сделаю это, или
эта вещь, или это дело.

189
00:09:00,870 --> 00:09:04,660
И: может быть использован для замены
очень просто, если-иначе филиалов,

190
00:09:04,660 --> 00:09:08,490
или если-иначе цепи, чтобы сделать
код выглядеть немного фантазии.

191
00:09:08,490 --> 00:09:09,250
>> Я Дуг Ллойд.

192
00:09:09,250 --> 00:09:11,410
И это CS50.

193
00:09:11,410 --> 00:09:12,959