1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Недела 4]

2
00:00:03,000 --> 00:00:05,000
[Дејвид Џ Malan] [Универзитетот Харвард]

3
00:00:05,000 --> 00:00:08,000
[Ова е CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> Добро, ова е CS50, а тоа е почеток на недела 4,

5
00:00:12,000 --> 00:00:16,000
и ова е една од најспоро можно сортирање алгоритми.

6
00:00:16,000 --> 00:00:19,000
Кој беше дека ние само одвиваа таму?

7
00:00:19,000 --> 00:00:24,000
Тоа беше меур вид, со цел голема О (n ^ 2) + сума,

8
00:00:24,000 --> 00:00:28,000
и навистина не сме единствените на овој свет да изгледа да знаете

9
00:00:28,000 --> 00:00:30,000
што меур вид е или трчање време.

10
00:00:30,000 --> 00:00:33,000
Всушност, ова е интервју со Ерик Шмит на Google

11
00:00:33,000 --> 00:00:45,000
и поранешниот сенатор Барак Обама само неколку години.

12
00:00:45,000 --> 00:00:48,000
>> Сега, сенаторот, ти си тука во Google,

13
00:00:48,000 --> 00:00:54,000
и сакам да мислам на претседателството како интервјуто за работа.

14
00:00:54,000 --> 00:00:58,000
Сега, тоа е тешко да се добие работа како претседател, а ти си минува низ строги мерки сега.

15
00:00:58,000 --> 00:01:00,000
Тоа е исто така тешко да се добие работа во Google.

16
00:01:00,000 --> 00:01:05,000
Имаме прашања, а ние бараме нашите кандидати прашања,

17
00:01:05,000 --> 00:01:10,000
и овој е од Лари Швимер.

18
00:01:10,000 --> 00:01:14,000
Вие момци мислам дека сум шегуваш? Тоа е право тука.

19
00:01:14,000 --> 00:01:18,000
Што е најефикасен начин да се најде еден милион 32-битни броеви?

20
00:01:18,000 --> 00:01:21,000
[Смеа]

21
00:01:21,000 --> 00:01:24,000
Добро

22
00:01:24,000 --> 00:01:26,000
Жал ми е. >> Не, не, не, не.

23
00:01:26,000 --> 00:01:34,000
Мислам дека меурот вид ќе биде погрешен начин да се оди.

24
00:01:34,000 --> 00:01:39,000
>> Ајде, кој му рекол ова?

25
00:01:39,000 --> 00:01:43,000
Минатата недела се потсетиме ние зеде пауза од кодот, барем за еден ден,

26
00:01:43,000 --> 00:01:46,000
и почна да се фокусира на некои повисоко ниво идеи и решавање на проблемот со поопшто

27
00:01:46,000 --> 00:01:49,000
во контекст на пребарување и подредување,

28
00:01:49,000 --> 00:01:53,000
и ќе воведе нешто што ние не го завршиме ова име на минатата недела,

29
00:01:53,000 --> 00:01:56,000
но асимптотска нотација, Биг О, Биг Омега,

30
00:01:56,000 --> 00:02:00,000
а понекогаш и Биг Тита нотација, и тие беа едноставно начини

31
00:02:00,000 --> 00:02:02,000
на опишување трчање време на алгоритми,

32
00:02:02,000 --> 00:02:05,000
колку време е потребно за алгоритам да се кандидира.

33
00:02:05,000 --> 00:02:08,000
>> И може да се потсетиме дека зборуваше за трчање време во однос на големината

34
00:02:08,000 --> 00:02:11,000
на влез, која ние обично повик n, без оглед на проблемот може да биде,

35
00:02:11,000 --> 00:02:13,000
каде n е бројот на луѓе во собата,

36
00:02:13,000 --> 00:02:17,000
бројот на страници во книгата на телефонот, и почнавме да се напише работи надвор

37
00:02:17,000 --> 00:02:21,000
како О (n ^ 2) или О (n) или О (n најавите л),

38
00:02:21,000 --> 00:02:24,000
па дури и кога математика не сосема работат надвор толку совршено

39
00:02:24,000 --> 00:02:28,000
и тоа беше n ² - n / 2 или нешто слично

40
00:02:28,000 --> 00:02:31,000
ние би наместо само фрлаат во некој од пониските цел термини,

41
00:02:31,000 --> 00:02:34,000
и мотивација таму е дека ние навистина сакаат

42
00:02:34,000 --> 00:02:37,000
вид на објективен начин на оценување

43
00:02:37,000 --> 00:02:39,000
извршување на програми или извршување на алгоритми

44
00:02:39,000 --> 00:02:42,000
дека на крајот на денот нема ништо да се направи, на пример,

45
00:02:42,000 --> 00:02:45,000
со брзината на вашиот компјутер денес.

46
00:02:45,000 --> 00:02:47,000
>> На пример, ако се спроведе меур вид,

47
00:02:47,000 --> 00:02:50,000
или да спроведе спојат вид или селекција вид на компјутер денес,

48
00:02:50,000 --> 00:02:53,000
2 GHz компјутер, и да се стартува,

49
00:02:53,000 --> 00:02:56,000
и тоа трае некои бројот на секунди, следната година има 3 GHz

50
00:02:56,000 --> 00:02:59,000
или 4 GHz компјутер, и тогаш може да тврдат дека "Леле, ми алгоритам

51
00:02:59,000 --> 00:03:03,000
е сега два пати толку брзо ", кога во реалноста тоа не е очигледно случајот.

52
00:03:03,000 --> 00:03:06,000
Тоа е само хардвер има добивано и побрзо, но вашиот компјутер

53
00:03:06,000 --> 00:03:10,000
не, и така ние навистина сакаме да се фрлаат работи како

54
00:03:10,000 --> 00:03:13,000
множители на 2 или мултипли од 3 кога станува збор за опишување

55
00:03:13,000 --> 00:03:17,000
колку брзо или колку е бавно алгоритам е и навистина само се фокусираат

56
00:03:17,000 --> 00:03:20,000
на n или некои фактор од него,

57
00:03:20,000 --> 00:03:24,000
некаква моќ од него, како и во случај на сорти од минатата недела.

58
00:03:24,000 --> 00:03:27,000
И се потсетиме дека со помош на спојат вид

59
00:03:27,000 --> 00:03:31,000
ние бевме во можност да го стори тоа многу подобро отколку меур сортирање и селекција вид

60
00:03:31,000 --> 00:03:33,000
па дури и вметнување вид.

61
00:03:33,000 --> 00:03:36,000
>> Ние се спушти до n најавите n, и повторно,

62
00:03:36,000 --> 00:03:39,000
потсетиме дека најавите n генерално се однесува на нешто што расте

63
00:03:39,000 --> 00:03:43,000
побавно тогаш n, па n најавите n досега беше добар

64
00:03:43,000 --> 00:03:45,000
бидејќи тоа е помалку од n ².

65
00:03:45,000 --> 00:03:47,000
Но, за да се постигне n најавите n со спојување вид

66
00:03:47,000 --> 00:03:51,000
она што беше основна зародишот на идејата дека моравме да потпора

67
00:03:51,000 --> 00:03:54,000
дека ние, исто така, балон назад во недела 0?

68
00:03:54,000 --> 00:03:58,000
Како ја решавање на сортирање проблем умно со спојување вид?

69
00:03:58,000 --> 00:04:04,000
Што беше клучна увид, можеби?

70
00:04:04,000 --> 00:04:07,000
Секој на сите.

71
00:04:07,000 --> 00:04:09,000
Океј, ајде да направиме чекор назад.

72
00:04:09,000 --> 00:04:11,000
Опишете се спојат вид со свои зборови.

73
00:04:11,000 --> 00:04:15,000
Како таа функционира?

74
00:04:15,000 --> 00:04:17,000
Океј, ние ќе ред назад кон недела 0.

75
00:04:17,000 --> 00:04:19,000
Океј, да.

76
00:04:19,000 --> 00:04:22,000
[Нечујни-студент]

77
00:04:22,000 --> 00:04:26,000
Океј, добро, па ние поделени низа на броеви во 2 парчиња.

78
00:04:26,000 --> 00:04:29,000
Ние подредени секоја од овие парчиња, а потоа ние ги спојуваат,

79
00:04:29,000 --> 00:04:33,000
и видовме оваа идеја пред земање на проблем кој е овој голем

80
00:04:33,000 --> 00:04:36,000
и сечкање до тоа во проблем што е тоа големи или овој голем.

81
00:04:36,000 --> 00:04:38,000
>> Да се ​​потсетиме на телефонот книга пример.

82
00:04:38,000 --> 00:04:42,000
Да се ​​потсетиме само-броење алгоритам од пред неколку недели,

83
00:04:42,000 --> 00:04:45,000
па се спојат вид беше инволвиран со оваа pseudocode тука.

84
00:04:45,000 --> 00:04:48,000
Кога си даде n елементи, прво тоа беше разумност провери.

85
00:04:48,000 --> 00:04:51,000
Ако n <2 тогаш не прават ништо на сите

86
00:04:51,000 --> 00:04:55,000
бидејќи ако n <2 тогаш n е очигледно 0 или 1,

87
00:04:55,000 --> 00:04:57,000
и така, ако тоа е или 0 или 1 нема ништо да го решите.

88
00:04:57,000 --> 00:04:59,000
Ќе завршиш.

89
00:04:59,000 --> 00:05:01,000
Вашата листа е веќе тривијално подредени.

90
00:05:01,000 --> 00:05:04,000
Но инаку ако имаш 2 или повеќе елементи оди напред и да ги делат

91
00:05:04,000 --> 00:05:06,000
во 2 дела, лево и десно.

92
00:05:06,000 --> 00:05:09,000
Сортирање секоја од тие дела, а потоа се логирате на подредени половини.

93
00:05:09,000 --> 00:05:13,000
Но, проблемот овде е дека на прв поглед ова изгледа како ние сме punting.

94
00:05:13,000 --> 00:05:17,000
Ова е кружен дефиниција дека ако сум те праша за сортирање овие n елементи

95
00:05:17,000 --> 00:05:22,000
и ти ќе ми кажеш "Добро, добро, ние ќе средиме оние n / 2 и оние n / 2 елементи"

96
00:05:22,000 --> 00:05:27,000
тогаш мојата следна прашање ќе биде "Добро, како да ги сортирате n / 2 елементи?"

97
00:05:27,000 --> 00:05:30,000
>> Но, поради структурата на оваа програма,

98
00:05:30,000 --> 00:05:33,000
бидејќи таму е оваа база случај, така да се каже,

99
00:05:33,000 --> 00:05:39,000
овој посебен случај кој се вели дека ако n е <некои фиксна вредност како 2 врати веднаш.

100
00:05:39,000 --> 00:05:42,000
Не одговори со истата кружни одговор.

101
00:05:42,000 --> 00:05:46,000
Овој процес, овој cyclicity на крајот ќе заврши.

102
00:05:46,000 --> 00:05:50,000
Ако те прашувам "Сортирај овие n елементи", и ќе речете: "Добро, сортирање овие n / 2"

103
00:05:50,000 --> 00:05:53,000
тогаш велат: "Добро, сортирање овие n / 4, N / 8, n/16"

104
00:05:53,000 --> 00:05:56,000
на крајот ќе се подели со доволно голем број

105
00:05:56,000 --> 00:05:59,000
дека ќе имаат само 1 елемент лево, на која точка може да се каже,

106
00:05:59,000 --> 00:06:02,000
"Еве, тука е сортирани поединечен елемент."

107
00:06:02,000 --> 00:06:06,000
Потоа брилијантноста на овој алгоритам се тука е да се изведе од фактот

108
00:06:06,000 --> 00:06:09,000
дека откако ќе ги имаат сите овие поединечно подредени списоци,

109
00:06:09,000 --> 00:06:12,000
од кои сите се од 1 големина, која се чини дека е бескорисно,

110
00:06:12,000 --> 00:06:15,000
штом еднаш ќе почнете спојување нив и спојување нив

111
00:06:15,000 --> 00:06:19,000
ќе се изгради до крај како Роб не во видео на конечно подредени листа.

112
00:06:19,000 --> 00:06:22,000
>> Но, оваа идеја се протега многу подалеку сортирање.

113
00:06:22,000 --> 00:06:26,000
Постои оваа идеја вградени во оваа програма позната како рекурзија,

114
00:06:26,000 --> 00:06:29,000
идејата која сте програмата,

115
00:06:29,000 --> 00:06:32,000
и да се реши некој проблем ќе се наречеш,

116
00:06:32,000 --> 00:06:36,000
или стави во контекст на програмските јазици што се во функција,

117
00:06:36,000 --> 00:06:39,000
и со цел да се реши еден проблем, можете функцијата се наречеш

118
00:06:39,000 --> 00:06:42,000
повторно и повторно и повторно, но функцијата

119
00:06:42,000 --> 00:06:44,000
не може да се јавите бесконечно многу пати.

120
00:06:44,000 --> 00:06:47,000
На крајот ќе мора да дното, така да се каже,

121
00:06:47,000 --> 00:06:49,000
и имаат некоја хард-кодирани база состојба во која се вели

122
00:06:49,000 --> 00:06:53,000
во овој момент престанат да повикуваат себе, така што целиот процес

123
00:06:53,000 --> 00:06:56,000
конечно се всушност запре.

124
00:06:56,000 --> 00:06:58,000
Што значи тоа навистина значи, да recurse?

125
00:06:58,000 --> 00:07:01,000
>> Ајде да видиме, ако можеме да направиме едноставна, тривијални пример, да речеме,

126
00:07:01,000 --> 00:07:03,000
3 луѓе со мене се тука на сцена, ако некој е удобно.

127
00:07:03,000 --> 00:07:06,000
1, ајде нагоре, 2 и 3.

128
00:07:06,000 --> 00:07:09,000
Ако 3 сакате да излезе тука.

129
00:07:09,000 --> 00:07:12,000
Ако сакате да застанат веднаш до мене тука во линија, да претпоставиме дека проблемот на дофат на раката

130
00:07:12,000 --> 00:07:15,000
е многу тривијално брои бројот на луѓе кои се тука.

131
00:07:15,000 --> 00:07:18,000
Но, искрено, јас сум уморна од сите овие броење примери.

132
00:07:18,000 --> 00:07:21,000
Ова ќе потрае некое време, 1, 2 и точка, точка, точка.

133
00:07:21,000 --> 00:07:23,000
Тоа ќе потрае засекогаш.

134
00:07:23,000 --> 00:07:25,000
Претпочитам само залог овој проблем целосно со помош на-Што е вашето име?

135
00:07:25,000 --> 00:07:27,000
Sara. >> Сара, во ред.

136
00:07:27,000 --> 00:07:29,000
Кели. >> Кели и?

137
00:07:29,000 --> 00:07:31,000
>> Willy. >> Вили, Сара, Кели и Вили.

138
00:07:31,000 --> 00:07:34,000
Токму сега јас се поставува прашањето од страна на некој

139
00:07:34,000 --> 00:07:37,000
колку луѓе се горе на оваа фаза, и јас немам идеја.

140
00:07:37,000 --> 00:07:40,000
Ова е навистина долга листа, и така наместо Одам да го направите овој трик.

141
00:07:40,000 --> 00:07:43,000
Одам да побара од лицето до мене да го направи најголемиот дел од работата,

142
00:07:43,000 --> 00:07:46,000
и откако таа се прави прави најголемиот дел од работата

143
00:07:46,000 --> 00:07:49,000
Одам да се направи најмалку износот на работа е можно и само додадете 1

144
00:07:49,000 --> 00:07:51,000
за она што нејзиниот одговор е, па тука ќе одиме.

145
00:07:51,000 --> 00:07:54,000
Сум бил праша колку луѓе се на сцената.

146
00:07:54,000 --> 00:07:57,000
Колку луѓе се на сцената лево од вас?

147
00:07:57,000 --> 00:08:00,000
Лево од мене? >> Океј, но не измамник.

148
00:08:00,000 --> 00:08:04,000
Тоа е добро, тоа е точно, но ако сакаме да продолжи оваа логика

149
00:08:04,000 --> 00:08:08,000
ајде да се претпостави дека слично сакате да залог овој проблем лево од вас,

150
00:08:08,000 --> 00:08:11,000
па наместо одговор директно оди напред и само ја префрлуваат одговорноста.

151
00:08:11,000 --> 00:08:14,000
О, колку луѓе се лево од мене?

152
00:08:14,000 --> 00:08:16,000
Колку луѓе се на лево?

153
00:08:16,000 --> 00:08:18,000
1.

154
00:08:18,000 --> 00:08:27,000
[Смеа]

155
00:08:27,000 --> 00:08:30,000
Океј, па 0, па што сега Вили има направено

156
00:08:30,000 --> 00:08:33,000
е сте се вратија вашиот одговор оваа насока велејќи 0.

157
00:08:33,000 --> 00:08:36,000
Сега, она што треба да направам? >> 1.

158
00:08:36,000 --> 00:08:39,000
Океј, па ти си на 1, па велат: "Добро, јас ќе одам да додадете 1

159
00:08:39,000 --> 00:08:41,000
на она брои Вили беше ", така 1 + 0.

160
00:08:41,000 --> 00:08:43,000
Ти си сега 1 па вашиот одговор на правото е сега

161
00:08:43,000 --> 00:08:45,000
1. >> И рудникот ќе биде 2.

162
00:08:45,000 --> 00:08:48,000
Добро, па ти си преземање на претходниот одговор од 1,

163
00:08:48,000 --> 00:08:51,000
додавање на минимална количина на работа што сакате да направите, што е 1.

164
00:08:51,000 --> 00:08:55,000
Вие сега имате 2, и тогаш предаде мене што вредност?

165
00:08:55,000 --> 00:08:57,000
3, мислам, жалам, 2.

166
00:08:57,000 --> 00:08:59,000
Добро.

167
00:08:59,000 --> 00:09:02,000
>> Па, имавме 0 налево.

168
00:09:02,000 --> 00:09:05,000
Потоа имавме 1, а потоа ние додадете 2,

169
00:09:05,000 --> 00:09:07,000
и сега сте ме предавање на број 2,

170
00:09:07,000 --> 00:09:10,000
и така сакам да кажам дека, во ред, 1, 3.

171
00:09:10,000 --> 00:09:13,000
Има навистина 3 народот што стои до мене на оваа фаза,

172
00:09:13,000 --> 00:09:16,000
па ние би можеле да имаат очигледно направиле тоа многу линеарно,

173
00:09:16,000 --> 00:09:19,000
многу во очигледен начин, но што ние навистина?

174
00:09:19,000 --> 00:09:21,000
Ние ја проблемот на големина 3 на почетокот.

175
00:09:21,000 --> 00:09:24,000
Ние тогаш тоа урна во проблем на големината 2,

176
00:09:24,000 --> 00:09:27,000
тогаш проблемот на големина 1, а потоа конечно база случај

177
00:09:27,000 --> 00:09:29,000
беше навистина, о, нема никој таму,

178
00:09:29,000 --> 00:09:33,000
на која точка Вили врати ефективно хард-кодирани одговор на неколку пати,

179
00:09:33,000 --> 00:09:36,000
а вториот беше тогаш клобуркаше до, клобуркаше до, клобуркаше до,

180
00:09:36,000 --> 00:09:39,000
а потоа со додавање на овој еден дополнителен 1

181
00:09:39,000 --> 00:09:41,000
ние сме спроведува оваа Основната идеја на рекурзија.

182
00:09:41,000 --> 00:09:44,000
>> Сега, во овој случај тоа навистина не се реши проблемот

183
00:09:44,000 --> 00:09:46,000
било поефикасно потоа видовме досега.

184
00:09:46,000 --> 00:09:48,000
Но, мислам за на алгоритми ние го направивме на сцената досега.

185
00:09:48,000 --> 00:09:51,000
Имавме 8 парчиња хартија на таблата,

186
00:09:51,000 --> 00:09:55,000
на видео, кога Шон беше во потрага по бројот 7, и она што тој го навистина?

187
00:09:55,000 --> 00:09:58,000
Па, тој не направи било каков вид на поделба и освојување.

188
00:09:58,000 --> 00:10:01,000
Тој не направи било каков вид на рекурзија.

189
00:10:01,000 --> 00:10:03,000
Наместо тоа, тој само го направи ова линеарни алгоритам.

190
00:10:03,000 --> 00:10:07,000
Но кога ќе се претстави идејата на подредени броеви на сцената живеат минатата недела

191
00:10:07,000 --> 00:10:09,000
тогаш имавме овој инстинкт да одат на средината,

192
00:10:09,000 --> 00:10:13,000
на која точка имавме помал листа на големина од 4 или друга листа на големина 4,

193
00:10:13,000 --> 00:10:17,000
а потоа имавме исти проблем, па ние се повторува, повторува, повторува.

194
00:10:17,000 --> 00:10:19,000
Со други зборови, ние recursed.

195
00:10:19,000 --> 00:10:24,000
Ви благодарам многу за нашите 3 волонтери тука за демонстрирање на рекурзијата со нас.

196
00:10:24,000 --> 00:10:28,000
>> Ајде да видиме ако не можеме да го направи тоа сега малку поконкретни,

197
00:10:28,000 --> 00:10:30,000
решавање на проблем кој повторно би можеле да направите многу лесно,

198
00:10:30,000 --> 00:10:34,000
но ние ќе го користат како отскочна штица за спроведување на оваа основна идеја.

199
00:10:34,000 --> 00:10:37,000
Ако сакам да се пресмета збирот на еден куп на броеви,

200
00:10:37,000 --> 00:10:39,000
На пример, ако помине во број 3,

201
00:10:39,000 --> 00:10:42,000
Сакам да ви даде вредност на сигма 3,

202
00:10:42,000 --> 00:10:46,000
па збирот на 3 + 2 + 1 + 0.

203
00:10:46,000 --> 00:10:48,000
Сакам да се вратам одговорот 6,

204
00:10:48,000 --> 00:10:51,000
па ние ќе ја имплементираат оваа сигма функција, овој збир функција

205
00:10:51,000 --> 00:10:54,000
кои, пак, се во влез, а потоа се враќа на собирање

206
00:10:54,000 --> 00:10:57,000
на тој број на целиот пат на 0.

207
00:10:57,000 --> 00:10:59,000
Ние би можеле да го направите ова прилично едноставно, нели?

208
00:10:59,000 --> 00:11:01,000
Ние би можеле да го направите ова со некаков вид на looping структура,

209
00:11:01,000 --> 00:11:04,000
па дозволете ми да оди напред и да се добие овој отворени.

210
00:11:04,000 --> 00:11:07,000
>> Вклучуваат stdio.h.

211
00:11:07,000 --> 00:11:09,000
Дозволете ми да се влезе во главната да работат со овде.

212
00:11:09,000 --> 00:11:12,000
Да зачувате ова како sigma.c.

213
00:11:12,000 --> 00:11:14,000
Тогаш јас ќе одам да си тука, и јас одам да се изјаснат за int n,

214
00:11:14,000 --> 00:11:18,000
и јас одам да го направите следново додека корисникот не соработуваат.

215
00:11:18,000 --> 00:11:22,000
Додека корисникот не ми даде позитивен број

216
00:11:22,000 --> 00:11:26,000
дозволете ми да оди напред и да ги поттикнуваат за n = GetInt,

217
00:11:26,000 --> 00:11:28,000
и дозволете ми да им даде некои инструкции како да што да направам,

218
00:11:28,000 --> 00:11:33,000
па printf ("позитивен цел број молам").

219
00:11:33,000 --> 00:11:39,000
Само нешто релативно едноставен вака, така што со време ние хит линија 14

220
00:11:39,000 --> 00:11:42,000
сега имаме позитивен цел број се претпоставува дека во n.

221
00:11:42,000 --> 00:11:44,000
>> Сега ајде да направиме нешто со него.

222
00:11:44,000 --> 00:11:50,000
Дозволете ми да оди напред и да се пресмета збирот, па int сума = сигма (л).

223
00:11:50,000 --> 00:11:54,000
Сигма е само собирање, па јас сум само да го пишува во познавач начин.

224
00:11:54,000 --> 00:11:56,000
Ние само ќе го наречеме сигма таму.

225
00:11:56,000 --> 00:11:58,000
Тоа е сума, и сега ќе одам да се печати резултатот,

226
00:11:58,000 --> 00:12:08,000
printf ("Сумата е% d \ n", сума).

227
00:12:08,000 --> 00:12:11,000
А потоа ќе се врати 0 за добра мерка.

228
00:12:11,000 --> 00:12:15,000
Ние го направивме она што оваа програма бара освен интересен дел,

229
00:12:15,000 --> 00:12:18,000
која е всушност да се спроведе сигма функција.

230
00:12:18,000 --> 00:12:22,000
>> Дозволете ми да одат надолу тука до дното, и дозволете ми да прогласи функција сигма.

231
00:12:22,000 --> 00:12:26,000
Тоа е мора да се земе променлива која е од тип integer,

232
00:12:26,000 --> 00:12:30,000
и она што тип на податок сакам да се вратат веројатно од сигма?

233
00:12:30,000 --> 00:12:34,000
Int, бидејќи сакам да одговара на моите очекувања on-line 15.

234
00:12:34,000 --> 00:12:37,000
Тука дозволете ми да оди напред и да ја имплементираат оваа

235
00:12:37,000 --> 00:12:41,000
во прилично недвосмислен начин.

236
00:12:41,000 --> 00:12:45,000
>> Ајде да одиме напред и да каже int сума = 0,

237
00:12:45,000 --> 00:12:47,000
и сега јас ќе одам да си имаат малку за телефонска линија тука

238
00:12:47,000 --> 00:12:50,000
што се случува да се каже нешто како ова,

239
00:12:50,000 --> 00:13:01,000
за (int i = 0; јас <= број; i + +) збирот + = i.

240
00:13:01,000 --> 00:13:05,000
И тогаш ќе одам да се вратат сума.

241
00:13:05,000 --> 00:13:07,000
Јас би можеле да имаат имплементирано овој во секој број на начини.

242
00:13:07,000 --> 00:13:09,000
Јас може да се користат додека јамка.

243
00:13:09,000 --> 00:13:11,000
Можев да прескокнат користење на збирот променлива ако јас навистина сакаше да,

244
00:13:11,000 --> 00:13:15,000
но на кратко, ние едноставно имаат функција која ако јас не глупак изјавува сума е 0.

245
00:13:15,000 --> 00:13:18,000
Тогаш тоа iterates од 0 на до преку број,

246
00:13:18,000 --> 00:13:23,000
и на секоја итерација се додава дека сегашната вредност на збирот а потоа се враќа сума.

247
00:13:23,000 --> 00:13:25,000
>> Сега, има мало оптимизација овде.

248
00:13:25,000 --> 00:13:29,000
Ова е веројатно потроши чекор, но толку било да е тоа. Тоа е во ред за сега.

249
00:13:29,000 --> 00:13:32,000
Ние сме најмалку се темелно и ќе 0 целиот пат на до.

250
00:13:32,000 --> 00:13:34,000
Не е многу тешко и прилично јасна,

251
00:13:34,000 --> 00:13:37,000
но излегува дека со функцијата сигма имаме иста можност

252
00:13:37,000 --> 00:13:39,000
како што направивме тука на сцена.

253
00:13:39,000 --> 00:13:42,000
На сцената ние само смета како многу луѓе беа до мене,

254
00:13:42,000 --> 00:13:47,000
но наместо тоа, ако сакаме да се брои бројот 3 + 2 + 1

255
00:13:47,000 --> 00:13:51,000
за одредување на 0 би можеле слично залог на функција

256
00:13:51,000 --> 00:13:55,000
дека јас наместо ќе се опише како рекурзивен.

257
00:13:55,000 --> 00:13:57,000
Еве нека се брзо разумност провери и бидете сигурни дека јас не глупак.

258
00:13:57,000 --> 00:14:00,000
>> Знам дека барем една работа во оваа програма јас го правам погрешно.

259
00:14:00,000 --> 00:14:04,000
Кога ќе притиснете ентер одам да се добие било каков вид на вика на мене?

260
00:14:04,000 --> 00:14:06,000
Што сум јас ќе биде викна на тоа?

261
00:14:06,000 --> 00:14:11,000
Да, јас заборавив на прототип, па јас сум со користење на функција наречена сигма на линија 15,

262
00:14:11,000 --> 00:14:16,000
но тоа не е прогласен додека линија 22, па најдобро проактивно одат нагоре тука

263
00:14:16,000 --> 00:14:22,000
и прогласи прототип, и јас ќе кажам int сигма (int број), и тоа е тоа.

264
00:14:22,000 --> 00:14:24,000
Тоа е имплементиран на дното.

265
00:14:24,000 --> 00:14:27,000
>> Или на друг начин би можел да се реши овој,

266
00:14:27,000 --> 00:14:30,000
Можев да ја преместите функцијата до таму, што не е лошо,

267
00:14:30,000 --> 00:14:32,000
но барем кога вашите програми почне да се долго, искрено,

268
00:14:32,000 --> 00:14:35,000
Мислам дека има некои вредност во секогаш има главниот на врвот

269
00:14:35,000 --> 00:14:38,000
така што ќе во читателот да ја отворам датотеката, а потоа веднаш ја видите

270
00:14:38,000 --> 00:14:40,000
она што го прави програмата без да пребарувате низ тоа

271
00:14:40,000 --> 00:14:42,000
гледа дека главната функција.

272
00:14:42,000 --> 00:14:49,000
Ајде да одиме надолу за да ми терминален прозорец тука, обидете се прави сигма направи сигма,

273
00:14:49,000 --> 00:14:51,000
и јас зезнав тука.

274
00:14:51,000 --> 00:14:55,000
Имплицитна изјава на функцијата GetInt значи дека си заборавил да го направи она што друго?

275
00:14:55,000 --> 00:14:57,000
[Нечујни-студент]

276
00:14:57,000 --> 00:15:00,000
Добро, па очигледно честа грешка, па ајде стави ова овде горе,

277
00:15:00,000 --> 00:15:04,000
cs50.h, а сега да се вратиме на мојот терминален прозорец.

278
00:15:04,000 --> 00:15:08,000
>> Јас ќе го исчистите екранот, а јас ќе повторување направи сигма.

279
00:15:08,000 --> 00:15:11,000
Се чини да се состави. А сега допуштете ми се кандидира сигма.

280
00:15:11,000 --> 00:15:15,000
Ќе внесете го бројот 3, а јас не добиваат 6, па не ригорозни чек,

281
00:15:15,000 --> 00:15:18,000
но барем тоа изгледа да се работи на прв поглед, но сега ајде да го рипувате, освен,

282
00:15:18,000 --> 00:15:21,000
и ајде да всушност поткрепа на идејата за рекурзија, повторно,

283
00:15:21,000 --> 00:15:24,000
во еден многу едноставен контекст, така што по неколку недели време

284
00:15:24,000 --> 00:15:27,000
кога ќе започнете истражуваат познавач структури на податоци од низи

285
00:15:27,000 --> 00:15:30,000
имаме уште една алатка во алатка со која ќе се

286
00:15:30,000 --> 00:15:33,000
манипулира со овие структури на податоци како што ќе видиме.

287
00:15:33,000 --> 00:15:36,000
Ова е итеративен пристап, јамка-базирани на пристап.

288
00:15:36,000 --> 00:15:39,000
>> Дозволете ми, наместо сега го направите тоа.

289
00:15:39,000 --> 00:15:44,000
Дозволете ми, наместо да се каже дека збирот на бројот

290
00:15:44,000 --> 00:15:48,000
за одредување на 0 е навистина истото како

291
00:15:48,000 --> 00:15:53,000
број + сигма (број - 1).

292
00:15:53,000 --> 00:15:57,000
Со други зборови, како на сцената јас punted на секој од луѓето до мене,

293
00:15:57,000 --> 00:16:00,000
и тие за возврат чуваат punting додека ние конечно дно на Вили,

294
00:16:00,000 --> 00:16:03,000
кој мораше да се врати на хард-кодирани одговор како 0.

295
00:16:03,000 --> 00:16:07,000
Еве сега ние сме слично punting да сигма

296
00:16:07,000 --> 00:16:10,000
истата функција како што беше првобитно наречено, но клучот увид тука

297
00:16:10,000 --> 00:16:12,000
е дека ние не сме повикувајќи сигма идентично.

298
00:16:12,000 --> 00:16:14,000
Ние не сме поминува во n.

299
00:16:14,000 --> 00:16:17,000
Ние сме јасно што минува во број - 1,

300
00:16:17,000 --> 00:16:20,000
па малку помал проблем, малку помал проблем.

301
00:16:20,000 --> 00:16:23,000
>> За жал, ова не е сосема решение сепак, и пред да го поправи

302
00:16:23,000 --> 00:16:26,000
она што може да се скока надвор како што очигледно на некои од вас

303
00:16:26,000 --> 00:16:28,000
дозволете ми да оди напред и повторување направи.

304
00:16:28,000 --> 00:16:30,000
Се чини да се компајлира во ред.

305
00:16:30,000 --> 00:16:32,000
Дозволете ми повторување сигма со 6.

306
00:16:32,000 --> 00:16:37,000
Whoops, дозволете ми повторување сигма со 6.

307
00:16:37,000 --> 00:16:42,000
Видовме и пред, иако случајно последен пат, како и.

308
00:16:42,000 --> 00:16:48,000
Зошто да се добие оваа криптичната сегментација грешка? Да.

309
00:16:48,000 --> 00:16:50,000
[Нечујни-студент]

310
00:16:50,000 --> 00:16:53,000
Нема база случај, и поконкретно, што најверојатно се случило?

311
00:16:53,000 --> 00:16:58,000
Ова е симптом на она однесување?

312
00:16:58,000 --> 00:17:00,000
Велат дека тоа малку погласно.

313
00:17:00,000 --> 00:17:02,000
[Нечујни-студент]

314
00:17:02,000 --> 00:17:05,000
Тоа е бесконечна јамка ефикасно, и на проблемот со бесконечна петелки

315
00:17:05,000 --> 00:17:08,000
кога тие подразбираат рекурзија во овој случај, функција која себеси се нарекува,

316
00:17:08,000 --> 00:17:10,000
она што се случува секој пат кога ќе се јавите на функција?

317
00:17:10,000 --> 00:17:13,000
Па, се сетам на тоа како ние изложени на меморијата во компјутерот.

318
00:17:13,000 --> 00:17:16,000
Рековме дека е ова парче од меморија се нарекува конзола која е на дното,

319
00:17:16,000 --> 00:17:19,000
и секој пат кога ќе се јавите на функција малку повеќе меморија добива стави

320
00:17:19,000 --> 00:17:24,000
на овој т.н. магацинот содржат локални променливи таа функција или параметри,

321
00:17:24,000 --> 00:17:27,000
па ако сигма повици сигма повици сигма повици сигма

322
00:17:27,000 --> 00:17:29,000
 повици сигма каде е оваа приказна крајот?

323
00:17:29,000 --> 00:17:31,000
>> Па, на крајот пречекорување на вкупната сума

324
00:17:31,000 --> 00:17:33,000
на меморија што имате на располагање на вашиот компјутер.

325
00:17:33,000 --> 00:17:37,000
Можете лизгањето на сегментот што си требал да остане во рамките на,

326
00:17:37,000 --> 00:17:40,000
и ќе го добиете овој сегментација грешка, основни фрлени,

327
00:17:40,000 --> 00:17:43,000
и она јадро фрлени значи дека јас сега имаат фајл наречен јадро

328
00:17:43,000 --> 00:17:46,000
која е датотека која содржи нули и единици

329
00:17:46,000 --> 00:17:49,000
кои, всушност, во иднина ќе биде дијагностички корисни.

330
00:17:49,000 --> 00:17:52,000
Ако тоа не е очигледно за вас, каде што вашиот бубачка е

331
00:17:52,000 --> 00:17:54,000
вие всушност може да направи малку форензички анализи, така да се каже,

332
00:17:54,000 --> 00:17:58,000
на ова јадро депонија датотека, која, пак, е само еден куп на оние кои и нули

333
00:17:58,000 --> 00:18:02,000
што во суштина претставува државата на вашата програма во меморијата

334
00:18:02,000 --> 00:18:05,000
моментот кога се урна на овој начин.

335
00:18:05,000 --> 00:18:11,000
>> На фикс е дека не можеме само слепо се врати сигма,

336
00:18:11,000 --> 00:18:14,000
бројот + сигма на малку помал проблем.

337
00:18:14,000 --> 00:18:16,000
Ние треба да имаат некој вид на база случај тука,

338
00:18:16,000 --> 00:18:19,000
и што треба основата случај веројатно да биде?

339
00:18:19,000 --> 00:18:22,000
[Нечујни-студент]

340
00:18:22,000 --> 00:18:25,000
Океј, па додека бројот е позитивен ние всушност треба да се врати ова,

341
00:18:25,000 --> 00:18:29,000
или стави на друг начин, ако бројот е, да речеме, <= на 0

342
00:18:29,000 --> 00:18:32,000
знаеш што, јас ќе одам напред и да се врати 0,

343
00:18:32,000 --> 00:18:36,000
слично Вили направив, и друго, јас ќе одам да се оди напред

344
00:18:36,000 --> 00:18:41,000
и да се врати ова, па тоа не е толку многу пократок

345
00:18:41,000 --> 00:18:44,000
од повторната верзија која ние шлаг до првиот со помош на за телефонска линија,

346
00:18:44,000 --> 00:18:48,000
но забележите дека има овој вид на елеганција на него.

347
00:18:48,000 --> 00:18:51,000
Наместо да се врати одреден број и вршење на сето ова математика

348
00:18:51,000 --> 00:18:54,000
и додавање на работите со локални променливи

349
00:18:54,000 --> 00:18:57,000
сте наместо велејќи: "Океј, ако тоа е супер лесен проблем,

350
00:18:57,000 --> 00:19:01,000
како број е <0, дозволете ми да веднаш се врати 0. "

351
00:19:01,000 --> 00:19:03,000
>> Ние нема да се мачат поддршка негативни броеви,

352
00:19:03,000 --> 00:19:05,000
па ќе одам на хард код вредноста на 0.

353
00:19:05,000 --> 00:19:08,000
Но во спротивно, за спроведување на оваа идеја за собирање

354
00:19:08,000 --> 00:19:11,000
сите овие броеви заедно ќе можат ефикасно да земе мал залак

355
00:19:11,000 --> 00:19:14,000
од проблемот, како и многу направивме тука на сцена,

356
00:19:14,000 --> 00:19:18,000
тогаш залог остатокот на проблемот на следната лице,

357
00:19:18,000 --> 00:19:20,000
но во овој случај следниот лице себе.

358
00:19:20,000 --> 00:19:22,000
Тоа е идентично име функција.

359
00:19:22,000 --> 00:19:25,000
Само помине тоа помали и помали и помали проблем секој пат,

360
00:19:25,000 --> 00:19:28,000
и иако не сме сосема формализиран работи во кодот тука

361
00:19:28,000 --> 00:19:33,000
тоа е токму она што се случува во недела 0 со телефонот книга.

362
00:19:33,000 --> 00:19:36,000
Ова е токму она што се случува во изминатите недели со Sean

363
00:19:36,000 --> 00:19:39,000
и со нашите демонстрации од пребарувањето за броеви.

364
00:19:39,000 --> 00:19:42,000
Тоа е преземање на проблемот и делење тоа повторно и повторно.

365
00:19:42,000 --> 00:19:44,000
>> Со други зборови, постои начин сега на преведување

366
00:19:44,000 --> 00:19:47,000
овој реалниот свет конструкција, ова високо ниво конструкција

367
00:19:47,000 --> 00:19:51,000
на поделба и освојување и прави нешто повторно и повторно

368
00:19:51,000 --> 00:19:56,000
во кодот, па ова е нешто што ќе видиме повторно во текот на времето.

369
00:19:56,000 --> 00:20:00,000
Сега, како настрана, ако сте нови на рекурзијата ви треба барем да се разбере сега

370
00:20:00,000 --> 00:20:02,000
зошто ова е смешно.

371
00:20:02,000 --> 00:20:05,000
Одам да одат во google.com,

372
00:20:05,000 --> 00:20:17,000
и јас одам да пребарувате за некои совети и трикови за рекурзија, влезе.

373
00:20:17,000 --> 00:20:21,000
Кажете му на лицето до вас, ако тие не се смееја само сега.

374
00:20:21,000 --> 00:20:23,000
Дали мислевте рекурзија?

375
00:20:23,000 --> 00:20:25,000
Дали мислевте-ах, таму ќе одиме.

376
00:20:25,000 --> 00:20:28,000
Океј, сега тоа е остатокот од секого.

377
00:20:28,000 --> 00:20:30,000
А малку велигденско јајце вградени таму некаде во Google.

378
00:20:30,000 --> 00:20:33,000
Како настрана, еден од линковите ќе стави на веб страната на курсот

379
00:20:33,000 --> 00:20:36,000
за денес е само оваа мрежа на различни алгоритми за сортирање,

380
00:20:36,000 --> 00:20:39,000
од кои некои ќе гледаше во минатата недела, но она што е убаво за оваа визуелизација

381
00:20:39,000 --> 00:20:43,000
како што се обиде да ја заврши вашиот ум околу различни работи поврзани со алгоритми

382
00:20:43,000 --> 00:20:46,000
знаете дека можете многу лесно сега да почне со различни типови на влезови.

383
00:20:46,000 --> 00:20:50,000
Влезови сите спротивен, влезови главно подредени, влезови случаен и така натаму.

384
00:20:50,000 --> 00:20:53,000
Како што се обидуваат да, повторно, се разликуваат овие работи во твојот ум

385
00:20:53,000 --> 00:20:57,000
сфатат дека овој URL на веб страната на курсот на предавања страница

386
00:20:57,000 --> 00:21:00,000
може да ви помогне причина преку некои од нив.

387
00:21:00,000 --> 00:21:05,000
>> Денес ние конечно да се реши овој проблем од време назад,

388
00:21:05,000 --> 00:21:08,000
кој беше дека оваа swap функција едноставно не работат,

389
00:21:08,000 --> 00:21:12,000
и она што е фундаментален проблем со оваа функција, swap,

390
00:21:12,000 --> 00:21:15,000
чија цел беше, пак, да се разменат вредност тука и тука

391
00:21:15,000 --> 00:21:17,000
како што тоа се случи?

392
00:21:17,000 --> 00:21:20,000
Ова всушност не работат. Зошто?

393
00:21:20,000 --> 00:21:22,000
Да.

394
00:21:22,000 --> 00:21:28,000
[Нечујни-студент]

395
00:21:28,000 --> 00:21:31,000
Точно, објаснувањето за ова bugginess

396
00:21:31,000 --> 00:21:34,000
едноставно е затоа што кога ќе се јавите функции во C

397
00:21:34,000 --> 00:21:38,000
и тие функции се аргументи, како и б тука,

398
00:21:38,000 --> 00:21:42,000
се поминува во примероци од она што вредност сте обезбедување на таа функција.

399
00:21:42,000 --> 00:21:46,000
Вие не сте обезбедување на оригинални вредности себе,

400
00:21:46,000 --> 00:21:49,000
па ние го виде тоа во контекст на buggyc,

401
00:21:49,000 --> 00:21:52,000
buggy3.c, која изгледаше малку нешто како ова.

402
00:21:52,000 --> 00:21:57,000
>> Потсетиме дека имавме x и y иницијализиран на 1 и 2, соодветно.

403
00:21:57,000 --> 00:21:59,000
Ние тогаш отпечатени она што беа.

404
00:21:59,000 --> 00:22:03,000
Јас тогаш тврдеше дека сум бил ги менуваат со повик трампа на x, y.

405
00:22:03,000 --> 00:22:06,000
Но, проблемот беше дека Замена работел,

406
00:22:06,000 --> 00:22:10,000
но само во рамките на swap самата функција.

407
00:22:10,000 --> 00:22:13,000
Веднаш штом ќе го погоди линија 40 оние заменети вредности

408
00:22:13,000 --> 00:22:16,000
беа фрлени, и така ништо

409
00:22:16,000 --> 00:22:21,000
во оригиналната функција главната всушност менуваат на сите,

410
00:22:21,000 --> 00:22:26,000
па ако мислите дека тогаш за тоа што ова изгледа како во однос на нашата меморија

411
00:22:26,000 --> 00:22:29,000
ако ова левата страна на одборот претставува-

412
00:22:29,000 --> 00:22:33,000
и јас ќе дадам се од себе за сите да видат ова-ако ова левата страна на таблата

413
00:22:33,000 --> 00:22:37,000
претставува, да речеме, вашата RAM меморија и магацинот се случува да расте на на овој начин,

414
00:22:37,000 --> 00:22:43,000
и ние го нарекуваме функција како главна, а главната има 2 локални променливи, x и y,

415
00:22:43,000 --> 00:22:48,000
ајде да се опише оние што x тука, и ајде да се опише овие како y тука,

416
00:22:48,000 --> 00:22:55,000
и да се стави во вредностите 1 и 2, така што ова тука е главен,

417
00:22:55,000 --> 00:22:58,000
и кога главната повикува на swap функција на оперативниот систем

418
00:22:58,000 --> 00:23:02,000
дава на swap функција свој откос на меморија на магацинот,

419
00:23:02,000 --> 00:23:04,000
сопствената рамка на магацинот, така да се каже.

420
00:23:04,000 --> 00:23:08,000
Таа, исто така издвојува 32 бита за овие ints.

421
00:23:08,000 --> 00:23:11,000
Тоа се случува да ги нарекуваме А и Б, но тоа е сосема произволна.

422
00:23:11,000 --> 00:23:13,000
Тоа би можело да ги повика она што сака, но што се случува кога главните

423
00:23:13,000 --> 00:23:19,000
повици swap е потребно овој 1, става копија таму, го става копија таму.

424
00:23:19,000 --> 00:23:23,000
>> Постои 1 друга локална променлива во трампа, иако, наречен што? >> Tmp.

425
00:23:23,000 --> 00:23:27,000
Tmp, па дозволете ми да се даде уште 32 бита тука,

426
00:23:27,000 --> 00:23:29,000
и она што го правам во оваа функција?

427
00:23:29,000 --> 00:23:34,000
Реков int мали добива, па има 1, па јас направив ова кога последен пат играше со овој пример.

428
00:23:34,000 --> 00:23:39,000
Тогаш добива б, па б е 2, па сега ова станува 2,

429
00:23:39,000 --> 00:23:42,000
и сега б добива Temp, па температура е 1,

430
00:23:42,000 --> 00:23:44,000
па сега б станува ова.

431
00:23:44,000 --> 00:23:46,000
Тоа е одлично. Тој работел.

432
00:23:46,000 --> 00:23:49,000
Но, тогаш штом функција враќа

433
00:23:49,000 --> 00:23:52,000
меморија swap ефективно исчезнува, така што тоа може да се користи

434
00:23:52,000 --> 00:23:58,000
од страна на некои други функција во иднина, а главната е очигледно целосно непроменет.

435
00:23:58,000 --> 00:24:00,000
Ние треба начин на фундаментално решавање на овој проблем,

436
00:24:00,000 --> 00:24:03,000
а денес ние конечно ќе имаат начин на тоа каде

437
00:24:03,000 --> 00:24:06,000
ние може да се воведе нешто што се нарекува покажувач.

438
00:24:06,000 --> 00:24:09,000
Излегува дека ние може да го реши овој проблем

439
00:24:09,000 --> 00:24:12,000
не со донесување на копии на x и y

440
00:24:12,000 --> 00:24:18,000
но наместо со полагање во она, мислите, на swap функција?

441
00:24:18,000 --> 00:24:20,000
Да, она што за адреса?

442
00:24:20,000 --> 00:24:22,000
Не сме навистина разговаравме за адреси во многу детали,

443
00:24:22,000 --> 00:24:25,000
но ако оваа табла претставува меморија на компјутерот ми е

444
00:24:25,000 --> 00:24:28,000
ние сигурно може да почни нумерирање на бајти во мојата меморија

445
00:24:28,000 --> 00:24:31,000
и велат дека ова е бајт # 1, ова е бајт # 2, бајт # 3,

446
00:24:31,000 --> 00:24:35,000
бајт # 4, бајт # ... 2 милијарди ако имам 2 гигабајти RAM меморија,

447
00:24:35,000 --> 00:24:38,000
па ние секако може да излезе со некои произволни броеви шема

448
00:24:38,000 --> 00:24:41,000
за сите индивидуални бајти во меморијата на компјутерот ми е.

449
00:24:41,000 --> 00:24:43,000
>> Што ако наместо кога ќе се јавам swap

450
00:24:43,000 --> 00:24:47,000
наместо помине во копии на x и y

451
00:24:47,000 --> 00:24:51,000
зошто не можам наместо да помине во адресата на x тука,

452
00:24:51,000 --> 00:24:55,000
адресата на y тука, во суштина поштенска адреса

453
00:24:55,000 --> 00:24:59,000
на x и y, бидејќи тогаш трампа, ако тој е информиран

454
00:24:59,000 --> 00:25:01,000
на адреса во меморијата на x и y,

455
00:25:01,000 --> 00:25:04,000
тогаш трампа, ако ние го научиле малку,

456
00:25:04,000 --> 00:25:07,000
тој би можел да вози на таа адреса, така да се каже,

457
00:25:07,000 --> 00:25:11,000
x, и го промените бројот таму, тогаш се вози на адресата на y,

458
00:25:11,000 --> 00:25:16,000
го промените бројот таму, дури и додека не всушност добивање копии на тие вредности себе,

459
00:25:16,000 --> 00:25:19,000
па иако ние разговаравме за тоа како меморија главните е

460
00:25:19,000 --> 00:25:23,000
и тоа како swap меморијата на моќни и опасни дел на C

461
00:25:23,000 --> 00:25:28,000
е дека секоја функција може да го допре меморија насекаде во компјутерот,

462
00:25:28,000 --> 00:25:32,000
и ова е моќен во тоа што можете да направите многу фенси работи со компјутерски програми во C.

463
00:25:32,000 --> 00:25:36,000
Ова е опасно затоа што, исто така, може да ја зафркнам многу лесно.

464
00:25:36,000 --> 00:25:39,000
Всушност, една од најчестите начини за програми, овие денови да се експлоатираат

465
00:25:39,000 --> 00:25:42,000
уште е не е програмер да се реализира

466
00:25:42,000 --> 00:25:45,000
дека тој или таа е дозволувајќи им на податоци

467
00:25:45,000 --> 00:25:49,000
да бидат напишани на локација во меморијата која не беше наменето.

468
00:25:49,000 --> 00:25:51,000
>> На пример, тој или таа изјавува низа на големина 10

469
00:25:51,000 --> 00:25:56,000
но потоа случајно се обидува да стави 11 бајти во таа низа од меморија,

470
00:25:56,000 --> 00:25:59,000
и ќе почнете допирање делови на меморија, која веќе не се валидни.

471
00:25:59,000 --> 00:26:02,000
Само да контекстуални ова, некои од вас можеби знаат дека

472
00:26:02,000 --> 00:26:06,000
софтвер често ќе побара сериски броеви или регистрација клучеви,

473
00:26:06,000 --> 00:26:08,000
Photoshop и Word и програми како оваа.

474
00:26:08,000 --> 00:26:12,000
Постојат пукнатини, како што некои од вас знаат, интернет каде што може да работи малку програма,

475
00:26:12,000 --> 00:26:14,000
и Voila, не повеќе барање за серискиот број.

476
00:26:14,000 --> 00:26:16,000
Како е тоа работа?

477
00:26:16,000 --> 00:26:21,000
Во многу случаи овие работи се едноставно наоѓање на компјутери

478
00:26:21,000 --> 00:26:24,000
текст сегменти во вистински нули на компјутерот и оние

479
00:26:24,000 --> 00:26:28,000
каде е тоа функција каде што серискиот број се бара,

480
00:26:28,000 --> 00:26:31,000
и ќе ги избрише тој простор, или додека на програмата се извршува

481
00:26:31,000 --> 00:26:33,000
можете да дознаам каде што клучот е, всушност, чуваат

482
00:26:33,000 --> 00:26:37,000
користење на нешто што се нарекува дебагерот, и можете да попуштат софтвер кој начин.

483
00:26:37,000 --> 00:26:40,000
Ова не е да се каже дека ова е нашата цел за наредните неколку дена,

484
00:26:40,000 --> 00:26:42,000
но има многу реални последици.

485
00:26:42,000 --> 00:26:45,000
Дека еден се случува да се вклучат кражба на софтвер,

486
00:26:45,000 --> 00:26:47,000
но исто така има компромис на целиот машини.

487
00:26:47,000 --> 00:26:50,000
>> Всушност, кога веб-сајтови овие денови се експлоатирани

488
00:26:50,000 --> 00:26:53,000
и компромитирани и податоци се протекоа и лозинки се украдени

489
00:26:53,000 --> 00:26:58,000
Ова често се однесува на лошото управување на една меморија,

490
00:26:58,000 --> 00:27:01,000
или, во случај на бази на податоци, неуспехот да се предвиди

491
00:27:01,000 --> 00:27:03,000
контрамерки влез, па повеќе за тоа во неделите што доаѓаат,

492
00:27:03,000 --> 00:27:07,000
но сега за сега само еден подлец преглед на вид на штета што можете да направите

493
00:27:07,000 --> 00:27:11,000
од страна не е сосема разбирање на тоа како работите работа под хауба.

494
00:27:11,000 --> 00:27:14,000
Ајде да одиме за разбирање зошто ова е скршен

495
00:27:14,000 --> 00:27:17,000
со алатка која ќе станува повеќе и повеќе корисни

496
00:27:17,000 --> 00:27:19,000
како нашите програми се посложени.

497
00:27:19,000 --> 00:27:21,000
Досега кога сте имале грешка во вашата програма

498
00:27:21,000 --> 00:27:23,000
како си помина за дебагирање тоа?

499
00:27:23,000 --> 00:27:25,000
Што вашиот техники биле досега, без разлика дали подучени од вашиот ТФ

500
00:27:25,000 --> 00:27:27,000
или само самоук?

501
00:27:27,000 --> 00:27:29,000
[Студентски] Printf.

502
00:27:29,000 --> 00:27:31,000
Printf, па printf веројатно е вашиот пријател во дека ако сакате да ја видите

503
00:27:31,000 --> 00:27:33,000
она што се случува во внатрешноста на вашата програма

504
00:27:33,000 --> 00:27:36,000
можете само да се printf тука, printf тука, printf тука.

505
00:27:36,000 --> 00:27:38,000
Потоа да се стартува, и ќе добиете еден куп на работи на екранот

506
00:27:38,000 --> 00:27:43,000
кои можете да ги користите за да потоа се заклучи што всушност се случува не е во ред во вашата програма.

507
00:27:43,000 --> 00:27:45,000
>> Printf има тенденција да биде многу моќна работа,

508
00:27:45,000 --> 00:27:47,000
но тоа е многу рачен процес.

509
00:27:47,000 --> 00:27:49,000
Мора да се стави printf тука, printf тука,

510
00:27:49,000 --> 00:27:51,000
и ако го стави во внатрешноста на јамка може да добие 100 линии

511
00:27:51,000 --> 00:27:53,000
на излез што потоа треба да кваси преку.

512
00:27:53,000 --> 00:27:58,000
Тоа не е многу лесен или интерактивни механизам за дебагирање програми,

513
00:27:58,000 --> 00:28:00,000
но за среќа постои алтернатива.

514
00:28:00,000 --> 00:28:03,000
Има програма, на пример, наречен GDB, на ГНУ дебагерот,

515
00:28:03,000 --> 00:28:06,000
што е малку таинствени во тоа како да го користам.

516
00:28:06,000 --> 00:28:08,000
Тоа е малку комплексна, но искрено,

517
00:28:08,000 --> 00:28:11,000
ова е една од оние работи каде што ако се стави во оваа недела и следната

518
00:28:11,000 --> 00:28:14,000
екстра час да се разбере нешто како GDB

519
00:28:14,000 --> 00:28:18,000
тоа ќе те спаси веројатно десетици часови на долг рок,

520
00:28:18,000 --> 00:28:21,000
па со тоа, дозволете ми да ви даде краток вовед за тоа како ова нешто работи.

521
00:28:21,000 --> 00:28:23,000
>> Јас сум во мојата терминален прозорец.

522
00:28:23,000 --> 00:28:26,000
Дозволете ми да оди напред и да ги собере на оваа програма, buggy3.

523
00:28:26,000 --> 00:28:28,000
Тоа е веќе во тек.

524
00:28:28,000 --> 00:28:31,000
Дозволете ми да го стартувате како што направивме некое време назад, и навистина, тоа е прекината.

525
00:28:31,000 --> 00:28:34,000
Но, зошто е ова? Можеби и јас зезнав на swap функција.

526
00:28:34,000 --> 00:28:37,000
Можеби тоа е a и b. Јас не сум сосема ќе ги движите наоколу правилно.

527
00:28:37,000 --> 00:28:39,000
Дозволете ми да оди напред и да го направите тоа.

528
00:28:39,000 --> 00:28:43,000
Наместо само стартувајте buggy3 дозволете ми наместо да ја извршите оваа програма GDB,

529
00:28:43,000 --> 00:28:48,000
и јас одам да го кажам да се кандидира buggy3,

530
00:28:48,000 --> 00:28:52,000
и јас одам да се вклучат во командната линија аргумент,-TUI,

531
00:28:52,000 --> 00:28:55,000
и ние ќе го стави ова во иднина проблеми на спец да ги потсети.

532
00:28:55,000 --> 00:28:57,000
И сега оваа црна и бела интерфејс појави кои, пак,

533
00:28:57,000 --> 00:28:59,000
е малку огромна На прво затоа што има сето ова

534
00:28:59,000 --> 00:29:02,000
гаранција информации долу тука, но барем има нешто познато.

535
00:29:02,000 --> 00:29:04,000
Во врвот на прозорецот е мојот вистински код,

536
00:29:04,000 --> 00:29:08,000
и ако дојдете до тука дозволете ми да дојдете до самиот врв на мојата датотека,

537
00:29:08,000 --> 00:29:11,000
и навистина, има buggy3.c и известување на дното на овој прозорец

538
00:29:11,000 --> 00:29:13,000
Имам GDB прашува.

539
00:29:13,000 --> 00:29:16,000
>> Ова не е иста како и моите нормални Џон Харвард прашува.

540
00:29:16,000 --> 00:29:19,000
Ова е предупредувањето што се случува да ми дозволат да се контролира gdb.

541
00:29:19,000 --> 00:29:21,000
GDB е дебагерот.

542
00:29:21,000 --> 00:29:24,000
А дебагерот е програма која ви овозможува да одиме преку

543
00:29:24,000 --> 00:29:27,000
извршување на вашата програма линија по линија по линија,

544
00:29:27,000 --> 00:29:30,000
на патот прави нешто што сакате на програмата,

545
00:29:30,000 --> 00:29:33,000
дури и функции за повикување, или бараат, уште поважно,

546
00:29:33,000 --> 00:29:35,000
на вредности различни променливата.

547
00:29:35,000 --> 00:29:37,000
Ајде да одиме напред и да го направите тоа.

548
00:29:37,000 --> 00:29:40,000
Одам да се оди напред и да напишеш во рок од брза GDB е,

549
00:29:40,000 --> 00:29:43,000
така забележите во долниот лев агол на екранот Сум напишани работи,

550
00:29:43,000 --> 00:29:45,000
и јас сум притиснете ентер, и што тоа го стори?

551
00:29:45,000 --> 00:29:50,000
Тоа буквално трчаше мојата програма, но јас всушност не гледам многу одат на тука

552
00:29:50,000 --> 00:29:55,000
бидејќи јас не се всушност изјави дебагерот

553
00:29:55,000 --> 00:29:57,000
за да го паузирате во одреден момент во времето.

554
00:29:57,000 --> 00:29:59,000
Само напишете рок работи на програмата.

555
00:29:59,000 --> 00:30:01,000
Јас всушност не гледам ништо. Не можам да го манипулира.

556
00:30:01,000 --> 00:30:03,000
>> Наместо тоа дозволете ми да го направите тоа.

557
00:30:03,000 --> 00:30:08,000
Во овој GDB брза дозволете ми наместо внесете пауза, влезе.

558
00:30:08,000 --> 00:30:10,000
Тоа не е она што мислев да напишеш.

559
00:30:10,000 --> 00:30:13,000
Ајде наместо напишете пауза главните.

560
00:30:13,000 --> 00:30:15,000
Со други зборови, сакам да се постави нешто што се нарекува точка на прекин,

561
00:30:15,000 --> 00:30:18,000
која е во потполност наречен поради тоа што ќе се скрши или да се откажеш

562
00:30:18,000 --> 00:30:21,000
извршување на својата програма на тоа конкретно место.

563
00:30:21,000 --> 00:30:23,000
Главните е името на мојата функција.

564
00:30:23,000 --> 00:30:25,000
Забележете дека GDB е прилично паметни.

565
00:30:25,000 --> 00:30:28,000
Го сфатиле дека главната случува да се започне околу на линијата 18

566
00:30:28,000 --> 00:30:32,000
на buggy3.c, а потоа се забележи тука во горниот лев

567
00:30:32,000 --> 00:30:34,000
б + е веднаш до линијата 18.

568
00:30:34,000 --> 00:30:38,000
Тоа ме потсетува дека јас постави точки на прекин на линијата 18.

569
00:30:38,000 --> 00:30:42,000
Овој пат кога ќе напишете рок, ќе одам да се кандидира ми програмата

570
00:30:42,000 --> 00:30:45,000
се додека не хитови кои точки на прекин,

571
00:30:45,000 --> 00:30:48,000
па на програмата ќе испуштам за мене на линијата 18.

572
00:30:48,000 --> 00:30:50,000
Еве ќе одиме, да го стартуваш.

573
00:30:50,000 --> 00:30:53,000
Ништо не чини да се случи, но известување на долниот лев агол

574
00:30:53,000 --> 00:30:58,000
почнувајќи програма, buggy3, точки на прекин 1 во главните во buggy3.c линија 18.

575
00:30:58,000 --> 00:31:00,000
Што можам да направам сега?

576
00:31:00,000 --> 00:31:03,000
>> Забележите можам да почнете да пишувате работи како печати,

577
00:31:03,000 --> 00:31:08,000
не printf, печатење х, а сега тоа е чудно.

578
00:31:08,000 --> 00:31:11,000
$ 1 е само љубопитност, како што ќе видиме

579
00:31:11,000 --> 00:31:14,000
секој пат кога ќе печати нешто ќе добие нов $ вредност.

580
00:31:14,000 --> 00:31:18,000
Тоа е така што ќе може да се однесува назад кон претходниот вредности само во случај,

581
00:31:18,000 --> 00:31:21,000
но сега за сега тоа што печати се ми кажуваше е дека вредноста на x во овој момент во приказната

582
00:31:21,000 --> 00:31:26,000
очигледно е 134.514.032.

583
00:31:26,000 --> 00:31:29,000
Што? Каде што дури и доаѓаат од?

584
00:31:29,000 --> 00:31:31,000
[Нечујни-студент]

585
00:31:31,000 --> 00:31:34,000
Всушност, тоа е она што ние ќе го нарекуваат ѓубре вредност, а ние не сме разговарале за ова, сепак,

586
00:31:34,000 --> 00:31:37,000
но причината што иницијализира променливи

587
00:31:37,000 --> 00:31:40,000
е очигледно дека тие имаат некоја вредност кои сакате да ги имаат.

588
00:31:40,000 --> 00:31:44,000
Но, за улов се потсетиме дека можете да декларираат променливи

589
00:31:44,000 --> 00:31:46,000
како што го направив пред еден момент во мојот сигма пример

590
00:31:46,000 --> 00:31:48,000
без всушност да им даде вредност.

591
00:31:48,000 --> 00:31:50,000
Потсетиме она што го направив овде во сигма.

592
00:31:50,000 --> 00:31:52,000
Јас прогласи n, но она што вредност не можев да го даде?

593
00:31:52,000 --> 00:31:56,000
Никој, бидејќи знаев дека во следните неколку линии

594
00:31:56,000 --> 00:31:59,000
GetInt ќе се грижи за проблемот за поставување на вредноста во внатрешноста на n.

595
00:31:59,000 --> 00:32:02,000
>> Но, во овој момент во приказната на линијата 11

596
00:32:02,000 --> 00:32:05,000
и линија 12 и линија 13 и линија 14

597
00:32:05,000 --> 00:32:08,000
во текот на тие неколку линии она што е вредноста на n?

598
00:32:08,000 --> 00:32:10,000
Во C едноставно не го знаат.

599
00:32:10,000 --> 00:32:14,000
Тоа е генерално некои ѓубре вредност, некои сосема случаен број

600
00:32:14,000 --> 00:32:17,000
што е лево над суштина од некои претходни функција

601
00:32:17,000 --> 00:32:21,000
откако е подигнат, па како програма трча

602
00:32:21,000 --> 00:32:24,000
потсетиме дека функцијата добива функција, функција, функција.

603
00:32:24,000 --> 00:32:27,000
Сите овие рамки се стави на меморијата, а потоа тие функции враќање,

604
00:32:27,000 --> 00:32:31,000
и како само јас сугерираше со гума нивната меморија е на крајот повторно да се користи.

605
00:32:31,000 --> 00:32:37,000
Па, тоа само така се случува, дека оваа променлива x во оваа програма

606
00:32:37,000 --> 00:32:41,000
се чини дека се содржани некои ѓубре вредност како 134514032

607
00:32:41,000 --> 00:32:44,000
од некои претходни функција, не оној што го напишав.

608
00:32:44,000 --> 00:32:47,000
Тоа може да биде нешто што доаѓа ефикасно со оперативниот систем,

609
00:32:47,000 --> 00:32:49,000
некоја функција под хауба.

610
00:32:49,000 --> 00:32:52,000
>> Океј, тоа е во ред, но ајде сега преминете на следната линија.

611
00:32:52,000 --> 00:32:55,000
Ако јас типот "следниот" во мојата GDB брзо и јас притиснете ентер,

612
00:32:55,000 --> 00:32:58,000
забележите дека истакнување движи надолу за да линија 19,

613
00:32:58,000 --> 00:33:01,000
но логично импликација е дека линијата 18

614
00:33:01,000 --> 00:33:06,000
сега заврши извршување, па ако јас повторно внесете "печати x"

615
00:33:06,000 --> 00:33:10,000
Јас сега треба да видите 1, и навистина, го правам.

616
00:33:10,000 --> 00:33:14,000
Повторно, $ нешта е начин на GDB ви потсетувајќи

617
00:33:14,000 --> 00:33:17,000
што историјата на отпечатоци се дека сте го направиле.

618
00:33:17,000 --> 00:33:21,000
Сега дозволете ми да оди напред и да испечатите y, и навистина, y е некои луди вредност, како и,

619
00:33:21,000 --> 00:33:24,000
но не е голема работа, бидејќи во линија 19 ние сме за да се додели

620
00:33:24,000 --> 00:33:27,000
на вредност 2, па да ми напишете "Напред" повторно.

621
00:33:27,000 --> 00:33:29,000
И сега ние сме на printf линија.

622
00:33:29,000 --> 00:33:31,000
Дозволете ми да се печати х.

623
00:33:31,000 --> 00:33:34,000
Дозволете ми да се печати y. Искрено, јас сум добивање малку уморни за печатење ова.

624
00:33:34,000 --> 00:33:38,000
Дозволете ми наместо напишете "дисплеј x" и "дисплеј y"

625
00:33:38,000 --> 00:33:41,000
и сега секој пат кога ќе напишете команда во иднина

626
00:33:41,000 --> 00:33:45,000
Јас ќе се потсети на она што е x и y, што е x и y, што е x и y.

627
00:33:45,000 --> 00:33:48,000
>> Можам исто така, како настрана, тип во "инфо локалното население."

628
00:33:48,000 --> 00:33:50,000
Информации е посебна команда.

629
00:33:50,000 --> 00:33:52,000
Локалните жители значи дека ми го покажува локални променливи.

630
00:33:52,000 --> 00:33:55,000
Само во случај да заборавам или ова е лудо, комплицирани функција

631
00:33:55,000 --> 00:33:57,000
дека јас или некој друг пишува инфо локалното население ќе ти кажам

632
00:33:57,000 --> 00:34:00,000
она што се сите на локални променливи во оваа локална функција

633
00:34:00,000 --> 00:34:03,000
дека може да се грижи за ако сакате да ѕиркаат наоколу.

634
00:34:03,000 --> 00:34:07,000
Сега, printf е за да се изврши, па дозволете ми да одиме напред и само типот "Напред".

635
00:34:07,000 --> 00:34:10,000
Бидејќи ние сме во оваа средина ние не сме всушност го гледате

636
00:34:10,000 --> 00:34:14,000
изврши долу тука, но се забележи станува малку искривени тука.

637
00:34:14,000 --> 00:34:17,000
Но забележите тоа е највисок екран таму,

638
00:34:17,000 --> 00:34:21,000
така што не е добра програма тука, но тоа е во ред затоа што секогаш може да ѕиркаат наоколу

639
00:34:21,000 --> 00:34:23,000
користење на печати ако сакам.

640
00:34:23,000 --> 00:34:26,000
>> Дозволете ми да напишеш следниот повторно, и сега тука е интересен дел.

641
00:34:26,000 --> 00:34:29,000
Во овој момент во приказната y е 2, а x е 1,

642
00:34:29,000 --> 00:34:32,000
како што е предложено тука, и повторно,

643
00:34:32,000 --> 00:34:35,000
Причината е ова автоматски прикажување сега е затоа што се користат командата

644
00:34:35,000 --> 00:34:40,000
дисплеј x и приказ y, па моментов напишете следниот

645
00:34:40,000 --> 00:34:43,000
во теорија x и y треба да стане заменети.

646
00:34:43,000 --> 00:34:45,000
Сега, ние веќе знаете дека нема да биде случај,

647
00:34:45,000 --> 00:34:49,000
но ќе видиме во еден момент како можеме да се нурне подлабоко да дознаам зошто тоа е вистина.

648
00:34:49,000 --> 00:34:54,000
Следно, и, за жал, y е уште 2 и x се уште е 1, и можам да потврдам колку.

649
00:34:54,000 --> 00:34:56,000
Верзија за x, печатење y.

650
00:34:56,000 --> 00:34:59,000
Навистина, не Замена всушност се случило, па да почнеме овој свет.

651
00:34:59,000 --> 00:35:01,000
Јасно трампа е скршен.

652
00:35:01,000 --> 00:35:04,000
Ајде наместо напишете "Run" повторно.

653
00:35:04,000 --> 00:35:07,000
Дозволете ми да кажам да, сакам да го рестартирате од почетокот, внесете.

654
00:35:07,000 --> 00:35:09,000
>> Сега сум назад на линијата 18.

655
00:35:09,000 --> 00:35:11,000
Сега забележите x и y се ѓубре вредности повторно.

656
00:35:11,000 --> 00:35:15,000
Потоа, следниот, следната, следниот.

657
00:35:15,000 --> 00:35:17,000
Ако добијам досадно јас исто така да само тип N за следната.

658
00:35:17,000 --> 00:35:21,000
Можете да го скратите да најкус можен секвенца од карактери.

659
00:35:21,000 --> 00:35:23,000
Swap сега е скршен.

660
00:35:23,000 --> 00:35:25,000
Ајде да се нурне во, па наместо на пишување следната,

661
00:35:25,000 --> 00:35:30,000
сега ќе одам да напишеш чекор, така што јас повлекува во внатрешноста на оваа функција

662
00:35:30,000 --> 00:35:33,000
така што можам да одат преку него, па јас хит чекор и потоа внесете.

663
00:35:33,000 --> 00:35:37,000
Забележете дека истакнување скокови долу пониски во мојата програма на линија 36.

664
00:35:37,000 --> 00:35:39,000
Сега што се локални променливи?

665
00:35:39,000 --> 00:35:41,000
Информации локалното население.

666
00:35:41,000 --> 00:35:43,000
Ништо не само уште, бидејќи ние не сме добиле таа линија,

667
00:35:43,000 --> 00:35:47,000
па ајде да одиме напред и да каже "Напред".

668
00:35:47,000 --> 00:35:50,000
Сега ние се чини дека имаат мали, печатење мали.

669
00:35:50,000 --> 00:35:52,000
Ѓубре вредност, нели? Јас мислам така.

670
00:35:52,000 --> 00:35:55,000
Како за печати, печатење б, 1 и 2?

671
00:35:55,000 --> 00:35:58,000
Во еден момент, штом ќе напишете следниот повторно

672
00:35:58,000 --> 00:36:02,000
мали се случува да се земе на вредноста на 1, се надевам,

673
00:36:02,000 --> 00:36:05,000
бидејќи мали се случува да биде доделен на вредноста на.

674
00:36:05,000 --> 00:36:08,000
>> Сега ајде да ги испечатите, печатење б,

675
00:36:08,000 --> 00:36:11,000
но сега печати мали, а тоа е навистина 1.

676
00:36:11,000 --> 00:36:14,000
Дозволете ми да направам следно. Дозволете ми да направам следно.

677
00:36:14,000 --> 00:36:16,000
Сум завршил на swap функција.

678
00:36:16,000 --> 00:36:19,000
Сè уште сум во него во согласност 40, па дозволете ми да се печати,

679
00:36:19,000 --> 00:36:22,000
печати б, и не ми е грижа што tmp е.

680
00:36:22,000 --> 00:36:27,000
Тоа изгледа како трампа е точно кога станува збор за замена на a и b.

681
00:36:27,000 --> 00:36:31,000
Но, ако јас сега напишеш следниот, јас скок назад на линија 25,

682
00:36:31,000 --> 00:36:34,000
и, се разбира, ако јас типот во x и печатење y

683
00:36:34,000 --> 00:36:38,000
тие се уште непроменета, па ние не се поправија проблемот.

684
00:36:38,000 --> 00:36:41,000
Но, дијагностички сега можеби со ова GDB програма

685
00:36:41,000 --> 00:36:44,000
ние сме најмалку добивано и еден чекор поблиску до разбирање

686
00:36:44,000 --> 00:36:47,000
што се случува погрешно, без да раѓа нашиот код со ставање на printf тука,

687
00:36:47,000 --> 00:36:50,000
printf тука, printf тука и тогаш тоа работи повторно и повторно

688
00:36:50,000 --> 00:36:52,000
се обидувам да дознаам што се случува погрешно.

689
00:36:52,000 --> 00:36:55,000
>> Одам да се оди напред и да се откажат од овој целосно со откажам.

690
00:36:55,000 --> 00:36:57,000
Тоа се случува да потоа каже: "Излези и покрај тоа?" Да.

691
00:36:57,000 --> 00:37:00,000
Сега сум назад во мојата нормална линија, и јас сум се направи со користење gdb.

692
00:37:00,000 --> 00:37:03,000
Како настрана, вие не треба да ја користите-TUI знаме.

693
00:37:03,000 --> 00:37:07,000
Всушност, ако го изостави добиете суштина долниот дел на екранот.

694
00:37:07,000 --> 00:37:11,000
Ако јас потоа внесете пауза главни и потоа стартувајте

695
00:37:11,000 --> 00:37:15,000
Јас се уште може да ја стартувате мојата програма, но она што ќе направите, е повеќе текстуално

696
00:37:15,000 --> 00:37:18,000
само ми го покаже тековната линија едно по едно време.

697
00:37:18,000 --> 00:37:21,000
На-TUI, текстуалните кориснички интерфејс,

698
00:37:21,000 --> 00:37:25,000
само покажува дека повеќе од програмата одеднаш, што е веројатно малку концептуално полесно.

699
00:37:25,000 --> 00:37:27,000
Но, навистина, јас само може да го направи следниот, следната, следната,

700
00:37:27,000 --> 00:37:30,000
и јас одам да ја видите една линија во време, и ако навистина сакаат да видат што се случува

701
00:37:30,000 --> 00:37:35,000
Можам да пишувам листа и да видиме еден куп на соседните линии.

702
00:37:35,000 --> 00:37:39,000
>> Има еден видео дека ние сме праша што ќе се види за проблемот поставува 3

703
00:37:39,000 --> 00:37:43,000
во која Нејт опфаќа некои од сложността на GDB,

704
00:37:43,000 --> 00:37:46,000
и ова е една од оние работи, искрено, каде што некои не-тривијални процент од вас

705
00:37:46,000 --> 00:37:49,000
никогаш не ќе се смести GDB, а тоа ќе биде лоша работа

706
00:37:49,000 --> 00:37:53,000
затоа што буквално ќе заврши поминува повеќе време подоцна овој семестар

707
00:37:53,000 --> 00:37:56,000
си поигруваше со одредување грешки тогаш ќе ако се стави во таа половина час / час

708
00:37:56,000 --> 00:38:00,000
оваа недела и следната учење да се чувствуваме удобно со gdb.

709
00:38:00,000 --> 00:38:02,000
Printf е вашиот пријател.

710
00:38:02,000 --> 00:38:05,000
GDB сега треба да ти биде пријател.

711
00:38:05,000 --> 00:38:08,000
>> Било какви прашања на GDB?

712
00:38:08,000 --> 00:38:12,000
И тука е брз листа на некои од најмоќните и корисни команди.

713
00:38:12,000 --> 00:38:15,000
Да. >> Можете да печатите низа?

714
00:38:15,000 --> 00:38:17,000
Можете да печатите низа? Апсолутно.

715
00:38:17,000 --> 00:38:19,000
Тоа не мора да биде само цели броеви.

716
00:38:19,000 --> 00:38:22,000
Ако променливата е е стринг само напишете во печатените s.

717
00:38:22,000 --> 00:38:24,000
Таа ќе ви покаже она што стринг променлива е.

718
00:38:24,000 --> 00:38:26,000
[Нечујни-студент]

719
00:38:26,000 --> 00:38:28,000
Тоа ќе ви даде адресата и низа себе.

720
00:38:28,000 --> 00:38:32,000
Таа ќе ви покаже и двете.

721
00:38:32,000 --> 00:38:34,000
И едно последно нешто, само затоа што тие се добри да се знае премногу.

722
00:38:34,000 --> 00:38:37,000
Трагата и рамка, дозволете ми да се нурне во овој последен пат,

723
00:38:37,000 --> 00:38:39,000
исто точно програма со gdb.

724
00:38:39,000 --> 00:38:44,000
Дозволете ми да оди напред и да ја стартувате на текстуалната кориснички интерфејс верзија,

725
00:38:44,000 --> 00:38:46,000
скрши главните.

726
00:38:46,000 --> 00:38:49,000
Дозволете ми да оди напред и да се кандидира повторно. Тука сум.

727
00:38:49,000 --> 00:38:55,000
Сега дозволете ми да одам наредната, следниот, следната, следниот, следната, чекор, внесете.

728
00:38:55,000 --> 00:39:00,000
>> А сега да претпоставиме дека сум сега во размена намерно, но јас сум како "По ѓаволите, што е вредноста на x?"

729
00:39:00,000 --> 00:39:02,000
Не можам х повеќе.

730
00:39:02,000 --> 00:39:05,000
Не можам y бидејќи тие не се во опсегот.

731
00:39:05,000 --> 00:39:07,000
Тие не се во контекст, но нема проблем.

732
00:39:07,000 --> 00:39:09,000
Можам да пишувам трагата.

733
00:39:09,000 --> 00:39:13,000
Тоа ми покажува сите функции кои се извршуваат до овој момент во времето.

734
00:39:13,000 --> 00:39:16,000
Забележете дека еден на дното, главно, линии со главните

735
00:39:16,000 --> 00:39:18,000
да биде на дното на нашата слика тука.

736
00:39:18,000 --> 00:39:22,000
Фактот дека трампа е над неа линии со трампа биде над неа во меморијата тука,

737
00:39:22,000 --> 00:39:26,000
и ако сакам да се вратам на главната привремено можам да кажам "рамка."

738
00:39:26,000 --> 00:39:30,000
Што број? Главните е рамка # 1.

739
00:39:30,000 --> 00:39:32,000
Одам да се оди напред и да каже "рамка 1."

740
00:39:32,000 --> 00:39:36,000
>> Сега сум назад во главната, и можам да печати x, и можам да печати y,

741
00:39:36,000 --> 00:39:40,000
но не можам да се печати или б.

742
00:39:40,000 --> 00:39:43,000
Но, можам да ако кажам: "Океј, почекајте една минута. Каде беше на swap?"

743
00:39:43,000 --> 00:39:46,000
Дозволете ми да оди напред и да каже "рамка 0."

744
00:39:46,000 --> 00:39:48,000
Сега сум повторно таму каде што сакате да биде, и како настрана,

745
00:39:48,000 --> 00:39:52,000
има други команди премногу, како ако сте навистина станува досадно пишување следниот, следната, следниот, следната,

746
00:39:52,000 --> 00:39:56,000
генерално може да се каже нешто како "следните 10", и дека ќе ја засили преку следните 10 линии.

747
00:39:56,000 --> 00:39:59,000
Исто така можете да напишете "продолжи" кога навистина се хранат со излегувајќи низ него.

748
00:39:59,000 --> 00:40:05,000
Продолжи ќе се кандидира на вашиот програма, без прекин, додека таа хитови друга точка на прекин,

749
00:40:05,000 --> 00:40:07,000
дали во јамка или спуштаат во вашата програма.

750
00:40:07,000 --> 00:40:11,000
>> Во овој случај ние продолжи до крајот, а програмата излезено нормално.

751
00:40:11,000 --> 00:40:13,000
Ова е фенси начин инфериорни процес.

752
00:40:13,000 --> 00:40:16,000
Само вашата програма излезено нормално.

753
00:40:16,000 --> 00:40:24,000
Повеќе за тоа во видеото и дебагирање сесии за да дојде.

754
00:40:24,000 --> 00:40:26,000
Тоа беше многу.

755
00:40:26,000 --> 00:40:35,000
Да го земеме нашите 5-минутна пауза тука, а ние ќе се вратат со structs и датотеки.

756
00:40:35,000 --> 00:40:38,000
>> Ако имате нурна во pset оваа недела веќе

757
00:40:38,000 --> 00:40:41,000
ќе знаеш дека ние ги користиме во дистрибуцијата код,

758
00:40:41,000 --> 00:40:45,000
изворниот код што ги нудиме на вас, како појдовна точка, некои нови техники.

759
00:40:45,000 --> 00:40:50,000
Конкретно, ние воведе оваа нова клучен збор наречен struct, за структурата,

760
00:40:50,000 --> 00:40:53,000
така што можеме да креираш кориснички променливи на сорти.

761
00:40:53,000 --> 00:40:57,000
Ние, исто така, воведе поимот на датотека I / O, датотеката влез и излез,

762
00:40:57,000 --> 00:41:00,000
и ова е така што можеме да го спаси државата

763
00:41:00,000 --> 00:41:03,000
на вашиот трка одбор на датотека на диск

764
00:41:03,000 --> 00:41:06,000
така што наставата другарите и можам да ги разберам

765
00:41:06,000 --> 00:41:09,000
она што се случува во внатрешноста на вашата програма, без рачно да играат

766
00:41:09,000 --> 00:41:11,000
десетици пријателите трка.

767
00:41:11,000 --> 00:41:13,000
Ние можеме да правиме ова повеќе automatedly.

768
00:41:13,000 --> 00:41:18,000
>> Оваа идеја на struct решава прилично релевантни проблем.

769
00:41:18,000 --> 00:41:21,000
Да претпоставиме дека сакаме да се имплементираат некои програмата

770
00:41:21,000 --> 00:41:25,000
дека некако следи на информации за студентите,

771
00:41:25,000 --> 00:41:28,000
и студентите би можеле да имаат, на пример, лична карта, име

772
00:41:28,000 --> 00:41:31,000
и куќа во место како Харвард, па овие се 3 парчиња информации

773
00:41:31,000 --> 00:41:34,000
ние сакаме да се задржи околу, па дозволете ми да оди напред и да почнете да пишувате малку програма тука,

774
00:41:34,000 --> 00:41:38,000
вклучуваат stdio.h.

775
00:41:38,000 --> 00:41:42,000
Дозволете ми да се направи вклучуваат cs50.h.

776
00:41:42,000 --> 00:41:44,000
А потоа започнете мојата главна функција.

777
00:41:44,000 --> 00:41:46,000
Јас нема да се мачат со било командната линија аргументи,

778
00:41:46,000 --> 00:41:49,000
и тука сакам да имам еден студент, па ќе одам да се каже

779
00:41:49,000 --> 00:41:54,000
студентот има име, па ќе одам да се каже "стринг име."

780
00:41:54,000 --> 00:41:59,000
Потоа јас ќе одам да се каже студент, исто така, има лична карта, па int id,

781
00:41:59,000 --> 00:42:03,000
и студентот има една куќа, па јас сум исто така, ќе кажат "стринг куќа."

782
00:42:03,000 --> 00:42:06,000
Тогаш јас ќе нареди овие малку повеќе демонтирани се допаѓа ова.

783
00:42:06,000 --> 00:42:11,000
Океј, сега имам 3 променливи со која треба да претставува еден студент, па "студент".

784
00:42:11,000 --> 00:42:15,000
>> И сега сакам да се доверат овие вредности, па дозволете ми да оди напред и да кажете нешто како

785
00:42:15,000 --> 00:42:18,000
"Id = 123."

786
00:42:18,000 --> 00:42:21,000
Името ќе добие Давид.

787
00:42:21,000 --> 00:42:24,000
Да речеме дека куќата се случува да се Mather,

788
00:42:24,000 --> 00:42:31,000
а потоа јас ќе одам да направите нешто произволно како printf ("% s,

789
00:42:31,000 --> 00:42:37,000
чиј број е% d, живее во% s.

790
00:42:37,000 --> 00:42:41,000
И сега, она што сакам да го приклучиш во тука, едно по друго?

791
00:42:41,000 --> 00:42:47,000
Име, ID, куќа, враќање 0.

792
00:42:47,000 --> 00:42:50,000
Океј, ако јас зезнав тука некаде

793
00:42:50,000 --> 00:42:54,000
Мислам дека имаме доста добра програма која ги зачувува еден студент.

794
00:42:54,000 --> 00:42:57,000
Се разбира, ова не е за сите што интересно. Што ако сакам да имам 2 ученици?

795
00:42:57,000 --> 00:42:59,000
Тоа не е голема работа. Јас може да го поддржи 2 луѓе.

796
00:42:59,000 --> 00:43:03,000
Дозволете ми да оди напред и да ја нагласи ова и оди надолу тука,

797
00:43:03,000 --> 00:43:09,000
и можам да кажам "id = 456" за некој како Роб кој живее во Киркланд.

798
00:43:09,000 --> 00:43:12,000
>> Океј, чекај, но не можам да го нарекуваме овие истото,

799
00:43:12,000 --> 00:43:15,000
и тоа изгледа како да сум ќе мора да ја копирате на оваа,

800
00:43:15,000 --> 00:43:19,000
па дозволете ми да кажам дека тие ќе бидат променливи Давид,

801
00:43:19,000 --> 00:43:23,000
и дозволете ми да се добијат некои копии од овие за заведување.

802
00:43:23,000 --> 00:43:27,000
Ние ќе го нарекуваме овие на Rob но ова не е оди на работа сега

803
00:43:27,000 --> 00:43:33,000
бидејќи имам-чекај, да ме промени да id1, name1 и house1.

804
00:43:33,000 --> 00:43:35,000
Роб ќе биде 2, 2.

805
00:43:35,000 --> 00:43:42,000
Морам да го промените ова тука, тука, тука, тука, тука, тука.

806
00:43:42,000 --> 00:43:45,000
Чекај, што за Томи? Да го направите ова повторно.

807
00:43:45,000 --> 00:43:49,000
Очигледно ако сеуште мислите дека ова е добар начин да се направи ова, не е,

808
00:43:49,000 --> 00:43:52,000
па копирај / вметни лошо.

809
00:43:52,000 --> 00:43:55,000
Но, ние се реши ова пред една недела.

810
00:43:55,000 --> 00:43:59,000
>> Она што беше нашето решение кога сакавме да имаат повеќе инстанци од иста тип на податок?

811
00:43:59,000 --> 00:44:01,000
[Студентите] низа.

812
00:44:01,000 --> 00:44:03,000
Низа, па дозволете ми да се обиде да го исчисти ова.

813
00:44:03,000 --> 00:44:07,000
Дозволете ми да се направи некои соба за себе на врвот, и дозволете ми наместо направите тоа тука.

814
00:44:07,000 --> 00:44:12,000
Ние ќе го наречеме овие луѓе, и наместо тоа, ќе одам да се каже "int ИД"

815
00:44:12,000 --> 00:44:14,000
и јас одам да го поддржи 3 од нас сега за сега.

816
00:44:14,000 --> 00:44:18,000
Одам да се каже "стринг имиња", а јас ќе ја поддржам 3 од нас,

817
00:44:18,000 --> 00:44:22,000
а потоа јас ќе одам да се каже "стринг куќи", а јас одам да го поддржи 3 од нас.

818
00:44:22,000 --> 00:44:26,000
Сега тука, наместо на Дејвид добива својот локални променливи

819
00:44:26,000 --> 00:44:28,000
можеме да се ослободиме од нив.

820
00:44:28,000 --> 00:44:30,000
Дека се чувствува добро, дека ние сме чистење ова.

821
00:44:30,000 --> 00:44:35,000
Јас тогаш може да се каже Дејвид ќе биде [0] и имиња [0]

822
00:44:35,000 --> 00:44:38,000
и куќи [0].

823
00:44:38,000 --> 00:44:41,000
А потоа Роб ние слично може да се спаси за ова.

824
00:44:41,000 --> 00:44:46,000
Да се ​​стави ова овде долу, па тој се случува да произволно да биде ИД [1].

825
00:44:46,000 --> 00:44:50,000
Тој ќе биде имиња [1],

826
00:44:50,000 --> 00:44:53,000
а потоа на крај, куќи [1].

827
00:44:53,000 --> 00:44:57,000
>> Уште малку досадни, и сега морам да дознаам ова,

828
00:44:57,000 --> 00:45:03,000
па да речеме "имиња [0], проект [0], куќи [0],

829
00:45:03,000 --> 00:45:06,000
и ајде да pluralize ова.

830
00:45:06,000 --> 00:45:09,000
ИД, ИД, ИД.

831
00:45:09,000 --> 00:45:12,000
И повторно, јас сум го прави тоа, па повторно, јас сум веќе прибегнување кон копирање / вметнување повторно,

832
00:45:12,000 --> 00:45:14,000
па шансите се има друго решение овде.

833
00:45:14,000 --> 00:45:18,000
Јас веројатно може да се исчисти овој горе понатаму со јамка или нешто слично,

834
00:45:18,000 --> 00:45:21,000
Значи во кратки, тоа е малку подобро, но сеуште се чувствува како

835
00:45:21,000 --> 00:45:24,000
Јас сум прибегнување кон copy / paste, но дури и тоа, тврдам,

836
00:45:24,000 --> 00:45:27,000
навистина не е фундаментално право решение, бидејќи

837
00:45:27,000 --> 00:45:29,000
што ако некогаш се одлучи знаеш што?

838
00:45:29,000 --> 00:45:32,000
Ние навистина треба да се складирање на е-мејл адреси за Давид и Роб

839
00:45:32,000 --> 00:45:34,000
и секој друг во оваа програма.

840
00:45:34,000 --> 00:45:36,000
Ние, исто така, треба да ги чувате телефонски броеви.

841
00:45:36,000 --> 00:45:39,000
Ние, исто така, треба да чува итни броеви за контакт.

842
00:45:39,000 --> 00:45:41,000
Ние ги имаат сите овие делови на податоци што сакате да го зачувате,

843
00:45:41,000 --> 00:45:43,000
Па, како да одите за тоа го прават?

844
00:45:43,000 --> 00:45:46,000
>> Вие декларирате друга низа на врвот, а потоа можете рачно да додадете

845
00:45:46,000 --> 00:45:49,000
е-маил адреса [0], е-мејл адреса [1]

846
00:45:49,000 --> 00:45:51,000
за Давид и Роб и така натаму.

847
00:45:51,000 --> 00:45:56,000
Но, има навистина само претпоставка основните овој дизајн

848
00:45:56,000 --> 00:45:59,000
дека јас сум со користење на чест систем да се знае дека

849
00:45:59,000 --> 00:46:03,000
[I] во секоја од неколку низи

850
00:46:03,000 --> 00:46:06,000
само така се случува да се однесуваат на истото лице,

851
00:46:06,000 --> 00:46:10,000
па [0] во IDS е бројот 123,

852
00:46:10,000 --> 00:46:13,000
и јас одам да се претпостави дека имињата [0]

853
00:46:13,000 --> 00:46:16,000
е иста личност име и куќи [0]

854
00:46:16,000 --> 00:46:21,000
е куќата на истиот човек и така натаму за сите различни низи што ја создавам.

855
00:46:21,000 --> 00:46:24,000
Но, забележуваат дека нема основни поврзување

856
00:46:24,000 --> 00:46:27,000
меѓу оние 3 парчиња информации, ID, назив и куќа,

857
00:46:27,000 --> 00:46:32,000
иако субјектот ние се обидуваме да модел во оваа програма не е низи.

858
00:46:32,000 --> 00:46:35,000
Низи се само оваа програмска начин за тоа.

859
00:46:35,000 --> 00:46:38,000
Што ние навистина сакаме да се моделира во нашата програма е личност

860
00:46:38,000 --> 00:46:41,000
како Давид, едно лице како Роб внатрешноста на кој

861
00:46:41,000 --> 00:46:46,000
или концизирајќи е име и идентификација и куќа.

862
00:46:46,000 --> 00:46:49,000
>> Можеме некако изразат оваа идеја на херметичка

863
00:46:49,000 --> 00:46:52,000
при што едно лице има лична карта, име и куќа

864
00:46:52,000 --> 00:46:55,000
а не да се впуштат во навистина овој hack при што ние само

865
00:46:55,000 --> 00:46:58,000
верувам дека заградата нешто

866
00:46:58,000 --> 00:47:02,000
се однесува на ист човечки субјект во секоја од овие различни низи?

867
00:47:02,000 --> 00:47:04,000
Ние всушност може да го направите тоа.

868
00:47:04,000 --> 00:47:08,000
Дозволете ми да одат над главната сега за сега, и дозволете ми да се создаде мојата тип на податоци

869
00:47:08,000 --> 00:47:10,000
за навистина прв пат.

870
00:47:10,000 --> 00:47:14,000
Ние се користи оваа техника во трка,

871
00:47:14,000 --> 00:47:17,000
но тука јас ќе одам да се оди напред и да се создаде тип на податоци,

872
00:47:17,000 --> 00:47:19,000
и знаеш што, јас одам да го наречеме студент или лице,

873
00:47:19,000 --> 00:47:23,000
и јас одам да се користи typedef за дефинирање на видот.

874
00:47:23,000 --> 00:47:25,000
Одам да се каже дека ова е една структура,

875
00:47:25,000 --> 00:47:29,000
а потоа оваа структура ќе биде од типот студент, ќе кажам,

876
00:47:29,000 --> 00:47:31,000
иако тоа е малку датиран сега за мене.

877
00:47:31,000 --> 00:47:33,000
Ние ќе каже "int id."

878
00:47:33,000 --> 00:47:35,000
Ние ќе каже "стринг име."

879
00:47:35,000 --> 00:47:37,000
Тогаш ние ќе каже "стринг куќа"

880
00:47:37,000 --> 00:47:40,000
па сега до крајот на овие неколку линии на код

881
00:47:40,000 --> 00:47:45,000
Имам само учи ѕвекот дека постои

882
00:47:45,000 --> 00:47:49,000
податочен тип покрај ints, покрај жици, покрај двојки, покрај плови.

883
00:47:49,000 --> 00:47:54,000
>> Од овој момент во времето линија 11, таму сега е нов тип на податоци се нарекува студенти,

884
00:47:54,000 --> 00:47:58,000
и сега може да прогласи студент променлива насекаде сакам,

885
00:47:58,000 --> 00:48:01,000
па дозволете ми да дојдете тука на луѓето.

886
00:48:01,000 --> 00:48:05,000
Сега можам да се ослободи од ова, и јас да се вратиш до Дејвид тука,

887
00:48:05,000 --> 00:48:10,000
и за Дејвид јас всушност може да се каже дека Давид,

888
00:48:10,000 --> 00:48:13,000
ние буквално да го името на променливата по себе,

889
00:48:13,000 --> 00:48:16,000
ќе биде од типот студент.

890
00:48:16,000 --> 00:48:18,000
Ова може да изгледа малку чудно, но тоа не е сите што се разликува

891
00:48:18,000 --> 00:48:22,000
од прогласување нешто како int или стринг или плови.

892
00:48:22,000 --> 00:48:24,000
Тоа само така се случува да се нарекува студент сега,

893
00:48:24,000 --> 00:48:28,000
и ако сакам да се стави нешто во внатрешноста на оваа структура

894
00:48:28,000 --> 00:48:31,000
Јас сега треба да се користи нова фигура на синтаксата, но тоа е прилично јасна,

895
00:48:31,000 --> 00:48:39,000
david.id = 123, david.name = "Давид" во главниот град D,

896
00:48:39,000 --> 00:48:42,000
и david.house = "Mather"

897
00:48:42,000 --> 00:48:46,000
и сега можам да се ослободи од овие работи тука.

898
00:48:46,000 --> 00:48:51,000
ИЗВЕСТУВАЊЕ сега сме редизајнирана нашата програма во навистина многу подобар начин

899
00:48:51,000 --> 00:48:54,000
во која сега нашата програма одразува реалниот свет.

900
00:48:54,000 --> 00:48:57,000
>> Има реалниот свет идејата за човек или студент.

901
00:48:57,000 --> 00:49:02,000
Тука имаме сега една верзија Ц на некое лице или поконкретно студент.

902
00:49:02,000 --> 00:49:05,000
Внатрешноста на тоа лице се овие релевантни карактеристики,

903
00:49:05,000 --> 00:49:10,000
Проект, име и куќа, па Роб суштина станува истото тука долу,

904
00:49:10,000 --> 00:49:14,000
така студент ограбуваат, и сега rob.id = 456,

905
00:49:14,000 --> 00:49:17,000
rob.name = "Роб".

906
00:49:17,000 --> 00:49:20,000
Фактот дека променливата се вика Роб е вид на бесмислени.

907
00:49:20,000 --> 00:49:22,000
Ние би можеле да се нарече x или y или z.

908
00:49:22,000 --> 00:49:25,000
Ние само ја нарекол Роб да биде семантички конзистентно,

909
00:49:25,000 --> 00:49:28,000
но, навистина името е внатре во тоа поле себе,

910
00:49:28,000 --> 00:49:30,000
па сега имам ова.

911
00:49:30,000 --> 00:49:33,000
Тоа исто така не се чувствува како најдобар дизајн во тоа дека јас сум хард кодирани Давид.

912
00:49:33,000 --> 00:49:35,000
Сум хард кодирани Роб.

913
00:49:35,000 --> 00:49:39,000
И јас се уште треба да се прибегне кон некои копирајте го и ставете секој пат кога ќе сакате нови променливи.

914
00:49:39,000 --> 00:49:43,000
Покрај тоа, морам да очигледно им даде на секоја од овие променливи име,

915
00:49:43,000 --> 00:49:46,000
иако јас многу повеќе би сакал да се опише овие променливи

916
00:49:46,000 --> 00:49:48,000
 повеќе генерички како студенти.

917
00:49:48,000 --> 00:49:52,000
>> Сега можеме да се логирате на идеите кои се работат добро за нас

918
00:49:52,000 --> 00:49:56,000
и наместо да се каже, "Знаете што, дај ми променлива наречена студенти,

919
00:49:56,000 --> 00:50:01,000
и нека таа да биде со големина од 3 ", па сега можам да насочите ова понатаму,

920
00:50:01,000 --> 00:50:04,000
се ослободи од рачно прогласи Давид,

921
00:50:04,000 --> 00:50:08,000
и јас наместо да кажете нешто како студенти [0] тука.

922
00:50:08,000 --> 00:50:11,000
Јас тогаш може да се каже студенти [0] тука,

923
00:50:11,000 --> 00:50:14,000
студенти [0] тука, и така натаму, и јас да оди наоколу

924
00:50:14,000 --> 00:50:16,000
и исчистете дека за заведување.

925
00:50:16,000 --> 00:50:19,000
Јас, исто така може да се обратите за сега можеби додавајќи јамка

926
00:50:19,000 --> 00:50:23,000
и користење на GetString и GetInt да всушност овие вредности од корисникот.

927
00:50:23,000 --> 00:50:27,000
Јас би можеле да одат за додавање на постојана бидејќи ова е генерално лоша пракса

928
00:50:27,000 --> 00:50:29,000
на хард код некои произволни број како 3 токму тука

929
00:50:29,000 --> 00:50:33,000
а потоа само се сеќавам дека треба да се стави повеќе од 3 ученици во неа.

930
00:50:33,000 --> 00:50:36,000
Тоа најверојатно ќе биде подобро да се користи # define на врвот на мојата датотека

931
00:50:36,000 --> 00:50:40,000
и фактор кој надвор, па навистина, дозволете ми да оди напред и да се генерализира ова.

932
00:50:40,000 --> 00:50:43,000
>> Дозволете ми да се отвори еден пример дека е меѓу денешните

933
00:50:43,000 --> 00:50:46,000
примери во однапред, structs1.

934
00:50:46,000 --> 00:50:49,000
Ова е повеќе комплетна програма која користи # define се тука

935
00:50:49,000 --> 00:50:51,000
и вели дека ние ќе имаме 3 ученици од стандардните.

936
00:50:51,000 --> 00:50:54,000
Еве јас сум прогласување класа во вредност од студентите,

937
00:50:54,000 --> 00:50:57,000
па училницата на учениците, а сега сум со користење на јамка

938
00:50:57,000 --> 00:51:00,000
само за да го кодот малку повеќе домот, се доверат на класа

939
00:51:00,000 --> 00:51:05,000
со внесување на корисникот, така iterate на од i = 0 до студенти, што е 3.

940
00:51:05,000 --> 00:51:07,000
И тогаш го извести корисникот во оваа верзија

941
00:51:07,000 --> 00:51:10,000
 она што е идентитетот на студентот, и јас го добиете со GetInt.

942
00:51:10,000 --> 00:51:13,000
Што е името на студентот, а потоа да се добие со GetString.

943
00:51:13,000 --> 00:51:15,000
Што е куќата на ученикот? Јас го добие со GetString.

944
00:51:15,000 --> 00:51:19,000
А потоа на дното тука јас само одлучи да го промени

945
00:51:19,000 --> 00:51:22,000
како јас сум печатење овие надвор и да всушност употреба на телефонска линија,

946
00:51:22,000 --> 00:51:24,000
и кој сум јас печатење?

947
00:51:24,000 --> 00:51:27,000
Според коментар сум печатење некој во Mather,

948
00:51:27,000 --> 00:51:30,000
и тоа е тоа така Роб и Томи и така натаму-всушност Томи во Mather.

949
00:51:30,000 --> 00:51:34,000
Томи и Дејвид ќе бидат испечатени во овој случај, но како е ова работа?

950
00:51:34,000 --> 00:51:40,000
Не сме виделе оваа функција пред тоа, но се погоди тоа што ова го прави тоа.

951
00:51:40,000 --> 00:51:42,000
Споредува жици.

952
00:51:42,000 --> 00:51:45,000
>> Тоа е малку не-очигледно како тоа се споредува жици, бидејќи излегува

953
00:51:45,000 --> 00:51:49,000
ако го враќа 0 тоа значи дека конците се еднакви.

954
00:51:49,000 --> 00:51:53,000
Ако го враќа -1 што значи дека еден доаѓа по азбучен ред пред другите,

955
00:51:53,000 --> 00:51:57,000
и ако го враќа 1 тоа значи дека друг збор доаѓа по азбучен ред

956
00:51:57,000 --> 00:52:00,000
пред други, и може да се погледне на интернет или во човек страница

957
00:52:00,000 --> 00:52:04,000
да се види точно кој начин е кој, но сето тоа сега го прават е тоа велејќи

958
00:52:04,000 --> 00:52:09,000
ако [i]. куќа е еднаква на "Mather"

959
00:52:09,000 --> 00:52:13,000
па ќе одиме напред и печатење, па и така е во Mather.

960
00:52:13,000 --> 00:52:16,000
Но, тука е нешто што не сме виделе порано, а ние ќе се вратам на тоа.

961
00:52:16,000 --> 00:52:21,000
Јас не се сеќавам воопшто да треба да го направите ова во било кој од моите програми.

962
00:52:21,000 --> 00:52:24,000
Слободен е очигледно мислејќи на меморија, ослободувајќи меморија,

963
00:52:24,000 --> 00:52:31,000
но она што меморијата сум јас очигледно ослободување во овој циклус на дното на оваа програма?

964
00:52:31,000 --> 00:52:34,000
Изгледа како да сум ослободувајќи името на лицето

965
00:52:34,000 --> 00:52:37,000
и куќата на една личност, но зошто е тоа така?

966
00:52:37,000 --> 00:52:41,000
>> Излегува сите овие недели дека сте биле со GetString

967
00:52:41,000 --> 00:52:45,000
ние сме вид на е воведување на бубачка во секој еден од вашите програми.

968
00:52:45,000 --> 00:52:51,000
GetString од страна на дизајнот доделува меморија, така што тоа може да се врати да ви стринг,

969
00:52:51,000 --> 00:52:55,000
како Давид, или Роб, и тогаш може да правите што сакате

970
00:52:55,000 --> 00:52:59,000
со тоа стринг во вашата програма, бидејќи ние сме се задржани меморијата за вас.

971
00:52:59,000 --> 00:53:02,000
Проблемот е сето ова време секој пат кога ќе се јавите GetString

972
00:53:02,000 --> 00:53:05,000
ние, авторите на GetString, се бара од оперативниот систем

973
00:53:05,000 --> 00:53:07,000
да ни даде малку RAM меморија за овој стринг.

974
00:53:07,000 --> 00:53:09,000
Дајте ни малку RAM меморија за следниот стринг.

975
00:53:09,000 --> 00:53:11,000
Ни даде некои повеќе RAM меморија за следниот стринг.

976
00:53:11,000 --> 00:53:13,000
Што ви, програмер, никогаш не се прави

977
00:53:13,000 --> 00:53:15,000
ни дава дека меморијата назад,

978
00:53:15,000 --> 00:53:17,000
па за овие неколку недели на сите програми што сум напишал

979
00:53:17,000 --> 00:53:20,000
имале она што се нарекува меморија скок при што тие ги користат

980
00:53:20,000 --> 00:53:24,000
се повеќе и повеќе меморија секој пат кога ќе се јавите GetString, и тоа е добро.

981
00:53:24,000 --> 00:53:27,000
Ние намерно го направи тоа во првите недели поради тоа што не е толку интересен

982
00:53:27,000 --> 00:53:29,000
да мора да се грижите за тоа каде стринг е што доаѓаат од.

983
00:53:29,000 --> 00:53:34,000
Сите што го сакате е зборот Роб да се врати кога корисникот ќе ја типови внатре

984
00:53:34,000 --> 00:53:38,000
>> Но се движи напред ние сега треба да започне да добива повеќе софистицирани за ова.

985
00:53:38,000 --> 00:53:42,000
Секое време ние алоцира меморија подобро на крајот ја предаде назад.

986
00:53:42,000 --> 00:53:45,000
Инаку во реалниот свет на вашиот Mac или PC може да имате повремено искусни

987
00:53:45,000 --> 00:53:50,000
симптоми каде што вашиот компјутер е мелење до застој конечно

988
00:53:50,000 --> 00:53:54,000
или глупави предење плажа топката е само окупаторската на компјутерот

989
00:53:54,000 --> 00:53:56,000
целата внимание и не можете да се прават работите.

990
00:53:56,000 --> 00:54:00,000
Тоа може да се објасни со кој било број на грешки, но меѓу оние можни грешки

991
00:54:00,000 --> 00:54:03,000
се работи вика меморија протекување при некој кој напиша дека парче софтвер

992
00:54:03,000 --> 00:54:07,000
сте користење не заборавајте да ослободите меморија

993
00:54:07,000 --> 00:54:10,000
дека тој или таа побара од оперативниот систем за,

994
00:54:10,000 --> 00:54:14,000
не се користи GetString, бидејќи тоа е CS50 работа, но со користење на слични функции

995
00:54:14,000 --> 00:54:16,000
кои бараат оперативниот систем за меморија.

996
00:54:16,000 --> 00:54:19,000
Ако вие или тие ја зафркнам и всушност никогаш не се врати таа меморија

997
00:54:19,000 --> 00:54:24,000
симптом на која може да биде дека програмата се забавува и го забавува и го успорува

998
00:54:24,000 --> 00:54:26,000
освен ако не се сеќавам да се јавите бесплатно.

999
00:54:26,000 --> 00:54:28,000
>> Ќе се врати кога и зошто ќе се јавите бесплатно,

1000
00:54:28,000 --> 00:54:32,000
но, ајде да одиме напред само за добра мерка и пробајте да ја отворите оваа конкретна програма.

1001
00:54:32,000 --> 00:54:35,000
Ова беше наречен structs1, внесете.

1002
00:54:35,000 --> 00:54:40,000
Дозволете ми да оди напред и да ја стартувате structs1, 123, Дејвид Mather,

1003
00:54:40,000 --> 00:54:47,000
456, Роб Киркланд, 789,

1004
00:54:47,000 --> 00:54:50,000
Томи Mather, и можеме да видиме на David во Mather, Томи во Mather.

1005
00:54:50,000 --> 00:54:53,000
Ова е само малку здрав разум Проверете дека е програмата е работа.

1006
00:54:53,000 --> 00:54:56,000
Сега, за жал, оваа програма е малку фрустрирачки во таа

1007
00:54:56,000 --> 00:55:00,000
Јас не сите кои работат, јас ја внеле во 9 различни жици, притиснете ентер,

1008
00:55:00,000 --> 00:55:04,000
беше кажано кој беше во Mather, но очигледно јас знаев кој беше во Mather веќе затоа што го напишавте.

1009
00:55:04,000 --> 00:55:07,000
Тоа би било барем убаво ако оваа програма е повеќе како база на податоци

1010
00:55:07,000 --> 00:55:10,000
а тоа всушност се сеќава на она што го внесе во

1011
00:55:10,000 --> 00:55:12,000
па јас никогаш не повторно треба да го внесете овие студент евиденција.

1012
00:55:12,000 --> 00:55:15,000
Можеби тоа е како registrarial систем.

1013
00:55:15,000 --> 00:55:21,000
>> Ние можеме да го направите тоа користејќи оваа техника позната како датотека I / O, датотеката влез и излез,

1014
00:55:21,000 --> 00:55:24,000
многу генерички начин на велејќи дека секој пат кога ќе сакате да го прочитате датотеки или да пишува датотеки

1015
00:55:24,000 --> 00:55:26,000
можете да го направите ова со одреден сет на функции.

1016
00:55:26,000 --> 00:55:29,000
Дозволете ми да оди напред и да се отвори овој пример structs2.c,

1017
00:55:29,000 --> 00:55:33,000
што е речиси идентични, но ајде да видиме што тоа сега го прави тоа.

1018
00:55:33,000 --> 00:55:36,000
На врвот на датотеката Изјавувам класа на студентите.

1019
00:55:36,000 --> 00:55:38,000
Јас тогаш се доверат на класа со внесување на корисникот,

1020
00:55:38,000 --> 00:55:41,000
па оние линии на код се исто како и пред тоа.

1021
00:55:41,000 --> 00:55:45,000
Потоа, ако дојдете тука јас печати секој кој е во Mather произволно како порано,

1022
00:55:45,000 --> 00:55:47,000
но ова е интересна нова функција.

1023
00:55:47,000 --> 00:55:51,000
Овие линии на код се нови, и тие се воведе нешто тука,

1024
00:55:51,000 --> 00:55:55,000
Датотека, сите капи, и има * во и тука.

1025
00:55:55,000 --> 00:55:58,000
Дозволете ми да се помести ова овде, a * овде, како и.

1026
00:55:58,000 --> 00:56:00,000
>> Оваа функција не сме виделе порано, fopen,

1027
00:56:00,000 --> 00:56:03,000
но тоа значи отварање датотека, па ајде обезмаслен преку нив,

1028
00:56:03,000 --> 00:56:05,000
и ова е нешто што ќе се врати во иднина psets,

1029
00:56:05,000 --> 00:56:10,000
но оваа линија тука суштина отвора фајл наречен база на податоци,

1030
00:56:10,000 --> 00:56:13,000
и тоа посебно се отвора во таков начин што тоа може да го направи она што со неа?

1031
00:56:13,000 --> 00:56:15,000
[Нечујни-студент]

1032
00:56:15,000 --> 00:56:19,000
Право, па "W" едноставно значи тоа кажува на оперативниот систем

1033
00:56:19,000 --> 00:56:21,000
ја отворите оваа датотека на таков начин што ќе можам да пишува на него.

1034
00:56:21,000 --> 00:56:23,000
Не сакам да го прочита. Не сакам само да се погледне во него.

1035
00:56:23,000 --> 00:56:26,000
Сакам да го промени и да додадете нешто потенцијално да го,

1036
00:56:26,000 --> 00:56:28,000
и датотеката ќе биде наречена база на податоци.

1037
00:56:28,000 --> 00:56:30,000
Ова би можело да се нарече нешто.

1038
00:56:30,000 --> 00:56:32,000
Ова може да биде database.txt. Ова би можело да биде. DB.

1039
00:56:32,000 --> 00:56:37,000
Ова би можело да биде еден збор, како foo, но јас произволно избра за името на датотеката база на податоци.

1040
00:56:37,000 --> 00:56:42,000
Ова е малку здрав разум проверка дека ќе се врати во големи детали текот на времето,

1041
00:56:42,000 --> 00:56:47,000
ако РП, за датотеката покажувач, не еднакви NULL тоа значи дека сите е добро.

1042
00:56:47,000 --> 00:56:51,000
>> Скратам приказната, функции како fopen понекогаш не успеваат.

1043
00:56:51,000 --> 00:56:53,000
Можеби датотеката не постои. Можеби сте надвор од диск простор.

1044
00:56:53,000 --> 00:56:55,000
Можеби немате дозвола да таа папка,

1045
00:56:55,000 --> 00:56:58,000
па ако fopen враќа null нешто лошо се случило.

1046
00:56:58,000 --> 00:57:02,000
Спротивно на тоа, ако fopen не врати null се е во ред

1047
00:57:02,000 --> 00:57:04,000
и јас да почнете со пишување на оваа датотека.

1048
00:57:04,000 --> 00:57:06,000
Еве еден нов трик.

1049
00:57:06,000 --> 00:57:08,000
Ова е за телефонска линија што е процесирањето над секој од моите студенти,

1050
00:57:08,000 --> 00:57:10,000
и тоа изгледа толку слична на она што ние го направивме досега,

1051
00:57:10,000 --> 00:57:15,000
но оваа функција е братучед на printf наречен fprintf за датотеката printf,

1052
00:57:15,000 --> 00:57:18,000
и ќе забележите тоа е различно во само 2 начини.

1053
00:57:18,000 --> 00:57:20,000
Еден, тоа почнува со f наместо p,

1054
00:57:20,000 --> 00:57:23,000
но тогаш неговата Првиот аргумент е очигледно што?

1055
00:57:23,000 --> 00:57:25,000
[Студентите] датотеката. >> Тоа е датотека.

1056
00:57:25,000 --> 00:57:30,000
Ова нешто што се нарекува РП, кои на крајот ќе разграничат каква датотека покажувачот е,

1057
00:57:30,000 --> 00:57:35,000
но сега за сега РП едноставно претставува датотека која се отвори,

1058
00:57:35,000 --> 00:57:41,000
па fprintf тука е велејќи печати број на овој корисник на датотека, не на екранот.

1059
00:57:41,000 --> 00:57:44,000
Печати името на корисникот на датотека, не на екранот,

1060
00:57:44,000 --> 00:57:47,000
куќата на датотека, не на екранот, а потоа тука долу, очигледно,

1061
00:57:47,000 --> 00:57:50,000
затвори датотека, а потоа надолу тука ослободи меморија.

1062
00:57:50,000 --> 00:57:53,000
>> Единствената разлика помеѓу оваа верзија 2 и верзија 1

1063
00:57:53,000 --> 00:57:58,000
е воведувањето на fopen и оваа датотека со *

1064
00:57:58,000 --> 00:58:01,000
и ова сфаќање на fprintf, па ајде да видиме што крајниот резултат е.

1065
00:58:01,000 --> 00:58:03,000
Дозволете ми да одам во мојата терминален прозорец.

1066
00:58:03,000 --> 00:58:06,000
Дозволете ми да се кандидира structs2, внесете.

1067
00:58:06,000 --> 00:58:09,000
Изгледа сите е добро. Да повторување structs2.

1068
00:58:09,000 --> 00:58:15,000
123, Дејвид Mather, 456, Роб Киркланд,

1069
00:58:15,000 --> 00:58:19,000
789, Томи Mather, внесете.

1070
00:58:19,000 --> 00:58:23,000
Изгледа дека се однесувал на ист, но ако јас сега прават ls

1071
00:58:23,000 --> 00:58:28,000
забележи она што датотеката е тука меѓу сите мојот код, база на податоци,

1072
00:58:28,000 --> 00:58:32,000
па ајде отвори таа, gedit на базата на податоци, и да бараат во тоа.

1073
00:58:32,000 --> 00:58:34,000
Тоа не е најсекси на формати на датотеки.

1074
00:58:34,000 --> 00:58:38,000
Тоа навистина е едно парче на податоци линија по линија по линија,

1075
00:58:38,000 --> 00:58:42,000
но оние од вас кои го користите Excel или CSV датотеки, одделени со запирки вредности,

1076
00:58:42,000 --> 00:58:47,000
Јас секако може да се користат fprintf да наместо можеби направи вакво нешто

1077
00:58:47,000 --> 00:58:50,000
така што јас всушност би можеле да се создаде еквивалент на Excel датотеката

1078
00:58:50,000 --> 00:58:53,000
со одвојување работи со запирки, а не само нови линии.

1079
00:58:53,000 --> 00:58:56,000
>> Во овој случај, ако имав наместо користи запирки наместо на нови линии

1080
00:58:56,000 --> 00:59:01,000
Јас буквално може да ја отворите оваа база на податоци датотека во Excel, ако наместо направи да изгледа вака.

1081
00:59:01,000 --> 00:59:03,000
На кратко, сега имаме моќ да пишуваат на датотеки

1082
00:59:03,000 --> 00:59:07,000
ние сега може да почне постојаниот податоци, имајќи го околу на диск

1083
00:59:07,000 --> 00:59:10,000
така што можеме да го задржи информации околу повторно и повторно.

1084
00:59:10,000 --> 00:59:14,000
Забележите неколку други работи кои се сега малку повеќе запознаени.

1085
00:59:14,000 --> 00:59:16,000
На врвот на оваа датотека C имаме typedef

1086
00:59:16,000 --> 00:59:21,000
затоа што сакавме да се создаде податочен тип кој претставува еден збор,

1087
00:59:21,000 --> 00:59:25,000
па овој вид е наречен збор, и во внатрешноста на оваа структура

1088
00:59:25,000 --> 00:59:27,000
тоа е малку познавач сега.

1089
00:59:27,000 --> 00:59:30,000
Зошто еден збор составен од очигледно низа?

1090
00:59:30,000 --> 00:59:33,000
Што е збор само интуитивно?

1091
00:59:33,000 --> 00:59:35,000
>> Тоа е низа од карактери.

1092
00:59:35,000 --> 00:59:37,000
Тоа е секвенца од знаци да се врати назад да се врати.

1093
00:59:37,000 --> 00:59:41,000
БУКВИ во сите настапи се случува да биде што произволно велат дека максималната должина

1094
00:59:41,000 --> 00:59:44,000
на било кој збор во речникот што се употребува за трка.

1095
00:59:44,000 --> 00:59:46,000
Зошто имам 1?

1096
00:59:46,000 --> 00:59:48,000
На нула карактер.

1097
00:59:48,000 --> 00:59:51,000
Сеќавам кога ние го сторивме на пример Bananagrams ни е потребно посебна вредност

1098
00:59:51,000 --> 00:59:55,000
на крајот на зборот, со цел да ги пратите

1099
00:59:55,000 --> 00:59:59,000
од каде зборови всушност заврши, а како проблем сет спецификација вели

1100
00:59:59,000 --> 01:00:03,000
тука сме асоцирањето со даден збор логичка вредност,

1101
01:00:03,000 --> 01:00:05,000
знаме, така да се каже, точно или неточно.

1102
01:00:05,000 --> 01:00:09,000
Го најде овој збор веќе, бидејќи сфаќаме

1103
01:00:09,000 --> 01:00:13,000
ние навистина треба начин на помнење не само што збор е во трка

1104
01:00:13,000 --> 01:00:15,000
но дали или не, на човекот, го најде

1105
01:00:15,000 --> 01:00:20,000
така што ако не го најдете зборот "на" не може само да напишете, внесете, на, внесете, на, внесете

1106
01:00:20,000 --> 01:00:23,000
и да добијат 3 поени, 3 поени, 3 поени, 3 поени.

1107
01:00:23,000 --> 01:00:26,000
Ние сакаме да бидеме во можност да црната листа на тој збор со поставување на bool

1108
01:00:26,000 --> 01:00:29,000
на true ако веќе сте го најде, и така тоа е причината зошто ние

1109
01:00:29,000 --> 01:00:31,000
врзуваат тоа во оваа структура.

1110
01:00:31,000 --> 01:00:35,000
>> Сега, тука долу во трка има оваа друга struct наречен речникот.

1111
01:00:35,000 --> 01:00:39,000
Отсутен тука е збор typedef затоа што во овој случај

1112
01:00:39,000 --> 01:00:43,000
ние потребни за да капсулирало идејата за речникот,

1113
01:00:43,000 --> 01:00:46,000
и речник содржи еден куп зборови,

1114
01:00:46,000 --> 01:00:49,000
како имплицирани од оваа низа, и колку од тие зборови се таму?

1115
01:00:49,000 --> 01:00:51,000
Па, она што оваа променлива наречена големина вели.

1116
01:00:51,000 --> 01:00:53,000
Но, ние само треба еден речник.

1117
01:00:53,000 --> 01:00:55,000
Ние не треба податочен тип се нарекува речникот.

1118
01:00:55,000 --> 01:00:58,000
Ние само треба еден од нив, па излегува во C

1119
01:00:58,000 --> 01:01:03,000
дека ако не се каже typedef, само велат struct, а потоа внатре во големи загради

1120
01:01:03,000 --> 01:01:05,000
ги ставаш променливи, тогаш стави името.

1121
01:01:05,000 --> 01:01:09,000
Ова се наведува една променлива наречена речник

1122
01:01:09,000 --> 01:01:11,000
што личи ова.

1123
01:01:11,000 --> 01:01:16,000
Спротивно на тоа, овие редови се создаде еднократно податоци структура наречена збор

1124
01:01:16,000 --> 01:01:19,000
дека можете да креирате повеќе копии на, како што ја создававме

1125
01:01:19,000 --> 01:01:22,000
повеќе копии на студентите.

1126
01:01:22,000 --> 01:01:24,000
>> Што значи тоа во крајна линија ни овозможи да се направи?

1127
01:01:24,000 --> 01:01:30,000
Дозволете ми да се вратам во, да речеме, еден поедноставен пример од поедноставни времиња,

1128
01:01:30,000 --> 01:01:34,000
и дозволете ми да се отвори, да речеме, compare1.c.

1129
01:01:34,000 --> 01:01:38,000
Проблемот тука при рака е всушност да лупам назад

1130
01:01:38,000 --> 01:01:41,000
слојот на низа и да започнете преземањето од овие обука тркала

1131
01:01:41,000 --> 01:01:44,000
бидејќи излегува дека низа сето ова време

1132
01:01:44,000 --> 01:01:47,000
е како што вети во неделата 1 навистина само прекар,

1133
01:01:47,000 --> 01:01:51,000
синоним од CS50 библиотека за нешто што изгледа малку повеќе криптичната,

1134
01:01:51,000 --> 01:01:53,000
char *, и видовме оваа ѕвезда порано.

1135
01:01:53,000 --> 01:01:55,000
Видовме во контекст на датотеки.

1136
01:01:55,000 --> 01:01:59,000
>> Ајде сега да видиме зошто ние се криел овој детал за некои Времето сега.

1137
01:01:59,000 --> 01:02:02,000
Тука е датотека наречена compare1.c,

1138
01:02:02,000 --> 01:02:07,000
и тоа очигледно го прашува корисникот за 2 жици, а и т,

1139
01:02:07,000 --> 01:02:11,000
а потоа се обидува да се споредат овие жици за еднаквост во линија 26,

1140
01:02:11,000 --> 01:02:14,000
и ако тие се еднакви тој вели: "Внесовте истото"

1141
01:02:14,000 --> 01:02:17,000
и ако тие не се еднакви тој вели: "Внесовте различни нешта."

1142
01:02:17,000 --> 01:02:19,000
Дозволете ми да оди напред и да ја извршите оваа програма.

1143
01:02:19,000 --> 01:02:23,000
Дозволете ми да одам во мојата изворниот директориум, направете compare1. Тоа Составувач ред.

1144
01:02:23,000 --> 01:02:25,000
Дозволете ми да се кандидира compare1.

1145
01:02:25,000 --> 01:02:27,000
Јас ќе зумирате, внесете.

1146
01:02:27,000 --> 01:02:29,000
Кажи нешто. ЗДРАВО.

1147
01:02:29,000 --> 01:02:32,000
Јас ќе кажам нешто повторно. ЗДРАВО.

1148
01:02:32,000 --> 01:02:34,000
Јас дефинитивно не внесете различни нешта.

1149
01:02:34,000 --> 01:02:37,000
>> Дозволете ми да се обиде повторно. Bye bye.

1150
01:02:37,000 --> 01:02:40,000
Дефинитивно не се разликува, па она што се случува тука?

1151
01:02:40,000 --> 01:02:44,000
Па, она што е навистина се спореди во линија 26?

1152
01:02:44,000 --> 01:02:46,000
[Нечујни-студент]

1153
01:02:46,000 --> 01:02:49,000
Да, па излегува дека стринг, тип на податоци, е вид на бела лага.

1154
01:02:49,000 --> 01:02:53,000
А низа е char *, но она што е char *?

1155
01:02:53,000 --> 01:02:56,000
А char *, како што велат, е покажувач,

1156
01:02:56,000 --> 01:03:00,000
и покажувач е, всушност, адреса,

1157
01:03:00,000 --> 01:03:05,000
сума локација во меморијата, а ако се случи да се внесе во еден збор како ЗДРАВО,

1158
01:03:05,000 --> 01:03:08,000
потсетиме од минатото дискусиите на стрингови

1159
01:03:08,000 --> 01:03:16,000
ова е како зборот Здраво.

1160
01:03:16,000 --> 01:03:19,000
Запомнете дека зборот како ЗДРАВО може да се претстави

1161
01:03:19,000 --> 01:03:22,000
како низа од карактери како оваа

1162
01:03:22,000 --> 01:03:25,000
а потоа со специјален карактер на крајот нарекува нулти карактер,

1163
01:03:25,000 --> 01:03:27,000
како \ означува.

1164
01:03:27,000 --> 01:03:29,000
Што е всушност низа?

1165
01:03:29,000 --> 01:03:32,000
Забележете дека ова е повеќе делови од меморијата,

1166
01:03:32,000 --> 01:03:36,000
и всушност, на крајот од него е познат само откако ќе се погледне преку цела низа

1167
01:03:36,000 --> 01:03:38,000
во потрага по специјални null карактер.

1168
01:03:38,000 --> 01:03:41,000
Но, ако ова е парче меморија од меморијата на компјутерот ми е,

1169
01:03:41,000 --> 01:03:44,000
ајде произволно да се каже дека овој стринг само што влегов среќа,

1170
01:03:44,000 --> 01:03:47,000
и тоа доби поставена на самиот почеток на RAM меморија на компјутерот ми е.

1171
01:03:47,000 --> 01:03:54,000
Ова е бајт 0, 1, 2, 3, 4, 5, 6 ...

1172
01:03:54,000 --> 01:04:02,000
>> Кога ќе се каже нешто како GetString и јас низа s = GetString

1173
01:04:02,000 --> 01:04:04,000
она што е навистина се врати?

1174
01:04:04,000 --> 01:04:08,000
За овие изминатите неколку недели, она што е навистина се чуваат во с

1175
01:04:08,000 --> 01:04:13,000
не е оваа низа по себе, но во овој случај она што се чуваат е

1176
01:04:13,000 --> 01:04:18,000
бројот 0, бидејќи она што GetString всушност не

1177
01:04:18,000 --> 01:04:20,000
е тоа не физички се врати стринг.

1178
01:04:20,000 --> 01:04:22,000
Тоа дури и не навистина да се направи концептуална смисла.

1179
01:04:22,000 --> 01:04:24,000
Што го прави тоа враќање е број.

1180
01:04:24,000 --> 01:04:28,000
Тој број е адресата на ЗДРАВО во меморијата,

1181
01:04:28,000 --> 01:04:32,000
и гудачки и тогаш, ако ние лупам назад овој слој, стринг не постои.

1182
01:04:32,000 --> 01:04:35,000
Тоа е само поедноставување на CS50 библиотека.

1183
01:04:35,000 --> 01:04:38,000
>> Ова навистина е нешто што се нарекува char *.

1184
01:04:38,000 --> 01:04:41,000
Char има смисла, бидејќи она што е збор, како Ало?

1185
01:04:41,000 --> 01:04:44,000
Па, тоа е серија на карактери, серија на карактери.

1186
01:04:44,000 --> 01:04:47,000
Char * значи адресата на карактер,

1187
01:04:47,000 --> 01:04:50,000
па што значи тоа да се врати стринг?

1188
01:04:50,000 --> 01:04:53,000
А убаво, едноставен начин за враќање низа

1189
01:04:53,000 --> 01:04:57,000
е наместо да се обидат да дознаам како ќе се вратам на 5 или 6 различни бајти

1190
01:04:57,000 --> 01:05:01,000
дозволете ми да се врати на адресата на која бајт?

1191
01:05:01,000 --> 01:05:03,000
Првиот.

1192
01:05:03,000 --> 01:05:06,000
Со други зборови, дозволете ми да ви даде адресата на некој лик во меморијата.

1193
01:05:06,000 --> 01:05:10,000
Тоа е она што char * претставува, адресата на еден единствен карактер во меморијата.

1194
01:05:10,000 --> 01:05:12,000
Повик таа променлива s.

1195
01:05:12,000 --> 01:05:15,000
Продавница во е дека одредена адреса, за што јас произволно рече дека е 0,

1196
01:05:15,000 --> 01:05:19,000
само да го задржи нешта едноставно, но во реалноста тоа е обично поголем број.

1197
01:05:19,000 --> 01:05:21,000
>> Почекајте една минута.

1198
01:05:21,000 --> 01:05:23,000
Ако сте само ми даде адресата на првиот карактер, како можам да знам што адресата е

1199
01:05:23,000 --> 01:05:25,000
на вториот лик, третата, четвртата и петтата?

1200
01:05:25,000 --> 01:05:27,000
[Нечујни-студент]

1201
01:05:27,000 --> 01:05:31,000
Вие само знам каде на крајот од стрингот е по пат на оваа корисна трик,

1202
01:05:31,000 --> 01:05:35,000
па кога ќе се користи нешто како printf, што printf буквално зема како своја аргумент,

1203
01:05:35,000 --> 01:05:39,000
потсетиме дека ние ги користиме случаеви оваа% s, а потоа ќе помине во

1204
01:05:39,000 --> 01:05:41,000
променлива која е складирање низа.

1205
01:05:41,000 --> 01:05:47,000
Што сте навистина поминува е адресата на првиот карактер на стрингот.

1206
01:05:47,000 --> 01:05:50,000
Printf потоа користи за јамка или додека јамка по приемот на таа адреса,

1207
01:05:50,000 --> 01:05:53,000
на пример, 0, па дозволете ми да го направите ова сега,

1208
01:05:53,000 --> 01:06:02,000
printf ("% s \ n" и);

1209
01:06:02,000 --> 01:06:07,000
Кога ќе се јавам printf ("% s \ n" и); она што јас сум навистина обезбедување printf со

1210
01:06:07,000 --> 01:06:13,000
е адресата на првиот карактер во с, која во оваа произволна случај е Х

1211
01:06:13,000 --> 01:06:16,000
>> Како се printf знаат што точно да се прикаже на екранот?

1212
01:06:16,000 --> 01:06:19,000
Лицето кое спроведува printf спроведува додека јамка или за телефонска линија

1213
01:06:19,000 --> 01:06:23,000
кој се вели дека е овој лик се изедначи со посебни null карактер?

1214
01:06:23,000 --> 01:06:25,000
Ако не, тоа печатите. Како за оваа?

1215
01:06:25,000 --> 01:06:28,000
Ако не го испечатите, да ја отпечати, печати, печати неа.

1216
01:06:28,000 --> 01:06:32,000
Ох, ова е посебен. Стоп за печатење и да се вратат на корисникот.

1217
01:06:32,000 --> 01:06:35,000
И тоа е буквално се што се случува под хауба,

1218
01:06:35,000 --> 01:06:38,000
и тоа е многу да се вари во првиот ден на класа,

1219
01:06:38,000 --> 01:06:43,000
но сега за сега тоа е навистина градење на блок на разбирање што

1220
01:06:43,000 --> 01:06:46,000
и тоа е се случува во внатрешноста на меморија нашиот компјутер,

1221
01:06:46,000 --> 01:06:49,000
и на крајот ќе закачам ова освен со мала помош

1222
01:06:49,000 --> 01:06:51,000
од една од нашите пријатели во Стенфорд.

1223
01:06:51,000 --> 01:06:56,000
>> Професорот Ник Parlante на Стенфорд има направено овој прекрасен видео инсерт

1224
01:06:56,000 --> 01:06:58,000
од сите видови на различни јазици кои воведе

1225
01:06:58,000 --> 01:07:00,000
оваа мала Claymation карактер Binky.

1226
01:07:00,000 --> 01:07:03,000
Гласот сте за да се слушне во само неколку секунди подлец преглед

1227
01:07:03,000 --> 01:07:05,000
е дека на Стенфорд професор, а ти си добивање

1228
01:07:05,000 --> 01:07:07,000
само 5 или 6 секунди на ова право сега,

1229
01:07:07,000 --> 01:07:09,000
но ова е забелешка на кој ќе се заклучи денес

1230
01:07:09,000 --> 01:07:11,000
и да започне в среда.

1231
01:07:11,000 --> 01:07:15,000
Јас ви даде Покажувач Забава со Binky, прегледот.

1232
01:07:15,000 --> 01:07:18,000
[♪ Музика ♪] [професор Parlante] Еј, Binky.

1233
01:07:18,000 --> 01:07:21,000
Разбудам. Тоа е време за покажувачот забава.

1234
01:07:21,000 --> 01:07:24,000
[Binky] Што е тоа? Учат за покажувачи?

1235
01:07:24,000 --> 01:07:26,000
О, стрина!

1236
01:07:26,000 --> 01:07:29,000
>> Ние ќе се видиме во среда.

1237
01:07:29,000 --> 01:07:32,000
[CS50.TV]