1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Преглед] [квиз 0]

2
00:00:03,000 --> 00:00:05,000
>> [Lexi Рос, Томи MacWilliam, Лукас Freitas, Јосиф Ong] [Универзитетот Харвард]

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

4
00:00:08,000 --> 00:00:10,000
>> Еј, сите.

5
00:00:10,000 --> 00:00:15,000
Добредојдовте на преглед сесија за 0 квиз, што се одржува оваа среда.

6
00:00:15,000 --> 00:00:19,000
Она што ние ќе правиме вечерва, Јас сум со 3 други TFS,

7
00:00:19,000 --> 00:00:24,000
и заедно ние ќе одиме преку преглед на она што ние го направивме во текот досега.

8
00:00:24,000 --> 00:00:27,000
Тоа нема да биде 100% сеопфатен, но тоа треба да ви даде подобра идеја

9
00:00:27,000 --> 00:00:31,000
на она што веќе го имаат долу и што уште треба да учат пред средата.

10
00:00:31,000 --> 00:00:34,000
И се чувствуваат слободни да ја подигне својата рака со прашања како што се случува заедно,

11
00:00:34,000 --> 00:00:38,000
но имајте на ум дека ние, исто така, ќе имаат малку време на крајот-

12
00:00:38,000 --> 00:00:41,000
ако добиеме преку со неколку минути да се резервни да направите општи прашања,

13
00:00:41,000 --> 00:00:47,000
па задржи тоа во предвид, и така ние ќе започне во почетокот со недела 0.

14
00:00:47,000 --> 00:00:50,000
>> [Квиз 0 Преглед!] [Дел 0] [Lexi Рос] Но, пред да го направите тоа, ајде да зборуваме за

15
00:00:50,000 --> 00:00:53,000
логистика на квизот.

16
00:00:53,000 --> 00:00:55,000
>> [Логистика] [квиз се одвива во средата 10/10 наместо на предавање]

17
00:00:55,000 --> 00:00:57,000
>> [(Види http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf за детали)] Таа е на Среда, 10 Октомври.

18
00:00:57,000 --> 00:01:00,000
>> Тоа е оваа среда, а ако одите на оваа адреса тука,

19
00:01:00,000 --> 00:01:03,000
кој исто така е достапна од CS50.net-Има еден линк до него-

20
00:01:03,000 --> 00:01:06,000
можете да видите информации за тоа каде да одат врз основа на

21
00:01:06,000 --> 00:01:10,000
Вашето презиме или училиште припадност, како и

22
00:01:10,000 --> 00:01:14,000
тоа кажува за што точно квизот ќе ги покрие и видови на прашања кои си оди за да се добие.

23
00:01:14,000 --> 00:01:19,000
Имајте на ум дека, исто така, ќе имаат шанса да ги видиш за квиз во делот,

24
00:01:19,000 --> 00:01:21,000
па вашите TFS треба да се оди над некои пракса проблеми,

25
00:01:21,000 --> 00:01:29,000
и тоа е уште една добра шанса да се види каде се уште треба да учат за квизот.

26
00:01:29,000 --> 00:01:32,000
Ајде да започне на почетокот со Бајти битови 'N'.

27
00:01:32,000 --> 00:01:35,000
Се сеќавам на еден малку е само 0 или 1,

28
00:01:35,000 --> 00:01:38,000
и бајт е збирка од 8 на оние делови.

29
00:01:38,000 --> 00:01:42,000
Ајде да погледнеме во оваа колекција на парчиња токму тука.

30
00:01:42,000 --> 00:01:44,000
Ние треба да бидеме во можност да дознаам колку делови има.

31
00:01:44,000 --> 00:01:48,000
Каде што смета има само 8 од нив, осум 0 или 1 единици.

32
00:01:48,000 --> 00:01:51,000
И бидејќи има 8 бита, тоа е 1 бајт,

33
00:01:51,000 --> 00:01:53,000
и ајде да го претворат во хексадецимален.

34
00:01:53,000 --> 00:01:58,000
Хексадецимален е база на 16, и тоа е прилично лесно да конвертирате

35
00:01:58,000 --> 00:02:01,000
број во бинарен, што е она што е, на број во хексадецимално.

36
00:02:01,000 --> 00:02:04,000
Сите што го правиме е гледаме групи од 4,

37
00:02:04,000 --> 00:02:07,000
и ние ги претворат во соодветните хексадецимално цифра.

38
00:02:07,000 --> 00:02:11,000
Започнуваме со право на-повеќето група на 4, па 0011.

39
00:02:11,000 --> 00:02:16,000
Тоа ќе биде еден 1 и една 2, па заедно што го прави 3.

40
00:02:16,000 --> 00:02:19,000
А потоа нека се погледне на други блок 4.

41
00:02:19,000 --> 00:02:24,000
1101. Тоа ќе биде еден 1, едно 4, и еден 8.

42
00:02:24,000 --> 00:02:28,000
Заедно дека ќе биде 13, што го прави Д

43
00:02:28,000 --> 00:02:32,000
И ние ќе се запамети дека во хексадецимално не само оди од 0 до 9.

44
00:02:32,000 --> 00:02:36,000
Одиме 0 до F, па после 9, 10 одговара на,

45
00:02:36,000 --> 00:02:40,000
11 до Б, и така натаму каде F е 15.

46
00:02:40,000 --> 00:02:44,000
Еве 13 е D,

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

48
00:02:49,000 --> 00:02:52,000
третираат секоја позиција како моќта на 2.

49
00:02:52,000 --> 00:02:58,000
Тоа е една 1, едно 2, нула 4S, нула 8s, еден 16, и така натаму,

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

51
00:03:03,000 --> 00:03:05,000
можеме да видиме одговорот на тоа.

52
00:03:05,000 --> 00:03:09,000
>> Во суштина ние ќе карши право назад кон лево,

53
00:03:09,000 --> 00:03:14,000
и ние сме множење секоја цифра од соодветните моќта на 2.

54
00:03:14,000 --> 00:03:19,000
И запомнете, за хексадецимален ние означуваат овие броеви со 0x на почетокот

55
00:03:19,000 --> 00:03:23,000
па ние не го мешаме со децимален број.

56
00:03:23,000 --> 00:03:29,000
Продолжува, ова е ASCII табелата,

57
00:03:29,000 --> 00:03:35,000
и она што го користи ASCII за е да ги мапира од ликови на нумерички вредности.

58
00:03:35,000 --> 00:03:39,000
Запомни во pset криптографијата ние направивме широка употреба на ASCII табелата

59
00:03:39,000 --> 00:03:43,000
со цел да се користат разни методи на криптографијата,

60
00:03:43,000 --> 00:03:47,000
на Цезар и на шифра Vigenère, за претворање на различни букви

61
00:03:47,000 --> 00:03:52,000
во низа според клучните дадени од страна на корисникот.

62
00:03:52,000 --> 00:03:56,000
Да ги погледнеме малку на ASCII математика.

63
00:03:56,000 --> 00:04:02,000
Гледајќи "P" + 1, во знак форма што би била П,

64
00:04:02,000 --> 00:04:07,000
и се сеќавам дека '5 '≠ 5.

65
00:04:07,000 --> 00:04:10,000
И како точно би конвертирате помеѓу оние 2 форми?

66
00:04:10,000 --> 00:04:13,000
Тоа не е всушност премногу тешко.

67
00:04:13,000 --> 00:04:16,000
Со цел да се добие 5 ние одземе '0 '

68
00:04:16,000 --> 00:04:20,000
бидејќи постојат 5 места меѓу '0 'и 5.'

69
00:04:20,000 --> 00:04:23,000
Со цел да се оди на друг начин ние само додадете 0,

70
00:04:23,000 --> 00:04:25,000
па тоа е вид на како редовни аритметика.

71
00:04:25,000 --> 00:04:29,000
Само сети се дека кога нешто има наводници околу неа тоа е карактер

72
00:04:29,000 --> 00:04:37,000
и на тој начин одговара на вредноста во ASCII табелата.

73
00:04:37,000 --> 00:04:40,000
Движат во повеќе општи компјутерски науки теми.

74
00:04:40,000 --> 00:04:43,000
Ние научив што алгоритам е и како ние ги користиме програмирање

75
00:04:43,000 --> 00:04:45,000
да се имплементираат алгоритми.

76
00:04:45,000 --> 00:04:48,000
Некои примери на алгоритми се нешто навистина едноставно како

77
00:04:48,000 --> 00:04:51,000
проверка дали бројот е дури и или непарни.

78
00:04:51,000 --> 00:04:54,000
За таа сеќавам ние современи бројот со 2 и проверете дали резултатот е 0.

79
00:04:54,000 --> 00:04:57,000
Ако е така, тоа е дури. Ако не, тоа е чудно.

80
00:04:57,000 --> 00:04:59,000
И тоа е пример на еден навистина основни алгоритам.

81
00:04:59,000 --> 00:05:02,000
>> А малку повеќе вклучени еден е бинарна пребарување,

82
00:05:02,000 --> 00:05:05,000
кои ние ќе одиме во текот подоцна во текот на преглед на сесија.

83
00:05:05,000 --> 00:05:09,000
И програмирање е термин кој се користи за полагање на алгоритам

84
00:05:09,000 --> 00:05:15,000
и конвертирање на тоа да се кодот на компјутер може да се прочита.

85
00:05:15,000 --> 00:05:20,000
2 примери на програмирање е нула,

86
00:05:20,000 --> 00:05:22,000
што е она што ние го сторивме во недела 0.

87
00:05:22,000 --> 00:05:25,000
Иако ние не, всушност тип надвор на код, тоа е начинот на спроведување

88
00:05:25,000 --> 00:05:29,000
овој алгоритам, кој е печатење на броеви 1-10,

89
00:05:29,000 --> 00:05:32,000
и тука ние го стори истото во C програмскиот јазик.

90
00:05:32,000 --> 00:05:41,000
Овие се функционално еквивалентни, само напишани во различни јазици или синтакса.

91
00:05:41,000 --> 00:05:44,000
Ние тогаш дознал за рационален израз,

92
00:05:44,000 --> 00:05:48,000
и рационален е вредност тоа е точно или неточно,

93
00:05:48,000 --> 00:05:51,000
и тука често рационален израз

94
00:05:51,000 --> 00:05:55,000
оди во внатрешноста на услови, па ако (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
Па, ние веќе се воспоставени x = 5, така што состојбата се случува да се оцени на true.

96
00:06:00,000 --> 00:06:03,000
И ако тоа е вистина, без оглед кодот е под услов

97
00:06:03,000 --> 00:06:08,000
ќе треба да се оценува од страна на компјутерот, така што стринг ќе се печатат

98
00:06:08,000 --> 00:06:12,000
до стандарден излез, а терминот состојба

99
00:06:12,000 --> 00:06:16,000
се однесува на она што е внатре во заградите на ако изјава.

100
00:06:16,000 --> 00:06:20,000
Се сеќавам на сите оператори.

101
00:06:20,000 --> 00:06:26,000
Запомни тоа е && и | | кога ние се обидуваме да се комбинираат 2 или повеќе услови,

102
00:06:26,000 --> 00:06:30,000
== Не = да се провери дали 2 работи се еднакви.

103
00:06:30,000 --> 00:06:36,000
Запомнете дека = е за доделување додека == е рационален оператор.

104
00:06:36,000 --> 00:06:41,000
≤, ≥, а потоа конечниот 2 се очигледен.

105
00:06:41,000 --> 00:06:45,000
Општ преглед на Булова логика тука.

106
00:06:45,000 --> 00:06:48,000
И рационален израз се исто така важни во петелки,

107
00:06:48,000 --> 00:06:50,000
која ќе одиме над сега.

108
00:06:50,000 --> 00:06:56,000
Учевме за 3 видови на јамки досега во CS50, за, време, и не време.

109
00:06:56,000 --> 00:06:59,000
А тоа е важно да се знае дека додека за повеќето намени

110
00:06:59,000 --> 00:07:02,000
ние всушност може да се користи било кој тип на јамка обично

111
00:07:02,000 --> 00:07:06,000
постојат одредени видови на цели или заеднички обрасци

112
00:07:06,000 --> 00:07:09,000
во програмирање што конкретно се јавите за една од овие петелки

113
00:07:09,000 --> 00:07:13,000
кои го прават тоа на најефикасен или домот да го кодот на тој начин.

114
00:07:13,000 --> 00:07:18,000
Ајде да одиме над она што секој од овие петелки има тенденција да се користи за најчесто.

115
00:07:18,000 --> 00:07:21,000
>> Во за телефонска линија ние обично веќе знаете колку пати сакаме да iterate.

116
00:07:21,000 --> 00:07:24,000
Тоа е она што ние го стави во состојба.

117
00:07:24,000 --> 00:07:28,000
Зашто, i = 0, i <10, на пример.

118
00:07:28,000 --> 00:07:31,000
Ние веќе знаеме што сакаме да направиме нешто 10 пати.

119
00:07:31,000 --> 00:07:34,000
Сега, за време јамка, генерално не мора да значи

120
00:07:34,000 --> 00:07:36,000
знам колку пати сакаме јамка да се кандидира.

121
00:07:36,000 --> 00:07:39,000
Но ние знаеме некој вид на услов што сакаме да

122
00:07:39,000 --> 00:07:41,000
секогаш да биде вистина или секогаш се лажни.

123
00:07:41,000 --> 00:07:44,000
На пример, додека е поставена.

124
00:07:44,000 --> 00:07:46,000
Да речеме дека е Булова променлива.

125
00:07:46,000 --> 00:07:48,000
Иако тоа е вистина ние сакаме кодот да се оцени,

126
00:07:48,000 --> 00:07:52,000
па малку повеќе растеглива, малку поопшта од за телефонска линија,

127
00:07:52,000 --> 00:07:55,000
но секој за телефонска линија, исто така, може да се конвертира време јамка.

128
00:07:55,000 --> 00:08:00,000
Конечно, дали додека петелки, кој може да биде trickiest да се сфати веднаш,

129
00:08:00,000 --> 00:08:04,000
често се користи кога сакаме да се оцени код прво

130
00:08:04,000 --> 00:08:06,000
пред прв пат да се провери состојбата.

131
00:08:06,000 --> 00:08:09,000
Честа употреба случај за не додека јамка

132
00:08:09,000 --> 00:08:12,000
е кога сакате да добиете корисник влез, и знаете дека сакате да побара од корисникот

133
00:08:12,000 --> 00:08:15,000
за влез барем еднаш, но ако тие не ви даде добар влез веднаш

134
00:08:15,000 --> 00:08:18,000
сакате да го задржите барајќи од нив се додека тие ви даде добар влез.

135
00:08:18,000 --> 00:08:21,000
Тоа е најчестата употреба на не додека јамка,

136
00:08:21,000 --> 00:08:23,000
и нека се погледне на актуелната структура на овие петелки.

137
00:08:23,000 --> 00:08:27,000
Тие обично секогаш имаат тенденција да се следат овие модели.

138
00:08:27,000 --> 00:08:30,000
>> На for внатре имате 3 компоненти:

139
00:08:30,000 --> 00:08:35,000
иницијализација, обично нешто како int i = 0 каде што е контра,

140
00:08:35,000 --> 00:08:40,000
состојба, каде што сакаш да го кажеш извршите оваа за јамка се додека оваа состојба се 'уште има,

141
00:08:40,000 --> 00:08:44,000
како јас <10, а потоа конечно, ажурирање, кој е како ние прираст

142
00:08:44,000 --> 00:08:47,000
контра променлива на секоја точка во јамка.

143
00:08:47,000 --> 00:08:50,000
А заеднички нешто да се види дека постои само i + +,

144
00:08:50,000 --> 00:08:52,000
што значи зголемување јас од 1 секое време.

145
00:08:52,000 --> 00:08:55,000
Вие исто така може да се направи нешто како i + = 2,

146
00:08:55,000 --> 00:08:58,000
што значи додадете 2 до јас секој пат кога ќе одам низ јамката.

147
00:08:58,000 --> 00:09:03,000
А потоа го направите ова едноставно се однесува на било код кој всушност работи како дел од циклусот.

148
00:09:03,000 --> 00:09:09,000
И за време јамка, овој пат ние всушност имаат иницијализација надвор од јамка,

149
00:09:09,000 --> 00:09:12,000
Така на пример, да речеме ние се обидуваме да го стори истото вид на јамка што јас само што е опишано.

150
00:09:12,000 --> 00:09:16,000
Ние би рекол int i = 0 пред јамка почнува.

151
00:09:16,000 --> 00:09:20,000
Тогаш можеме да речеме додека јас <10 ​​направите ова,

152
00:09:20,000 --> 00:09:22,000
така што истиот блок од код како порано,

153
00:09:22,000 --> 00:09:26,000
и овој пат ажурирање дел од кодот, на пример, i + +,

154
00:09:26,000 --> 00:09:29,000
всушност оди во внатрешноста на јамка.

155
00:09:29,000 --> 00:09:33,000
И конечно, за направите додека, тоа е слично на време јамка,

156
00:09:33,000 --> 00:09:36,000
но ние треба да се запамети дека кодот ќе ги оценува еднаш

157
00:09:36,000 --> 00:09:40,000
пред состојба се проверува, па тоа го прави многу повеќе смисла

158
00:09:40,000 --> 00:09:44,000
ако се погледне во него, со цел на врвот до дното.

159
00:09:44,000 --> 00:09:49,000
Во направите додека јамка код евалуира дури и пред да се погледне на време состојба,

160
00:09:49,000 --> 00:09:55,000
а додека јамка, се проверува во прв план.

161
00:09:55,000 --> 00:09:59,000
Извештаи и променливи.

162
00:09:59,000 --> 00:10:04,000
Кога сакаме да се создаде нова променлива ние прво ќе сакате да го иницијализира.

163
00:10:04,000 --> 00:10:07,000
>> На пример, int бар иницијализира на променлива бар,

164
00:10:07,000 --> 00:10:10,000
но тоа не го даде вредност, па она што е вредност бар сега?

165
00:10:10,000 --> 00:10:12,000
Ние не знаеме.

166
00:10:12,000 --> 00:10:14,000
Тоа може да биде некои ѓубре вредност што беше претходно зачувани во меморијата таму,

167
00:10:14,000 --> 00:10:16,000
и ние не сакаме да ја користат таа променлива

168
00:10:16,000 --> 00:10:19,000
додека ние всушност го даде вредност,

169
00:10:19,000 --> 00:10:21,000
па ние го прогласи тука.

170
00:10:21,000 --> 00:10:24,000
Тогаш ние се иницијализира да биде 42 подолу.

171
00:10:24,000 --> 00:10:28,000
Сега, се разбира, ние знаеме дека тоа може да се направи една линија, int бар = 42.

172
00:10:28,000 --> 00:10:30,000
Но, само за да се расчисти повеќе чекори што се случуваат,

173
00:10:30,000 --> 00:10:34,000
декларација и иницијализација се случува одделно тука.

174
00:10:34,000 --> 00:10:38,000
Тоа се случува на еден чекор, а следниот, int baz = бар + 1,

175
00:10:38,000 --> 00:10:44,000
оваа изјава подолу, кои постепено baz, па на крајот на овој блок

176
00:10:44,000 --> 00:10:48,000
ако ние требаше да се печати вредноста на baz тоа ќе биде 44

177
00:10:48,000 --> 00:10:52,000
затоа што декларираат и се иницијализира да биде 1> бар,

178
00:10:52,000 --> 00:10:58,000
и тогаш тоа прираст уште еднаш со + +.

179
00:10:58,000 --> 00:11:02,000
Отидовме во текот на овој прилично кратко, но тоа е добро да имаш општо

180
00:11:02,000 --> 00:11:04,000
разбирање на она што се теми и настани.

181
00:11:04,000 --> 00:11:06,000
Ние, главно, го направи ова во нула,

182
00:11:06,000 --> 00:11:09,000
па можете да мислам на теми како повеќе секвенци на кодот

183
00:11:09,000 --> 00:11:11,000
работи во исто време.

184
00:11:11,000 --> 00:11:14,000
Во реалноста, тоа најверојатно не работи во исто време,

185
00:11:14,000 --> 00:11:17,000
но вид на апстрактно можеме да размислуваме за тоа на тој начин.

186
00:11:17,000 --> 00:11:20,000
>> Во почеток, на пример, имавме повеќе sprites.

187
00:11:20,000 --> 00:11:22,000
Тоа може да се извршување на различни кодот во исто време.

188
00:11:22,000 --> 00:11:26,000
Еден може да се шетаат додека другите кажува нешто

189
00:11:26,000 --> 00:11:29,000
во различен дел од екранот.

190
00:11:29,000 --> 00:11:34,000
Настани се уште еден начин на одделување на логиката

191
00:11:34,000 --> 00:11:37,000
помеѓу различните елементи на вашиот код,

192
00:11:37,000 --> 00:11:40,000
и гребење бевме во можност да симулираат настани употребувајќи го објавување,

193
00:11:40,000 --> 00:11:43,000
и тоа е всушност кога ќе примам, а не кога ќе чујам,

194
00:11:43,000 --> 00:11:47,000
но во суштина тоа е начин да пренесува информации

195
00:11:47,000 --> 00:11:49,000
од една фигура на друга.

196
00:11:49,000 --> 00:11:52,000
На пример, можеби ќе сакате да се пренесе од игра,

197
00:11:52,000 --> 00:11:56,000
и кога друг самовила добива повеќе од игра,

198
00:11:56,000 --> 00:11:58,000
тој одговара на одреден начин.

199
00:11:58,000 --> 00:12:03,000
Тоа е важен модел за да се разбере за програмирање.

200
00:12:03,000 --> 00:12:07,000
Само да одиме во текот на основните недела 0, она што го помина во текот досега,

201
00:12:07,000 --> 00:12:10,000
нека се погледне на овој едноставен Ц програма.

202
00:12:10,000 --> 00:12:14,000
Текстот може да биде малку мали од тука, но јас ќе одам над неа навистина брзо.

203
00:12:14,000 --> 00:12:20,000
Ние сме вклучувајќи 2 насловот датотеки на врвот, cs50.h и stdio.h.

204
00:12:20,000 --> 00:12:23,000
Ние потоа дефинирање на постојана наречена граница да биде 100.

205
00:12:23,000 --> 00:12:26,000
Ние потоа спроведувањето на нашата главна функција.

206
00:12:26,000 --> 00:12:29,000
Бидејќи ние не користите командната линија аргументи тука ние треба да се стави празнина

207
00:12:29,000 --> 00:12:32,000
како аргументите за главните.

208
00:12:32,000 --> 00:12:38,000
Гледаме int над главниот. Тоа е враќање тип, па оттука се врати 0 на дното.

209
00:12:38,000 --> 00:12:41,000
И ние сме со користење CS50 библиотека функција се int

210
00:12:41,000 --> 00:12:45,000
да побара од корисникот за влез, а ние се чува во овој променливата x,

211
00:12:45,000 --> 00:12:51,000
па ние прогласи x погоре, и ние да се иницијализира со x = GetInt.

212
00:12:51,000 --> 00:12:53,000
>> Ние тогаш провери да се види дали на корисникот ни даде добар влез.

213
00:12:53,000 --> 00:12:59,000
Ако тоа е ≥ ГРАНИЧНИТЕ ние сакаме да се врати грешка код на 1 и печати порака за грешка.

214
00:12:59,000 --> 00:13:02,000
И конечно, ако корисникот ни даде добар влез

215
00:13:02,000 --> 00:13:08,000
ние ќе плоштад бројот и печати од кои се резултат.

216
00:13:08,000 --> 00:13:11,000
Само за да бидете сигурни дека тие сите хит дома

217
00:13:11,000 --> 00:13:17,000
можете да видите на етикетите на различни делови на код овде.

218
00:13:17,000 --> 00:13:19,000
Јас спомнав константна, насловот датотеки.

219
00:13:19,000 --> 00:13:21,000
О, int x. Бидете сигурни да се запамети дека е локална променлива.

220
00:13:21,000 --> 00:13:24,000
Дека контрасти од една глобална променлива, што ние ќе зборуваме за

221
00:13:24,000 --> 00:13:27,000
малку подоцна во текот на преглед сесија,

222
00:13:27,000 --> 00:13:30,000
и ние се јавувате на библиотека функција printf,

223
00:13:30,000 --> 00:13:34,000
па ако ние не било вклучено stdio.h хедер датотека

224
00:13:34,000 --> 00:13:37,000
ние не ќе биде во можност да се јавите printf.

225
00:13:37,000 --> 00:13:42,000
И јас верувам дека на стрелката што доби отсечени тука е да се покажува кон% d,

226
00:13:42,000 --> 00:13:45,000
која е форматирање стринг во printf.

227
00:13:45,000 --> 00:13:52,000
Таа вели печати ја оваа променлива како број,% d.

228
00:13:52,000 --> 00:13:58,000
И тоа е за недела 0.

229
00:13:58,000 --> 00:14:06,000
Сега Лукас ќе продолжи.

230
00:14:06,000 --> 00:14:08,000
Еј, момци. Моето име е Лукас.

231
00:14:08,000 --> 00:14:10,000
Јас сум сафомор во најдобар куќа на кампусот, Mather,

232
00:14:10,000 --> 00:14:14,000
и јас одам да се зборува малку за недела 1 и 2,1.

233
00:14:14,000 --> 00:14:16,000
[Недела 1 и 2,1!] [Лукас Freitas]

234
00:14:16,000 --> 00:14:19,000
Како Lexi велеше, кога почнавме преведување на вашата кодот од нула до C

235
00:14:19,000 --> 00:14:23,000
една од работите што ги забележав е дека не можете да само

236
00:14:23,000 --> 00:14:26,000
напишете вашиот код и да ја стартувате со користење на зелено знаме веќе.

237
00:14:26,000 --> 00:14:30,000
Всушност, треба да користите некои чекори да направите вашиот C програма

238
00:14:30,000 --> 00:14:33,000
стане извршна датотека.

239
00:14:33,000 --> 00:14:36,000
Во суштина она што го правите кога сте пишување програма е тоа што

240
00:14:36,000 --> 00:14:40,000
Можете Преведете вашата идеја на јазик што го компајлерот може да се разбере,

241
00:14:40,000 --> 00:14:44,000
Значи, кога сте пишување програма во C

242
00:14:44,000 --> 00:14:47,000
она што го правиш е всушност пишување нешто што вашиот компајлерот ќе разбере,

243
00:14:47,000 --> 00:14:50,000
а потоа компајлерот ќе преведе овој код

244
00:14:50,000 --> 00:14:53,000
во нешто што вашиот компјутер ќе се разбере.

245
00:14:53,000 --> 00:14:55,000
>> И Работата е, вашиот компјутер е всушност многу глупава.

246
00:14:55,000 --> 00:14:57,000
Вашиот компјутер може да се разбере 0-ти и 1S,

247
00:14:57,000 --> 00:15:01,000
па, всушност, во првите компјутери луѓето обично програмирани

248
00:15:01,000 --> 00:15:04,000
користење на 0-ти и 1S, но не повеќе, благодарам на Бога.

249
00:15:04,000 --> 00:15:07,000
Ние не треба да се запаметат секвенци за 0-ти и 1S

250
00:15:07,000 --> 00:15:10,000
за за јамка или за некое време јамка и така натаму.

251
00:15:10,000 --> 00:15:13,000
Тоа е причината зошто имаме компајлерот.

252
00:15:13,000 --> 00:15:17,000
Што компајлерот не е основа преведува кодот Ц,

253
00:15:17,000 --> 00:15:21,000
во нашиот случај, на јазик што вашиот компјутер ќе се разбере,

254
00:15:21,000 --> 00:15:25,000
која е предмет код, и компајлерот дека ние сме користење

255
00:15:25,000 --> 00:15:30,000
се нарекува ѕвекот, така што ова е всушност симбол за ѕвекот.

256
00:15:30,000 --> 00:15:33,000
Кога имате програма, што треба да направите 2 работи.

257
00:15:33,000 --> 00:15:37,000
Прво, морате да ги собере својата програма, а потоа ви се случува да се кандидира на вашиот програма.

258
00:15:37,000 --> 00:15:41,000
Да ги собере вашата програма имаш многу опции за да го стори тоа.

259
00:15:41,000 --> 00:15:44,000
Првиот е да се направи ѕвекот оваа апликација

260
00:15:44,000 --> 00:15:47,000
во која програма е името на вашата програма.

261
00:15:47,000 --> 00:15:51,000
Во овој случај можете да видите тие се само велејќи: "Еј, состави мојата програма."

262
00:15:51,000 --> 00:15:56,000
Вие не сте велејќи: "Сакам ова име за мојата програма" или ништо.

263
00:15:56,000 --> 00:15:58,000
>> Втората опција е давање на име за вашата програма.

264
00:15:58,000 --> 00:16:02,000
Може да се каже ѕвекот-о а потоа името што сакате

265
00:16:02,000 --> 00:16:06,000
извршна датотека да се именува како и тогаш оваа апликација.

266
00:16:06,000 --> 00:16:11,000
И исто така можете да прават програма, и да видиме како во првите 2 случаи

267
00:16:11,000 --> 00:16:15,000
Ставив. В, а во третата, ми останува само програми?

268
00:16:15,000 --> 00:16:18,000
Да, вие всушност не треба да се стави. В кога користите направи.

269
00:16:18,000 --> 00:16:22,000
Инаку компајлерот е, всушност, ќе се развикам.

270
00:16:22,000 --> 00:16:24,000
И, исто така, јас не знам дали вие момци се сеќавам,

271
00:16:24,000 --> 00:16:29,000
но многу пати ние исто така се користи-lcs50 или-филмот.

272
00:16:29,000 --> 00:16:31,000
Тоа се нарекува поврзува.

273
00:16:31,000 --> 00:16:35,000
Тоа само кажува на компајлерот дека ќе го искористите овие библиотеки право таму,

274
00:16:35,000 --> 00:16:39,000
па ако сакате да го користите cs50.h вие всушност треба да напишете

275
00:16:39,000 --> 00:16:43,000
ѕвекот оваа апликација-lcs50.

276
00:16:43,000 --> 00:16:45,000
Ако не го сторат тоа, компајлерот нема да знаете

277
00:16:45,000 --> 00:16:50,000
дека сте користење на овие функции во cs50.h.

278
00:16:50,000 --> 00:16:52,000
И кога ќе сакате да се кандидира на вашиот програма ќе имаат 2 опции.

279
00:16:52,000 --> 00:16:57,000
Ако не ѕвекот оваа апликација ќе не даде името на вашата програма.

280
00:16:57,000 --> 00:17:01,000
Мора да го стартувате користење. / A.out.

281
00:17:01,000 --> 00:17:06,000
A.out е стандард име кое ѕвекот дава вашата програма, ако не го даде името.

282
00:17:06,000 --> 00:17:11,000
Инаку си оди за да се направи. / Програмата, ако даде името на вашата програма,

283
00:17:11,000 --> 00:17:15,000
а исто така и ако не се направи програма за името дека програмата се случува да се

284
00:17:15,000 --> 00:17:23,000
веќе се случува да биде програмиран со истото име како датотека c.

285
00:17:23,000 --> 00:17:26,000
Тогаш ние разговаравме за типови на податоци и податоци.

286
00:17:26,000 --> 00:17:31,000
>> Во суштина типови на податоци се иста работа како што е малку кутии кои ги користат

287
00:17:31,000 --> 00:17:35,000
за чување на вредности, па типови на податоци се всушност само како Pokémons.

288
00:17:35,000 --> 00:17:39,000
Тие доаѓаат во сите големини и видови.

289
00:17:39,000 --> 00:17:43,000
Јас не знам дали тоа аналогија прави смисла.

290
00:17:43,000 --> 00:17:46,000
Големината на податоците, всушност, зависи од машина архитектура.

291
00:17:46,000 --> 00:17:49,000
Сите податоци големини што јас ќе одам да покаже тука

292
00:17:49,000 --> 00:17:53,000
се всушност за 32-битна машина, што е случај и на нашата апаратот,

293
00:17:53,000 --> 00:17:56,000
но ако се всушност кодирање вашиот Mac или во Windows, исто така,

294
00:17:56,000 --> 00:17:59,000
веројатно сте ќе имаат 64-битна машина,

295
00:17:59,000 --> 00:18:03,000
па не заборавајте дека податоците големини кои јас ќе одам да покаже тука

296
00:18:03,000 --> 00:18:06,000
се за 32-битна машина.

297
00:18:06,000 --> 00:18:08,000
Првиот што го видовме беше int,

298
00:18:08,000 --> 00:18:10,000
што е прилично јасна.

299
00:18:10,000 --> 00:18:13,000
Можете да го користите int да ја запази цел број.

300
00:18:13,000 --> 00:18:16,000
Ние, исто така, видов карактер, знак.

301
00:18:16,000 --> 00:18:20,000
Ако сакате да го користите писмо или малку симбол ти си веројатно се случува да се користи знак.

302
00:18:20,000 --> 00:18:26,000
А знак има 1 бајт, што значи 8 бита, како Lexi рече.

303
00:18:26,000 --> 00:18:31,000
Во суштина ние имаме ASCII табелата дека има 256

304
00:18:31,000 --> 00:18:34,000
можни комбинации на 0-ти и 1S,

305
00:18:34,000 --> 00:18:37,000
а потоа, кога ќе напишете знак дека ќе се преведе

306
00:18:37,000 --> 00:18:44,000
ликот кој влезови сте број кој го имате во ASCII табелата, како Lexi рече.

307
00:18:44,000 --> 00:18:48,000
Ние исто така имаат плови, кои ние ги користиме за чување на децимални броеви.

308
00:18:48,000 --> 00:18:53,000
Ако сакате да изберете 3,14, на пример, сте ќе треба да се користи плови

309
00:18:53,000 --> 00:18:55,000
или двојно дека има поголема точност.

310
00:18:55,000 --> 00:18:57,000
А плови има 4 бајти.

311
00:18:57,000 --> 00:19:01,000
Двоен има 8 бајти, па само разликата е прецизност.

312
00:19:01,000 --> 00:19:04,000
Ние, исто така имаат долг кој се користи за цели броеви,

313
00:19:04,000 --> 00:19:09,000
и можете да видите за 32-битна машина на int и долго имаат иста големина,

314
00:19:09,000 --> 00:19:13,000
па тоа не е никаква смисла да се користи долго во 32-битна машина.

315
00:19:13,000 --> 00:19:17,000
>> Но, ако сте со користење на Mac и 64-битна машина, всушност долго има големина 8,

316
00:19:17,000 --> 00:19:19,000
па тоа навистина зависи од архитектура.

317
00:19:19,000 --> 00:19:22,000
За 32-битна машина не дава никаква смисла да се користи долго навистина.

318
00:19:22,000 --> 00:19:25,000
И потоа долго долго, од друга страна, има 8 бајти,

319
00:19:25,000 --> 00:19:30,000
па затоа е многу добар, ако сакате да имате подолг број.

320
00:19:30,000 --> 00:19:34,000
И, конечно, имаме низа, што е, всушност, char *,

321
00:19:34,000 --> 00:19:37,000
што е покажувач кон char.

322
00:19:37,000 --> 00:19:40,000
Тоа е многу лесно да се мисли дека големината на низата ќе биде како

323
00:19:40,000 --> 00:19:42,000
бројот на карактери кои имате таму,

324
00:19:42,000 --> 00:19:45,000
но всушност char * себе

325
00:19:45,000 --> 00:19:49,000
има големина од покажувач кон char, што е 4 бајти.

326
00:19:49,000 --> 00:19:52,000
Големина на char * е 4 бајти.

327
00:19:52,000 --> 00:19:56,000
Тоа не е важно дали имате мал збор или буква или ништо.

328
00:19:56,000 --> 00:19:58,000
Тоа ќе биде 4 бајти.

329
00:19:58,000 --> 00:20:01,000
Ние исто така, научив малку за леење,

330
00:20:01,000 --> 00:20:04,000
Па како што можете да видите, ако имате, на пример, програма со која вели

331
00:20:04,000 --> 00:20:08,000
int x = 3, а потоа printf ("% d", x / 2)

332
00:20:08,000 --> 00:20:12,000
ви момци знаат што се случува да се печати на екран?

333
00:20:12,000 --> 00:20:14,000
>> Некој? >> [Студентите] 2.

334
00:20:14,000 --> 00:20:16,000
1. >> 1, да.

335
00:20:16,000 --> 00:20:20,000
Кога ќе го направите 3/2 тоа се случува да се добие 1.5,

336
00:20:20,000 --> 00:20:24,000
но бидејќи ние сме со користење на целобројна тоа се случува да се игнорира децимална дел,

337
00:20:24,000 --> 00:20:26,000
и ви се случува да имаат 1.

338
00:20:26,000 --> 00:20:29,000
Ако не сакате тоа да се случи што можете да направите, на пример,

339
00:20:29,000 --> 00:20:33,000
се прогласи плови y = x.

340
00:20:33,000 --> 00:20:40,000
Тогаш х кои се користат да биде 3 е сега ќе биде 3.000 во y.

341
00:20:40,000 --> 00:20:44,000
А потоа можете да печатите на y / 2.

342
00:20:44,000 --> 00:20:50,000
Всушност, јас треба да имаат 2. таму.

343
00:20:50,000 --> 00:20:55,000
Тоа се случува да се направи 3.00/2.00,

344
00:20:55,000 --> 00:20:58,000
и си оди за да се добие 1.5.

345
00:20:58,000 --> 00:21:06,000
И ние имаме овој 0,2 ѓ само да прашам за 2 децимална единици во децималниот дел.

346
00:21:06,000 --> 00:21:12,000
Ако имате 0,3 ѓ тоа се случува да имаат всушност 1,500.

347
00:21:12,000 --> 00:21:16,000
Ако е 2 тоа се случува да биде 1.50.

348
00:21:16,000 --> 00:21:18,000
Ние, исто така, имаат овој случај.

349
00:21:18,000 --> 00:21:22,000
Ако го направите плови x = 3,14, а потоа можете printf x

350
00:21:22,000 --> 00:21:24,000
сте ќе добие 3,14.

351
00:21:24,000 --> 00:21:29,000
И ако не x = ИНТ на x,

352
00:21:29,000 --> 00:21:34,000
што значи третираат x како int и ќе се печати x сега

353
00:21:34,000 --> 00:21:36,000
ви се случува да имаат 3,00.

354
00:21:36,000 --> 00:21:38,000
Дали тоа има смисла?

355
00:21:38,000 --> 00:21:41,000
Затоа што ти си прв лекување x како цел број, па ти си го игнорира децимална дел,

356
00:21:41,000 --> 00:21:45,000
а потоа сте печатење х.

357
00:21:45,000 --> 00:21:47,000
И, конечно, исто така можете да го направите ова,

358
00:21:47,000 --> 00:21:52,000
int x = 65, а потоа ќе се изјасни за знак c = x,

359
00:21:52,000 --> 00:21:56,000
а потоа доколку ги отпечатите в сте всушност ќе добие

360
00:21:56,000 --> 00:21:59,000
А, значи, во основа она што го правиш тука

361
00:21:59,000 --> 00:22:02,000
е преведување на цел број во лик,

362
00:22:02,000 --> 00:22:05,000
како само ASCII табелата прави.

363
00:22:05,000 --> 00:22:08,000
Ние, исто така зборуваше за математика оператори.

364
00:22:08,000 --> 00:22:14,000
Повеќето од нив се прилично јасна, така +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
а исто така и ние разговаравме за современи, што е остатокот од поделба на 2 броја.

366
00:22:20,000 --> 00:22:23,000
Ако имате 10% 3, на пример,

367
00:22:23,000 --> 00:22:27,000
тоа значи подели 10 од 3, а што е остатокот?

368
00:22:27,000 --> 00:22:30,000
Тоа ќе биде 1, па тоа е всушност многу корисно за многу од програмите.

369
00:22:30,000 --> 00:22:38,000
За Vigenère и Цезар Јас сум прилично сигурен дека сите од вас момци користи МО.

370
00:22:38,000 --> 00:22:43,000
За математика оператори, да бидат многу внимателни при комбинирањето * и /.

371
00:22:43,000 --> 00:22:48,000
>> На пример, ако се направи (3/2) * 2 она што ви се случува да се добие?

372
00:22:48,000 --> 00:22:50,000
[Студентите] 2.

373
00:22:50,000 --> 00:22:54,000
Да, затоа што 3/2, 2 ќе биде 1,5,

374
00:22:54,000 --> 00:22:57,000
но бидејќи правиш операции помеѓу 2 броеви

375
00:22:57,000 --> 00:22:59,000
ти си, всушност само ќе се разгледа 1,

376
00:22:59,000 --> 00:23:03,000
а потоа 1 * 2 ќе биде 2, па да биде многу, многу внимателно

377
00:23:03,000 --> 00:23:07,000
кога го прави аритметички со цели броеви, бидејќи

378
00:23:07,000 --> 00:23:12,000
можете да добиете дека 2 = 3, во тој случај.

379
00:23:12,000 --> 00:23:14,000
И исто така да бидат многу внимателни за предност.

380
00:23:14,000 --> 00:23:21,000
Обично треба користете загради за да бидете сигурни дека знаете што правите.

381
00:23:21,000 --> 00:23:27,000
Некои корисни кратенки, се разбира, е i + + или i + = 1

382
00:23:27,000 --> 00:23:30,000
или со користење + =.

383
00:23:30,000 --> 00:23:34,000
Тоа е истото што го прават i = i + 1.

384
00:23:34,000 --> 00:23:39,000
Можете исто така да го направам - или I - = 1,

385
00:23:39,000 --> 00:23:42,000
која е истото како i = i -1,

386
00:23:42,000 --> 00:23:46,000
нешто што момци користат многу во за петелки, барем.

387
00:23:46,000 --> 00:23:52,000
Исто така, за * ако користите * = а ако не, на пример,

388
00:23:52,000 --> 00:23:57,000
i * = 2 е истото како вели i = i * 2,

389
00:23:57,000 --> 00:23:59,000
и истото за поделба.

390
00:23:59,000 --> 00:24:08,000
Ако го направите I / = 2 тоа е истото како i = i / 2.

391
00:24:08,000 --> 00:24:10,000
>> Сега за функции.

392
00:24:10,000 --> 00:24:13,000
Вие момци дозна дека функции се многу добра стратегија да се спаси код

393
00:24:13,000 --> 00:24:16,000
додека си програмирање, па ако сакате да се изврши истата задача

394
00:24:16,000 --> 00:24:20,000
во кодот повторно и повторно, веројатно ќе сакате да користите функција

395
00:24:20,000 --> 00:24:25,000
само така да не мора да копирате и залепите кодот одново и одново.

396
00:24:25,000 --> 00:24:28,000
Всушност, главната е во функција, а кога ќе ви покаже формат на функција

397
00:24:28,000 --> 00:24:32,000
сте ќе видите дека тоа е многу очигледно.

398
00:24:32,000 --> 00:24:35,000
Ние исто така користиме функции од некои библиотеки,

399
00:24:35,000 --> 00:24:39,000
на пример, printf, GetIn, кој е од библиотеката CS50,

400
00:24:39,000 --> 00:24:43,000
и други функции, како toupper.

401
00:24:43,000 --> 00:24:46,000
Сите тие функции се всушност спроведени во други библиотеки,

402
00:24:46,000 --> 00:24:49,000
и кога ќе се стави оние јаже датотеки во почетокот на вашата програма

403
00:24:49,000 --> 00:24:53,000
ти си велејќи дека може да ми даде код за тие функции

404
00:24:53,000 --> 00:24:57,000
па јас не треба да ги имплементираат од мене?

405
00:24:57,000 --> 00:25:00,000
И исто така можете да напишете своја сопствена функции, па кога ќе почнете програмирање

406
00:25:00,000 --> 00:25:04,000
ќе сфатите дека библиотеки немаат сите функции кои ви се потребни.

407
00:25:04,000 --> 00:25:10,000
За последните pset, на пример, ние напиша подготви, трка, и побара,

408
00:25:10,000 --> 00:25:13,000
и тоа е многу, многу важно да се биде во можност да пишувам функции

409
00:25:13,000 --> 00:25:17,000
бидејќи тие се корисни, а ние ги користите во секое време во програмирање,

410
00:25:17,000 --> 00:25:19,000
и тоа заштедува многу код.

411
00:25:19,000 --> 00:25:21,000
Форматот на функција е оваа.

412
00:25:21,000 --> 00:25:24,000
Имаме враќање тип на почетокот. Што е враќање тип?

413
00:25:24,000 --> 00:25:27,000
Тоа е само кога функцијата ќе се врати.

414
00:25:27,000 --> 00:25:29,000
Ако имате некоја функција, на пример, факториел,

415
00:25:29,000 --> 00:25:31,000
што се случува да се пресмета факториел од цел број,

416
00:25:31,000 --> 00:25:34,000
веројатно дека ќе се врати цел број, исто така.

417
00:25:34,000 --> 00:25:37,000
Тогаш враќање тип ќе биде int.

418
00:25:37,000 --> 00:25:41,000
Printf всушност има враќање тип празнина

419
00:25:41,000 --> 00:25:43,000
затоа што не си се враќа ништо.

420
00:25:43,000 --> 00:25:45,000
Сте само печатење работи на екран

421
00:25:45,000 --> 00:25:48,000
и напуштање на функцијата потоа.

422
00:25:48,000 --> 00:25:51,000
Тогаш го имате име на функција што можете да одберете.

423
00:25:51,000 --> 00:25:55,000
Треба да бидете малку разумен, како не избере име како xyz

424
00:25:55,000 --> 00:25:58,000
или како x2f.

425
00:25:58,000 --> 00:26:02,000
Обидете се да се направи до името што има смисла.

426
00:26:02,000 --> 00:26:04,000
>> На пример, ако тоа е факториел, велат факториел.

427
00:26:04,000 --> 00:26:08,000
Ако тоа е функција што се случува да нацрта нешто, името го нацрта.

428
00:26:08,000 --> 00:26:11,000
И тогаш имаме параметри, кои се викаат исто така аргументи,

429
00:26:11,000 --> 00:26:14,000
кои се како средства кои вашата функција треба

430
00:26:14,000 --> 00:26:17,000
од кодот да се изврши својата задача.

431
00:26:17,000 --> 00:26:20,000
Ако сакате да се пресмета факториел од голем број

432
00:26:20,000 --> 00:26:23,000
веројатно ќе треба да имаат голем број да се пресмета факториел.

433
00:26:23,000 --> 00:26:27,000
Еден од аргументите што ви се случува да имаат е бројот себе.

434
00:26:27,000 --> 00:26:31,000
А потоа тоа се случува да се направи нешто и да се врати вредноста на крајот

435
00:26:31,000 --> 00:26:35,000
освен ако тоа е празнина функција.

436
00:26:35,000 --> 00:26:37,000
Ајде да видиме еден пример.

437
00:26:37,000 --> 00:26:40,000
Ако сакам да пишувам функција која ги сумира сите броеви во низа на цели броеви,

438
00:26:40,000 --> 00:26:43,000
Прво на сите, на враќање тип ќе биде int

439
00:26:43,000 --> 00:26:46,000
бидејќи имам низа од цели броеви.

440
00:26:46,000 --> 00:26:51,000
И тогаш ќе одам да имаат функција име како sumArray,

441
00:26:51,000 --> 00:26:54,000
а потоа тоа се случува да се земе низа себе, да int nums,

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

443
00:26:58,000 --> 00:27:02,000
Потоа морам да се иницијализира со променлива наречена сума, на пример, на 0,

444
00:27:02,000 --> 00:27:08,000
и секој пат кога ќе видите елемент во низата јас треба да го додадете во неа, толку направив за телефонска линија.

445
00:27:08,000 --> 00:27:15,000
Исто како Lexi рече, ќе се направи int i = 0, I <должина и i + +.

446
00:27:15,000 --> 00:27:20,000
И за секој елемент во низата што го направив сума + = nums [i],

447
00:27:20,000 --> 00:27:24,000
а потоа се вратив сумата, па тоа е многу едноставна, и тоа заштедува многу код

448
00:27:24,000 --> 00:27:28,000
ако сте со користење на оваа функција многу пати.

449
00:27:28,000 --> 00:27:32,000
Тогаш ние се погледне во услови.

450
00:27:32,000 --> 00:27:38,000
Имаме ако, друго, и друго, ако.

451
00:27:38,000 --> 00:27:42,000
Ајде да видиме што е разликата меѓу нив.

452
00:27:42,000 --> 00:27:45,000
Фрлите поглед на овие 2 кодови. Која е разликата меѓу нив?

453
00:27:45,000 --> 00:27:49,000
Првиот е-основа кодови сакате да кажете

454
00:27:49,000 --> 00:27:51,000
Ако бројот е +, -, или 0.

455
00:27:51,000 --> 00:27:55,000
Првиот вели дека ако тоа е> 0, тогаш тоа е позитивно.

456
00:27:55,000 --> 00:28:00,000
Ако тоа е = на 0, тогаш тоа е 0, и ако е <0, тогаш тоа е негативно.

457
00:28:00,000 --> 00:28:04,000
>> А другиот е тоа ако друго ако, на друго место.

458
00:28:04,000 --> 00:28:07,000
Разликата меѓу двете е дека и оваа всушност се случува да

459
00:28:07,000 --> 00:28:13,000
проверете дали> 0, <0 или = 0 три пати,

460
00:28:13,000 --> 00:28:17,000
па ако имаш број 2, на пример, тоа се случува да дојде тука и да кажам

461
00:28:17,000 --> 00:28:21,000
ако (x> 0), и тоа се случува да се каже да, па јас печати позитивни.

462
00:28:21,000 --> 00:28:25,000
Но, иако знам дека тоа е> 0 и тоа нема да биде 0 или <0

463
00:28:25,000 --> 00:28:29,000
Јас сум уште се случува да се направи тоа е 0, тоа е <0,

464
00:28:29,000 --> 00:28:33,000
па јас сум всушност се случува во внатрешноста на IFS дека не треба да

465
00:28:33,000 --> 00:28:38,000
бидејќи јас веќе знам дека тоа нема да се задоволи некој од овие услови.

466
00:28:38,000 --> 00:28:41,000
Може ли да користам ако друго ако, друго изјава.

467
00:28:41,000 --> 00:28:45,000
Тоа во основа вели дека ако x = 0 Се печати позитивни.

468
00:28:45,000 --> 00:28:48,000
Ако не е, јас одам да се, исто така се тестираат ова.

469
00:28:48,000 --> 00:28:51,000
Ако е 2 не одам да го направите тоа.

470
00:28:51,000 --> 00:28:54,000
Во суштина, ако имав x = 2 ќе речеш

471
00:28:54,000 --> 00:28:57,000
ако (x> 0), да, па печати ја оваа.

472
00:28:57,000 --> 00:29:00,000
Сега дека јас знам дека тоа е> 0 и дека тоа задоволни првиот ако

473
00:29:00,000 --> 00:29:02,000
Јас не сум дури и ќе ја извршите оваа код.

474
00:29:02,000 --> 00:29:09,000
Кодот тече побрзо, всушност, 3 пати побрзо, ако се користи ова.

475
00:29:09,000 --> 00:29:11,000
Ние, исто така дознав и и или.

476
00:29:11,000 --> 00:29:15,000
Јас не одам да одат преку овој, бидејќи Lexi веќе разговаравме за нив.

477
00:29:15,000 --> 00:29:17,000
Тоа е само && и | | оператор.

478
00:29:17,000 --> 00:29:21,000
>> Единствено нешто што јас ќе го кажам е да се биде внимателен кога имате 3 услови.

479
00:29:21,000 --> 00:29:24,000
Користете загради, бидејќи тоа е многу збунувачки кога имате состојба

480
00:29:24,000 --> 00:29:27,000
и уште еден или друг.

481
00:29:27,000 --> 00:29:30,000
Користете загради само за да бидете сигурни дека вашата услови смисла

482
00:29:30,000 --> 00:29:34,000
бидејќи во тој случај, на пример, може да се замисли дека

483
00:29:34,000 --> 00:29:38,000
тоа би можело да биде првиот услов и еден или на друг

484
00:29:38,000 --> 00:29:41,000
или 2 условите комбинираат во една и

485
00:29:41,000 --> 00:29:45,000
или третиот, па само да се биде внимателен.

486
00:29:45,000 --> 00:29:48,000
И, конечно, ние разговаравме за прекинувачи.

487
00:29:48,000 --> 00:29:53,000
Прекинувачот е многу корисно кога имате променлива.

488
00:29:53,000 --> 00:29:55,000
Да речеме дека имате променлива како n

489
00:29:55,000 --> 00:29:59,000
кој може да биде 0, 1 или 2, и за секој од овие случаи

490
00:29:59,000 --> 00:30:01,000
сте ќе треба да се изврши една задача.

491
00:30:01,000 --> 00:30:04,000
Може да се каже вклучите променлива, и тоа покажува дека

492
00:30:04,000 --> 00:30:08,000
вредноста тогаш е како value1 Одам да го направите ова,

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

494
00:30:12,000 --> 00:30:15,000
бидејќи ние веќе убеден дека случајот

495
00:30:15,000 --> 00:30:20,000
а потоа value2 и така натаму, и јас исто така може да има стандардно прекинувач.

496
00:30:20,000 --> 00:30:24,000
Тоа значи дека ако тоа не ги задоволи сите случаи кои ги имав

497
00:30:24,000 --> 00:30:29,000
што јас ќе одам да се направи нешто друго, но тоа е опционално.

498
00:30:29,000 --> 00:30:36,000
Тоа е се за мене. Сега ајде да имаат Томи.

499
00:30:36,000 --> 00:30:41,000
Добро, ова ќе биде Недела 3-носталгичната.

500
00:30:41,000 --> 00:30:45,000
Ова се некои од темите што ќе се покриваат, крипто, обемот, низи, итн.

501
00:30:45,000 --> 00:30:49,000
Само брз збор за криптирање. Ние нема да ги нападне овој дом.

502
00:30:49,000 --> 00:30:52,000
>> Ние го сторивме тоа во pset 2, но за квиз бидете сигурни дека знаете разликата

503
00:30:52,000 --> 00:30:54,000
меѓу Цезар шифра и шифра Vigenère,

504
00:30:54,000 --> 00:30:57,000
како и на оние шифри работа и она што тоа е како да го криптирате

505
00:30:57,000 --> 00:30:59,000
и декриптирање на текст со користење на овие 2 шифри.

506
00:30:59,000 --> 00:31:03,000
Запомнете, Цезар шифра едноставно ротира секој карактер од страна на истиот износ,

507
00:31:03,000 --> 00:31:06,000
правење сигурни дека МО со бројот на букви во азбуката.

508
00:31:06,000 --> 00:31:09,000
И шифра Vigenère, од друга страна, пак, ротира секој карактер

509
00:31:09,000 --> 00:31:12,000
со различен износ, па наместо велејќи

510
00:31:12,000 --> 00:31:15,000
секој лик ротира од 3 Vigenère ќе ротираат секој карактер

511
00:31:15,000 --> 00:31:17,000
од различен износ во зависност од некои клучни зборови

512
00:31:17,000 --> 00:31:20,000
каде секоја буква во збор претставува некои различен износ

513
00:31:20,000 --> 00:31:26,000
за да ја ротирате јасен текст од.

514
00:31:26,000 --> 00:31:28,000
Ајде прво да зборуваме за променлива обем.

515
00:31:28,000 --> 00:31:30,000
Постојат 2 различни видови на променливи.

516
00:31:30,000 --> 00:31:33,000
Имаме локални променливи, и овие се случува да се дефинира

517
00:31:33,000 --> 00:31:36,000
надвор од главниот или надвор било функција или блок,

518
00:31:36,000 --> 00:31:39,000
и овие ќе бидат достапни насекаде во вашата програма.

519
00:31:39,000 --> 00:31:41,000
Ако имате функција и во таа функција е време јамка

520
00:31:41,000 --> 00:31:44,000
големата глобална променлива е достапна насекаде.

521
00:31:44,000 --> 00:31:48,000
А локална променлива, од друга страна, е scoped до местото каде што се дефинирани.

522
00:31:48,000 --> 00:31:53,000
>> Ако имате функцијата тука, на пример, имаме оваа функција g,

523
00:31:53,000 --> 00:31:56,000
и во внатрешноста на г постои променлива тука наречен y,

524
00:31:56,000 --> 00:31:58,000
а тоа значи дека тоа е локална променлива.

525
00:31:58,000 --> 00:32:00,000
Иако оваа променлива се нарекува y

526
00:32:00,000 --> 00:32:03,000
и оваа променлива се нарекува y овие 2 функции

527
00:32:03,000 --> 00:32:06,000
немаат поим што меѓусебно локални променливи се.

528
00:32:06,000 --> 00:32:10,000
Од друга страна, се тука и велиме int x = 5,

529
00:32:10,000 --> 00:32:12,000
и ова е надвор од опсегот на било која функција.

530
00:32:12,000 --> 00:32:16,000
Тоа е надвор од опсегот на главните, така што ова е глобална променлива.

531
00:32:16,000 --> 00:32:20,000
Тоа значи дека во внатрешноста на овие 2 функции кога велам х - или x + +

532
00:32:20,000 --> 00:32:26,000
Јас сум пристапува на ист x при овој y и оваа y се различни променливи.

533
00:32:26,000 --> 00:32:30,000
Тоа е разликата помеѓу глобалната променлива и локална променлива.

534
00:32:30,000 --> 00:32:33,000
Што се однесува до дизајнот е во прашање, понекогаш тоа е веројатно подобра идеја

535
00:32:33,000 --> 00:32:37,000
да се задржи променливи локални кога веројатно може

536
00:32:37,000 --> 00:32:39,000
бидејќи има еден куп на глобални променливи може да се добијат навистина збунувачки.

537
00:32:39,000 --> 00:32:42,000
Ако имате еден куп функции сите менување на истото

538
00:32:42,000 --> 00:32:45,000
можеби ќе заборавам што ако оваа функција случајно модифицира оваа глобална,

539
00:32:45,000 --> 00:32:47,000
и оваа друга функција не знае за тоа,

540
00:32:47,000 --> 00:32:50,000
и тоа не добие прилично збунувачки, како можете да добиете повеќе код.

541
00:32:50,000 --> 00:32:53,000
Чување променливи локални кога веројатно може

542
00:32:53,000 --> 00:32:56,000
е само добар дизајн.

543
00:32:56,000 --> 00:33:00,000
Низи, се сеќавам, се едноставно листи на елементи од ист тип.

544
00:33:00,000 --> 00:33:04,000
Внатрешноста на Ки не можат да имаат листа како 1, 2.0, здраво.

545
00:33:04,000 --> 00:33:06,000
Ние едноставно не може да го направи тоа.

546
00:33:06,000 --> 00:33:11,000
>> Кога ќе прогласи низа во C сите елементи мора да бидат од ист тип.

547
00:33:11,000 --> 00:33:14,000
Еве ги имаат низа на 3 цели броеви.

548
00:33:14,000 --> 00:33:18,000
Тука имам должината на низата, но ако јас сум само тоа прогласување во оваа синтакса

549
00:33:18,000 --> 00:33:21,000
каде што прецизира колкав сите елементи се не технички треба оваа 3.

550
00:33:21,000 --> 00:33:25,000
Компајлерот е доволно паметни да дознаам колку е голема низа треба да биде.

551
00:33:25,000 --> 00:33:28,000
Сега кога сакам да се добие или да поставите вредноста на низа

552
00:33:28,000 --> 00:33:30,000
ова е синтакса да го направите тоа.

553
00:33:30,000 --> 00:33:33,000
Ова всушност ќе се измени вториот елемент на низата, бидејќи, се сеќавам,

554
00:33:33,000 --> 00:33:36,000
Нумерирањето започнува од 0, а не на 1.

555
00:33:36,000 --> 00:33:42,000
Ако сакате да ја прочитате таа вредност можам да кажам нешто како int x = array [1].

556
00:33:42,000 --> 00:33:44,000
Или ако сакам да ја постави таа вредност, како што јас го правам овде,

557
00:33:44,000 --> 00:33:47,000
Можам да кажам низа [1] = 4.

558
00:33:47,000 --> 00:33:50,000
Тоа време пристап до елементите од нивниот индекс

559
00:33:50,000 --> 00:33:52,000
или нивната позиција или каде што тие се во низа,

560
00:33:52,000 --> 00:33:57,000
и дека листата започнува од 0.

561
00:33:57,000 --> 00:34:00,000
Ние, исто така може да имаат низи на низи,

562
00:34:00,000 --> 00:34:03,000
и ова се нарекува мулти-димензионална низа.

563
00:34:03,000 --> 00:34:05,000
Кога имаме мулти-димензионална низа

564
00:34:05,000 --> 00:34:07,000
тоа значи дека можеме да имаме нешто како редови и колони,

565
00:34:07,000 --> 00:34:11,000
и ова е само еден начин на визуелизација на овој или размислување за тоа.

566
00:34:11,000 --> 00:34:14,000
Кога имам мулти-димензионална низа што значи јас ќе одам да почнат потреба

567
00:34:14,000 --> 00:34:17,000
повеќе од 1 индекс, бидејќи ако имам мрежа

568
00:34:17,000 --> 00:34:19,000
само велејќи дека она што ред сте во не ни дава број.

569
00:34:19,000 --> 00:34:22,000
Тоа е навистина само ќе ни даде листа на броеви.

570
00:34:22,000 --> 00:34:25,000
Да речеме дека имам оваа низа тука.

571
00:34:25,000 --> 00:34:30,000
Имам низа наречен мрежа, и сакам да кажам дека тоа е 2 редови и 3 колони,

572
00:34:30,000 --> 00:34:32,000
и така ова е еден начин на визуелизација на тоа.

573
00:34:32,000 --> 00:34:37,000
Кога велам дека сакате да го добиете елемент на [1] [2]

574
00:34:37,000 --> 00:34:41,000
тоа значи дека, бидејќи тие се редови, а потоа колони

575
00:34:41,000 --> 00:34:44,000
Одам да скокне до Row 1 од реков 1.

576
00:34:44,000 --> 00:34:49,000
>> Потоа јас ќе одам да дојди до колона 2, а јас одам да се добие вредност 6.

577
00:34:49,000 --> 00:34:51,000
Смисла?

578
00:34:51,000 --> 00:34:55,000
Мулти-димензионални низи, се сеќавам, се технички само низа од низи.

579
00:34:55,000 --> 00:34:57,000
Ние може да има низи од низи од низи.

580
00:34:57,000 --> 00:35:00,000
Ние можеме да Продолжувам да одам, но навистина еден начин да се размислува за

581
00:35:00,000 --> 00:35:03,000
како тоа се поставени и што се случува е да се визуелизира

582
00:35:03,000 --> 00:35:09,000
во мрежа се допаѓа ова.

583
00:35:09,000 --> 00:35:12,000
Кога ќе помине низа на функции, тие се случува да се однесуваме

584
00:35:12,000 --> 00:35:16,000
малку поинаку отколку кога се поминува редовно променливи функции

585
00:35:16,000 --> 00:35:18,000
како поминува еден int или плови.

586
00:35:18,000 --> 00:35:21,000
Кога ќе помине во int или знак или било кој од овие други типови на податоци

587
00:35:21,000 --> 00:35:24,000
ние едноставно се погледне ако функцијата модифицира

588
00:35:24,000 --> 00:35:28,000
вредноста на таа променлива таа промена нема да се пропагира до

589
00:35:28,000 --> 00:35:32,000
на повик функција.

590
00:35:32,000 --> 00:35:35,000
Со низа, од друга страна, тоа ќе се случи.

591
00:35:35,000 --> 00:35:39,000
Ако поминувам во низа за некоја функција и таа функција го менува некои од елементите,

592
00:35:39,000 --> 00:35:43,000
кога ќе се вратам до функцијата што ја нарече

593
00:35:43,000 --> 00:35:47,000
мојата низа е сега се случува да се биде различен, и речник за тоа

594
00:35:47,000 --> 00:35:50,000
е низи се пренесуваат по референца, како што ќе видиме подоцна.

595
00:35:50,000 --> 00:35:53,000
Ова е поврзано со тоа како покажувачи работа, каде што овие основни типови на податоци,

596
00:35:53,000 --> 00:35:55,000
од друга страна, се пренесуваат од вредност.

597
00:35:55,000 --> 00:35:59,000
>> Можеме да размислуваме за тоа што се прави копија на некои променлива, а потоа поминува во копија.

598
00:35:59,000 --> 00:36:01,000
Не е важно она што го правиме со таа променлива.

599
00:36:01,000 --> 00:36:06,000
Повикувајќи функција не ќе бидат свесни дека тоа беше сменето.

600
00:36:06,000 --> 00:36:10,000
Низите се само малку различни во тој поглед.

601
00:36:10,000 --> 00:36:13,000
На пример, како што само виде, главниот е само функција

602
00:36:13,000 --> 00:36:15,000
што може да се земе во 2 аргументи.

603
00:36:15,000 --> 00:36:20,000
Првиот аргумент на главната функција е argc, или бројот на аргументи,

604
00:36:20,000 --> 00:36:23,000
и вториот аргумент е наречен argv,

605
00:36:23,000 --> 00:36:27,000
и оние кои се вистинските вредности на тие аргументи.

606
00:36:27,000 --> 00:36:30,000
Да речеме дека имам програма наречена this.c,

607
00:36:30,000 --> 00:36:34,000
и велам направи ова, и јас одам да ја извршите оваа во командната линија.

608
00:36:34,000 --> 00:36:38,000
Сега да помине во некои аргументи на мојот програма наречена ова,

609
00:36:38,000 --> 00:36:42,000
Јас може да се каже нешто како. / Ова е cs 50.

610
00:36:42,000 --> 00:36:45,000
Тоа е она што ние замислуваме Дејвид да се направи секој ден во терминал.

611
00:36:45,000 --> 00:36:48,000
Но сега главната функција во внатрешноста на таа програма

612
00:36:48,000 --> 00:36:52,000
има овие вредности, па argc е 4.

613
00:36:52,000 --> 00:36:56,000
Тоа може да биде малку збунувачки, бидејќи навистина ние сме само поминува во е cs 50.

614
00:36:56,000 --> 00:36:58,000
Тоа е само 3.

615
00:36:58,000 --> 00:37:02,000
Но, се сеќавам дека првиот елемент на argv или првиот аргумент

616
00:37:02,000 --> 00:37:05,000
е името на самата функција.

617
00:37:05,000 --> 00:37:07,190
Тоа значи дека имаме 4 работи тука,

618
00:37:07,190 --> 00:37:10,530
и првиот елемент е и ќе биде. / ова.

619
00:37:10,530 --> 00:37:12,970
И ова ќе биде претставен како стринг.

620
00:37:12,970 --> 00:37:18,590
Тогаш останатите елементи се она што ние ја внеле во по името на програмата.

621
00:37:18,590 --> 00:37:22,720
Па само како настрана, како што веројатно гледаат во pset 2,

622
00:37:22,720 --> 00:37:28,780
се сеќавам дека стрингот 50 се ≠ на број 50.

623
00:37:28,780 --> 00:37:32,520
Значи не можеме да кажеме нешто како, "int x = argv 3. '

624
00:37:32,520 --> 00:37:36,470
>> Тоа не е само случува да се направи смисла на зборот, бидејќи ова е стринг, а тоа е цел број.

625
00:37:36,470 --> 00:37:38,510
Значи, ако сакате да го конвертирате помеѓу 2, се сеќавам, ние ќе

626
00:37:38,510 --> 00:37:40,810
имаат оваа магија функција наречена atoi.

627
00:37:40,810 --> 00:37:46,270
Кој ги зема низа и се враќа на целобројна претставен внатрешноста на стрингот.

628
00:37:46,270 --> 00:37:48,360
Па тоа е лесен грешка да се направи на квизот,

629
00:37:48,360 --> 00:37:51,590
само размислување дека ова автоматски ќе биде точниот тип.

630
00:37:51,590 --> 00:37:53,860
Но, само знам дека тие секогаш ќе бидат жици

631
00:37:53,860 --> 00:38:00,920
дури и ако стрингот содржи само цел број или знак или со подвижна запирка.

632
00:38:00,920 --> 00:38:03,380
Па сега ајде да зборуваме за трчање време.

633
00:38:03,380 --> 00:38:06,700
Кога имаме сите овие алгоритми кои го прават сите овие луди работи,

634
00:38:06,700 --> 00:38:11,580
станува навистина корисно да се постави прашањето "Колку долго тие ќе потрае?"

635
00:38:11,580 --> 00:38:15,500
Ние сме тоа со нешто што се нарекува асимптотска нотација.

636
00:38:15,500 --> 00:38:18,430
Па тоа значи дека - добро, ајде да речеме дека ние им дадеме на нашите алгоритам

637
00:38:18,430 --> 00:38:20,840
некои навистина, навистина, навистина голема влез.

638
00:38:20,840 --> 00:38:23,840
Ние сакаме да го поставуваме прашањето: "Колку долго тоа ќе трае?

639
00:38:23,840 --> 00:38:26,370
Колку чекори што ќе ги преземе нашата алгоритам да се кандидира

640
00:38:26,370 --> 00:38:29,980
како функција на големината на влез? "

641
00:38:29,980 --> 00:38:33,080
Така, првиот начин можеме да ја опишеме кандидира време е со голема О

642
00:38:33,080 --> 00:38:35,380
И тоа е нашата најлошото трчање време.

643
00:38:35,380 --> 00:38:38,590
Значи, ако сакаме да го решите низа, а ние им дадеме на нашите алгоритам низа

644
00:38:38,590 --> 00:38:41,000
тоа е во обратен редослед кога тоа треба да биде во растечки редослед,

645
00:38:41,000 --> 00:38:43,130
тоа ќе биде најлошото.

646
00:38:43,130 --> 00:38:49,800
Ова е нашиот горна граница во должина на време нашите алгоритам ќе ги преземе.

647
00:38:49,800 --> 00:38:54,740
Од друга страна, ова Ω се случува да се опише најдобар случај трчање време.

648
00:38:54,740 --> 00:38:58,210
Значи, ако ние им даде на веќе сортирана низа на сортирање алгоритам,

649
00:38:58,210 --> 00:39:00,940
колку долго ќе потрае да го средиме?

650
00:39:00,940 --> 00:39:06,610
И ова, тогаш, ја опишува пониска врзани за трчање време.

651
00:39:06,610 --> 00:39:10,980
Значи тука се само некои зборови кои опишуваат некои вообичаени работи пати.

652
00:39:10,980 --> 00:39:13,120
Овие се во растечки редослед.

653
00:39:13,120 --> 00:39:16,060
Најбрз трчање време имаме се нарекува постојано.

654
00:39:16,060 --> 00:39:19,800
>> Тоа значи дека без разлика колку многу елементи ние им дадеме на нашите алгоритам,

655
00:39:19,800 --> 00:39:22,280
без разлика колку големи нашата низа е, сортирање го ова

656
00:39:22,280 --> 00:39:26,510
или прави она што го правиме на низа секогаш ќе го заземат истиот износ на време.

657
00:39:26,510 --> 00:39:30,270
Значи можеме да претставуваат дека само со 1, која е константа.

658
00:39:30,270 --> 00:39:32,410
Ние, исто така, погледна логаритамска кандидира време.

659
00:39:32,410 --> 00:39:34,800
Значи нешто како бинарна пребарување е логаритамска,

660
00:39:34,800 --> 00:39:37,140
каде што се намали проблемот на половина во секое време

661
00:39:37,140 --> 00:39:40,970
а потоа работи едноставно се добие повисока од таму.

662
00:39:40,970 --> 00:39:43,580
И ако сте некогаш пишување О на било факториел алгоритам,

663
00:39:43,580 --> 00:39:47,850
најверојатно не треба да се разгледа ова како вашиот ден работа.

664
00:39:47,850 --> 00:39:53,910
Кога ќе се споредат трчање пати е важно да се има предвид овие работи.

665
00:39:53,910 --> 00:39:57,760
Значи, ако имам алгоритам што е О (n), и некој друг

666
00:39:57,760 --> 00:40:03,590
има алгоритам на О (2n) овие се всушност асимптоматично еквивалентни.

667
00:40:03,590 --> 00:40:06,590
Значи, ако ние замислуваме n да биде голем број како eleventy милијарди:

668
00:40:06,590 --> 00:40:13,090
па кога ние сме во споредба eleventy милијарди нешто како eleventy милијарди + 3,

669
00:40:13,090 --> 00:40:17,640
одеднаш кои 3 навистина не направи голема разлика повеќе.

670
00:40:17,640 --> 00:40:20,980
Тоа е причината зошто ние се случува да се размислува за овие работи кои треба да бидат еднакви.

671
00:40:20,980 --> 00:40:24,220
Па работи како овие константи тука, има 2 x ова, или додавање на 3,

672
00:40:24,220 --> 00:40:27,180
овие се само константи, и овие се случува да падне до.

673
00:40:27,180 --> 00:40:32,480
Значи тоа е зошто сите 3 од овие работи пати се исти како и велејќи дека тие се O (N).

674
00:40:32,480 --> 00:40:37,490
Слично на тоа, ако имаме 2 други работи времиња, да речеме О (n ³ + 2n ²), можеме да додадете

675
00:40:37,490 --> 00:40:42,070
+ N, + 7, а потоа имаме уште кандидира време тоа е само О (n ³).

676
00:40:42,070 --> 00:40:46,290
повторно, овие се иста работа, бидејќи тие - тие не се исти.

677
00:40:46,290 --> 00:40:49,840
Тоа се истите работи, жалам. Значи овие се исти, бидејќи

678
00:40:49,840 --> 00:40:53,090
овој ³ n се случува да доминира оваа 2n ².

679
00:40:53,090 --> 00:40:59,130
>> Што не е иста работа е ако сме се кандидира времиња како О (n ³) и О (n ²)

680
00:40:59,130 --> 00:41:02,820
бидејќи овој ³ n е многу поголем од овој ² n.

681
00:41:02,820 --> 00:41:05,470
Значи, ако имаме експоненти, одеднаш ова започнува да е важно,

682
00:41:05,470 --> 00:41:08,280
но кога ние сме само се занимаваат со фактори како што се до тука,

683
00:41:08,280 --> 00:41:12,810
тогаш тоа нема да е важно, бидејќи тие се само ќе падне надвор.

684
00:41:12,810 --> 00:41:16,760
Ајде да ги разгледаме во некои од алгоритми видовме досега

685
00:41:16,760 --> 00:41:19,260
и зборуваат за нивните кандидира време.

686
00:41:19,260 --> 00:41:23,850
Првиот начин да барате број во список, што сме го виделе, беше линеарно пребарување.

687
00:41:23,850 --> 00:41:26,950
И спроведувањето на линеарно пребарување е супер лесно.

688
00:41:26,950 --> 00:41:30,490
Ние само имаат листа, и ние ќе треба да се погледне во секој елемент од листата

689
00:41:30,490 --> 00:41:34,260
додека не се најде бројот што го барате.

690
00:41:34,260 --> 00:41:38,370
Тоа значи дека во најлош случај, ова О (n).

691
00:41:38,370 --> 00:41:40,860
И најлош случај тука може да биде ако елементот е

692
00:41:40,860 --> 00:41:45,710
последниот елемент, а потоа со помош линеарно пребарување ние треба да се погледне во секој елемент

693
00:41:45,710 --> 00:41:50,180
додека не стигнете до последниот, со цел да знаат дека тоа всушност бил во листата.

694
00:41:50,180 --> 00:41:52,910
Ние не само да се откажат од половина пат и велат: "Тоа не е веројатно таму."

695
00:41:52,910 --> 00:41:55,980
Со линеарно пребарување ние треба да погледнеме во целата работа.

696
00:41:55,980 --> 00:41:59,090
Најдобар случај трчање време, од друга страна, е постојан

697
00:41:59,090 --> 00:42:04,200
затоа што во најдобар случај елементот што го барате е само првиот во листата.

698
00:42:04,200 --> 00:42:08,930
Па затоа се случува да ни потрае точно 1 чекор, без разлика колку големи листата е

699
00:42:08,930 --> 00:42:12,140
ако ние сме во потрага по првиот елемент во секое време.

700
00:42:12,140 --> 00:42:15,390
>> Па кога ќе пребарување, се сеќавам, тоа не се бара дека нашата листа се подредени.

701
00:42:15,390 --> 00:42:19,430
Затоа што ние сме едноставно ќе се погледне во текот секој елемент, а тоа не е важно

702
00:42:19,430 --> 00:42:23,560
она што цел тие елементи се внатре

703
00:42:23,560 --> 00:42:28,110
А поинтелигентен пребарување алгоритам е нешто како бинарна пребарување.

704
00:42:28,110 --> 00:42:31,500
Запомнете, спроведувањето на бинарни пребарување е кога ќе одиш да

705
00:42:31,500 --> 00:42:34,320
ги бараме во средината на листата.

706
00:42:34,320 --> 00:42:38,000
И бидејќи ние сме во потрага по среден, бараме дека листата е сортирана

707
00:42:38,000 --> 00:42:40,580
или на друго место не знаеме каде средината е, и ние треба да се погледне во текот

708
00:42:40,580 --> 00:42:44,480
целата листа за да го најдете, а потоа во тој момент ние сме само губат време.

709
00:42:44,480 --> 00:42:48,480
Значи, ако имаме подредени листа и ќе најдеме на средина, ние ќе се споредуваат средината

710
00:42:48,480 --> 00:42:51,590
на елементот што го барате.

711
00:42:51,590 --> 00:42:54,640
Ако тоа е премногу висока, тогаш можеме да заборавиме на десната половина

712
00:42:54,640 --> 00:42:57,810
затоа што знаеме дека ако нашите елемент е веќе премногу висока

713
00:42:57,810 --> 00:43:01,080
и сè да се право на овој елемент е дури и повисок,

714
00:43:01,080 --> 00:43:02,760
тогаш ние не треба да се погледне таму веќе.

715
00:43:02,760 --> 00:43:05,430
Каде што од друга страна, ако нашата елемент е премногу ниска,

716
00:43:05,430 --> 00:43:08,700
знаеме што е лево од тој елемент е исто така премногу ниска,

717
00:43:08,700 --> 00:43:11,390
па тоа не е никаква смисла да се погледне таму, или.

718
00:43:11,390 --> 00:43:15,760
На овој начин, со секој чекор и секој пат кога ќе погледнеме во средина на листата,

719
00:43:15,760 --> 00:43:19,060
ние ќе ги намали нашиот проблем на половина бидејќи одеднаш знаеме

720
00:43:19,060 --> 00:43:23,040
еден куп на броеви кои не може да биде оној што го барате.

721
00:43:23,040 --> 00:43:26,950
>> Во pseudocode тоа ќе изгледа нешто како ова,

722
00:43:26,950 --> 00:43:30,990
и затоа што се сечење на листата на половина секој пат,

723
00:43:30,990 --> 00:43:34,920
нашата најлошото кандидира време скокови од линеарни да логаритамска.

724
00:43:34,920 --> 00:43:39,260
Па одеднаш имаме влезете во чекори со цел да се најде на елемент во листата.

725
00:43:39,260 --> 00:43:42,460
Најдобар случај трчање време, сепак, се уште е постојана

726
00:43:42,460 --> 00:43:45,180
затоа што сега, ајде да речеме дека елементот што го барате е

727
00:43:45,180 --> 00:43:48,380
секогаш точно средината на оригиналната листа.

728
00:43:48,380 --> 00:43:52,080
Значи можеме да расте нашата листа толку големи како што сакаме, но ако елементот што го барате е на средината,

729
00:43:52,080 --> 00:43:54,910
тогаш тоа е само ќе не однесе 1 чекор.

730
00:43:54,910 --> 00:44:00,920
Значи тоа е причината зошто ние сме О (log n) и Ω (1) или константа.

731
00:44:00,920 --> 00:44:04,510
Да, всушност се кандидира бинарни пребарување на овој список.

732
00:44:04,510 --> 00:44:08,020
Па да речеме дека ние сме во потрага за елементот 164.

733
00:44:08,020 --> 00:44:11,650
Првото нешто што ние се случува да направите е да најдете средина на оваа листа.

734
00:44:11,650 --> 00:44:15,060
Тоа само така се случува, дека средината се случува да падне помеѓу овие 2 броја,

735
00:44:15,060 --> 00:44:18,960
па ајде само произволно се каже, секој пат средина паѓа помеѓу 2 броја,

736
00:44:18,960 --> 00:44:21,150
ајде да се заокружи.

737
00:44:21,150 --> 00:44:24,330
Ние само треба да бидете сигурни дека ќе го направите ова секој чекор од патот.

738
00:44:24,330 --> 00:44:29,040
Па ние ќе се заокружи и ние ќе кажеме дека 161 е средината на нашата листа.

739
00:44:29,040 --> 00:44:34,640
Значи 161 <164, и секој елемент на лево од 161

740
00:44:34,640 --> 00:44:39,120
е <164, па ние знаеме дека тоа нема да ни помогне на сите

741
00:44:39,120 --> 00:44:42,690
да се започне овде, бидејќи елементот што го барате не може да биде таму.

742
00:44:42,690 --> 00:44:47,060
Значи она што можеме да направиме е ние само може да заборави за што целата левата половина на листата,

743
00:44:47,060 --> 00:44:51,700
а сега само се разгледа од десно на 161 па натаму.

744
00:44:51,700 --> 00:44:54,050
>> Значи, повторно, ова е средина; ајде да се заокружи.

745
00:44:54,050 --> 00:44:56,260
Сега 175 е премногу голема.

746
00:44:56,260 --> 00:44:59,180
Па знаеме дека нема да ни помогне да барате тука или тука,

747
00:44:59,180 --> 00:45:06,610
па ние само може да се фрли што подалеку, и на крајот ќе ја погоди 164.

748
00:45:06,610 --> 00:45:10,560
Било какви прашања во бинарна пребарување?

749
00:45:10,560 --> 00:45:14,180
Ајде да се движи на од пребарувањето преку веќе сортирана листа

750
00:45:14,180 --> 00:45:17,660
да се всушност земање на листата на броеви во било која цел

751
00:45:17,660 --> 00:45:20,960
и правење на таа листа во растечки редослед.

752
00:45:20,960 --> 00:45:24,060
Првиот алгоритам ние погледна беше наречен меур вид.

753
00:45:24,060 --> 00:45:27,300
И ова ќе биде поедноставно од алгоритми видовме.

754
00:45:27,300 --> 00:45:32,970
Меур вид вели дека кога било 2 елементи во внатрешноста на листата се од место,

755
00:45:32,970 --> 00:45:36,500
значи постои поголем број од лево на помал број,

756
00:45:36,500 --> 00:45:40,190
тогаш ние ќе ги трампа, затоа што тоа значи дека на листата ќе биде

757
00:45:40,190 --> 00:45:42,860
"Повеќе сортирани" отколку што беше порано.

758
00:45:42,860 --> 00:45:45,180
И ние сме само ќе продолжи овој процес повторно и повторно и повторно

759
00:45:45,180 --> 00:45:52,100
до крајот на елементи вид на балон на нивната точна локација и ние имаме подредени листа.

760
00:45:52,100 --> 00:45:57,230
>> На кандидира време на овој ќе биде О (n ²). Зошто?

761
00:45:57,230 --> 00:46:00,370
Па, затоа што во најлош случај, ние ќе треба да се земе секој елемент, и

762
00:46:00,370 --> 00:46:04,570
ние ќе се заокружи споредувајќи го со секој друг елемент во листата.

763
00:46:04,570 --> 00:46:08,030
Но, во најдобар случај, имаме веќе сортирана листа, меур вид на

764
00:46:08,030 --> 00:46:12,230
само ќе поминат низ еднаш, да каже "Не бе. Јас не направи свопови, па јас сум се направи."

765
00:46:12,230 --> 00:46:17,410
Па ние имаме најдобар случај трчање време на Ω (л).

766
00:46:17,410 --> 00:46:20,680
Ајде да се кандидира меур вид на листа.

767
00:46:20,680 --> 00:46:23,560
Или прво, ајде да погледнеме некои pseudocode навистина брзо.

768
00:46:23,560 --> 00:46:28,160
Сакаме да кажеме дека сме сакате да ги пратите, во секој повторување на јамка,

769
00:46:28,160 --> 00:46:32,190
ги пратите на тоа дали сме или не сме промениле елементи.

770
00:46:32,190 --> 00:46:37,610
Значи причината за тоа е, ние ќе запре кога не сме заменети било какви елементи.

771
00:46:37,610 --> 00:46:41,980
Значи на почетокот на нашата телефонска линија не сме сменил ништо, па ние ќе се каже дека е лажна.

772
00:46:41,980 --> 00:46:47,170
Сега, ние ќе треба да поминат низ листата и споредете елемент јас да елемент i + 1

773
00:46:47,170 --> 00:46:50,310
и ако тоа е случај дека постои поголем број од лево на помал број,

774
00:46:50,310 --> 00:46:52,310
тогаш ние само ќе ги трампа.

775
00:46:52,310 --> 00:46:54,490
>> А потоа ние ќе да се запамети дека ние заменети елемент.

776
00:46:54,490 --> 00:46:58,900
Тоа значи дека ние треба да одиме низ листата најмалку 1 повеќе време

777
00:46:58,900 --> 00:47:02,160
бидејќи состојбата во која што застанавме е кога целата листа е веќе сортирани,

778
00:47:02,160 --> 00:47:04,890
што значи ние не дадоа никакви свопови.

779
00:47:04,890 --> 00:47:09,960
Значи тоа е зошто нашата состојба овде е 'додека некои елементи биле заменети. "

780
00:47:09,960 --> 00:47:13,720
Па сега ајде да се погледне на овој работи на листата.

781
00:47:13,720 --> 00:47:16,640
Имам листа 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
Меур вид се случува да започне целиот пат на левата страна, а тоа се случува да се споредат

783
00:47:19,850 --> 00:47:24,700
на i елементи, така 0 до i + 1, кој е елемент 1.

784
00:47:24,700 --> 00:47:29,020
Тоа се случува да се каже, и 5> 0, но токму сега 5 е на лево,

785
00:47:29,020 --> 00:47:32,500
па затоа треба да се разменуваат со 5 и 0.

786
00:47:32,500 --> 00:47:35,470
Кога ќе ги разменуваат, одеднаш се добие оваа поинаква листа.

787
00:47:35,470 --> 00:47:38,260
Сега 5> 1, па ние ќе ги трампа.

788
00:47:38,260 --> 00:47:42,160
5 не е> 6, така што не треба да правите ништо тука.

789
00:47:42,160 --> 00:47:46,690
Но, 6> 4, па ние треба да се разменуваат.

790
00:47:46,690 --> 00:47:49,740
Повторно, ние треба да ја извршите преку целата листа за да на крајот откријат

791
00:47:49,740 --> 00:47:52,330
дека тие се на ред, ние ги трампа,

792
00:47:52,330 --> 00:47:57,120
и во овој момент ние треба да ја извршите преку листа 1 повеќе време

793
00:47:57,120 --> 00:48:05,390
да бидете сигурни дека сè е во ред, и во овој момент меур вид заврши.

794
00:48:05,390 --> 00:48:10,720
А различни алгоритам за преземање на некои елементи и сортирање нив е селекција вид.

795
00:48:10,720 --> 00:48:15,740
Идејата зад селекција вид е дека ние ќе се изгради подредени дел од листата

796
00:48:15,740 --> 00:48:18,150
1 елемент во исто време.

797
00:48:18,150 --> 00:48:23,170
>> И начинот на кој ние се случува да се направи тоа е преку градење на левата сегмент на листата.

798
00:48:23,170 --> 00:48:27,510
И во основа, секој - за секој чекор, ние ќе преземе најмалиот елемент имаме лево

799
00:48:27,510 --> 00:48:32,310
што не е сортирана сепак, и ние ќе се движи во таа подредени сегмент.

800
00:48:32,310 --> 00:48:35,850
Тоа значи дека треба постојано да се најдат на минимум несортиран елемент

801
00:48:35,850 --> 00:48:40,720
а потоа се земе дека минимум елемент и разменуваат со што

802
00:48:40,720 --> 00:48:45,090
лево повеќето елемент кој не е сортирана.

803
00:48:45,090 --> 00:48:50,890
Периодот за време на овој ќе биде О (n ²) затоа што во најлош случај

804
00:48:50,890 --> 00:48:55,070
ние треба да се споредуваат секој елемент на секој друг елемент.

805
00:48:55,070 --> 00:48:59,250
Затоа што ние сме велејќи дека ако почнеме од левата половина на листата, ние треба

806
00:48:59,250 --> 00:49:02,970
да поминат низ целиот право сегмент да се најде најмалиот елемент.

807
00:49:02,970 --> 00:49:05,430
А потоа, повторно, ние треба да одиме во текот на целиот право сегмент и

808
00:49:05,430 --> 00:49:08,210
Продолжувам да одам во текот на овој одново и одново и одново.

809
00:49:08,210 --> 00:49:11,350
Тоа ќе биде n ². Ние ќе треба за телефонска линија во внатрешноста на друга за телефонска линија

810
00:49:11,350 --> 00:49:13,350
што укажува n ².

811
00:49:13,350 --> 00:49:16,530
Во најдобар случај мисла, да речеме ние го даде веќе сортирана листа;

812
00:49:16,530 --> 00:49:19,270
ние всушност не го сторат било подобро отколку n ².

813
00:49:19,270 --> 00:49:21,730
Бидејќи изборот вид нема начин на знаејќи дека

814
00:49:21,730 --> 00:49:25,540
минималните елемент е само еден јас се случи да се гледа.

815
00:49:25,540 --> 00:49:28,970
Таа се уште треба да бидете сигурни дека ова е всушност минимум.

816
00:49:28,970 --> 00:49:31,670
>> И единствениот начин да бидете сигурни дека тоа е на минимум, со користење на овој алгоритам,

817
00:49:31,670 --> 00:49:34,640
е да се погледне во секој елемент повторно.

818
00:49:34,640 --> 00:49:38,420
Значи, навистина, ако ви даде тоа - ако ви даде избор вид веќе сортирана листа,

819
00:49:38,420 --> 00:49:42,720
тоа не се случува да се направи било подобро отколку што му дава листа која не е сортирана уште.

820
00:49:42,720 --> 00:49:46,320
Патем, ако тоа се случува да биде случај дека нешто не е О (нешто)

821
00:49:46,320 --> 00:49:50,640
и омега на нешто, ние само може да се каже повеќе посочно дека тоа е θ на нешто.

822
00:49:50,640 --> 00:49:52,760
Значи, ако видите дека излезе насекаде, тоа е она што само значи.

823
00:49:52,760 --> 00:49:57,580
>> Ако нешто не е во тета од n ², тоа е и голема О (n ²) и Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
Значи најдобар случај и најлош случај, тоа не се направи разлика,

825
00:49:59,790 --> 00:50:04,400
алгоритам се случува да го прават истото во секое време.

826
00:50:04,400 --> 00:50:06,610
Значи тоа е она што pseudocode за избор вид може да изгледа вака.

827
00:50:06,610 --> 00:50:10,630
Ние сме во основа ќе каже дека сакам да iterate во текот на листа

828
00:50:10,630 --> 00:50:15,180
од лево кон десно, и на секој повторување на јамка, јас одам да се движат

829
00:50:15,180 --> 00:50:19,780
минималните елемент во оваа решат дел од листата.

830
00:50:19,780 --> 00:50:23,260
И јас еднаш се движи нешто таму, јас никогаш не треба да се погледне во тоа елемент повторно.

831
00:50:23,260 --> 00:50:28,600
Бидејќи штом ќе разменуваат елемент во левиот дел од листата, тоа е сортирана

832
00:50:28,600 --> 00:50:32,600
бидејќи ние сме прави се што е во растечки редослед со користење минимални.

833
00:50:32,600 --> 00:50:38,740
Значи рековме, во ред, ние сме во позиција I, и ние треба да се погледне во сите елементи

834
00:50:38,740 --> 00:50:42,260
на правото на i со цел да се најде на минимум.

835
00:50:42,260 --> 00:50:46,150
Па тоа значи дека ние сакаме да се погледне од i + 1 на крајот на листата.

836
00:50:46,150 --> 00:50:51,610
И сега, ако елемент што ние сме во моментов во потрага по е помалку од нашата минимална досега,

837
00:50:51,610 --> 00:50:54,190
кои, се сеќавам, ние сме отпочнување на минимум надвор да биде само

838
00:50:54,190 --> 00:50:57,020
она елемент ние сме во моментов во, јас ќе се претпостави дека е на минимум.

839
00:50:57,020 --> 00:51:00,270
Ако најдам елемент кој е помал од тоа, тогаш јас ќе одам да се каже, во ред,

840
00:51:00,270 --> 00:51:02,700
добро, сум ги нашол нов минимум.

841
00:51:02,700 --> 00:51:06,080
Одам да се сетам каде што најмалку беше.

842
00:51:06,080 --> 00:51:09,560
>> Па сега, еднаш сум поминала низ тоа право несортиран сегмент,

843
00:51:09,560 --> 00:51:16,690
Можам да кажам јас одам да се разменуваат со минимум елемент со елемент, кој е во позиција i.

844
00:51:16,690 --> 00:51:21,100
Тоа се случува да се изгради мојата листа, мојата подредени дел од листата од лево кон десно,

845
00:51:21,100 --> 00:51:25,190
и ние никогаш не треба да се погледне во елемент уште еднаш, откако таа е во тој дел.

846
00:51:25,190 --> 00:51:27,930
Откако ние сме го сменил.

847
00:51:27,930 --> 00:51:30,260
Значи, да се кандидира за избор вид на оваа листа.

848
00:51:30,260 --> 00:51:38,220
Сино елемент тука се случува да биде јас, и црвено елемент ќе биде минимум елемент.

849
00:51:38,220 --> 00:51:41,570
Па јас започнува по целиот пат од лево од листата, па на 5.

850
00:51:41,570 --> 00:51:44,610
Сега ние треба да се најде на минимум несортиран елемент.

851
00:51:44,610 --> 00:51:49,480
Па велиме 0 <5, па 0 е мојот нов минимум.

852
00:51:49,480 --> 00:51:53,820
>> Но не можам да престане да постои, бидејќи иако може да се препознае дека 0 е најмал,

853
00:51:53,820 --> 00:51:59,390
ние треба да поминува низ секој друг елемент од листата за да бидете сигурни.

854
00:51:59,390 --> 00:52:01,760
Значи 1 е поголем, 6 е поголема, 4 е поголем.

855
00:52:01,760 --> 00:52:05,850
Тоа значи дека по гледањето на сите овие елементи, јас сум определен 0 е најмал.

856
00:52:05,850 --> 00:52:09,800
Па ќе одам да се разменуваат со 5 и 0.

857
00:52:09,800 --> 00:52:15,480
Еднаш се разменуваат тоа, јас ќе одам да добиете нова листа, и знам дека никогаш не треба да се погледне во тоа 0 повторно

858
00:52:15,480 --> 00:52:19,380
затоа што еднаш сум го сменил, сум го решат и ние ќе завршиш.

859
00:52:19,380 --> 00:52:22,730
Сега тоа само така се случува, дека син елемент е повторно на 5,

860
00:52:22,730 --> 00:52:26,030
и ние треба да се погледне на 1, 6 и 4 за да се утврди дека 1

861
00:52:26,030 --> 00:52:31,520
е најмалиот минимум елемент, па ние ќе трампа 1 и 5.

862
00:52:31,520 --> 00:52:36,890
Повторно, ние треба да погледнеме во - споредат 5 до 6 и 4,

863
00:52:36,890 --> 00:52:39,830
и ние ќе трампа на 4 и 5, и, конечно, да ги споредиме

864
00:52:39,830 --> 00:52:45,740
оние 2 броја и swap нив се додека ние го добиваме нашиот подредени листа.

865
00:52:45,740 --> 00:52:49,730
Било какви прашања за избор вид?

866
00:52:49,730 --> 00:52:56,420
Во ред. Ајде да се движи до последната тема тука, а тоа е рекурзија.

867
00:52:56,420 --> 00:52:59,810
>> Рекурзија, се сеќавам, дали е ова навистина мета каде што нешто е функција

868
00:52:59,810 --> 00:53:02,740
постојано се нарекува.

869
00:53:02,740 --> 00:53:05,620
Така во еден момент, додека нашите fuction е постојано себеси се нарекува,

870
00:53:05,620 --> 00:53:10,100
треба да има одреден момент во кој ние престанат да повикуваат себеси.

871
00:53:10,100 --> 00:53:13,670
Бидејќи ако ние не го сторат тоа, тогаш ние само ќе продолжи да го стори оваа засекогаш,

872
00:53:13,670 --> 00:53:16,660
и нашата програма е само нема да се прекине.

873
00:53:16,660 --> 00:53:19,200
Оваа состојба се нарекува база случај.

874
00:53:19,200 --> 00:53:22,570
И на база случај вели, наместо нарекувајќи функција повторно,

875
00:53:22,570 --> 00:53:25,330
Јас сум само ќе се вратат некои вредност.

876
00:53:25,330 --> 00:53:28,080
Значи еднаш сме се врати на вредност, Запревме повикувајќи себеси,

877
00:53:28,080 --> 00:53:32,550
а остатокот на повици што е направен досега, исто така, можат да се вратат.

878
00:53:32,550 --> 00:53:36,050
Спротивно на база случај е рекурзивен случај.

879
00:53:36,050 --> 00:53:39,050
И ова е кога сакаме да се направи уште еден повик на функција, дека ние сме во моментов внатре

880
00:53:39,050 --> 00:53:44,690
А ние веројатно, иако не секогаш, сакаат да користат различни аргументи.

881
00:53:44,690 --> 00:53:48,940
>> Значи, ако имаме функција наречена ѓ, и ѓ само се нарекува земаат 1 аргумент,

882
00:53:48,940 --> 00:53:52,010
а ние само ги повикува ѓ (1), ѓ (1), ѓ (1), и тоа само така се случува, дека

883
00:53:52,010 --> 00:53:56,510
аргументот 1 паѓа во рекурзивен случај, ние никогаш уште ќе престане.

884
00:53:56,510 --> 00:54:01,620
Дури и ако имаме база случај, ние треба да бидете сигурни дека на крајот ние ќе погоди дека базата на случајот.

885
00:54:01,620 --> 00:54:04,250
Ние не само задржи престојуваат во овој рекурзивен случај.

886
00:54:04,250 --> 00:54:09,870
Општо земено, кога ние самите се јавите, ние сме веројатно ќе имаат различни аргумент секој пат.

887
00:54:09,870 --> 00:54:12,700
Тука е навистина едноставен рекурзивен функција.

888
00:54:12,700 --> 00:54:15,090
Па ова ќе се пресмета факториел на број.

889
00:54:15,090 --> 00:54:17,790
До почетокот тука имаме нашата база случај.

890
00:54:17,790 --> 00:54:22,330
Во случај n ≤ 1, ние нема да се јавите факториел повторно.

891
00:54:22,330 --> 00:54:26,490
Ние ќе запре, а ние сме само ќе се вратат некои вредност.

892
00:54:26,490 --> 00:54:30,170
Ако ова не е точно, тогаш ние ќе ја погоди нашата рекурзивен случај.

893
00:54:30,170 --> 00:54:33,550
Забележете тука дека ние не сме само повикување факториел (л), затоа што тоа нема да биде многу корисна.

894
00:54:33,550 --> 00:54:36,810
Ние ќе се јавите факториел на нешто друго.

895
00:54:36,810 --> 00:54:40,850
>> И така може да се види, на крајот ако помине факториел (5) или нешто,

896
00:54:40,850 --> 00:54:45,900
ние ќе се јавите факториел (4) и така натаму, и на крајот ние ќе да ја погоди оваа база случај.

897
00:54:45,900 --> 00:54:51,730
Па ова изгледа добро. Ајде да видиме што се случува кога ние всушност ја извршите оваа.

898
00:54:51,730 --> 00:54:57,840
Ова е оџакот, и да речеме дека главната ќе ја повика оваа функција со аргумент (4).

899
00:54:57,840 --> 00:55:02,200
Значи уште факториел гледа и = 4, факториел ќе се јавам.

900
00:55:02,200 --> 00:55:05,010
Сега, одеднаш, имаме факториел (3).

901
00:55:05,010 --> 00:55:10,780
Па овие функции се случува да расте до крајот ние го погоди нашата база случај.

902
00:55:10,780 --> 00:55:17,830
Во овој момент, повратната вредност на ова е враќање (NX повратната вредност на ова),

903
00:55:17,830 --> 00:55:21,290
повратната вредност на ова е NX повратната вредност на ова.

904
00:55:21,290 --> 00:55:23,290
На крајот ние треба да се погоди некој број.

905
00:55:23,290 --> 00:55:26,560
На врвот тука, ние велиме враќање 1.

906
00:55:26,560 --> 00:55:30,650
Тоа значи дека откако ќе се врати тој број, ние може да pop ова исклучување на магацинот.

907
00:55:30,650 --> 00:55:36,570
Значи ова факториел (1) е направено.

908
00:55:36,570 --> 00:55:41,190
Кога 1 се враќа, овој факториел (1) се враќа, ова враќање на 1.

909
00:55:41,190 --> 00:55:46,910
Повратната вредност на ова, се сеќавам, беше NX повратната вредност на ова.

910
00:55:46,910 --> 00:55:50,720
Значи одеднаш, овој човек знае дека сакам да се врати 2.

911
00:55:50,720 --> 00:55:55,910
>> Значи се сеќавам, се врати вредноста на ова е само NX вратената вредност се тука.

912
00:55:55,910 --> 00:56:01,160
Па сега можеме да кажеме 3 x 2, и, конечно, тука можеме да кажеме

913
00:56:01,160 --> 00:56:04,010
ова е само случува да биде 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
И еднаш ова се враќа, ние се фаќате за еден број во внатрешноста на главниот.

915
00:56:09,570 --> 00:56:15,460
Било какви прашања на рекурзија?

916
00:56:15,460 --> 00:56:17,090
Во ред. Значи има повеќе време за прашањата на крајот,

917
00:56:17,090 --> 00:56:23,360
но сега Џозеф ќе ги покрие останатите теми.

918
00:56:23,360 --> 00:56:25,590
>> [Џозеф Ong] Во ред. Па сега дека ние сме зборуваше за recursions,

919
00:56:25,590 --> 00:56:27,840
ајде да разговараме малку за она што се спојат вид е.

920
00:56:27,840 --> 00:56:31,740
Се спојат вид е всушност уште еден начин на сортирање на листата на броеви.

921
00:56:31,740 --> 00:56:36,430
И како таа работи е, со спојување вид ќе имаш листа, и она што го правиме е

922
00:56:36,430 --> 00:56:39,120
ние велиме, да се подели тоа во 2 дела.

923
00:56:39,120 --> 00:56:42,750
Ние прво ќе се кандидира спојат вид повторно на левата половина,

924
00:56:42,750 --> 00:56:45,040
потоа ќе се кандидира спојат вид на десната половина,

925
00:56:45,040 --> 00:56:50,240
и дека ни дава сега 2 половини кои се подредени, и сега ние ќе се комбинираат тие половини заедно.

926
00:56:50,240 --> 00:56:55,010
Тоа е малку тешко да се види без пример, па ќе одиме преку предлог и да видиме што се случува.

927
00:56:55,010 --> 00:56:59,590
Значи кога ќе почнете со оваа листа, што го подели на 2 дела.

928
00:56:59,590 --> 00:57:02,300
Трчаме спојат вид на левата половина прв план.

929
00:57:02,300 --> 00:57:06,660
Значи тоа е левата половина, а сега ги поминува низ оваа листа повторно

930
00:57:06,660 --> 00:57:09,800
кој добива помина во спојат вид, а потоа гледаме, пак,

931
00:57:09,800 --> 00:57:13,270
на левата страна на оваа листа и трчаме спојат вид на неа.

932
00:57:13,270 --> 00:57:15,880
Сега, ние се фаќате за листа на 2 броја,

933
00:57:15,880 --> 00:57:19,010
и сега на левата половина е само 1 елемент долго, а ние не можеме да

934
00:57:19,010 --> 00:57:23,380
подели на листата што е само 1 елемент во половина, па ние само се каже, еднаш имаме 50,

935
00:57:23,380 --> 00:57:26,400
што е само 1 елемент, тоа е веќе сортирана.

936
00:57:26,400 --> 00:57:29,860
>> Откако ќе завршиш со тоа, можеме да видиме дека можеме да

937
00:57:29,860 --> 00:57:32,230
се движи кон десната половина на оваа листа,

938
00:57:32,230 --> 00:57:36,480
и 3 исто така се подредени, па сега дека двете половини од оваа листа се подредени

939
00:57:36,480 --> 00:57:39,080
можеме да се приклучат на овие броеви назад заедно.

940
00:57:39,080 --> 00:57:45,320
Па ние со нетрпение во 50 и 3, 3 е помал од 50, па тоа оди во прв, а потоа 50 влегува внатре

941
00:57:45,320 --> 00:57:49,340
Сега, тоа е направено, ние одиме назад до таа листа и вид тоа е десната половина.

942
00:57:49,340 --> 00:57:52,440
42 е свој број, па тоа е веќе сортирана.

943
00:57:52,440 --> 00:57:57,850
Па сега ќе се споредат овие 2 и 3 е помал од 42, така што добива стави во прв,

944
00:57:57,850 --> 00:58:02,340
сега 42 добива ставам, и 50 добива стави внатре

945
00:58:02,340 --> 00:58:07,220
Сега, тоа е сортирана, ние одиме сите на патот назад до врвот, 1337 и 15.

946
00:58:07,220 --> 00:58:14,560
Па, ние сега се погледне на левата половина од оваа листа; 1337 е сама по себе па затоа се подредени и истиот со 15.

947
00:58:14,560 --> 00:58:19,020
Па сега ние се комбинираат овие 2 броја да се најде дека оригиналната листа, 15 <1337,

948
00:58:19,020 --> 00:58:23,060
така тоа оди во прв, а потоа 1337 оди внатре

949
00:58:23,060 --> 00:58:26,640
И сега ние подредени двете половини од оригиналната листа до врвот.

950
00:58:26,640 --> 00:58:30,440
И сите ние треба да направите е да се комбинираат овие.

951
00:58:30,440 --> 00:58:36,890
Ние гледаме на првите 2 броја на оваа листа, 3 <15, па оди во вид низа во прв план.

952
00:58:36,890 --> 00:58:44,460
15 <42, па тоа оди внатре Сега, 42 <1337, што оди внатре

953
00:58:44,460 --> 00:58:51,010
50 <1337, па тоа оди внатре и ќе забележите дека ние само се 2 броја исклучување на оваа листа.

954
00:58:51,010 --> 00:58:53,640
Значи ние не сме само наизменични помеѓу 2 листи.

955
00:58:53,640 --> 00:58:56,050
Ние сме само гледајќи во почетокот, и ние сме преземање на елемент

956
00:58:56,050 --> 00:59:00,270
тоа е помала и тогаш стави ја во нашата низа.

957
00:59:00,270 --> 00:59:04,080
Сега сме споени сите половини и ние ќе завршиш.

958
00:59:04,080 --> 00:59:07,780
>> Било какви прашања во врска со спојат вид? Да?

959
00:59:07,780 --> 00:59:14,190
[Студентски] Ако тоа е поделба во различни групи, зошто не тие само го подели еднаш

960
00:59:14,190 --> 00:59:19,970
и имаш 3 и 2 со група? [Остатокот од прашањето неразбирливо]

961
00:59:19,970 --> 00:59:24,940
Причината - Значи, прашањето е, зошто не можеме само да ги спојат во тоа првиот чекор откако ќе ги имаат?

962
00:59:24,940 --> 00:59:29,530
Причината можеме да го направите ова, со почеток во левата повеќето елементи на двете страни,

963
00:59:29,530 --> 00:59:33,040
и тогаш земи помала и го стави во, е дека ние знаеме дека овие

964
00:59:33,040 --> 00:59:35,290
индивидуални листи се подредени наредби.

965
00:59:35,290 --> 00:59:37,290
Значи, ако јас сум во потрага по левата повеќето елементи на двете половини,

966
00:59:37,290 --> 00:59:40,490
Знам дека тие се случува да биде најмалата елементи на тие листи.

967
00:59:40,490 --> 00:59:43,930
Па јас може да ги стави во најмалиот елемент точки на оваа голема листа.

968
00:59:43,930 --> 00:59:47,810
Од друга страна, ако се погледне во оние 2 листи во второто ниво таму,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 и 15, и оние кои не се подредени.

970
00:59:51,640 --> 00:59:55,770
Значи, ако јас се погледне во 50 и 1337, јас ќе одам да се стави 50 во мојата листа во прв план.

971
00:59:55,770 --> 01:00:00,130
Но, тоа не навистина има смисла, бидејќи 3 е најмалиот елемент од сите оние.

972
01:00:00,130 --> 01:00:04,390
Значи единствената причина ние да го правиме ова комбинирање чекор е затоа што нашите листи веќе се подредени.

973
01:00:04,390 --> 01:00:07,010
Која е причината зошто ние мора да се фаќате целиот пат до дното

974
01:00:07,010 --> 01:00:09,800
бидејќи кога имаме само еден единствен број, знаеш дека еден број

975
01:00:09,800 --> 01:00:14,120
во и по себе е веќе сортирана листа.

976
01:00:14,120 --> 01:00:19,360
>> Било какви прашања? Не?

977
01:00:19,360 --> 01:00:24,260
Комплексноста? Па, можете да видите дека на секој чекор има крај броеви,

978
01:00:24,260 --> 01:00:27,590
и можеме да ги поделиме на листата на половина најавите n пати,

979
01:00:27,590 --> 01:00:31,700
која е местото каде што ќе го добиеме овој n x најавите n комплексност.

980
01:00:31,700 --> 01:00:34,940
И ќе видите најдобар случај за спојување вид е n најавите n, и тоа само така се случува,

981
01:00:34,940 --> 01:00:39,340
дека најлошото, или Ω таму, исто така е n најавите n.

982
01:00:39,340 --> 01:00:42,480
Нешто да се има предвид.

983
01:00:42,480 --> 01:00:45,750
Преселба на, ајде да одиме на некои супер основните датотека I / O.

984
01:00:45,750 --> 01:00:48,830
Ако сте го гледаше во трка, ќе забележите имавме некој вид на систем

985
01:00:48,830 --> 01:00:51,270
каде што можете да напишете на log датотеката, ако се чита преку код.

986
01:00:51,270 --> 01:00:53,730
Ајде да видиме како може да го направи тоа.

987
01:00:53,730 --> 01:00:57,450
Па, ние сме fprintf, кои можете да замислите како само printf,

988
01:00:57,450 --> 01:01:01,720
но само печатење во датотека наместо тоа, а оттука и ѓ на почетокот.

989
01:01:01,720 --> 01:01:07,570
Овој вид на код се тука, она што го прави тоа е, како што може да се види во трка,

990
01:01:07,570 --> 01:01:12,310
тоа оди преку вашиот 2-димензионална низа печатење ред по што бројките се.

991
01:01:12,310 --> 01:01:17,850
Во овој случај, printf отпечатоци до вашиот терминал или она што ние го нарекуваме стандарден излез на секција.

992
01:01:17,850 --> 01:01:22,170
>> И сега, во овој случај, сите ние треба да направите е да го замени printf со fprintf,

993
01:01:22,170 --> 01:01:26,770
каже дека тоа што датотеката која сакате да се печати, а во овој случај тоа само да го печати до таа датотека

994
01:01:26,770 --> 01:01:32,230
наместо тоа печатење на вашиот терминал.

995
01:01:32,230 --> 01:01:36,500
Па, тогаш што моли на прашањето: Каде да добиеме овој вид на датотека од, нели?

996
01:01:36,500 --> 01:01:39,840
Минавме влезете во овој fprintf fuction но немавме идеја од каде доаѓа.

997
01:01:39,840 --> 01:01:43,980
Па, во почетокот на код, што ја имавме беше овој дел од кодот овде,

998
01:01:43,980 --> 01:01:48,340
која во основа вели дека ја отворам датотеката повици log.txt.

999
01:01:48,340 --> 01:01:53,220
Што правиме после тоа е дека ние треба да бидете сигурни дека датотеката е, всушност, отворена успешно.

1000
01:01:53,220 --> 01:01:57,070
Па тоа би можело да пропадне поради повеќе причини, вие немате доволно простор на вашиот компјутер, на пример.

1001
01:01:57,070 --> 01:01:59,790
Така, тоа е секогаш важно пред да направите било операции со датотеки

1002
01:01:59,790 --> 01:02:03,300
дека ние се провери дали таа датотека беше отворена успешно.

1003
01:02:03,300 --> 01:02:09,330
Значи она што, тоа е аргумент за fopen, добро, можеме да отворите датотека во многу начини.

1004
01:02:09,330 --> 01:02:13,510
Што можеме да направиме е, можеме да го помине W, што значи замени датотека, ако тоа излегува веќе,

1005
01:02:13,510 --> 01:02:18,070
Ние може да помине на кој тие додаваат на крајот на датотеката наместо највисок тоа,

1006
01:02:18,070 --> 01:02:22,730
или може да се определи r, што значи, да ја отворам датотеката како само за читање.

1007
01:02:22,730 --> 01:02:24,890
Значи, ако на програмата се обидува да направи никакви промени на датотеката,

1008
01:02:24,890 --> 01:02:30,140
развикам нив и не нека го направи тоа.

1009
01:02:30,140 --> 01:02:33,320
Конечно, откако ќе завршиш со датотека, направено прави операции на неа,

1010
01:02:33,320 --> 01:02:35,860
ние треба да бидете сигурни дека ние затвори датотека.

1011
01:02:35,860 --> 01:02:38,830
И така на крајот на вашата програма, ви се случува да ги помине повторно

1012
01:02:38,830 --> 01:02:42,120
оваа датотека што ќе се отвори, и само да го затворите.

1013
01:02:42,120 --> 01:02:44,650
Значи ова е нешто важно што ќе треба да бидете сигурни дека го правите.

1014
01:02:44,650 --> 01:02:47,180
Па не заборавајте можете да отворите некоја датотека, тогаш може да се запише во датотеката,

1015
01:02:47,180 --> 01:02:51,270
прават операции во датотеката, но тогаш ќе мора да го затвори датотека на крајот.

1016
01:02:51,270 --> 01:02:53,270
>> Било какви прашања на основните датотека I / O? Да?

1017
01:02:53,270 --> 01:02:58,050
[Студентски збор, неразбирливо]

1018
01:02:58,050 --> 01:03:02,480
Токму тука. Прашањето е, каде што овој log.txt датотеката се појавува?

1019
01:03:02,480 --> 01:03:07,890
Па, ако сте само да го даде log.txt, тоа создава во истиот директориум како извршна.

1020
01:03:07,890 --> 01:03:10,500
Па ако Ти си - >> [Студентски збор, неразбирливо]

1021
01:03:10,500 --> 01:03:18,830
Да. Во истата папка, или во истиот директориум, како што го нарекуваат.

1022
01:03:18,830 --> 01:03:21,400
Сега меморија, магацинот и грамада.

1023
01:03:21,400 --> 01:03:23,400
Па, како е меморија утврдени во компјутер?

1024
01:03:23,400 --> 01:03:26,270
Па, можете да си замислите меморија, како вид на овој блок тука.

1025
01:03:26,270 --> 01:03:30,260
И во меморијата имаме она што се нарекува грамада заглавени таму, и на магацинот тоа е таму долу.

1026
01:03:30,260 --> 01:03:34,480
И грамада расте надолу и магацинот расте нагоре.

1027
01:03:34,480 --> 01:03:38,620
Па како Томи споменати - добро де, и ние имаме овие други 4 сегменти кои ќе се дојде до во вториот -

1028
01:03:38,620 --> 01:03:42,890
Како Томи реков порано, знаеш колку неговите функции се нарекуваат себеси и се јавите едни со други?

1029
01:03:42,890 --> 01:03:44,930
Тие се изгради овој вид на магацинот рамка.

1030
01:03:44,930 --> 01:03:47,360
Па, ако главната повици foo, foo добива стави на магацинот.

1031
01:03:47,360 --> 01:03:52,430
Foo повици бар, бар да се стави на магацинот, и кој добива се стави на магацинот после.

1032
01:03:52,430 --> 01:03:57,040
И како ќе се вратат, секој од нив се соблече на магацинот.

1033
01:03:57,040 --> 01:04:00,140
Што секоја од овие локации и меморија се одржи?

1034
01:04:00,140 --> 01:04:03,110
Па, на врвот, која е текстот сегмент, содржи самата програма.

1035
01:04:03,110 --> 01:04:06,390
Па машина код, тоа е таму, откако ќе ги собере вашата програма.

1036
01:04:06,390 --> 01:04:08,520
Потоа, било иницијализира глобални променливи.

1037
01:04:08,520 --> 01:04:12,660
>> Па имате глобални променливи во вашата програма, а ти каже како, a = 5,

1038
01:04:12,660 --> 01:04:15,260
кој добива се стави во тој сегмент, а веднаш под тоа,

1039
01:04:15,260 --> 01:04:18,990
имате било какви деиницијализира глобалната податоци, што е само int a,

1040
01:04:18,990 --> 01:04:20,990
но вие не велат дека тоа е еднакво на ништо.

1041
01:04:20,990 --> 01:04:23,870
Реализираат овие се глобални променливи, па тие се надвор од главните.

1042
01:04:23,870 --> 01:04:28,560
Значи ова значи било глобални променливи кои се објавени, но не се иницијализира.

1043
01:04:28,560 --> 01:04:32,310
Значи она што е во грамада? Меморија доделени користење Примерок, која ние ќе дојдеме до во малку.

1044
01:04:32,310 --> 01:04:35,990
И, конечно, со магацинот имате било какви локални променливи

1045
01:04:35,990 --> 01:04:39,950
и сите функции може да се јавите во било кој од своите параметри.

1046
01:04:39,950 --> 01:04:43,720
Последното нешто, ти навистина не треба да знаат што на животната средина променливи се направи,

1047
01:04:43,720 --> 01:04:46,700
но секогаш кога ќе ја стартувате програмата, има нешто поврзано, како

1048
01:04:46,700 --> 01:04:49,550
ова е корисничкото име на лицето кое го водеше програма.

1049
01:04:49,550 --> 01:04:51,550
И тоа ќе биде вид на дното.

1050
01:04:51,550 --> 01:04:54,540
Во однос на меморијата адреси, кои се хексадецимално вредности,

1051
01:04:54,540 --> 01:04:58,170
вредностите на врвот почетокот на 0, и тие одат по целиот пат до дното.

1052
01:04:58,170 --> 01:05:00,440
Во овој случај, ако сте во 32-битен систем,

1053
01:05:00,440 --> 01:05:05,390
на адреса на дното ќе биде 0x, проследено со AF, бидејќи тоа е 32 бита,

1054
01:05:05,390 --> 01:05:10,890
кој е 8 бајти, и во овој случај 8 бајти одговара на 8 хексадецимални цифри.

1055
01:05:10,890 --> 01:05:20,110
Значи тука долу ви се случува да имаат, како, 0xffffff, и таму ви се случува да имаат 0.

1056
01:05:20,110 --> 01:05:23,660
Значи она што се покажувачи? Некои од вас може да не се опфатени ова во делот пред.

1057
01:05:23,660 --> 01:05:26,660
но ние не одиме над неа во предавањето, па покажувач е само тип на податоци

1058
01:05:26,660 --> 01:05:34,030
која продавници, наместо некаква вредност како 50, ги чува адресата на некои локација во меморијата.

1059
01:05:34,030 --> 01:05:36,020
Како што меморија [неразбирливо].

1060
01:05:36,020 --> 01:05:41,120
Значи во овој случај, она што го имаме е, имаме покажувач на цел број или int *,

1061
01:05:41,120 --> 01:05:46,210
и содржи оваа хексадецимален адреса на 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> Значи она што го имаме е, сега, овој покажувачот поени во некоја локација во меморијата,

1063
01:05:50,880 --> 01:05:56,020
и тоа е само, вредноста 50 е во овој мемориска локација.

1064
01:05:56,020 --> 01:06:01,810
На некои 32-битни системи, на сите 32-битни системи, показалки од 32 бита или 4 бајти.

1065
01:06:01,810 --> 01:06:06,020
Но, на пример, на 64-битен систем, показалки се 64 бити.

1066
01:06:06,020 --> 01:06:08,040
Значи тоа е нешто што ќе сакате да се задржи во умот.

1067
01:06:08,040 --> 01:06:12,310
Така, на крајот-битен систем, покажувач е крајот бита долга.

1068
01:06:12,310 --> 01:06:17,320
Покажувачи се вид на тешко да се вари без дополнителни работи,

1069
01:06:17,320 --> 01:06:20,300
па ајде да одиме преку еден пример на динамичен алокација на меморија.

1070
01:06:20,300 --> 01:06:25,130
Што динамична алокација на меморија прави за вас, или она што ние го нарекуваме Примерок,

1071
01:06:25,130 --> 01:06:29,280
што ви овозможува да одвои некој вид на податоци надвор од собата.

1072
01:06:29,280 --> 01:06:31,830
Па овој податок е вид на потрајно за време на траењето на програмата.

1073
01:06:31,830 --> 01:06:36,430
Бидејќи како што знаете, ако пријават x внатрешноста на функција, а таа функција се враќа,

1074
01:06:36,430 --> 01:06:40,910
веќе немате пристап до податоците што се чуваат во х.

1075
01:06:40,910 --> 01:06:44,420
Што совети нека направите е тие нека чување меморија или продавница вредности

1076
01:06:44,420 --> 01:06:46,840
во различни сегмент на меморија, имено грамада.

1077
01:06:46,840 --> 01:06:49,340
Сега откако ќе се врати од функцијата, се додека имаме покажувачот

1078
01:06:49,340 --> 01:06:54,960
за таа локација во меморијата, тогаш што можеме да направиме е ние само може да се погледне на вредности таму.

1079
01:06:54,960 --> 01:06:58,020
Ајде да погледнеме еден пример: Ова е нашата меморија распоред повторно.

1080
01:06:58,020 --> 01:07:00,050
И ние имаме оваа функција, главен.

1081
01:07:00,050 --> 01:07:06,870
Што го прави тоа е - добро, па едноставно, нели - int x = 5, тоа е само една променлива на магацинот во главниот.

1082
01:07:06,870 --> 01:07:12,450
>> Од друга страна, ние сега прогласи покажувач кој повикува функцијата giveMeThreeInts.

1083
01:07:12,450 --> 01:07:16,800
И така сега ние одиме во оваа функција и ќе создадеме нова магацинот рамка за тоа.

1084
01:07:16,800 --> 01:07:20,440
Меѓутоа, во овој магацинот рамка, изјавуваме int * Temp,

1085
01:07:20,440 --> 01:07:23,210
кои во mallocs 3 броеви за нас.

1086
01:07:23,210 --> 01:07:25,880
Па големината на int ќе ни даде колку бајти овој int е,

1087
01:07:25,880 --> 01:07:29,620
и Примерок ни дава дека многу бајти на просторот на грамада.

1088
01:07:29,620 --> 01:07:32,890
Значи во овој случај, ние направивме доволно простор за 3 цели броеви,

1089
01:07:32,890 --> 01:07:36,830
и грамада е начин, таму горе, кој е зошто сум го привлече повисоко.

1090
01:07:36,830 --> 01:07:42,900
Откако ќе завршиш, ќе се вратиме тука, треба само 3 ints врати,

1091
01:07:42,900 --> 01:07:47,000
и го враќа адреса, во овој случај околу тоа каде тоа сеќавање е.

1092
01:07:47,000 --> 01:07:51,250
И ние во собата покажувачот = Switch, и таму имаме само уште еден покажувач.

1093
01:07:51,250 --> 01:07:54,550
Но, она што таа функција се враќа се наредени тука и исчезнува.

1094
01:07:54,550 --> 01:07:59,250
Значи температура исчезнува, но ние се уште ги одржуваат адреса од каде

1095
01:07:59,250 --> 01:08:01,850
тие 3 броеви се во внатрешноста на електричната мрежа.

1096
01:08:01,850 --> 01:08:06,180
Така што во овој сет, покажувачи се scoped локално за рангирани рамка,

1097
01:08:06,180 --> 01:08:09,860
но споменот на кои се однесуваат е во грамада.

1098
01:08:09,860 --> 01:08:12,190
>> Дали тоа има смисла?

1099
01:08:12,190 --> 01:08:14,960
[Студентски] можете да повторам дека? >> [Џозеф] Да.

1100
01:08:14,960 --> 01:08:20,270
Значи, ако јас се вратиме само малку, ќе видите дека Темп распределени

1101
01:08:20,270 --> 01:08:23,500
некои меморија за грамада таму.

1102
01:08:23,500 --> 01:08:28,680
Значи, кога оваа функција, giveMeThreeInts се враќа, овој магацинот тука ќе исчезне.

1103
01:08:28,680 --> 01:08:35,819
А со тоа и било кој од променливи, во овој случај, овој показател дека беше доделена во рангирани рамка.

1104
01:08:35,819 --> 01:08:39,649
Што се случува да исчезне, но бидејќи ние се врати temp

1105
01:08:39,649 --> 01:08:46,330
и ние во собата покажувачот = Temp, покажувачот е сега се случува да се укаже истата меморија на локација како Temp беше.

1106
01:08:46,330 --> 01:08:50,370
Па сега, иако губиме Temp, дека локалните покажувач,

1107
01:08:50,370 --> 01:08:59,109
ние уште го чувам на мемориската адреса на она што беше укажува на внатрешноста на таа променлива покажувач.

1108
01:08:59,109 --> 01:09:03,740
Прашања? Тоа може да биде еден вид на збунувачки тема ако не се качил над неа во делот.

1109
01:09:03,740 --> 01:09:09,240
Можеме, вашиот ТФ дефинитивно ќе одам над неа и се разбира, ние може да одговара на прашања

1110
01:09:09,240 --> 01:09:11,500
на крајот на ревијата сесија за ова.

1111
01:09:11,500 --> 01:09:14,220
Но, ова е вид на комплексна тема, и имам повеќе примери кои ќе се појавиш

1112
01:09:14,220 --> 01:09:18,790
кои ќе ви помогнат појасни она совети всушност се.

1113
01:09:18,790 --> 01:09:22,500
>> Во овој случај, показалки се еквивалентни на низи,

1114
01:09:22,500 --> 01:09:25,229
па јас само да го користите овој покажувач како истото како int низа.

1115
01:09:25,229 --> 01:09:29,840
Па јас сум индексирање во 0, и менување на првиот број на 1,

1116
01:09:29,840 --> 01:09:39,689
менување на вториот број на 2 и 3 целобројни до 3.

1117
01:09:39,689 --> 01:09:44,210
Па повеќе на покажувачи. Па, да се потсетиме Binky.

1118
01:09:44,210 --> 01:09:48,319
Во овој случај ние сме доделени покажувач, или ние прогласи покажувач,

1119
01:09:48,319 --> 01:09:52,760
но на почетокот, кога јас само прогласи покажувач, тоа не е укажува на кое било место во меморијата.

1120
01:09:52,760 --> 01:09:54,930
Тоа е само ѓубре вредности во него.

1121
01:09:54,930 --> 01:09:56,470
Па јас немам идеја каде овој покажувачот е да се покажува.

1122
01:09:56,470 --> 01:10:01,630
Таа има адреса која е само исполнет со 0 и 1, каде што беше првично објавени.

1123
01:10:01,630 --> 01:10:04,810
Јас не може да направи ништо со тоа, додека јас го нарекувам Примерок на неа

1124
01:10:04,810 --> 01:10:08,390
а потоа тоа ми дава малку простор на грамада каде што може да се стави вредности внатре.

1125
01:10:08,390 --> 01:10:11,980
Потоа повторно, не знам што е внатре на оваа меморија.

1126
01:10:11,980 --> 01:10:16,780
Така првото нешто што треба да направите е да проверите дали системот има доволно меморија

1127
01:10:16,780 --> 01:10:20,850
да ми даде назад 1 број на прво место, кој е зошто јас го правам ова се провери.

1128
01:10:20,850 --> 01:10:25,020
Ако покажувачот е нула, што значи дека не имаат доволно простор или некоја друга грешка,

1129
01:10:25,020 --> 01:10:26,320
па јас треба да излезете надвор од мојата програма.

1130
01:10:26,320 --> 01:10:29,400
 Но, ако тоа не успее, сега можам да ја користат таа покажувачот

1131
01:10:29,400 --> 01:10:35,020
и она * покажувачот не е тоа на следниов начин каде адресата е

1132
01:10:35,020 --> 01:10:38,480
каде што вредноста е, и го поставува тоа еднаква на 1.

1133
01:10:38,480 --> 01:10:41,850
Значи, овде, ние сме проверка ако меморијата постоел.

1134
01:10:41,850 --> 01:10:45,380
>> Откако ќе знаеш дека постои, може да се стави во неа

1135
01:10:45,380 --> 01:10:50,460
што вредноста што сакате да се стави во неа, во овој случај 1.

1136
01:10:50,460 --> 01:10:53,060
Откако ќе завршиш со тоа, треба да се ослободи дека покажувачот

1137
01:10:53,060 --> 01:10:57,160
бидејќи ние треба да се вратиме на систем кој меморија, која ви побара на прво место.

1138
01:10:57,160 --> 01:10:59,690
Бидејќи компјутерот не знае кога ќе завршиш со него.

1139
01:10:59,690 --> 01:11:02,510
Во овој случај ние експлицитно го кажувам, во ред, ние ќе завршиш со тоа меморијата.

1140
01:11:02,510 --> 01:11:10,780
Ако некој друг процес што треба, некоја друга програма што треба, се чувствуваат слободни да оди напред и да ја однесете.

1141
01:11:10,780 --> 01:11:15,110
Она што исто така може да направите е ние едноставно може да се добие адресата на локални променливи на собата.

1142
01:11:15,110 --> 01:11:19,080
Значи int x е внатре во рангирани рамките на главната.

1143
01:11:19,080 --> 01:11:23,060
И кога ние ги користиме оваа симболот, ова и оператор, она што го прави тоа е

1144
01:11:23,060 --> 01:11:27,310
е потребно x и x е само некои податоци во меморија, но тоа има адреса.

1145
01:11:27,310 --> 01:11:33,790
Тоа се наоѓа некаде. Значи со повик на & X, што тоа не е тоа ни дава адресата на x.

1146
01:11:33,790 --> 01:11:38,430
Со тоа, ние сме прави покажувачот точка до каде x е во меморијата.

1147
01:11:38,430 --> 01:11:41,710
Сега ние само се нешто како * x, ние ќе добие 5 врати.

1148
01:11:41,710 --> 01:11:43,820
Ѕвездата се вика dereferencing неа.

1149
01:11:43,820 --> 01:11:46,640
Го следите адреса и да добиете вредноста на тоа чуваат таму.

1150
01:11:51,000 --> 01:11:53,310
>> Било какви прашања? Да?

1151
01:11:53,310 --> 01:11:56,500
[Студентски] Ако не го сторат 3-истакна нешто, не се уште собира?

1152
01:11:56,500 --> 01:11:59,490
Да. Ако не го сторат 3-покажувачот нешто, тоа е уште се случува да ги собере,

1153
01:11:59,490 --> 01:12:02,720
но јас ќе ви покаже што се случува во една секунда, и без тоа го прават,

1154
01:12:02,720 --> 01:12:04,860
тоа е она што ние го нарекуваме меморија излегуваат во јавноста. Вие не сте давање на системот

1155
01:12:04,860 --> 01:12:07,850
врати неговата меморија, па по некое време на програмата ќе се акумулираат

1156
01:12:07,850 --> 01:12:10,940
меморија која не е користење и ништо друго да го користите.

1157
01:12:10,940 --> 01:12:15,750
Ако некогаш сте виделе Firefox со 1,5 милиони килобајти на вашиот компјутер,

1158
01:12:15,750 --> 01:12:17,840
во Task Manager, тоа е она што се случува.

1159
01:12:17,840 --> 01:12:20,760
Имаш меморија излегуваат во јавноста во програмата дека тие не се ракување.

1160
01:12:23,080 --> 01:12:26,240
Па како не покажувачот аритметички работа?

1161
01:12:26,240 --> 01:12:29,480
Па, покажувачот аритметичка е вид на како индексирање во низа.

1162
01:12:29,480 --> 01:12:36,370
Во овој случај, имам покажувач, и она што го правам е го направи покажувачот точка за првиот елемент

1163
01:12:36,370 --> 01:12:42,100
од оваа низа од 3 броеви што сум распределени.

1164
01:12:42,100 --> 01:12:46,670
Па сега што правам, ѕвезда покажувачот само го менува првиот елемент во листата.

1165
01:12:46,670 --> 01:12:49,140
Ѕвезда покажувачот 1 точки овде.

1166
01:12:49,140 --> 01:12:53,140
Значи покажувачот е над тука, покажувачот 1 е завршена тука, покажувачот 2 е овде.

1167
01:12:53,140 --> 01:12:56,610
>> Па само додавање на 1 е истото што се движат по должината на оваа низа.

1168
01:12:56,610 --> 01:12:59,880
Што правиме е, кога правиме покажувачот 1 ќе ја добиете адресата овде,

1169
01:12:59,880 --> 01:13:04,180
а со цел да се добие вредност во тука, ќе се стави ѕвезда од целиот израз

1170
01:13:04,180 --> 01:13:05,990
да го Dereference.

1171
01:13:05,990 --> 01:13:09,940
Значи, во овој случај, јас сум поставување на првото место во оваа низа на 1,

1172
01:13:09,940 --> 01:13:13,970
втората локација до 2, а трето место на 3.

1173
01:13:13,970 --> 01:13:18,180
Тогаш она што го правам во текот тука е Јас сум печатење нашите покажувачот 1,

1174
01:13:18,180 --> 01:13:19,970
што само ми дава 2.

1175
01:13:19,970 --> 01:13:23,650
Сега сум зголемување, покажувач, па покажувачот е еднаква на покажувачот 1,

1176
01:13:23,650 --> 01:13:26,780
која се движи напред.

1177
01:13:26,780 --> 01:13:30,810
Па сега ако јас испечатите покажувачот 1, покажувачот 1 е сега 3,

1178
01:13:30,810 --> 01:13:33,990
кој во овој случај отпечатоци од 3.

1179
01:13:33,990 --> 01:13:36,560
А со цел да се ослободи нешто, на покажувачот што го даде

1180
01:13:36,560 --> 01:13:40,540
мора да укажува на почетокот на низата која се вратив од Примерок.

1181
01:13:40,540 --> 01:13:43,430
Значи, во овој случај, ако јас се да се јавите 3 токму тука, тоа не би било право,

1182
01:13:43,430 --> 01:13:45,070
затоа што тоа е во средината на низата.

1183
01:13:45,070 --> 01:13:48,820
Морам да одземе за да се дојде до оригинална локација

1184
01:13:48,820 --> 01:13:50,420
почетна првата точка пред да може да ја ослободи.

1185
01:13:56,300 --> 01:13:58,450
Значи, тука е повеќе вклучени пример.

1186
01:13:58,450 --> 01:14:03,360
Во овој случај, ние сме доделување 7 карактери во карактер низа.

1187
01:14:03,360 --> 01:14:06,480
>> И во овој случај она што го правиме е ние сме looping во текот на првите 6 од нив,

1188
01:14:06,480 --> 01:14:09,900
и ние сме ги поставување до Ш

1189
01:14:09,900 --> 01:14:13,350
Значи, за int i = 0, i> 6, i + +,

1190
01:14:13,350 --> 01:14:16,220
Значи, покажувач + Јас само ќе ни даде, во овој случај,

1191
01:14:16,220 --> 01:14:20,860
покажувач, покажувач 1, покажувачот 2, покажувач 3, и така натаму и така натаму во јамка.

1192
01:14:20,860 --> 01:14:24,040
Што тоа се случува да направите е да станува таа адреса, dereferences тоа да се добие вредност,

1193
01:14:24,040 --> 01:14:27,440
и промените кои вредноста на З

1194
01:14:27,440 --> 01:14:30,350
Потоа на крајот се сеќава на ова е стринг, нели?

1195
01:14:30,350 --> 01:14:33,560
Сите жици мора да заврши со нула раскинувањето карактер.

1196
01:14:33,560 --> 01:14:38,620
Значи, она што го правам е во покажувачот 6 ставам null терминаторот карактер внатре

1197
01:14:38,620 --> 01:14:43,980
И сега што сум во основа прави овде е спроведување printf за низа, нели?

1198
01:14:43,980 --> 01:14:46,190
>> Значи, кога се printf сега кога тоа е до крајот на серијата?

1199
01:14:46,190 --> 01:14:48,230
Кога хитови на нула раскинувањето карактер.

1200
01:14:48,230 --> 01:14:52,030
Значи, во овој случај, мојот оригинален покажувачот поени до почетокот на оваа низа.

1201
01:14:52,030 --> 01:14:56,410
Јас печати првиот карактер надвор. Ми се движи над еден.

1202
01:14:56,410 --> 01:14:58,420
Јас печати дека карактерот надвор. Ми се движи над.

1203
01:14:58,420 --> 01:15:02,180
И јас го правам тоа додека не стигнат до крајот.

1204
01:15:02,180 --> 01:15:07,750
И сега на крајот * покажувачот ќе Dereference ова и ќе добиете нула раскинувањето карактер назад.

1205
01:15:07,750 --> 01:15:11,780
И така ми додека јамка работи само кога таа вредност не е нула раскинувањето карактер.

1206
01:15:11,780 --> 01:15:13,770
Значи, сега излезете од овој циклус.

1207
01:15:18,780 --> 01:15:21,180
И така, ако Јас одземе 6 од овој покажувач,

1208
01:15:21,180 --> 01:15:22,860
Се враќам сè до почетокот.

1209
01:15:22,860 --> 01:15:27,880
Запомнете, јас го правам тоа, бидејќи морам да одам на почетокот, со цел да се ослободи.

1210
01:15:27,880 --> 01:15:30,270
>> Значи, знам дека беше многу. Дали постојат било какви прашања?

1211
01:15:30,270 --> 01:15:31,870
Ве молиме, да?

1212
01:15:31,870 --> 01:15:36,610
[Студентски збор неразбирливо]

1213
01:15:36,610 --> 01:15:38,190
Може да се каже дека погласни? Жал ми е.

1214
01:15:38,190 --> 01:15:44,140
[Студентски] На последниот слајд право, пред да ја ослободи покажувач,

1215
01:15:44,140 --> 01:15:47,300
Каде бевте всушност менување на вредноста на покажувачот?

1216
01:15:47,300 --> 01:15:50,370
[Џозеф] Значи, токму овде. >> [Студентски] О, во ред.

1217
01:15:50,370 --> 01:15:51,890
[Џозеф] Значи, имам покажувачот минус минус, десно,

1218
01:15:51,890 --> 01:15:54,140
која се движи нешто назад еден, а потоа го ослободи,

1219
01:15:54,140 --> 01:15:57,000
бидејќи овој покажувачот треба да се истакне на почетокот на низата.

1220
01:15:57,000 --> 01:16:00,420
[Студентски] Но, тоа нема да бидат потребни те запре по таа линија.

1221
01:16:00,420 --> 01:16:03,130
[Џозеф] Значи, ако јас го запрел по ова, ова ќе се смета за меморија излегуваат во јавноста,

1222
01:16:03,130 --> 01:16:04,810
бидејќи јас не се кандидира на бесплатно.

1223
01:16:04,810 --> 01:16:11,290
[Студентски] Јас [неразбирливо] по првите три линии каде што требаше покажувачот 1 [неразбирливо].

1224
01:16:11,290 --> 01:16:13,140
[Џозеф] Ух-нели. Значи, она што е прашање таму?

1225
01:16:13,140 --> 01:16:14,780
Жал ми е. Не, не. Оди, оди, те молам.

1226
01:16:14,780 --> 01:16:16,870
[Студентски] Значи, вие не сте менување на вредноста на покажувачи.

1227
01:16:16,870 --> 01:16:19,130
Вие не би морале да ја завршат покажувачот минус минус.

1228
01:16:19,130 --> 01:16:19,730
[Џозеф] Да, точно.

1229
01:16:19,730 --> 01:16:21,890
Значи, кога правам покажувачот 1 и покажувачот 2,

1230
01:16:21,890 --> 01:16:24,410
Јас не го правам покажувачот е еднаква на покажувачот 1.

1231
01:16:24,410 --> 01:16:27,260
Така, на покажувачот само останува укажува на почетокот на низата.

1232
01:16:27,260 --> 01:16:31,460
Тоа е само кога правам плус плус дека поставува вредноста назад во внатрешноста на покажувачот,

1233
01:16:31,460 --> 01:16:33,550
дека тоа всушност се движи ова заедно.

1234
01:16:36,860 --> 01:16:37,780
Во ред.

1235
01:16:40,550 --> 01:16:42,030
Повеќе прашања?

1236
01:16:44,680 --> 01:16:47,790
>> Повторно, ако ова е вид на огромна, ова ќе бидат опфатени во сесија.

1237
01:16:47,790 --> 01:16:50,710
Прашајте го вашиот настава колеги за тоа, а ние може да одговори на прашањата на крајот.

1238
01:16:53,510 --> 01:16:56,600
И обично не сакаме да го направите ова минус работа.

1239
01:16:56,600 --> 01:16:59,760
Ова треба да бараат од мене следење на колку сум поместување во низата.

1240
01:16:59,760 --> 01:17:04,520
Значи, во целина, ова е само за да се објасни како покажувачот аритметички дела.

1241
01:17:04,520 --> 01:17:07,970
Но, она што ние обично сакале да направите е да сакаме да се создаде копија на покажувачот,

1242
01:17:07,970 --> 01:17:11,640
а потоа ние ќе ја користат таа копија кога ние сме се движат наоколу во низа.

1243
01:17:11,640 --> 01:17:14,660
Значи, во овие случаи го користите копија за печатење на целата низа,

1244
01:17:14,660 --> 01:17:19,040
но ние не треба да се направи како покажувач минус 6 или ги пратите на тоа колку ние се пресели во тоа,

1245
01:17:19,040 --> 01:17:22,700
само затоа што знаеме дека нашата изворна точка се уште посочи на почетокот на листата

1246
01:17:22,700 --> 01:17:25,340
и сето она што го менува беше оваа копија.

1247
01:17:25,340 --> 01:17:28,250
Значи, воопшто, да ја смени копии од вашите оригинални покажувач.

1248
01:17:28,250 --> 01:17:32,350
Не се обиде да најде решение за како - don't менуваат оригиналните примероци.

1249
01:17:32,350 --> 01:17:35,290
Обидувајќи се да се смени само копии од вашите оригинални.

1250
01:17:41,540 --> 01:17:44,870
Значи, ќе забележите кога ќе помине стринг во printf

1251
01:17:44,870 --> 01:17:48,990
вие не мора да се стави една ѕвезда пред него како што направивме со сите други dereferences, нели?

1252
01:17:48,990 --> 01:17:54,180
Значи, ако испечатите целиот Низата% s очекува е на адреса,

1253
01:17:54,180 --> 01:17:57,610
и во овој случај покажувач или во овој случај како низа од карактери.

1254
01:17:57,610 --> 01:18:00,330
>> Карактери, char * s и низи се иста работа.

1255
01:18:00,330 --> 01:18:03,690
Покажувачот е да карактери и карактер низите се иста работа.

1256
01:18:03,690 --> 01:18:05,720
И така, сите ние треба да направите е да помине во покажувач.

1257
01:18:05,720 --> 01:18:08,150
Ние не треба да се помине во како * покажувачот или нешто слично.

1258
01:18:13,110 --> 01:18:14,930
Значи, низи и покажувачи се иста работа.

1259
01:18:14,930 --> 01:18:19,160
Кога правиш нешто како x [Y] овде за низа,

1260
01:18:19,160 --> 01:18:21,960
она што таа го прави под хауба е тоа велејќи дека, добро, тоа е лик низа,

1261
01:18:21,960 --> 01:18:23,690
па тоа е покажувачот.

1262
01:18:23,690 --> 01:18:26,510
И така x се иста работа,

1263
01:18:26,510 --> 01:18:28,650
и така тоа што го прави е тоа додава y на x,

1264
01:18:28,650 --> 01:18:31,820
која е истото што се движат напред во меморија која многу.

1265
01:18:31,820 --> 01:18:34,930
И сега x + y ни дава некој вид на адреса,

1266
01:18:34,930 --> 01:18:37,570
и ние Dereference на адресата или следете ги стрелките

1267
01:18:37,570 --> 01:18:41,640
каде таа локација во меморијата е и ние да добијат вредност од таа локација во меморијата.

1268
01:18:41,640 --> 01:18:43,720
Значи, па овие две се токму истото.

1269
01:18:43,720 --> 01:18:45,840
Тоа е само синтактички шеќер.

1270
01:18:45,840 --> 01:18:48,090
Тие го прават истото. Тие се само различни syntactics за секоја друга.

1271
01:18:51,500 --> 01:18:57,590
>> Значи, она што може да тргне наопаку со покажувачи? Како, многу. Во ред. Значи, лоши работи.

1272
01:18:57,590 --> 01:19:02,410
Некои лоши работи што можете да направите да не се проверува дали вашиот Примерок повик се враќа нула, нели?

1273
01:19:02,410 --> 01:19:06,560
Во овој случај, јас барам на системот да ми даде - што е тоа број?

1274
01:19:06,560 --> 01:19:11,200
Како 2 милијарди пати 4, бидејќи големината на цел број е 4 бајти.

1275
01:19:11,200 --> 01:19:13,810
Јас сум го бара како 8 милијарди бајти.

1276
01:19:13,810 --> 01:19:17,270
Се разбира мојот компјутер не ќе биде во можност да ми даде дека многу меморија назад.

1277
01:19:17,270 --> 01:19:20,960
И ние не провери дали ова е нула, па кога ние се обидуваме да Dereference тоа таму -

1278
01:19:20,960 --> 01:19:24,270
следете ги стрелките за тоа каде тоа се случува да - ние не го имаат тоа меморија.

1279
01:19:24,270 --> 01:19:27,150
Тоа е она што ние го нарекуваме dereferencing е нулти покажувач.

1280
01:19:27,150 --> 01:19:29,710
И ова всушност предизвикува да segfault.

1281
01:19:29,710 --> 01:19:31,790
Ова е еден од начините можете да segfault.

1282
01:19:34,090 --> 01:19:38,090
Други лоши работи што можете да направите - О, добро.

1283
01:19:38,090 --> 01:19:40,650
Тоа беше dereferencing е нулти покажувач. Во ред.

1284
01:19:40,650 --> 01:19:45,160
Други лоши нешта - и, за да се утврди дека само стави проверка таму

1285
01:19:45,160 --> 01:19:46,980
кој проверува дали покажувачот е null

1286
01:19:46,980 --> 01:19:51,000
и да излезете од програмата, ако се случи тоа Примерок враќа null покажувачот.

1287
01:19:55,110 --> 01:19:59,850
Тоа е XKCD стрип. Луѓето го разбирам сега. Вид.

1288
01:20:06,120 --> 01:20:09,350
>> Значи, меморија. И јас отидов во текот на овој.

1289
01:20:09,350 --> 01:20:12,000
Ние сме повикувајќи Примерок во еден циклус, но секој пат кога ние го нарекуваме Примерок

1290
01:20:12,000 --> 01:20:14,370
ние сме губење на патеката на која овој покажувачот е да се покажува,

1291
01:20:14,370 --> 01:20:15,750
затоа што ние сме го clobbering.

1292
01:20:15,750 --> 01:20:18,410
Значи, првичниот повик за Примерок ми дава меморија овде.

1293
01:20:18,410 --> 01:20:19,990
Мој покажувачот совети за тоа.

1294
01:20:19,990 --> 01:20:23,020
Сега, јас не го ослободи, па сега јас го нарекувам Примерок повторно.

1295
01:20:23,020 --> 01:20:26,070
Сега тоа укажува овде. Сега мојата меморија е да се покажува овде.

1296
01:20:26,070 --> 01:20:27,640
Посочувајќи овде. Посочувајќи овде.

1297
01:20:27,640 --> 01:20:31,820
Но јас сум се губеше на адресите на сите мемориски овде дека јас распределени.

1298
01:20:31,820 --> 01:20:35,100
И така сега немам никакво повикување на нив повеќе.

1299
01:20:35,100 --> 01:20:37,230
Значи, јас не може да ги ослободи надвор од овој циклус.

1300
01:20:37,230 --> 01:20:39,390
И така, со цел да се поправи нешто како ова,

1301
01:20:39,390 --> 01:20:42,250
ако сте заборавиле да ослободите меморија и ќе се добие оваа меморија излегуваат во јавноста,

1302
01:20:42,250 --> 01:20:45,810
Мора да се ослободи меморија во внатрешноста на овој циклус откако ќе завршиш со него.

1303
01:20:45,810 --> 01:20:51,400
Па, ова е она што се случува. Знам дека многу ве мразат тоа.

1304
01:20:51,400 --> 01:20:55,270
Но сега - Yay! Ќе добиете како 44.000 килобајти.

1305
01:20:55,270 --> 01:20:57,110
Значи, вие се бесплатно на крајот од циклусот,

1306
01:20:57,110 --> 01:20:59,770
и дека се случува само ослободи меморија во секое време.

1307
01:20:59,770 --> 01:21:03,620
Во суштина, вашата програма не имаат меморија излегуваат во јавноста повеќе.

1308
01:21:03,620 --> 01:21:08,150
>> И сега нешто друго можете да направите е бесплатно некои меморија дека сте прашани за двапати.

1309
01:21:08,150 --> 01:21:11,060
Во овој случај, можете Примерок нешто, промени својата вредност.

1310
01:21:11,060 --> 01:21:13,140
Ќе ја ослободи еднаш, бидејќи ти рече дека се направи со неа.

1311
01:21:13,140 --> 01:21:14,940
Но, тогаш ние го ослободи повторно.

1312
01:21:14,940 --> 01:21:16,730
Ова е нешто што е прилично лошо.

1313
01:21:16,730 --> 01:21:18,820
Тоа нема да првично segfault,

1314
01:21:18,820 --> 01:21:23,350
но по некое време тоа што ова не е двојно ослободување ова расипува вашиот грамада структура,

1315
01:21:23,350 --> 01:21:27,200
и ќе дознаете малку повеќе за ова, ако одлучите да се земе една класа како CS61.

1316
01:21:27,200 --> 01:21:30,000
Но во суштина по некое време на вашиот компјутер ќе се збунети

1317
01:21:30,000 --> 01:21:33,010
за она што мемориски локации се таму каде што и каде тоа е се чуваат -

1318
01:21:33,010 --> 01:21:34,800
каде што податоците се чуваат во меморијата.

1319
01:21:34,800 --> 01:21:38,080
И така ослободувањето покажувач двапати е лоша работа што вие не сакате да го направите.

1320
01:21:38,080 --> 01:21:41,600
>> Други работи кои може да тргне наопаку не е користење на sizeof.

1321
01:21:41,600 --> 01:21:44,460
Значи, во овој случај Примерок 8 бајти,

1322
01:21:44,460 --> 01:21:46,700
и тоа е истото како два цели броја, нели?

1323
01:21:46,700 --> 01:21:49,580
Значи, тоа е совршено безбедна, но е тоа?

1324
01:21:49,580 --> 01:21:52,160
Па, како Лукас зборуваше за на различни архитектури,

1325
01:21:52,160 --> 01:21:54,220
броеви се на различни должини.

1326
01:21:54,220 --> 01:21:57,970
Значи, на апаратот кој што го користите, цели броеви се околу 4 бајти,

1327
01:21:57,970 --> 01:22:02,370
но за некои други систем тие би можеле да бидат 8 бајти или тие може да биде 16 бајти.

1328
01:22:02,370 --> 01:22:05,680
Значи, ако јас само го користите овој број над тука,

1329
01:22:05,680 --> 01:22:07,310
оваа програма може да работи на апаратот,

1330
01:22:07,310 --> 01:22:10,360
но тоа не се случува да доделам доволно меморија за некои други систем.

1331
01:22:10,360 --> 01:22:14,020
Во овој случај, тоа е она што на операторот sizeof се користи за.

1332
01:22:14,020 --> 01:22:16,880
Кога ние го нарекуваме sizeof (int), што тоа не е

1333
01:22:16,880 --> 01:22:21,910
 што ни ја дава големината на цел број на систем што на програмата се извршува.

1334
01:22:21,910 --> 01:22:25,490
Значи, во овој случај, sizeof (int) ќе се вратат 4 на нешто како на апаратот,

1335
01:22:25,490 --> 01:22:29,980
и сега ова ќе 4 * 2, кој е 8,

1336
01:22:29,980 --> 01:22:32,330
што е само износот на просторот потребен за два цели броја.

1337
01:22:32,330 --> 01:22:36,710
На друг систем, ако int е како 16 бајти или 8 бајти,

1338
01:22:36,710 --> 01:22:39,380
тоа е само случува да се врати доволно бајти за да ја запази таа сума.

1339
01:22:41,830 --> 01:22:45,310
>> И, конечно, structs.

1340
01:22:45,310 --> 01:22:48,340
Значи, ако си сакал да се складира Судоку одбор во меморија, како да го направите ова?

1341
01:22:48,340 --> 01:22:51,570
Можете да мислите на како променлива за прв нешто,

1342
01:22:51,570 --> 01:22:53,820
променлива за втората работа, променлива за третата работа,

1343
01:22:53,820 --> 01:22:56,420
променлива по четврти работа - лошо, нели?

1344
01:22:56,420 --> 01:23:00,750
Значи, подобрување може да се направи на врвот на ова е да се направи 9 x 9 низа.

1345
01:23:00,750 --> 01:23:04,480
Тоа е во ред, но што ако си сакал да се дружат други работи со одборот Судоку

1346
01:23:04,480 --> 01:23:06,490
како што тешкотијата на одборот е,

1347
01:23:06,490 --> 01:23:11,740
или, на пример, она што вашиот резултат е, или колку време е донесена да се реши овој форум систем?

1348
01:23:11,740 --> 01:23:14,970
Па, она што можете да направите е да можете да креирате struct.

1349
01:23:14,970 --> 01:23:18,910
Она што јас сум во основа велејќи е јас сум дефинирање оваа структура над тука,

1350
01:23:18,910 --> 01:23:23,230
и јас сум дефинирање на Судоку одбор кој се состои од одборот што е 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> И што има тоа има покажувачи за името на ниво.

1352
01:23:26,650 --> 01:23:30,730
Исто така, има x и y, кои се координатите на местото каде што сум сега.

1353
01:23:30,730 --> 01:23:35,980
Исто така, има време поминато [неразбирливо], а таа има вкупниот број на потези сум внесуваат досега.

1354
01:23:35,980 --> 01:23:40,010
И така во овој случај, можам да Група А целиот куп на податоци во само една структура

1355
01:23:40,010 --> 01:23:42,790
наместо тоа како летаат наоколу во како различни варијабли

1356
01:23:42,790 --> 01:23:44,540
дека јас навистина не може да ги пратите.

1357
01:23:44,540 --> 01:23:49,720
И ова ни овозможува да имаат само убаво синтакса за вид на референцирање различни работи во внатрешноста на оваа struct.

1358
01:23:49,720 --> 01:23:53,430
Јас само може да го направи board.board, и јас го добиете Судоку одбор назад.

1359
01:23:53,430 --> 01:23:56,320
Board.level, да се добие колку е тешко е тоа.

1360
01:23:56,320 --> 01:24:00,540
Board.x и board.y ми даде координатите на местото каде што може да биде во одборот.

1361
01:24:00,540 --> 01:24:04,730
И така јас сум пристап што ние го нарекуваме полиња во структурата.

1362
01:24:04,730 --> 01:24:08,840
Ова дефинира sudokuBoard, која е еден вид што имам.

1363
01:24:08,840 --> 01:24:14,800
И сега ние сме тука. Имам променлива наречена "одбор" од типот sudokuBoard.

1364
01:24:14,800 --> 01:24:18,820
Па сега можам да влезам сите области кои ја сочинуваат оваа структура овде.

1365
01:24:20,830 --> 01:24:22,450
>> Било какви прашања во врска со structs? Да?

1366
01:24:22,450 --> 01:24:25,890
[Студентски] За int x, y, можете прогласена и во една линија? >> [Џозеф] Ух-нели.

1367
01:24:25,890 --> 01:24:27,400
[Студентски] Значи, може да ви само го направи тоа со сите нив?

1368
01:24:27,400 --> 01:24:31,200
Како и во x, y запирка пати дека вкупните?

1369
01:24:31,200 --> 01:24:34,460
[Џозеф] Да, дефинитивно може да го направи тоа, но причината ја ставив x и y на иста линија -

1370
01:24:34,460 --> 01:24:36,330
и прашање е зошто можеме само го прават тоа на иста линија?

1371
01:24:36,330 --> 01:24:38,600
Зошто не можеме само да ги ставите сите овие на истата линија е

1372
01:24:38,600 --> 01:24:42,090
x и y се поврзани едни со други,

1373
01:24:42,090 --> 01:24:44,780
и ова е само стилски повеќе точни, во некоја смисла,

1374
01:24:44,780 --> 01:24:46,600
бидејќи тоа е групирање две работи на иста линија

1375
01:24:46,600 --> 01:24:49,340
дека како вид на се однесуваат на иста работа.

1376
01:24:49,340 --> 01:24:51,440
И јас само се подели на овие распаѓа. Тоа е само стил нешто.

1377
01:24:51,440 --> 01:24:53,720
Функционално не прави никаква разлика она.

1378
01:24:58,150 --> 01:24:59,270
Сите други прашања за structs?

1379
01:25:03,030 --> 01:25:06,620
Можете да дефинирате Pokédex со структурата.

1380
01:25:06,620 --> 01:25:11,720
А Покемон има голем број и има писмо, сопственик, тип.

1381
01:25:11,720 --> 01:25:16,990
А потоа ако имате низа на Покемон, можете да направите до Pokédex, нели?

1382
01:25:16,990 --> 01:25:20,810
Океј, кул. Значи, прашањата за structs. Оние кои се поврзани со structs.

1383
01:25:20,810 --> 01:25:25,270
>> Конечно, gdb. Што значи GDB да го направите? Тоа ви овозможува да debug вашата програма.

1384
01:25:25,270 --> 01:25:27,650
И ако не сте го користеле GDB, би препорачува гледање на краток

1385
01:25:27,650 --> 01:25:31,250
и само одат над она што GDB е, како да работат со него, како можете да ја користите,

1386
01:25:31,250 --> 01:25:32,900
и тестирање на програмата.

1387
01:25:32,900 --> 01:25:37,400
И уште па што GDB ви овозможува да направите е тоа што ви овозможува пауза [неразбирливо] до вашата програма

1388
01:25:37,400 --> 01:25:38,920
и практичен линија.

1389
01:25:38,920 --> 01:25:42,600
На пример, сакам да го паузирате извршување на како алинеја 3 од мојата програма,

1390
01:25:42,600 --> 01:25:46,010
и додека јас сум на линија 3 можам да испечатите сите вредности кои се таму.

1391
01:25:46,010 --> 01:25:49,710
И така она што го нарекуваме како задржувањето во линија

1392
01:25:49,710 --> 01:25:52,350
е што ние го нарекуваме овој ставање на точки на прекин на таа линија

1393
01:25:52,350 --> 01:25:55,920
и потоа можеме да печатиме променливи во државата на програмата во тоа време.

1394
01:25:55,920 --> 01:25:58,990
>> Ние можеме да потоа од таму чекор преку програмата линија-по-линија.

1395
01:25:58,990 --> 01:26:03,200
И потоа можеме да се погледне на состојбата на магацинот во тоа време.

1396
01:26:03,200 --> 01:26:08,600
И така, со цел да се користи GDB, она што го правиме е што ние го нарекуваме ѕвекот на датотеката C,

1397
01:26:08,600 --> 01:26:11,290
но ние треба да го положат-ggdb знаме.

1398
01:26:11,290 --> 01:26:15,850
И откако ќе завршиш со кои ние едноставно се кандидира gdb на добиената излезната датотека.

1399
01:26:15,850 --> 01:26:18,810
И така ќе добиете некои како маса на текст, како таков,

1400
01:26:18,810 --> 01:26:21,990
но, навистина сите што треба да направите е да напишете команди на почетокот.

1401
01:26:21,990 --> 01:26:24,250
Пауза главната става точка на прекин на главните.

1402
01:26:24,250 --> 01:26:28,470
Листа на 400 листи на линии на код околу линија 400.

1403
01:26:28,470 --> 01:26:31,410
И така во овој случај вие само може да погледне наоколу и да се каже, ох,

1404
01:26:31,410 --> 01:26:34,360
Сакам да се постави точка на прекин на линија 397, која е на оваа линија,

1405
01:26:34,360 --> 01:26:37,170
а потоа вашата програма работи во тој чекор и тоа се случува да се скрши.

1406
01:26:37,170 --> 01:26:41,120
Тоа се случува да пауза таму, и можете да го испечатите, на пример, вредноста на ниска или висока.

1407
01:26:41,120 --> 01:26:46,410
И така постојат еден куп команди што треба да знаете,

1408
01:26:46,410 --> 01:26:48,660
и ова слајдшоу ќе одат нагоре на веб страната,

1409
01:26:48,660 --> 01:26:54,000
па ако само сакате да референца овие или како да ги стави на вашиот измамник листови, се чувствуваат слободни.

1410
01:26:54,000 --> 01:27:00,650
>> Кул. Тоа беше квиз Преглед 0, а ние ќе останат околу, ако имате било какви прашања.

1411
01:27:00,650 --> 01:27:03,850
Во ред.

1412
01:27:03,850 --> 01:27:09,030
>>  [Аплауз]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]