1
00:00:00,000 --> 00:00:04,664

2
00:00:04,664 --> 00:00:05,580
ДАГ Lloyd: Ладно.

3
00:00:05,580 --> 00:00:08,877
Так что теперь давайте возьмемся
действительно большая тема, функции.

4
00:00:08,877 --> 00:00:11,460
До сих пор в процессе, все
Программы, которые мы были пишущие

5
00:00:11,460 --> 00:00:12,969
были написаны внутри основной.

6
00:00:12,969 --> 00:00:14,260
Они довольно простые программы.

7
00:00:14,260 --> 00:00:16,940
Вам не нужно, чтобы все эти
филиалы и вещей происходит.

8
00:00:16,940 --> 00:00:18,773
Мы можем просто уместить его
внутри основной и

9
00:00:18,773 --> 00:00:20,407
не получить страшно подавляющим.

10
00:00:20,407 --> 00:00:22,990
Но, как курс продолжается и
как вы начнете разрабатывать программы

11
00:00:22,990 --> 00:00:26,260
самостоятельно, они, вероятно, будет
чтобы начать, чтобы получить гораздо больше, чем 10

12
00:00:26,260 --> 00:00:27,200
или 15 строк.

13
00:00:27,200 --> 00:00:31,400
Вы можете получить сотни или тысячи
или десятки тысяч строк кода.

14
00:00:31,400 --> 00:00:34,690
И это на самом деле не
что с ума мысль.

15
00:00:34,690 --> 00:00:39,720
Как таковая, она, вероятно, не очень хорошая идея
сохранить все внутри основной.

16
00:00:39,720 --> 00:00:43,240
Это может стать немного трудно найти
то, что вы ищете, если вы сделаете это.

17
00:00:43,240 --> 00:00:47,040
>> К счастью, хотя C, и в значительной степени
каждый язык программирования, который

18
00:00:47,040 --> 00:00:50,386
может работать, позволяет
нам написать функции.

19
00:00:50,386 --> 00:00:52,260
И я просто хочу, чтобы
Возьмите быстрый сторону здесь

20
00:00:52,260 --> 00:00:54,971
отметить, что функций
одна область информатики.

21
00:00:54,971 --> 00:00:57,970
И вы будете видеть больше из них в
различные точки на протяжении всего курса

22
00:00:57,970 --> 00:00:59,290
и если вы будете продолжать дальше.

23
00:00:59,290 --> 00:01:02,280
Там, где есть много
синонимы одного и того же слова.

24
00:01:02,280 --> 00:01:03,390
Так мы называем функции.

25
00:01:03,390 --> 00:01:05,980
Но вы могли бы также услышать их
упоминается как процедур,

26
00:01:05,980 --> 00:01:09,570
или методы, в частности, если вы когда-либо
сделать любой объектно-ориентированного программирования

27
00:01:09,570 --> 00:01:11,950
before-- и не беспокоиться
если у вас нет, не

28
00:01:11,950 --> 00:01:14,280
большой deal-- но в
аудиторские ориентированные языки

29
00:01:14,280 --> 00:01:16,129
часто называемые методами.

30
00:01:16,129 --> 00:01:17,670
Иногда они называются подпрограммами.

31
00:01:17,670 --> 00:01:20,690
Но они на самом деле все они относятся
к тому же основной идеи.

32
00:01:20,690 --> 00:01:22,480
>> Давайте посмотрим, что эта идея.

33
00:01:22,480 --> 00:01:23,310
Что такое функция?

34
00:01:23,310 --> 00:01:26,470
Ну функция действительно
не более, чем черный ящик.

35
00:01:26,470 --> 00:01:31,430
Черный ящик, который имеет множество нулевой
или более входов и один выход.

36
00:01:31,430 --> 00:01:33,420
Так, например, эта
может быть функцией.

37
00:01:33,420 --> 00:01:35,510
Эта функция называется функ.

38
00:01:35,510 --> 00:01:39,330
И это занимает три входа A, B и С.

39
00:01:39,330 --> 00:01:42,580
И внутри этого черного ящика, мы
не знаю точно, что он делает,

40
00:01:42,580 --> 00:01:45,100
но он обрабатывает входы
в некотором роде, а затем он

41
00:01:45,100 --> 00:01:48,680
дает один выход, в этом случае, г.

42
00:01:48,680 --> 00:01:50,504
Теперь, чтобы сделать его немного
менее абстрактным, мы

43
00:01:50,504 --> 00:01:52,420
Можно сказать, что, возможно, мы
есть функция под названием

44
00:01:52,420 --> 00:01:58,750
Добавим, что занимает три входа A, B, и
С и обрабатывает выходные данные в некотором роде

45
00:01:58,750 --> 00:02:01,010
внутри черного ящика к
производить один выход.

46
00:02:01,010 --> 00:02:05,190
Таким образом, в этом случае, если
добавить занимает 3, 6, и 7.

47
00:02:05,190 --> 00:02:07,020
Где-то внутри
добавить функцию, мы бы

48
00:02:07,020 --> 00:02:09,750
ожидать, что они будут добавлены вместе
для получения выходного сигнала, который

49
00:02:09,750 --> 00:02:13,220
3 плюс 6 плюс 7 или 16.

50
00:02:13,220 --> 00:02:17,940
>> Точно так же, у вас есть функция под названием
мульт, который принимает два входа, а и б,

51
00:02:17,940 --> 00:02:21,070
обрабатывает их в некотором роде такой
что выход функции

52
00:02:21,070 --> 00:02:22,920
является продуктом двух входов.

53
00:02:22,920 --> 00:02:25,080
Два входа перемножаются.

54
00:02:25,080 --> 00:02:29,150
4 и 5 передается в Mult,
что-то случится, выход мы ожидаем

55
00:02:29,150 --> 00:02:31,090
20.

56
00:02:31,090 --> 00:02:32,507
Почему мы называем это черный ящик?

57
00:02:32,507 --> 00:02:34,840
Ну, если мы не написания
Функции себя, что

58
00:02:34,840 --> 00:02:36,869
мы сделали совсем немного до сих пор CS50.

59
00:02:36,869 --> 00:02:39,910
Мы видели печати F, например, что
это функция, которую мы не написать

60
00:02:39,910 --> 00:02:42,305
сами, но мы используем все время.

61
00:02:42,305 --> 00:02:44,180
Если мы не пишем
функции сами,

62
00:02:44,180 --> 00:02:48,450
мы на самом деле не нужно знать, как это
на самом деле реализованы под капотом.

63
00:02:48,450 --> 00:02:51,710
>> Так, например, черный ящик I
только что показал вам для умножения,

64
00:02:51,710 --> 00:02:53,740
сть а, б может быть
defined-- и это только

65
00:02:53,740 --> 00:02:57,902
некоторые pseudocode-- может быть
определяется как выход через раз б.

66
00:02:57,902 --> 00:02:58,860
Это имеет смысл, верно.

67
00:02:58,860 --> 00:03:01,370
Если у нас есть функция под названием
мульт, который принимает два входа.

68
00:03:01,370 --> 00:03:04,750
Мы бы ожидать, что результат будет
быть два входа перемножаются,

69
00:03:04,750 --> 00:03:06,240
а раз б.

70
00:03:06,240 --> 00:03:09,170
Но мульт также может быть
реализованы, как это,

71
00:03:09,170 --> 00:03:13,150
мы имеем переменную счетчика на
получить набор внутри Mult 0.

72
00:03:13,150 --> 00:03:18,000
А потом мы повторяем этот процесс
б раз добавить к счетчику.

73
00:03:18,000 --> 00:03:24,270
Например, если мы умножим 3а по
5б, мы могли бы сказать установить счетчик на 0,

74
00:03:24,270 --> 00:03:27,700
повторить пять раз, добавить 3 до прилавка.

75
00:03:27,700 --> 00:03:34,490
Итак, мы начинаем с 0, а затем мы делаем
Это в пять раз 3, 6, 9, 12, 15.

76
00:03:34,490 --> 00:03:37,500
Это тот же самый результат. Мы
до сих пор получить 3 раз 5 раз

77
00:03:37,500 --> 00:03:39,500
реализация отличается.

78
00:03:39,500 --> 00:03:41,490
>> Это означает, что мы
когда мы говорим, черный ящик.

79
00:03:41,490 --> 00:03:44,406
Это просто означает, что мы действительно не заботятся
как это реализовано под капотом

80
00:03:44,406 --> 00:03:46,170
тех пор, пока выход, что мы ожидаем.

81
00:03:46,170 --> 00:03:49,045
На самом деле, это часть договора
использования функции, в частности,

82
00:03:49,045 --> 00:03:50,630
Функции, которые пишут другие.

83
00:03:50,630 --> 00:03:53,980
Поведение всегда будет
типичными, непредсказуемый

84
00:03:53,980 --> 00:03:55,420
на основе имени функции.

85
00:03:55,420 --> 00:03:57,500
И вот почему это действительно
важно, когда вы пишете функции

86
00:03:57,500 --> 00:04:00,020
или когда другие люди пишут
Функции, которые вы могли бы использовать,

87
00:04:00,020 --> 00:04:03,590
что эти функции имеют
ясно, относительно очевидные имена,

88
00:04:03,590 --> 00:04:04,990
и хорошо документированы.

89
00:04:04,990 --> 00:04:08,560
Что, конечно, случай
для функции, как печать ф.

90
00:04:08,560 --> 00:04:09,860
>> Так почему же мы используем функции?

91
00:04:09,860 --> 00:04:14,220
Ну, как я сказал ранее, если мы пишем
весь наш код внутри главных

92
00:04:14,220 --> 00:04:17,120
можете получить действительно громоздким
и действительно сложная.

93
00:04:17,120 --> 00:04:19,980
Функции позволяют нам способность
организовать вещи и разбить

94
00:04:19,980 --> 00:04:24,540
очень сложная задача в
много более управляемые части суб.

95
00:04:24,540 --> 00:04:28,130
Функции также позволяют нам
упростить процесс кодирования.

96
00:04:28,130 --> 00:04:33,080
Это намного проще отладить 10
Функция линия против линии 100

97
00:04:33,080 --> 00:04:35,890
функция или функция в 1000 линия.

98
00:04:35,890 --> 00:04:38,400
Если у нас есть только для отладки
маленькие кусочки в то время,

99
00:04:38,400 --> 00:04:42,110
или написать небольшие кусочки в то время,
это делает этот опыт программирования

100
00:04:42,110 --> 00:04:43,070
намного лучше.

101
00:04:43,070 --> 00:04:44,910
Доверься мне в этом.

102
00:04:44,910 --> 00:04:48,400
>> Наконец, если мы пишем функции мы
можно повторно использовать эти различные части.

103
00:04:48,400 --> 00:04:49,880
Функции могут быть переработаны.

104
00:04:49,880 --> 00:04:51,880
Они могут быть использованы в
одна программа или другой.

105
00:04:51,880 --> 00:04:53,713
Вы уже написали
функция, все, что вам

106
00:04:53,713 --> 00:04:56,530
нужно сделать, это сказать, что программа
где найти эту функцию.

107
00:04:56,530 --> 00:04:59,680
Мы утилизации и использования
печатать е более 40 лет.

108
00:04:59,680 --> 00:05:02,150
Но это было только один раз написано.

109
00:05:02,150 --> 00:05:04,270
Довольно полезно, правильно.

110
00:05:04,270 --> 00:05:04,830
Все в порядке.

111
00:05:04,830 --> 00:05:06,040
Так функции велики.

112
00:05:06,040 --> 00:05:06,860
Мы знаем это.

113
00:05:06,860 --> 00:05:08,700
Теперь давайте начнем писать их.

114
00:05:08,700 --> 00:05:10,830
Давайте начнем получать
их в наших программах.

115
00:05:10,830 --> 00:05:13,869
Для того, чтобы сделать это, первый
что мы делаем, это объявить функцию.

116
00:05:13,869 --> 00:05:16,160
Когда вы объявляете функцию
то, что вы делаете в основном

117
00:05:16,160 --> 00:05:18,900
говорит компилятору,
эй, только так вы знаете,

118
00:05:18,900 --> 00:05:20,850
Я собираюсь писать
функция позже

119
00:05:20,850 --> 00:05:22,987
и вот что он будет выглядеть.

120
00:05:22,987 --> 00:05:24,820
Причина этого в том,
что компиляторы могут

121
00:05:24,820 --> 00:05:27,900
сделать некоторые странные вещи, если
они видят набор символов

122
00:05:27,900 --> 00:05:29,560
что они не знакомы.

123
00:05:29,560 --> 00:05:33,000
Таким образом, мы просто дать компилятору
возглавляет, я создаю функцию

124
00:05:33,000 --> 00:05:35,492
и он собирается сделать это.

125
00:05:35,492 --> 00:05:38,450
Объявления функций обычно если
Вы организует свой код таким образом,

126
00:05:38,450 --> 00:05:41,872
что другие смогут
понять и использовать,

127
00:05:41,872 --> 00:05:44,330
Вы вообще хотите, чтобы положить все
Ваши объявления функций

128
00:05:44,330 --> 00:05:48,220
на самом верху вашего кода, прямо
прежде чем начать писать основной даже.

129
00:05:48,220 --> 00:05:50,770
И удобно, есть
очень стандартная форма

130
00:05:50,770 --> 00:05:53,500
что каждая функция декларация следующим образом.

131
00:05:53,500 --> 00:05:56,090
Они все в значительной степени выглядеть следующим.

132
00:05:56,090 --> 00:06:01,440
Есть три части к функции
Декларация, возвращаемый тип, имя,

133
00:06:01,440 --> 00:06:03,420
и список аргументов.

134
00:06:03,420 --> 00:06:07,180
>> Теперь тип возвращение Каких
Переменная выход функции воли.

135
00:06:07,180 --> 00:06:10,710
Так, например, если мы вспомним
Минуту назад к умножения двух

136
00:06:10,710 --> 00:06:15,690
Функция номера, то, что мы ожидаем, если
умножим целое число целое число

137
00:06:15,690 --> 00:06:18,502
выход будет
вероятно, целое, право.

138
00:06:18,502 --> 00:06:20,710
Умножается два целых числа
вместе, вы получите целое число.

139
00:06:20,710 --> 00:06:24,167
Так тип возвращаемого что
Функция будет Int.

140
00:06:24,167 --> 00:06:26,000
Имя это то, что вы хотите
обратить ваше функции.

141
00:06:26,000 --> 00:06:29,330
Это, вероятно, наименее важным
часть функции декларации,

142
00:06:29,330 --> 00:06:30,827
с точки зрения функциональности.

143
00:06:30,827 --> 00:06:33,160
Но на самом деле, вероятно, один
из наиболее важных частей

144
00:06:33,160 --> 00:06:36,243
в объявлении функции в условиях
зная, что на самом деле функция

145
00:06:36,243 --> 00:06:37,120
делает.

146
00:06:37,120 --> 00:06:40,474
Если вы назвать вашу функцию F или г или
ч или тайна или что-то подобное,

147
00:06:40,474 --> 00:06:42,765
вы, вероятно, собирается получить
немного споткнулся, пытаясь

148
00:06:42,765 --> 00:06:44,650
вспомнить, что эти функции делают.

149
00:06:44,650 --> 00:06:47,880
Поэтому важно, чтобы дать вашей
осмысленные имена функции.

150
00:06:47,880 --> 00:06:51,030
>> Наконец, список аргументов
разделенные запятой

151
00:06:51,030 --> 00:06:55,260
всех входов в вашей функции,
каждый из которых имеет тип и имя.

152
00:06:55,260 --> 00:06:57,840
Так что не только у вас есть, чтобы
указать, какой тип переменной

153
00:06:57,840 --> 00:07:00,760
выход функция,
Вы также хотите, чтобы указать

154
00:07:00,760 --> 00:07:07,694
какой тип и типы переменных в
Функция будет принимать в качестве входных.

155
00:07:07,694 --> 00:07:08,860
Так давайте сделаем пример здесь.

156
00:07:08,860 --> 00:07:10,220
Давайте просто посмотрим
в более конкретном один.

157
00:07:10,220 --> 00:07:13,130
Так вот пример функции
Заявление для функции,

158
00:07:13,130 --> 00:07:14,925
хотел бы добавить два целых числа вместе.

159
00:07:14,925 --> 00:07:17,800
Сумма двух целых чисел будет
быть целым числом, а также, как мы только что

160
00:07:17,800 --> 00:07:18,450
обсуждается.

161
00:07:18,450 --> 00:07:21,610
И поэтому тип возврата
здесь, в зеленый, будет Int.

162
00:07:21,610 --> 00:07:25,190
Это просто говорит нам, что добавить два целых
собирается, в конце концов,

163
00:07:25,190 --> 00:07:28,799
выход, или выплюнуть обратно
к нам, целое число.

164
00:07:28,799 --> 00:07:31,590
Учитывая то, что эта функция делает мы
хочу, чтобы дать ему значимое имя.

165
00:07:31,590 --> 00:07:33,630
Добавить два целых кажется
целесообразно, учитывая

166
00:07:33,630 --> 00:07:37,574
мы берем два целых числа в качестве входных
и, надеюсь, добавив их вместе.

167
00:07:37,574 --> 00:07:40,240
Это может быть немного громоздким
Имя и откровенно эта функция

168
00:07:40,240 --> 00:07:42,430
Вероятно, нет необходимости
так как мы имеем добавление

169
00:07:42,430 --> 00:07:46,310
Оператор, если вы помните из нашего
обсуждение операторов, ранее.

170
00:07:46,310 --> 00:07:49,650
Но давайте просто скажем, ради
Аргумент, что эта функция полезна

171
00:07:49,650 --> 00:07:52,860
и так мы будем называть его добавить два целых.

172
00:07:52,860 --> 00:07:55,230
Наконец, эта функция принимает два входа.

173
00:07:55,230 --> 00:07:56,960
Каждый из которых является целым числом.

174
00:07:56,960 --> 00:07:59,900
Итак, мы имеем эту запятую
список разделенных входов.

175
00:07:59,900 --> 00:08:02,830
Теперь мы обычно хотят
дать имя каждому из них

176
00:08:02,830 --> 00:08:05,070
таким образом, что они могут быть использованы
в функции.

177
00:08:05,070 --> 00:08:07,180
Имена не страшно важно.

178
00:08:07,180 --> 00:08:11,400
>> В этом случае, мы не обязательно
есть какой-то смысл, прикрепленный к ним.

179
00:08:11,400 --> 00:08:13,140
Таким образом, мы можем просто назвать их и б.

180
00:08:13,140 --> 00:08:14,257
Это совершенно нормально.

181
00:08:14,257 --> 00:08:16,090
Однако, если вы найдете
самостоятельно в ситуации,

182
00:08:16,090 --> 00:08:19,497
где имена переменных
действительно может быть важным,

183
00:08:19,497 --> 00:08:21,830
Вы можете называть их
что-то другое, чем а и Ь

184
00:08:21,830 --> 00:08:24,701
чтобы дать им что-то больше
символически значимым.

185
00:08:24,701 --> 00:08:27,700
Но в данном случае, мы на самом деле не
знаете что-нибудь еще о функции.

186
00:08:27,700 --> 00:08:29,320
Мы просто хотим, чтобы добавить два целых числа.

187
00:08:29,320 --> 00:08:32,429
Таким образом, мы просто позвонить
тех, целые числа а и б.

188
00:08:32,429 --> 00:08:33,990
Вот один пример.

189
00:08:33,990 --> 00:08:36,287
>> Почему бы вам не взять второй
думать об этом,

190
00:08:36,287 --> 00:08:38,870
как бы вы написать функцию
Заявление для функции,

191
00:08:38,870 --> 00:08:42,940
умножает двух чисел с плавающей запятой?

192
00:08:42,940 --> 00:08:45,910
Вы помните, что такое
число с плавающей запятой?

193
00:08:45,910 --> 00:08:48,120
Что бы эта функция
Заявление выглядит?

194
00:08:48,120 --> 00:08:53,330
Я на самом деле рекомендуем Вам приостановить видео
сюда и сколько времени вам нужно.

195
00:08:53,330 --> 00:08:55,521
Подумайте о том, что это
Объявление функции будет?

196
00:08:55,521 --> 00:08:56,770
Что бы тип возвращаемого быть?

197
00:08:56,770 --> 00:08:58,103
Что бы значимое имя будет?

198
00:08:58,103 --> 00:08:59,580
Что бы входы быть?

199
00:08:59,580 --> 00:09:03,190
Так почему бы вам не сделать паузу видео здесь
и написать план функцию декларацию

200
00:09:03,190 --> 00:09:07,640
для функции, которая будет умножать
два плавающей запятой вместе.

201
00:09:07,640 --> 00:09:09,330
Надеюсь, вы паузу видео.

202
00:09:09,330 --> 00:09:12,950
>> Итак, давайте взглянем на пример
одной из возможных декларации.

203
00:09:12,950 --> 00:09:17,340
Поплавок Mult два реала плавать х, у поплавка.

204
00:09:17,340 --> 00:09:19,090
Произведение двух
чисел с плавающей точкой,

205
00:09:19,090 --> 00:09:21,710
которые являются вспомнить, как мы
представляют реальные цифры

206
00:09:21,710 --> 00:09:26,770
или номера с десятичными значениями в С,
будет число с плавающей точкой.

207
00:09:26,770 --> 00:09:28,570
Когда вы умножаете
десятичной в десятичном,

208
00:09:28,570 --> 00:09:30,460
вы, вероятно, собирается получить десятичной.

209
00:09:30,460 --> 00:09:31,960
Вы хотите, чтобы дать ему соответствующую имя.

210
00:09:31,960 --> 00:09:33,810
Умножьте два реала кажется нормально.

211
00:09:33,810 --> 00:09:36,620
Но вы могли бы действительно назвать это
Mult двумя поплавками, или Mult поплавки.

212
00:09:36,620 --> 00:09:39,540
Ничего подобного, до тех пор, как это
дал ему актуальное значение на то, что

213
00:09:39,540 --> 00:09:41,469
это черный ящик собирался сделать.

214
00:09:41,469 --> 00:09:44,260
И опять же, в этом случае, мы не
кажется, есть какой-то смысл придает

215
00:09:44,260 --> 00:09:46,390
на именами
переменные мы переходящие в,

216
00:09:46,390 --> 00:09:48,645
так что мы просто называем их х и у.

217
00:09:48,645 --> 00:09:51,020
Теперь, если вы их называете что-то
еще, что это совершенно нормально.

218
00:09:51,020 --> 00:09:53,310
В самом деле, если вы сделали
эта декларация, а

219
00:09:53,310 --> 00:09:55,450
вместо этого используя двойников
поплавков, если вспомнить,

220
00:09:55,450 --> 00:09:59,100
что удваивается это другая
способ более точно

221
00:09:59,100 --> 00:10:02,330
указать реальные цифры или
с плавающей запятой переменные.

222
00:10:02,330 --> 00:10:03,620
Это совершенно нормально тоже.

223
00:10:03,620 --> 00:10:04,670
Либо один из тех, было бы прекрасно.

224
00:10:04,670 --> 00:10:06,711
На самом деле, есть несколько
различные комбинации

225
00:10:06,711 --> 00:10:08,410
способов заявить эту функцию.

226
00:10:08,410 --> 00:10:10,884
Но эти две довольно хорошие.

227
00:10:10,884 --> 00:10:12,550
Мы объявили функцию, это здорово.

228
00:10:12,550 --> 00:10:15,700
Мы сказали, что это компилятор
является то, что мы собираемся делать.

229
00:10:15,700 --> 00:10:17,630
Теперь давайте на самом деле писать эту функцию.

230
00:10:17,630 --> 00:10:20,750
Давайте дадим ему определение,
таким образом, что внутри черного ящика

231
00:10:20,750 --> 00:10:22,840
предсказуемое поведение происходит.

232
00:10:22,840 --> 00:10:26,270
На самом деле, мы умножения двух действительных
номера вместе, или добавление номера

233
00:10:26,270 --> 00:10:29,760
вместе, или делать то, что это
что мы попросили нашу функцию общего.

234
00:10:29,760 --> 00:10:32,780
>> Таким образом, в самом деле, давайте попробуем определить и
умножить два реала, который мы только что

235
00:10:32,780 --> 00:10:35,350
говорили о второй назад.

236
00:10:35,350 --> 00:10:38,560
Теперь начало
определение функции

237
00:10:38,560 --> 00:10:41,720
выглядит почти точно так же,
как функция декларации.

238
00:10:41,720 --> 00:10:43,170
У меня есть и из них.

239
00:10:43,170 --> 00:10:47,770
В верхней части находится объявление функции,
тип, название, разделенные запятой аргумент

240
00:10:47,770 --> 00:10:49,410
Список, точка с запятой.

241
00:10:49,410 --> 00:10:53,800
Точка с запятой указывает, что
что объявление функции.

242
00:10:53,800 --> 00:10:57,060
Начало функции
определение выглядит почти в точности

243
00:10:57,060 --> 00:11:03,790
то же самое, тип, имя, разделенные запятой
Список аргументов, нет запятой,

244
00:11:03,790 --> 00:11:05,206
открыть фигурную скобку.

245
00:11:05,206 --> 00:11:07,580
Открытая фигурная скобка, как
мы делали с основной,

246
00:11:07,580 --> 00:11:09,540
означает, что мы сейчас
начинает определять

247
00:11:09,540 --> 00:11:14,567
что происходит внутри черного ящика, что
мы решили назвать Несколько два реала.

248
00:11:14,567 --> 00:11:15,900
Вот один из способов, чтобы его реализовать.

249
00:11:15,900 --> 00:11:20,370
Мы могли бы сказать, что мы могли бы объявить новый
переменная типа поплавка называется продукт

250
00:11:20,370 --> 00:11:24,020
и назначить эту переменную
в стоимость х раз у.

251
00:11:24,020 --> 00:11:27,306
А потом вернуться продукт.

252
00:11:27,306 --> 00:11:28,430
Что означает возвращение здесь.

253
00:11:28,430 --> 00:11:31,090
Ну возвращение путь
укажем, что, как

254
00:11:31,090 --> 00:11:33,400
мы передаем выход обратно.

255
00:11:33,400 --> 00:11:38,160
Так что-то вернуть, так же, как,
это выход черного ящика.

256
00:11:38,160 --> 00:11:40,732
Так вот, как вы это делаете.

257
00:11:40,732 --> 00:11:42,190
Вот еще один способ ее реализации.

258
00:11:42,190 --> 00:11:45,050
Мы могли бы просто вернуть х раз у.

259
00:11:45,050 --> 00:11:45,870
х поплавок.

260
00:11:45,870 --> 00:11:46,660
у с плавающей точкой.

261
00:11:46,660 --> 00:11:48,490
Так х раз у также поплавок.

262
00:11:48,490 --> 00:11:50,750
Мы даже не нужно
создать еще одну переменную.

263
00:11:50,750 --> 00:11:56,750
Так что это другой способ
осуществить тот же черный ящик.

264
00:11:56,750 --> 00:11:58,570
>> Теперь воспользоваться моментом,
приостановить видео еще раз,

265
00:11:58,570 --> 00:12:01,680
и попытаться определить добавить два целых,
который является другой функции, что мы

266
00:12:01,680 --> 00:12:03,090
говорили о минуту назад.

267
00:12:03,090 --> 00:12:06,440
Опять здесь, я положил функции
Декларация, и так как точка с запятой,

268
00:12:06,440 --> 00:12:08,420
и открытая фигурная скобка
и закрытым вьющиеся

269
00:12:08,420 --> 00:12:12,080
скобка, чтобы указать, где мы будем заполнять
в содержимом добавить два целых,

270
00:12:12,080 --> 00:12:15,530
так что мы определяем частности
Поведение внутри черного ящика.

271
00:12:15,530 --> 00:12:16,380
Так приостановить видео.

272
00:12:16,380 --> 00:12:18,790
И взять столько времени, сколько
Вы должны попробовать и определить

273
00:12:18,790 --> 00:12:25,040
реализация добавить два целых, например
что, когда функция выводит значение,

274
00:12:25,040 --> 00:12:29,209
он делает, на самом деле, возвращение
сумма двух входов.

275
00:12:29,209 --> 00:12:32,000
Так же, как и в предыдущем примере,
Есть несколько различных способов

276
00:12:32,000 --> 00:12:34,210
что вы могли бы реализовать добавить два целых.

277
00:12:34,210 --> 00:12:35,130
Вот один.

278
00:12:35,130 --> 00:12:37,172
В здесь, в оранжевый У меня
просто были некоторые comments--

279
00:12:37,172 --> 00:12:38,880
Я просто добавил некоторые
комментарии, чтобы указать,

280
00:12:38,880 --> 00:12:41,400
что происходит в каждой строке кода.

281
00:12:41,400 --> 00:12:45,430
Так что я объявить переменную
называется сумма типа Int.

282
00:12:45,430 --> 00:12:47,279
Я говорю сумма равна плюс б.

283
00:12:47,279 --> 00:12:50,070
Вот где мы на самом деле делаем
работа добавления А и В вместе.

284
00:12:50,070 --> 00:12:51,850
И я вернусь сумму.

285
00:12:51,850 --> 00:12:56,460
И, что имеет смысл, поскольку
сумма переменная типа Int.

286
00:12:56,460 --> 00:13:00,180
И то, что тип данных, что это
функция сообщает мне, что собирается вывести?

287
00:13:00,180 --> 00:13:00,680
Int.

288
00:13:00,680 --> 00:13:03,072
Так я возвращаюсь сумму, которая
является целой переменной.

289
00:13:03,072 --> 00:13:06,030
И, что имеет смысл, учитывая то, что мы
Объявление и определение нашу функцию

290
00:13:06,030 --> 00:13:07,320
делать.

291
00:13:07,320 --> 00:13:09,700
>> Теперь вы можете также определить
функция таким образом,

292
00:13:09,700 --> 00:13:15,260
INT сумма равна плюс В- пропустить что
в первую очередь, а затем step--, вернуться сумму.

293
00:13:15,260 --> 00:13:17,760
Теперь вы могли бы также
реализованы это так,

294
00:13:17,760 --> 00:13:19,180
который я очень не рекомендую.

295
00:13:19,180 --> 00:13:22,540
Это плохой стиль для одного
что и в самом деле плохой дизайн,

296
00:13:22,540 --> 00:13:24,420
но это, на самом деле, работы.

297
00:13:24,420 --> 00:13:30,199
Если вы берете этот код, который INT
добавить плохую сумматор точка C, и использовать его.

298
00:13:30,199 --> 00:13:31,990
Это на самом деле добавить
два числа вместе.

299
00:13:31,990 --> 00:13:37,632
Это очень плохая реализация
этого конкретного поведения.

300
00:13:37,632 --> 00:13:38,340
Но он работает.

301
00:13:38,340 --> 00:13:41,200
Это просто здесь для иллюстрации
и дело, что мы на самом деле не

302
00:13:41,200 --> 00:13:44,530
все равно, что происходит внутри
черный ящик, пока

303
00:13:44,530 --> 00:13:46,510
как это имеет вывод, который мы ожидали.

304
00:13:46,510 --> 00:13:48,870
Это плохо разработаны черный ящик.

305
00:13:48,870 --> 00:13:53,801
Но в конце концов, это делает
еще выход сумма плюс б.

306
00:13:53,801 --> 00:13:54,300
Все в порядке.

307
00:13:54,300 --> 00:13:56,320
Так мы объявили функций.

308
00:13:56,320 --> 00:13:57,490
И мы определили функцию.

309
00:13:57,490 --> 00:13:58,540
Так что это действительно хорошо.

310
00:13:58,540 --> 00:14:03,020
Теперь давайте начнем использовать функции
что мы объявили и мы определили.

311
00:14:03,020 --> 00:14:05,960
Для вызова function-- это на самом деле
довольно easy-- все, что вам нужно сделать,

312
00:14:05,960 --> 00:14:09,070
это передать его соответствующими аргументами,
Аргументы типа данных

313
00:14:09,070 --> 00:14:11,600
что он ожидает, и
затем назначить возвращение

314
00:14:11,600 --> 00:14:15,190
Значение этой функции
и this-- оправдание me--

315
00:14:15,190 --> 00:14:19,390
присвоить возвращаемое значение этой функции
к чему-то правильного типа.

316
00:14:19,390 --> 00:14:22,410
>> Итак, давайте посмотрим на
На практике это в файле

317
00:14:22,410 --> 00:14:27,730
называется сумматор 1 точка С,
У меня в CS50 IDE.

318
00:14:27,730 --> 00:14:31,042
Так вот гадюка 1 точка гр.

319
00:14:31,042 --> 00:14:33,500
В начале вы видите, я
мой включает в себя, фунт включают,

320
00:14:33,500 --> 00:14:35,460
Стандарт И.О., и CS50 точка ч.

321
00:14:35,460 --> 00:14:37,700
А потом у меня объявление функции.

322
00:14:37,700 --> 00:14:39,570
Это где я
говорит компилятор Я

323
00:14:39,570 --> 00:14:42,850
будет написания
Функция называется добавить два целых.

324
00:14:42,850 --> 00:14:45,780
Это происходит для вывода
целая переменная типа.

325
00:14:45,780 --> 00:14:47,360
Это то, что эта часть прямо здесь.

326
00:14:47,360 --> 00:14:51,950
А то у меня два входа к нему
и б, каждый из которых представляет собой целое число.

327
00:14:51,950 --> 00:14:58,250
Внутри главного, я прошу у пользователя
вход говоря, дай мне целое.

328
00:14:58,250 --> 00:15:01,040
И они предложено забыть
INT, которая является функцией, что

329
00:15:01,040 --> 00:15:03,240
включен в библиотеке CS50.

330
00:15:03,240 --> 00:15:07,660
И, что сохраняется в
х, целая переменная.

331
00:15:07,660 --> 00:15:09,886
>> Тогда мы подтолкнуть их еще целого.

332
00:15:09,886 --> 00:15:13,070
Мы получаем еще целое
и хранить, что в у.

333
00:15:13,070 --> 00:15:17,990
А потом, здесь, на линии 28, является
где мы делаем нашу вызов функции.

334
00:15:17,990 --> 00:15:23,770
Мы говорим, Int Z равных
добавить 2 Интс х запятой у.

335
00:15:23,770 --> 00:15:25,980
Вы видите, почему это имеет смысл?

336
00:15:25,980 --> 00:15:29,710
х является переменной целого типа и
у является переменной целого типа.

337
00:15:29,710 --> 00:15:31,220
Так что это хорошо.

338
00:15:31,220 --> 00:15:34,570
Это имеет смысл с какой нашей функции
Декларация о соответствии 17 выглядит.

339
00:15:34,570 --> 00:15:38,300
Список ввода разделенные запятой
ожидает два целых числа, а и б.

340
00:15:38,300 --> 00:15:40,300
В этом случае, мы можем назвать
им, что мы хотим.

341
00:15:40,300 --> 00:15:42,300
Это просто ожидает два целых числа.

342
00:15:42,300 --> 00:15:44,930
И х представляет собой целое число, и у является целым числом.

343
00:15:44,930 --> 00:15:45,640
Это работает.

344
00:15:45,640 --> 00:15:48,680
>> И мы знаем, что функция будет
Для вывода числа, а также.

345
00:15:48,680 --> 00:15:51,290
И таким образом, мы сохраняем
выход функции,

346
00:15:51,290 --> 00:15:56,050
добавить два целых, в целое типа
Переменная, которая мы называем г.

347
00:15:56,050 --> 00:16:01,980
И тогда мы можем говорить, что сумма
процентов я и процентов я это я процентов.

348
00:16:01,980 --> 00:16:06,210
х, у и г соответственно
заполнения в тех процентов я годов.

349
00:16:06,210 --> 00:16:08,334
Что является определение
добавить два целых выглядеть?

350
00:16:08,334 --> 00:16:09,125
Это довольно просто.

351
00:16:09,125 --> 00:16:11,270
Это один из тех, что мы
только что видел секунду назад,

352
00:16:11,270 --> 00:16:14,390
INT сумма равняется б обратный плюс сумму.

353
00:16:14,390 --> 00:16:15,420
Это работает?

354
00:16:15,420 --> 00:16:17,270
Давайте сохранить файл.

355
00:16:17,270 --> 00:16:22,080
И тогда здесь, на моем терминале
Я собираюсь сделать сумматор 1,

356
00:16:22,080 --> 00:16:23,000
и я очистить экран.

357
00:16:23,000 --> 00:16:25,791
Я собираюсь увеличить потому что я знаю
это немного трудно увидеть.

358
00:16:25,791 --> 00:16:31,520

359
00:16:31,520 --> 00:16:33,770
>> Так мы собираем эту программу в качестве сумматора 1.

360
00:16:33,770 --> 00:16:37,910
Таким образом, мы можем сделать точка слэш сумматор 1.

361
00:16:37,910 --> 00:16:40,060
Дайте мне целое, 10.

362
00:16:40,060 --> 00:16:42,380
Дайте мне еще целое, 20.

363
00:16:42,380 --> 00:16:45,200
Сумма 10 и 20 30.

364
00:16:45,200 --> 00:16:47,615
Таким образом, мы сделали вызов успешный функцию.

365
00:16:47,615 --> 00:16:55,820
Вы можете запустить функцию снова, отрицательный
10, 17 сумма отрицательного 10 и 17 7.

366
00:16:55,820 --> 00:16:57,120
Эта функция работает.

367
00:16:57,120 --> 00:16:59,240
Он имеет поведение
что мы ожидаем его.

368
00:16:59,240 --> 00:17:03,610
И таким образом, мы сделали успешный
Функция, определение, заявление,

369
00:17:03,610 --> 00:17:07,288
и вызов успешным функция.

370
00:17:07,288 --> 00:17:09,079
Пара разное
пункты о функциях

371
00:17:09,079 --> 00:17:10,611
прежде, чем мы закончим этот раздел.

372
00:17:10,611 --> 00:17:12,319
Напомним, из нашего
обсуждение типов данных,

373
00:17:12,319 --> 00:17:16,109
Ранее, что функции
не может занять ни один вход.

374
00:17:16,109 --> 00:17:17,930
Если это так, то мы
объявить функцию

375
00:17:17,930 --> 00:17:19,788
как имеющий список аргументов недействительными.

376
00:17:19,788 --> 00:17:21,579
Помнишь вам, что
Наиболее общая функция

377
00:17:21,579 --> 00:17:25,036
мы видели до сих пор, что происходит
список аргументов пустота?

378
00:17:25,036 --> 00:17:27,300
Это главный.

379
00:17:27,300 --> 00:17:30,850
Напомним также, что функция иногда
на самом деле не имеют выход.

380
00:17:30,850 --> 00:17:34,210
В этом случае, мы объявляем функцию
как имеющие тип возвращаемого недействительным.

381
00:17:34,210 --> 00:17:37,880
Давайте закончим этот параграф
решения проблемы практики.

382
00:17:37,880 --> 00:17:39,900
>> Так вот проблема выложил.

383
00:17:39,900 --> 00:17:43,630
Я хочу, чтобы вы написать функцию
называется действительным треугольник.

384
00:17:43,630 --> 00:17:47,410
Что эта функция должна делать
это взять три реальные цифры

385
00:17:47,410 --> 00:17:51,930
которые представляют длины три
стороны треугольника, как ее параметров,

386
00:17:51,930 --> 00:17:54,550
или его аргументы, или его
inputs-- другой набор синонимов

387
00:17:54,550 --> 00:17:57,340
что вы можете столкнуться.

388
00:17:57,340 --> 00:18:01,120
Эта функция должна
либо выход истинным или ложным

389
00:18:01,120 --> 00:18:04,960
в зависимости от того этих трех длин
способны сделать треугольник.

390
00:18:04,960 --> 00:18:09,930
Вы помните, что тип данных
мы использовали, чтобы указать, верно или неверно?

391
00:18:09,930 --> 00:18:11,436
Теперь, как вы это реализовать?

392
00:18:11,436 --> 00:18:13,810
Ну знаете, есть пара
правил, касающихся треугольников

393
00:18:13,810 --> 00:18:15,480
что на самом деле полезно знать.

394
00:18:15,480 --> 00:18:18,292
Треугольник может иметь только
Стороны с положительной длины.

395
00:18:18,292 --> 00:18:19,000
В этом есть смысл.

396
00:18:19,000 --> 00:18:21,432
Вы, наверное, сказав, хм.

397
00:18:21,432 --> 00:18:23,390
Другая вещь, к сведению
хотя, является то, что сумма

398
00:18:23,390 --> 00:18:25,484
длин любой
Стороны треугольника

399
00:18:25,484 --> 00:18:27,650
должен быть больше, чем
Длина третьей стороны.

400
00:18:27,650 --> 00:18:28,690
Это на самом деле так.

401
00:18:28,690 --> 00:18:34,150
Вы не можете иметь треугольник сторон 1,
2 и 4, например, из-за 1 плюс 2

402
00:18:34,150 --> 00:18:36,270
не больше, чем 4.

403
00:18:36,270 --> 00:18:38,870
Так что те правила, которые
определить, действительно ли три

404
00:18:38,870 --> 00:18:42,740
Входы могут, предположительно, образуют треугольник.

405
00:18:42,740 --> 00:18:46,360
Так что через пару минут
и объявить, а затем определить

406
00:18:46,360 --> 00:18:49,810
эта функция называется действительным
треугольника, так, что он на самом деле

407
00:18:49,810 --> 00:18:51,650
имеет поведение указанный здесь.

408
00:18:51,650 --> 00:18:57,030
>> Это будет справедливо, если выход этих трех сторон
способны содержащая треугольник,

409
00:18:57,030 --> 00:19:01,950
и ложь в противном случае
Готовы увидеть, как вы сделали?

410
00:19:01,950 --> 00:19:04,650
Вот одна реализация
из действительна треугольник.

411
00:19:04,650 --> 00:19:05,770
Это не только один.

412
00:19:05,770 --> 00:19:07,770
Ваш может незначительно отличаться.

413
00:19:07,770 --> 00:19:11,040
Но это делает, на самом деле, есть
поведение, которое мы ожидаем.

414
00:19:11,040 --> 00:19:14,450
Мы заявляем, что наше функцию на
очень сверху, BOOL действительный треугольник

415
00:19:14,450 --> 00:19:16,630
плавать х флоат у поплавка г.

416
00:19:16,630 --> 00:19:18,930
Итак, еще раз, эта функция
принимает три реальные цифры

417
00:19:18,930 --> 00:19:22,280
в качестве аргументов, плавающие
точка значение переменных,

418
00:19:22,280 --> 00:19:26,510
и выводит истинным или ложным
значение, которое является логическим, напомним.

419
00:19:26,510 --> 00:19:28,660
Так вот почему тип возвращаемого значения BOOL.

420
00:19:28,660 --> 00:19:30,016
Затем мы определяем функцию.

421
00:19:30,016 --> 00:19:33,140
Первое, что мы делаем, это проверить, чтобы убедиться,
что все стороны положительны.

422
00:19:33,140 --> 00:19:37,010
Если х меньше или равно
0, или если у равно 0,

423
00:19:37,010 --> 00:19:41,050
или если г меньше или равно 0,
что не может быть треугольником.

424
00:19:41,050 --> 00:19:42,380
Они не имеют и положительные стороны.

425
00:19:42,380 --> 00:19:45,790
И так мы можем вернуться
ложь в этой ситуации.

426
00:19:45,790 --> 00:19:49,010
Далее, мы проверяем, чтобы убедиться,
что каждая пара входов

427
00:19:49,010 --> 00:19:51,830
больше, чем третий.

428
00:19:51,830 --> 00:19:54,530
>> Так что, если х плюс у менее
или равным г,

429
00:19:54,530 --> 00:19:57,060
или если х плюс г меньше
или равным Y,

430
00:19:57,060 --> 00:20:01,730
или если у плюс г, меньше или равно
х, что также не может быть допустимым треугольник.

431
00:20:01,730 --> 00:20:03,800
Таким образом, мы снова вернуться ложным.

432
00:20:03,800 --> 00:20:06,900
Предположим, что мы прошли обе проверки
хотя, то мы можем вернуться правда.

433
00:20:06,900 --> 00:20:09,440
Потому что те, с трех сторон
способны returning--

434
00:20:09,440 --> 00:20:11,647
создания действительный треугольник.

435
00:20:11,647 --> 00:20:12,230
Вот и все.

436
00:20:12,230 --> 00:20:13,830
Теперь вы объявлены и определены.

437
00:20:13,830 --> 00:20:17,330
И вы можете быть в состоянии в настоящее время для
использовать и вызвать эту функцию.

438
00:20:17,330 --> 00:20:19,470
Отличная работа.

439
00:20:19,470 --> 00:20:20,650
Я Дуг Ллойд.

440
00:20:20,650 --> 00:20:22,820
Это CS50.

441
00:20:22,820 --> 00:20:24,340