1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Review] [Câu đố 0]

2
00:00:03,000 --> 00:00:05,000
>> [Lexi Ross, Tommy MacWilliam, Lucas Freitas, Joseph Ong] [Đại học Harvard]

3
00:00:05,000 --> 00:00:08,000
>> [Đây là CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Hey, tất cả mọi người.

5
00:00:10,000 --> 00:00:15,000
Chào mừng bạn đến với phiên xem xét cho 0 Quiz, đang diễn ra này Wednesday.

6
00:00:15,000 --> 00:00:19,000
Những gì chúng ta sẽ làm tối nay, tôi với 3 TFs khác,

7
00:00:19,000 --> 00:00:24,000
và cùng nhau chúng ta sẽ đi qua một đánh giá về những gì chúng tôi đã thực hiện trong khóa học cho đến nay.

8
00:00:24,000 --> 00:00:27,000
Nó sẽ không được 100% toàn diện, nhưng nó sẽ cho bạn một ý tưởng tốt hơn

9
00:00:27,000 --> 00:00:31,000
của những gì bạn đã có và những gì bạn vẫn cần phải học tập trước khi thứ tư.

10
00:00:31,000 --> 00:00:34,000
Và cảm thấy tự do để nâng cao tay của bạn với những câu hỏi như chúng ta sẽ cùng,

11
00:00:34,000 --> 00:00:38,000
nhưng hãy nhớ rằng chúng ta cũng sẽ có một chút ít thời gian vào cuối

12
00:00:38,000 --> 00:00:41,000
nếu chúng tôi nhận được thông qua với một vài phút để phụ tùng để làm các câu hỏi chung chung,

13
00:00:41,000 --> 00:00:47,000
để giữ cho rằng trong tâm trí, và do đó, chúng ta sẽ bắt đầu từ đầu với Tuần 0.

14
00:00:47,000 --> 00:00:50,000
>> [Quiz 0 Review] [0] [Lexi Ross] Nhưng trước khi chúng ta làm chúng ta hãy nói về

15
00:00:50,000 --> 00:00:53,000
các dịch vụ hậu cần của bài kiểm tra.

16
00:00:53,000 --> 00:00:55,000
>> Logistics] [Câu đố diễn ra vào ngày Thứ Tư 10/10 để thay thế cho bài giảng]

17
00:00:55,000 --> 00:00:57,000
>> [(Xem http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf để biết thêm chi tiết)] Đó là ngày thứ tư tháng 10 10.

18
00:00:57,000 --> 00:01:00,000
>> Đó là thứ Tư này, và nếu bạn đi đến URL này ở đây,

19
00:01:00,000 --> 00:01:03,000
mà cũng có thể truy cập từ CS50.net-có một liên kết đến nó

20
00:01:03,000 --> 00:01:06,000
bạn có thể xem thông tin về nơi để đi dựa trên

21
00:01:06,000 --> 00:01:10,000
tên cuối cùng của bạn hoặc liên kết trường học cũng như

22
00:01:10,000 --> 00:01:14,000
nó nói về chính xác những gì các bài kiểm tra sẽ bao gồm các loại câu hỏi mà bạn sẽ nhận được.

23
00:01:14,000 --> 00:01:19,000
Hãy nhớ rằng bạn cũng sẽ có cơ hội xem xét về bài kiểm tra trong phần,

24
00:01:19,000 --> 00:01:21,000
TFs của bạn sẽ được đi qua một số vấn đề thực hành,

25
00:01:21,000 --> 00:01:29,000
và đó là một cơ hội tốt để xem mà bạn vẫn cần phải học cho bài kiểm tra.

26
00:01:29,000 --> 00:01:32,000
Hãy bắt đầu ngay từ đầu với Bytes Bits n '.

27
00:01:32,000 --> 00:01:35,000
Hãy nhớ một chút chỉ là 0 hoặc 1,

28
00:01:35,000 --> 00:01:38,000
và một byte là một bộ sưu tập 8 của những bit.

29
00:01:38,000 --> 00:01:42,000
Hãy nhìn vào bộ sưu tập này của các bit ngay tại đây.

30
00:01:42,000 --> 00:01:44,000
Chúng tôi sẽ có thể để tìm ra bao nhiêu bit.

31
00:01:44,000 --> 00:01:48,000
Nơi mà chúng tôi đếm có 8 trong số họ, tám 0 hoặc 1 đơn vị.

32
00:01:48,000 --> 00:01:51,000
Và kể từ khi có 8 bit, đó là 1 byte,

33
00:01:51,000 --> 00:01:53,000
và chúng ta hãy chuyển nó sang hệ thập lục phân.

34
00:01:53,000 --> 00:01:58,000
Hệ thập lục phân là căn cứ 16, và nó rất dễ dàng để chuyển đổi

35
00:01:58,000 --> 00:02:01,000
một số trong hệ nhị phân, đó là những gì có nghĩa là, một số trong hệ thập lục phân.

36
00:02:01,000 --> 00:02:04,000
Tất cả những gì chúng tôi làm là chúng ta nhìn vào nhóm 4,

37
00:02:04,000 --> 00:02:07,000
và chúng tôi chuyển đổi chúng sang các chữ số thập lục phân thích hợp.

38
00:02:07,000 --> 00:02:11,000
Chúng tôi bắt đầu với nhóm phải nhất của 4, 0011.

39
00:02:11,000 --> 00:02:16,000
Đó sẽ là một 1 và một trong 2, vì vậy với nhau mà làm cho 3.

40
00:02:16,000 --> 00:02:19,000
Và sau đó chúng ta hãy nhìn vào các khối khác 4.

41
00:02:19,000 --> 00:02:24,000
1101. Đó sẽ là một 1, 4, và một trong 8.

42
00:02:24,000 --> 00:02:28,000
Cùng đó là sẽ là 13, mà làm cho D.

43
00:02:28,000 --> 00:02:32,000
Và chúng tôi sẽ nhớ rằng trong hệ thập lục phân, chúng tôi không chỉ cần đi từ 0 đến 9.

44
00:02:32,000 --> 00:02:36,000
Chúng tôi đi 0 đến F, vì vậy sau 9, 10 tương ứng với A,

45
00:02:36,000 --> 00:02:40,000
11 đến B, vân vân đó F là 15.

46
00:02:40,000 --> 00:02:44,000
Ở đây 13 là một D,

47
00:02:44,000 --> 00:02:49,000
do đó, để chuyển đổi nó sang thập phân tất cả những gì chúng ta làm là chúng tôi thực sự

48
00:02:49,000 --> 00:02:52,000
điều trị từng vị trí như là một sức mạnh của 2.

49
00:02:52,000 --> 00:02:58,000
Đó là một trong 1, 2, không 4s, không 8s, là một trong 16, vân vân,

50
00:02:58,000 --> 00:03:03,000
và đó là một chút khó để tính toán trong đầu của bạn, nhưng nếu chúng ta đi sang slide tiếp theo

51
00:03:03,000 --> 00:03:05,000
chúng ta có thể thấy câu trả lời cho điều đó.

52
00:03:05,000 --> 00:03:09,000
>> Về cơ bản chúng ta sẽ đối diện từ bên phải sang trái,

53
00:03:09,000 --> 00:03:14,000
và chúng tôi đang nhân mỗi chữ số bằng năng lực tương ứng của 2.

54
00:03:14,000 --> 00:03:19,000
Và hãy nhớ, cho hệ thập lục phân, chúng ta biểu thị những con số này với 0x ở đầu

55
00:03:19,000 --> 00:03:23,000
nên chúng tôi không nhầm lẫn nó với một số thập phân.

56
00:03:23,000 --> 00:03:29,000
Tiếp tục trên, đây là một bảng ASCII,

57
00:03:29,000 --> 00:03:35,000
và những gì chúng tôi sử dụng mã ASCII là bản đồ từ các nhân vật giá trị số.

58
00:03:35,000 --> 00:03:39,000
Nhớ trong pset mật mã, chúng tôi đã sử dụng rộng rãi của bảng ASCII

59
00:03:39,000 --> 00:03:43,000
để sử dụng các phương pháp khác nhau về mật mã,

60
00:03:43,000 --> 00:03:47,000
Caesar và mật mã Vigenère, để chuyển đổi các chữ cái khác nhau

61
00:03:47,000 --> 00:03:52,000
trong một chuỗi theo phím được đưa ra bởi người sử dụng.

62
00:03:52,000 --> 00:03:56,000
Hãy xem xét một chút về môn toán ASCII.

63
00:03:56,000 --> 00:04:02,000
Nhìn vào 'P' + 1, ở dạng nhân vật đó sẽ là Q,

64
00:04:02,000 --> 00:04:07,000
và nhớ rằng '5 '≠ 5.

65
00:04:07,000 --> 00:04:10,000
Và cách chính xác chúng tôi sẽ chuyển đổi giữa 2 hình thức?

66
00:04:10,000 --> 00:04:13,000
Nó không thực sự quá khó khăn.

67
00:04:13,000 --> 00:04:16,000
Để nhận được 5 chúng ta trừ đi '0 '

68
00:04:16,000 --> 00:04:20,000
bởi vì có 5 nơi giữa '0 'và '5'.

69
00:04:20,000 --> 00:04:23,000
Để đi theo cách khác chúng ta chỉ cần thêm số 0,

70
00:04:23,000 --> 00:04:25,000
vì vậy nó là loại giống như số học thường xuyên.

71
00:04:25,000 --> 00:04:29,000
Chỉ cần nhớ rằng khi một cái gì đó có dấu ngoặc kép xung quanh nó là một nhân vật

72
00:04:29,000 --> 00:04:37,000
và do đó tương ứng với một giá trị trong bảng mã ASCII.

73
00:04:37,000 --> 00:04:40,000
Di chuyển vào các chủ đề khoa học chung máy tính.

74
00:04:40,000 --> 00:04:43,000
Chúng tôi đã học được những gì một thuật toán và làm thế nào chúng ta sử dụng lập trình

75
00:04:43,000 --> 00:04:45,000
để thực hiện các thuật toán.

76
00:04:45,000 --> 00:04:48,000
Một số ví dụ của các thuật toán là một cái gì đó thực sự đơn giản như

77
00:04:48,000 --> 00:04:51,000
kiểm tra xem một số là số chẵn hoặc lẻ.

78
00:04:51,000 --> 00:04:54,000
Cho rằng nhớ là chúng tôi mod số 2 và kiểm tra nếu kết quả là 0.

79
00:04:54,000 --> 00:04:57,000
Nếu vậy, nó thậm chí còn. Nếu không, thật kỳ lạ.

80
00:04:57,000 --> 00:04:59,000
Và đó là một ví dụ về một thuật toán thực sự cơ bản.

81
00:04:59,000 --> 00:05:02,000
>> Một chút của một tham gia nhiều hơn là tìm kiếm nhị phân,

82
00:05:02,000 --> 00:05:05,000
mà chúng ta sẽ đi qua trong phiên xem xét.

83
00:05:05,000 --> 00:05:09,000
Và lập trình là thuật ngữ chúng tôi sử dụng một thuật toán

84
00:05:09,000 --> 00:05:15,000
và chuyển đổi nó để mã máy tính có thể đọc.

85
00:05:15,000 --> 00:05:20,000
2 ví dụ về lập trình Scratch,

86
00:05:20,000 --> 00:05:22,000
đó là những gì chúng tôi đã làm trong tuần 0.

87
00:05:22,000 --> 00:05:25,000
Mặc dù chúng tôi không thực sự loại ra các mã đó là một cách thực hiện

88
00:05:25,000 --> 00:05:29,000
thuật toán này, được in các số 1-10,

89
00:05:29,000 --> 00:05:32,000
và ở đây chúng tôi làm như vậy trong ngôn ngữ lập trình C.

90
00:05:32,000 --> 00:05:41,000
Đây là những chức năng tương đương, chỉ cần viết bằng ngôn ngữ khác nhau hoặc cú pháp.

91
00:05:41,000 --> 00:05:44,000
Sau đó chúng tôi đã học được về các biểu thức boolean,

92
00:05:44,000 --> 00:05:48,000
và boolean là một giá trị đó là đúng hoặc sai,

93
00:05:48,000 --> 00:05:51,000
và ở đây trong mọi biểu thức boolean

94
00:05:51,000 --> 00:05:55,000
đi vào bên trong các điều kiện, vì vậy nếu (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
tốt, chúng tôi đã được thiết lập x = 5, do đó, điều kiện được đi để đánh giá đúng sự thật.

96
00:06:00,000 --> 00:06:03,000
Và nếu đó là sự thật, bất cứ điều gì đang ở dưới điều kiện

97
00:06:03,000 --> 00:06:08,000
sẽ được đánh giá bằng máy tính, do đó chuỗi sẽ được in

98
00:06:08,000 --> 00:06:12,000
đầu ra tiêu chuẩn, và tình trạng hạn

99
00:06:12,000 --> 00:06:16,000
đề cập đến bất cứ điều gì là bên trong dấu ngoặc đơn của câu lệnh if.

100
00:06:16,000 --> 00:06:20,000
Nhớ tất cả các nhà khai thác.

101
00:06:20,000 --> 00:06:26,000
Ghi && và | | khi chúng tôi đang cố gắng để kết hợp 2 hoặc nhiều điều kiện,

102
00:06:26,000 --> 00:06:30,000
== Không = để kiểm tra xem 2 điều này là bình đẳng.

103
00:06:30,000 --> 00:06:36,000
Hãy nhớ rằng = là chuyển nhượng trong khi == là một nhà điều hành boolean.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ và sau đó cuối cùng 2 tự giải thích.

105
00:06:41,000 --> 00:06:45,000
Một đánh giá chung của logic boolean ở đây.

106
00:06:45,000 --> 00:06:48,000
Và biểu thức boolean cũng rất quan trọng trong các vòng lặp,

107
00:06:48,000 --> 00:06:50,000
mà chúng ta sẽ đi qua.

108
00:06:50,000 --> 00:06:56,000
Chúng tôi đã học được khoảng 3 loại của các vòng cho đến nay năm CS50,, trong khi, và làm trong khi.

109
00:06:56,000 --> 00:06:59,000
Và điều quan trọng là phải biết rằng trong khi đối với hầu hết các mục đích

110
00:06:59,000 --> 00:07:02,000
chúng tôi thực sự có thể sử dụng bất kỳ loại vòng lặp thường

111
00:07:02,000 --> 00:07:06,000
có một số loại mục đích hoặc các mẫu phổ biến

112
00:07:06,000 --> 00:07:09,000
trong lập trình cụ thể gọi cho một trong những vòng

113
00:07:09,000 --> 00:07:13,000
mà làm cho nó hiệu quả nhất hoặc thanh lịch để mã nó theo cách đó.

114
00:07:13,000 --> 00:07:18,000
Hãy đi qua những gì mỗi của những vòng có xu hướng được sử dụng thường xuyên nhất.

115
00:07:18,000 --> 00:07:21,000
>> Trong một vòng lặp for, chúng ta thường đã biết bao nhiêu lần chúng ta muốn để lặp.

116
00:07:21,000 --> 00:07:24,000
Đó là những gì chúng ta đặt trong tình trạng này.

117
00:07:24,000 --> 00:07:28,000
Đối với, i = 0, i <10, ví dụ.

118
00:07:28,000 --> 00:07:31,000
Chúng ta đã biết rằng chúng tôi muốn làm một cái gì đó 10 lần.

119
00:07:31,000 --> 00:07:34,000
Bây giờ, cho một vòng lặp trong khi, nói chung chúng tôi không nhất thiết phải

120
00:07:34,000 --> 00:07:36,000
biết bao nhiêu lần chúng tôi muốn vòng lặp để chạy.

121
00:07:36,000 --> 00:07:39,000
Nhưng chúng tôi biết một số loại điều kiện mà chúng ta muốn nó

122
00:07:39,000 --> 00:07:41,000
luôn luôn đúng hoặc luôn luôn là sai lầm.

123
00:07:41,000 --> 00:07:44,000
Ví dụ, khi được thiết lập.

124
00:07:44,000 --> 00:07:46,000
Hãy nói rằng đó là một biến boolean.

125
00:07:46,000 --> 00:07:48,000
Trong khi đó là sự thật, chúng tôi muốn code để đánh giá,

126
00:07:48,000 --> 00:07:52,000
do đó, một chút mở rộng hơn, một chút tổng quát hơn so với một vòng lặp for,

127
00:07:52,000 --> 00:07:55,000
nhưng bất kỳ vòng lặp for cũng có thể được chuyển đổi thành một vòng lặp while.

128
00:07:55,000 --> 00:08:00,000
Cuối cùng, làm trong khi vòng lặp, có thể là khó khăn nhất để hiểu ngay,

129
00:08:00,000 --> 00:08:04,000
thường được sử dụng khi chúng ta muốn đánh giá các mã đầu tiên

130
00:08:04,000 --> 00:08:06,000
trước khi lần đầu tiên chúng ta kiểm tra điều kiện.

131
00:08:06,000 --> 00:08:09,000
Một trường hợp sử dụng phổ biến cho một làm trong khi vòng lặp

132
00:08:09,000 --> 00:08:12,000
là khi bạn muốn để có được đầu vào của người dùng, và bạn biết bạn muốn yêu cầu người dùng

133
00:08:12,000 --> 00:08:15,000
cho đầu vào ít nhất một lần, nhưng nếu họ không cung cấp cho bạn nhập tốt ngay

134
00:08:15,000 --> 00:08:18,000
bạn muốn giữ lại yêu cầu họ cho đến khi họ cung cấp cho bạn các đầu vào tốt.

135
00:08:18,000 --> 00:08:21,000
Đó là việc sử dụng phổ biến nhất của một vòng lặp trong khi,

136
00:08:21,000 --> 00:08:23,000
và chúng ta hãy nhìn vào cấu trúc thực tế của các vòng lặp.

137
00:08:23,000 --> 00:08:27,000
Họ thường luôn luôn có xu hướng làm theo các mô hình.

138
00:08:27,000 --> 00:08:30,000
>> Trên vòng lặp cho bên trong, bạn có 3 thành phần:

139
00:08:30,000 --> 00:08:35,000
khởi tạo, kiểu như int i = 0 nơi mà tôi là bộ đếm,

140
00:08:35,000 --> 00:08:40,000
điều kiện, mà chúng tôi muốn nói chạy vòng lặp như lâu như tình trạng này vẫn còn giữ,

141
00:08:40,000 --> 00:08:44,000
như i <10, và cuối cùng, cập nhật, đó là làm thế nào chúng ta tăng

142
00:08:44,000 --> 00:08:47,000
biến đếm tại mỗi điểm trong vòng lặp.

143
00:08:47,000 --> 00:08:50,000
Một điều phổ biến để xem có chỉ là i + +,

144
00:08:50,000 --> 00:08:52,000
có nghĩa là tăng i lên 1 mỗi lần.

145
00:08:52,000 --> 00:08:55,000
Bạn cũng có thể làm một cái gì đó giống như i + = 2,

146
00:08:55,000 --> 00:08:58,000
có nghĩa là thêm 2 đến tôi mỗi khi bạn đi qua vòng lặp.

147
00:08:58,000 --> 00:09:03,000
Và sau đó làm điều này chỉ đề cập đến bất kỳ mã mà thực sự chạy như là một phần của vòng lặp.

148
00:09:03,000 --> 00:09:09,000
Và đối với một vòng lặp trong khi, lần này chúng tôi thực sự có việc khởi tạo bên ngoài vòng lặp,

149
00:09:09,000 --> 00:09:12,000
ví dụ như vậy, chúng ta hãy nói rằng chúng tôi đang cố gắng để làm cùng một loại vòng lặp như tôi vừa mô tả.

150
00:09:12,000 --> 00:09:16,000
Chúng tôi sẽ nói int i = 0 trước khi vòng lặp bắt đầu.

151
00:09:16,000 --> 00:09:20,000
Sau đó, chúng ta có thể nói rằng trong khi tôi <10 làm điều này,

152
00:09:20,000 --> 00:09:22,000
vì vậy cùng một khối mã như trước,

153
00:09:22,000 --> 00:09:26,000
và lần này phần cập nhật của mã này, ví dụ, i + +,

154
00:09:26,000 --> 00:09:29,000
thực sự đi bên trong của vòng lặp.

155
00:09:29,000 --> 00:09:33,000
Và cuối cùng, cho làm trong khi, nó tương tự như vòng lặp while,

156
00:09:33,000 --> 00:09:36,000
nhưng chúng ta phải nhớ rằng mã sẽ đánh giá một lần

157
00:09:36,000 --> 00:09:40,000
trước khi điều kiện được kiểm tra, vì vậy nó làm cho rất nhiều ý nghĩa hơn

158
00:09:40,000 --> 00:09:44,000
nếu bạn nhìn vào nó theo thứ tự trên xuống dưới.

159
00:09:44,000 --> 00:09:49,000
Trong một, làm trong khi vòng lặp mã đánh giá thậm chí trước khi bạn nhìn vào các điều kiện trong khi

160
00:09:49,000 --> 00:09:55,000
trong khi một vòng lặp while, nó kiểm tra đầu tiên.

161
00:09:55,000 --> 00:09:59,000
Báo cáo và các biến.

162
00:09:59,000 --> 00:10:04,000
Khi chúng ta muốn tạo một biến mới, đầu tiên chúng ta muốn khởi tạo nó.

163
00:10:04,000 --> 00:10:07,000
>> Ví dụ, int bar khởi tạo biến thanh,

164
00:10:07,000 --> 00:10:10,000
nhưng nó không cung cấp cho nó một giá trị, do đó, giá trị của thanh là những gì bây giờ?

165
00:10:10,000 --> 00:10:12,000
Chúng tôi không biết.

166
00:10:12,000 --> 00:10:14,000
Nó có thể là một số giá trị mà trước đó đã được lưu trữ trong bộ nhớ có rác,

167
00:10:14,000 --> 00:10:16,000
và chúng tôi không muốn sử dụng biến

168
00:10:16,000 --> 00:10:19,000
cho đến khi chúng tôi thực sự cung cấp cho nó một giá trị,

169
00:10:19,000 --> 00:10:21,000
do đó, chúng ta khai báo nó ở đây.

170
00:10:21,000 --> 00:10:24,000
Sau đó, chúng ta khởi tạo nó là 42 dưới đây.

171
00:10:24,000 --> 00:10:28,000
Bây giờ, tất nhiên, chúng ta biết điều này có thể được thực hiện trên một dòng, int bar = 42.

172
00:10:28,000 --> 00:10:30,000
Nhưng chỉ để được rõ ràng nhiều bước mà đang xảy ra,

173
00:10:30,000 --> 00:10:34,000
khai báo và khởi tạo đang diễn ra một cách riêng biệt ở đây.

174
00:10:34,000 --> 00:10:38,000
Nó xảy ra trên một bước, và một trong những kế tiếp, int baz = bar + 1,

175
00:10:38,000 --> 00:10:44,000
tuyên bố này dưới đây, đó baz tăng, do đó, ở phần cuối của khối mã này

176
00:10:44,000 --> 00:10:48,000
nếu chúng ta để in các giá trị của baz nó sẽ là 44

177
00:10:48,000 --> 00:10:52,000
bởi vì chúng ta khai báo và khởi tạo nó là 1> thanh,

178
00:10:52,000 --> 00:10:58,000
và sau đó chúng tôi tăng nó một lần nữa với + +.

179
00:10:58,000 --> 00:11:02,000
Chúng tôi đã đi qua này một thời gian ngắn khá, nhưng nó rất tốt để có một vị tướng

180
00:11:02,000 --> 00:11:04,000
sự hiểu biết về những gì các chủ đề và các sự kiện.

181
00:11:04,000 --> 00:11:06,000
Chúng tôi chủ yếu đã làm điều này trong Scratch,

182
00:11:06,000 --> 00:11:09,000
vì vậy bạn có thể nghĩ các chủ đề như nhiều chuỗi mã

183
00:11:09,000 --> 00:11:11,000
chạy cùng một lúc.

184
00:11:11,000 --> 00:11:14,000
Trong thực tế, nó có thể không chạy cùng một lúc,

185
00:11:14,000 --> 00:11:17,000
nhưng loại trừu tượng chúng ta có thể nghĩ về nó theo cách đó.

186
00:11:17,000 --> 00:11:20,000
>> Scratch, ví dụ, chúng tôi đã có nhiều sprites.

187
00:11:20,000 --> 00:11:22,000
Nó có thể được thực thi mã khác nhau cùng một lúc.

188
00:11:22,000 --> 00:11:26,000
Một người có thể được đi bộ trong khi người kia đang nói điều gì đó

189
00:11:26,000 --> 00:11:29,000
trong một phần khác nhau của màn hình.

190
00:11:29,000 --> 00:11:34,000
Sự kiện này là một cách khác để tách ra logic

191
00:11:34,000 --> 00:11:37,000
giữa các yếu tố khác nhau của mã của bạn,

192
00:11:37,000 --> 00:11:40,000
và trong Scratch, chúng tôi đã có thể để mô phỏng các sự kiện bằng cách sử dụng Bảng phát hình,

193
00:11:40,000 --> 00:11:43,000
và đó là thực sự khi tôi nhận được, không phải khi tôi nghe,

194
00:11:43,000 --> 00:11:47,000
nhưng về cơ bản đó là một cách để truyền thông tin

195
00:11:47,000 --> 00:11:49,000
từ một sprite khác.

196
00:11:49,000 --> 00:11:52,000
Ví dụ, bạn có thể muốn truyền tải trò chơi trên,

197
00:11:52,000 --> 00:11:56,000
và khi sprite khác nhận được trò chơi trên,

198
00:11:56,000 --> 00:11:58,000
nó phản ứng theo một cách nhất định.

199
00:11:58,000 --> 00:12:03,000
Đây là một mô hình quan trọng để hiểu cho lập trình.

200
00:12:03,000 --> 00:12:07,000
Chỉ cần đi qua Tuần cơ bản 0, những gì chúng tôi đã đi qua cho đến nay,

201
00:12:07,000 --> 00:12:10,000
chúng ta hãy nhìn vào chương trình C đơn giản này.

202
00:12:10,000 --> 00:12:14,000
Các văn bản có thể là một chút nhỏ từ đây, nhưng tôi sẽ đi qua nó thực sự nhanh chóng.

203
00:12:14,000 --> 00:12:20,000
Chúng tôi bao gồm 2 tập tin tiêu đề, đầu cs50.h và stdio.h.

204
00:12:20,000 --> 00:12:23,000
Chúng tôi sau đó xác định một giới hạn được gọi là liên tục là 100.

205
00:12:23,000 --> 00:12:26,000
Sau đó chúng tôi đang thực hiện các chức năng chính của chúng tôi.

206
00:12:26,000 --> 00:12:29,000
Vì chúng ta không sử dụng đối số dòng lệnh ở đây, chúng ta cần đặt khoảng trống

207
00:12:29,000 --> 00:12:32,000
như là đối số cho chính.

208
00:12:32,000 --> 00:12:38,000
Chúng tôi thấy int trên chính. Đó là kiểu trả về, do đó trở về 0 ở phía dưới.

209
00:12:38,000 --> 00:12:41,000
Và chúng tôi đang sử dụng CS50 chức năng thư viện có được int

210
00:12:41,000 --> 00:12:45,000
yêu cầu người dùng cho đầu vào, và chúng tôi lưu trữ nó trong biến x,

211
00:12:45,000 --> 00:12:51,000
do đó, chúng ta khai báo x ở trên, và chúng tôi khởi tạo nó với x = getInt.

212
00:12:51,000 --> 00:12:53,000
>> Chúng tôi sau đó kiểm tra xem nếu người sử dụng đã cho chúng ta đầu vào tốt.

213
00:12:53,000 --> 00:12:59,000
Nếu đó là ≥ LIMIT chúng tôi muốn trả lại một mã lỗi của 1 và in thông báo lỗi.

214
00:12:59,000 --> 00:13:02,000
Và cuối cùng, nếu người sử dụng đã cho chúng ta tốt đầu vào

215
00:13:02,000 --> 00:13:08,000
chúng ta sẽ vuông vắn số và in ra kết quả đó.

216
00:13:08,000 --> 00:13:11,000
Chỉ cần bảo đảm rằng tất cả các nhà hit

217
00:13:11,000 --> 00:13:17,000
bạn sẽ nhìn thấy nhãn của các bộ phận khác nhau của mã ở đây.

218
00:13:17,000 --> 00:13:19,000
Tôi đã đề cập liên tục, tập tin tiêu đề.

219
00:13:19,000 --> 00:13:21,000
Ồ, int x. Hãy chắc chắn để nhớ đó là một biến địa phương.

220
00:13:21,000 --> 00:13:24,000
Tương phản từ một biến toàn cầu, mà chúng ta sẽ nói về

221
00:13:24,000 --> 00:13:27,000
một chút sau đó trong phiên xem xét,

222
00:13:27,000 --> 00:13:30,000
và chúng tôi đang kêu gọi các chức năng thư viện printf,

223
00:13:30,000 --> 00:13:34,000
vì vậy nếu chúng tôi đã không bao gồm các tập tin header stdio.h

224
00:13:34,000 --> 00:13:37,000
chúng tôi sẽ không thể gọi printf.

225
00:13:37,000 --> 00:13:42,000
Và tôi tin rằng mũi tên đó đã cắt được trỏ đến% d,

226
00:13:42,000 --> 00:13:45,000
đó là một chuỗi định dạng trong printf.

227
00:13:45,000 --> 00:13:52,000
Nó nói in ra biến này như một số% d,.

228
00:13:52,000 --> 00:13:58,000
Và đó là nó cho Tuần lễ 0.

229
00:13:58,000 --> 00:14:06,000
Bây giờ Lucas sẽ để tiếp tục.

230
00:14:06,000 --> 00:14:08,000
Hey, guys. Tên tôi là Lucas.

231
00:14:08,000 --> 00:14:10,000
Tôi là một sinh viên năm thứ hai trong nhà tốt nhất trong trường, Mather,

232
00:14:10,000 --> 00:14:14,000
và tôi sẽ nói một chút về Tuần 1 và 2,1.

233
00:14:14,000 --> 00:14:16,000
[Tuần 1 và 2,1!] [Lucas Freitas]

234
00:14:16,000 --> 00:14:19,000
Như Lexi đã nói, khi chúng tôi bắt đầu dịch mã của bạn từ Scratch C

235
00:14:19,000 --> 00:14:23,000
một trong những điều mà chúng tôi nhận thấy rằng bạn không thể chỉ

236
00:14:23,000 --> 00:14:26,000
viết mã của bạn và chạy nó bằng cách sử dụng một lá cờ màu xanh lá cây nữa.

237
00:14:26,000 --> 00:14:30,000
Trên thực tế, bạn phải sử dụng một số bước để làm cho chương trình C của bạn

238
00:14:30,000 --> 00:14:33,000
trở thành một tập tin thực thi.

239
00:14:33,000 --> 00:14:36,000
Về cơ bản những gì bạn làm khi bạn đang viết một chương trình là

240
00:14:36,000 --> 00:14:40,000
bạn dịch ý tưởng của bạn thành một ngôn ngữ mà một trình biên dịch có thể hiểu được,

241
00:14:40,000 --> 00:14:44,000
vì vậy khi bạn đang viết một chương trình trong C

242
00:14:44,000 --> 00:14:47,000
những gì bạn đang làm là thực sự viết một cái gì đó mà trình biên dịch của bạn sẽ hiểu,

243
00:14:47,000 --> 00:14:50,000
và sau đó trình biên dịch sẽ dịch rằng mã

244
00:14:50,000 --> 00:14:53,000
thành một cái gì đó mà máy tính của bạn sẽ hiểu.

245
00:14:53,000 --> 00:14:55,000
>> Và điều, máy tính của bạn thực sự là rất ngu ngốc.

246
00:14:55,000 --> 00:14:57,000
Máy tính của bạn chỉ có thể hiểu 0 và 1,

247
00:14:57,000 --> 00:15:01,000
do đó, thực sự trong các máy tính đầu tiên người ta thường lập trình

248
00:15:01,000 --> 00:15:04,000
sử dụng 0 và 1, nhưng không được nữa, cảm ơn Chúa.

249
00:15:04,000 --> 00:15:07,000
Chúng tôi không có để ghi nhớ các chuỗi 0 và 1

250
00:15:07,000 --> 00:15:10,000
cho một vòng lặp hoặc một vòng lặp while và do đó.

251
00:15:10,000 --> 00:15:13,000
Đó là lý do tại sao chúng tôi có một trình biên dịch.

252
00:15:13,000 --> 00:15:17,000
Một trình biên dịch là nó về cơ bản dịch mã C,

253
00:15:17,000 --> 00:15:21,000
trong trường hợp của chúng tôi, một ngôn ngữ mà máy tính của bạn sẽ hiểu,

254
00:15:21,000 --> 00:15:25,000
đó là mã đối tượng, và trình biên dịch mà chúng tôi đang sử dụng

255
00:15:25,000 --> 00:15:30,000
được gọi là kêu vang, vì vậy đây thực sự là biểu tượng cho kêu vang.

256
00:15:30,000 --> 00:15:33,000
Khi bạn đã có chương trình của bạn, bạn phải làm 2 việc.

257
00:15:33,000 --> 00:15:37,000
Trước tiên, bạn phải biên dịch chương trình của bạn, và sau đó bạn sẽ để chạy chương trình của bạn.

258
00:15:37,000 --> 00:15:41,000
Để biên dịch chương trình của bạn, bạn có rất nhiều lựa chọn để làm như vậy.

259
00:15:41,000 --> 00:15:44,000
Người đầu tiên là làm program.c kêu vang

260
00:15:44,000 --> 00:15:47,000
mà các chương trình là tên của chương trình của bạn.

261
00:15:47,000 --> 00:15:51,000
Trong trường hợp này, bạn có thể thấy chúng tôi chỉ nói rằng "Hey, biên dịch chương trình của tôi."

262
00:15:51,000 --> 00:15:56,000
Bạn tôi không nói rằng: "Tôi muốn tên này cho chương trình của tôi" hoặc bất cứ điều gì.

263
00:15:56,000 --> 00:15:58,000
>> Lựa chọn thứ hai là đưa ra một tên cho chương trình của bạn.

264
00:15:58,000 --> 00:16:02,000
Bạn có thể nói kêu vang-o và sau đó là tên mà bạn muốn

265
00:16:02,000 --> 00:16:06,000
các tập tin thực thi được đặt tên là và sau đó program.c.

266
00:16:06,000 --> 00:16:11,000
Và bạn cũng có thể làm cho chương trình và xem như thế nào trong 2 trường hợp đầu tiên

267
00:16:11,000 --> 00:16:15,000
Tôi đặt c, và trong 1/3, tôi chỉ có các chương trình?

268
00:16:15,000 --> 00:16:18,000
Yeah, bạn thực sự không nên đặt c khi bạn sử dụng.

269
00:16:18,000 --> 00:16:22,000
Nếu không, các trình biên dịch thực sự là sẽ hét vào mặt bạn.

270
00:16:22,000 --> 00:16:24,000
Và cũng có thể, tôi không biết nếu các bạn nhớ,

271
00:16:24,000 --> 00:16:29,000
nhưng rất nhiều lần chúng tôi cũng được sử dụng lcs50,-lm.

272
00:16:29,000 --> 00:16:31,000
Điều đó được gọi là liên kết.

273
00:16:31,000 --> 00:16:35,000
Nó chỉ nói cho trình biên dịch mà bạn sẽ sử dụng các thư viện phải có,

274
00:16:35,000 --> 00:16:39,000
vì vậy nếu bạn muốn sử dụng cs50.h bạn thực sự phải gõ

275
00:16:39,000 --> 00:16:43,000
kêu vang program.c-lcs50.

276
00:16:43,000 --> 00:16:45,000
Nếu bạn không làm điều đó, trình biên dịch sẽ không biết

277
00:16:45,000 --> 00:16:50,000
mà bạn đang sử dụng các chức năng trong cs50.h.

278
00:16:50,000 --> 00:16:52,000
Và khi bạn muốn chạy chương trình của bạn, bạn có 2 lựa chọn.

279
00:16:52,000 --> 00:16:57,000
Nếu bạn đã làm program.c kêu vang, bạn đã không đặt tên cho chương trình của bạn.

280
00:16:57,000 --> 00:17:01,000
Bạn phải chạy nó bằng cách sử dụng / a.out..

281
00:17:01,000 --> 00:17:06,000
A.out là một cái tên tiêu chuẩn mà kêu vang cho chương trình của bạn nếu bạn không cung cấp cho nó một cái tên.

282
00:17:06,000 --> 00:17:11,000
Nếu không, bạn sẽ làm gì / chương trình. Nếu bạn đặt tên cho chương trình của bạn,

283
00:17:11,000 --> 00:17:15,000
và cũng có thể nếu bạn đã làm cho chương trình tên một chương trình đang đi để có được

284
00:17:15,000 --> 00:17:23,000
đã được lập trình cùng tên với tập tin c.

285
00:17:23,000 --> 00:17:26,000
Sau đó, chúng tôi nói chuyện về các loại dữ liệu và dữ liệu.

286
00:17:26,000 --> 00:17:31,000
>> Về cơ bản các loại dữ liệu là điều tương tự như hộp nhỏ mà họ sử dụng

287
00:17:31,000 --> 00:17:35,000
để lưu trữ các giá trị, do đó, các kiểu dữ liệu thực sự giống như Pokemon.

288
00:17:35,000 --> 00:17:39,000
Họ đi vào tất cả các kích cỡ và các loại.

289
00:17:39,000 --> 00:17:43,000
Tôi không biết nếu tương tự có ý nghĩa.

290
00:17:43,000 --> 00:17:46,000
Kích thước dữ liệu thực sự phụ thuộc vào cấu trúc máy tính.

291
00:17:46,000 --> 00:17:49,000
Tất cả các dữ liệu kích thước mà tôi sẽ để hiển thị ở đây

292
00:17:49,000 --> 00:17:53,000
thực sự cho một máy 32-bit, đó là trường hợp thiết bị của chúng tôi,

293
00:17:53,000 --> 00:17:56,000
nhưng nếu bạn thực sự mã hóa máy Mac của bạn hoặc trong một Windows

294
00:17:56,000 --> 00:17:59,000
có thể là bạn đang đi để có một máy tính 64-bit,

295
00:17:59,000 --> 00:18:03,000
do đó, hãy nhớ rằng các kích thước dữ liệu mà tôi sẽ hiển thị ở đây

296
00:18:03,000 --> 00:18:06,000
cho các máy tính 32-bit.

297
00:18:06,000 --> 00:18:08,000
Người đầu tiên mà chúng ta thấy là một int,

298
00:18:08,000 --> 00:18:10,000
đó là khá đơn giản.

299
00:18:10,000 --> 00:18:13,000
Bạn sử dụng int để lưu trữ một số nguyên.

300
00:18:13,000 --> 00:18:16,000
Chúng tôi cũng thấy các nhân vật, các char.

301
00:18:16,000 --> 00:18:20,000
Nếu bạn muốn sử dụng một lá thư hoặc biểu tượng một chút, bạn có thể sẽ sử dụng một char.

302
00:18:20,000 --> 00:18:26,000
Một char có 1 byte, có nghĩa là 8 bit, như Lexi nói.

303
00:18:26,000 --> 00:18:31,000
Về cơ bản chúng ta có một bảng ASCII có 256

304
00:18:31,000 --> 00:18:34,000
kết hợp có thể có của số 0 và số 1,

305
00:18:34,000 --> 00:18:37,000
và sau đó khi bạn gõ một char nó sẽ dịch

306
00:18:37,000 --> 00:18:44,000
nhân vật mà đầu vào cho bạn một số mà bạn có trong bảng mã ASCII, như Lexi.

307
00:18:44,000 --> 00:18:48,000
Chúng tôi cũng có float, mà chúng tôi sử dụng để lưu trữ các số thập phân.

308
00:18:48,000 --> 00:18:53,000
Nếu bạn muốn chọn 3,14, ví dụ, bạn sẽ sử dụng một phao

309
00:18:53,000 --> 00:18:55,000
hoặc một đôi có độ chính xác hơn.

310
00:18:55,000 --> 00:18:57,000
Float A có 4 byte.

311
00:18:57,000 --> 00:19:01,000
Đôi A có 8 byte, do đó, sự khác biệt duy nhất là độ chính xác.

312
00:19:01,000 --> 00:19:04,000
Chúng tôi cũng có một thời gian dài được sử dụng cho các số nguyên,

313
00:19:04,000 --> 00:19:09,000
và bạn có thể nhìn thấy cho một máy tính 32-bit một int và một thời gian dài có cùng kích thước,

314
00:19:09,000 --> 00:19:13,000
vì vậy nó không thực sự làm cho cảm giác sử dụng một thời gian dài trong một máy tính 32-bit.

315
00:19:13,000 --> 00:19:17,000
>> Nhưng nếu bạn đang sử dụng một máy Mac và 64-bit, thực sự là một dài có kích thước 8,

316
00:19:17,000 --> 00:19:19,000
do đó, nó thực sự phụ thuộc vào kiến ​​trúc.

317
00:19:19,000 --> 00:19:22,000
Đối với các máy 32-bit, nó không làm cho cảm giác sử dụng một thời gian dài thực sự.

318
00:19:22,000 --> 00:19:25,000
Và sau đó một lâu dài, mặt khác, có 8 byte,

319
00:19:25,000 --> 00:19:30,000
do đó, nó là rất tốt nếu bạn muốn có một số nguyên lâu hơn.

320
00:19:30,000 --> 00:19:34,000
Và cuối cùng, chúng ta có chuỗi, mà thực sự là một char *,

321
00:19:34,000 --> 00:19:37,000
mà là một con trỏ đến một char.

322
00:19:37,000 --> 00:19:40,000
Nó rất dễ dàng để nghĩ rằng kích thước của chuỗi được sẽ như thế

323
00:19:40,000 --> 00:19:42,000
số lượng ký tự mà bạn đã có,

324
00:19:42,000 --> 00:19:45,000
nhưng thực sự là char *

325
00:19:45,000 --> 00:19:49,000
có kích thước của một con trỏ đến một char, đó là 4 byte.

326
00:19:49,000 --> 00:19:52,000
Kích thước của một char * là 4 byte.

327
00:19:52,000 --> 00:19:56,000
Nó không quan trọng nếu bạn có một từ nhỏ hoặc một lá thư hoặc bất cứ điều gì.

328
00:19:56,000 --> 00:19:58,000
Nó sẽ là 4 byte.

329
00:19:58,000 --> 00:20:01,000
Chúng tôi cũng đã học được một chút về đúc,

330
00:20:01,000 --> 00:20:04,000
vì vậy khi bạn có thể thấy, nếu bạn có, ví dụ, một chương trình nói rằng

331
00:20:04,000 --> 00:20:08,000
int x = 3 và sau đó printf ("% d", x / 2)

332
00:20:08,000 --> 00:20:12,000
làm bạn biết những gì nó sẽ in ra màn hình?

333
00:20:12,000 --> 00:20:14,000
>> Một người nào đó >> [sinh viên] 2.

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

335
00:20:16,000 --> 00:20:20,000
Khi bạn làm 3/2 nó đang xảy ra để có được 1,5,

336
00:20:20,000 --> 00:20:24,000
nhưng kể từ khi chúng tôi đang sử dụng một số nguyên nó sẽ bỏ qua phần thập phân,

337
00:20:24,000 --> 00:20:26,000
và bạn sẽ có 1.

338
00:20:26,000 --> 00:20:29,000
Nếu bạn không muốn điều đó xảy ra những gì bạn có thể làm, ví dụ,

339
00:20:29,000 --> 00:20:33,000
là khai báo một phao y = x.

340
00:20:33,000 --> 00:20:40,000
Sau đó, x mà sử dụng được 3 sẽ là 3,000 trong y.

341
00:20:40,000 --> 00:20:44,000
Và sau đó bạn có thể in các y / 2.

342
00:20:44,000 --> 00:20:50,000
Thực ra, tôi cần phải có một 2. ở đó.

343
00:20:50,000 --> 00:20:55,000
Nó sẽ làm 3.00/2.00,

344
00:20:55,000 --> 00:20:58,000
và bạn đang đi để có được 1,5.

345
00:20:58,000 --> 00:21:06,000
Và chúng ta có f 0,2 chỉ để yêu cầu 2 đơn vị thập phân trong phần thập phân.

346
00:21:06,000 --> 00:21:12,000
Nếu bạn có 0,3 f nó sẽ thực sự có 1,500.

347
00:21:12,000 --> 00:21:16,000
Nếu đó là 2 nó sẽ là 1,50.

348
00:21:16,000 --> 00:21:18,000
Chúng tôi cũng có trường hợp này ở đây.

349
00:21:18,000 --> 00:21:22,000
Nếu bạn làm float x = 3,14 và sau đó bạn printf x

350
00:21:22,000 --> 00:21:24,000
bạn đang đi để có được 3,14.

351
00:21:24,000 --> 00:21:29,000
Và nếu bạn làm x = int x,

352
00:21:29,000 --> 00:21:34,000
có nghĩa là điều trị x là một int và bạn in x bây giờ

353
00:21:34,000 --> 00:21:36,000
bạn sẽ có 3,00.

354
00:21:36,000 --> 00:21:38,000
Điều đó làm cho tinh thần?

355
00:21:38,000 --> 00:21:41,000
Bởi vì bạn đang đầu tiên điều trị x là một số nguyên, vì vậy bạn đang bỏ qua phần thập phân,

356
00:21:41,000 --> 00:21:45,000
và sau đó bạn đang in x.

357
00:21:45,000 --> 00:21:47,000
Và cuối cùng, bạn cũng có thể làm được điều này,

358
00:21:47,000 --> 00:21:52,000
int x = 65, và sau đó bạn khai báo một char c = x,

359
00:21:52,000 --> 00:21:56,000
và sau đó nếu bạn in c, bạn đang thực sự sẽ nhận được

360
00:21:56,000 --> 00:21:59,000
A, do đó, về cơ bản những gì bạn đang làm gì ở đây

361
00:21:59,000 --> 00:22:02,000
dịch các số nguyên vào nhân vật,

362
00:22:02,000 --> 00:22:05,000
giống như bảng ASCII.

363
00:22:05,000 --> 00:22:08,000
Chúng tôi cũng đã nói về các nhà khai thác toán học.

364
00:22:08,000 --> 00:22:14,000
Hầu hết trong số đó là khá đơn giản, do đó, +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
và chúng tôi cũng nói về mod, đó là phần còn lại của một bộ phận của 2 con số.

366
00:22:20,000 --> 00:22:23,000
Nếu bạn có 10% 3, ví dụ,

367
00:22:23,000 --> 00:22:27,000
nó có nghĩa là phân chia 10 cho 3, và phần còn lại là những gì?

368
00:22:27,000 --> 00:22:30,000
Nó sẽ là 1, do đó, nó thực sự rất hữu ích cho rất nhiều chương trình.

369
00:22:30,000 --> 00:22:38,000
Đối với Vigenère và Caesar tôi khá chắc chắn rằng tất cả các bạn sử dụng mod.

370
00:22:38,000 --> 00:22:43,000
Giới thiệu các nhà khai thác toán học, phải rất cẩn thận khi kết hợp * và /.

371
00:22:43,000 --> 00:22:48,000
>> Ví dụ, nếu bạn làm (3/2) * 2 bạn đang đi để có được?

372
00:22:48,000 --> 00:22:50,000
[Sinh viên] 2.

373
00:22:50,000 --> 00:22:54,000
Yeah, 2, bởi vì 3/2 sẽ là 1,5,

374
00:22:54,000 --> 00:22:57,000
nhưng kể từ khi bạn đang làm hoạt động giữa 2 số nguyên

375
00:22:57,000 --> 00:22:59,000
bạn đang thực sự chỉ cần đi để xem xét 1,

376
00:22:59,000 --> 00:23:03,000
và sau đó 1 * 2 sẽ là 2, do đó, có rất, rất cẩn thận

377
00:23:03,000 --> 00:23:07,000
khi làm số học với số nguyên vì

378
00:23:07,000 --> 00:23:12,000
bạn có thể nhận được rằng 2 = 3, trong trường hợp đó.

379
00:23:12,000 --> 00:23:14,000
Và cũng có thể rất cẩn thận về ưu tiên.

380
00:23:14,000 --> 00:23:21,000
Bạn thường nên sử dụng dấu ngoặc để chắc chắn rằng bạn biết những gì bạn đang làm.

381
00:23:21,000 --> 00:23:27,000
Một số phím tắt hữu ích, tất nhiên, là một trong những i + + hoặc i + = 1

382
00:23:27,000 --> 00:23:30,000
hoặc bằng cách sử dụng + =.

383
00:23:30,000 --> 00:23:34,000
Đó là điều tương tự như làm i = i + 1.

384
00:23:34,000 --> 00:23:39,000
Bạn cũng có thể làm tôi - hoặc i - = 1,

385
00:23:39,000 --> 00:23:42,000
đó là điều tương tự như i = i -1,

386
00:23:42,000 --> 00:23:46,000
một cái gì đó bạn sử dụng rất nhiều trong cho các vòng, ít nhất.

387
00:23:46,000 --> 00:23:52,000
Ngoài ra, *, nếu bạn sử dụng * = và nếu bạn làm, ví dụ,

388
00:23:52,000 --> 00:23:57,000
i * = 2 là điều tương tự như nói i = i * 2,

389
00:23:57,000 --> 00:23:59,000
và điều tương tự để chia.

390
00:23:59,000 --> 00:24:08,000
Nếu bạn làm i / = 2 đó là điều tương tự như i = i / 2.

391
00:24:08,000 --> 00:24:10,000
>> Bây giờ về chức năng.

392
00:24:10,000 --> 00:24:13,000
Các bạn học có chức năng là một chiến lược rất tốt để lưu mã

393
00:24:13,000 --> 00:24:16,000
trong khi bạn đang lập trình, vì vậy nếu bạn muốn thực hiện cùng một nhiệm vụ

394
00:24:16,000 --> 00:24:20,000
trong mã một lần nữa và một lần nữa, có thể là bạn muốn sử dụng một chức năng

395
00:24:20,000 --> 00:24:25,000
chỉ để bạn không phải để sao chép và dán mã hơn và hơn nữa.

396
00:24:25,000 --> 00:24:28,000
Trên thực tế, chính là một chức năng, và khi tôi hiển thị cho bạn các định dạng của một hàm

397
00:24:28,000 --> 00:24:32,000
bạn sẽ thấy rằng đó là khá rõ ràng.

398
00:24:32,000 --> 00:24:35,000
Chúng tôi cũng sử dụng các chức năng từ một số thư viện,

399
00:24:35,000 --> 00:24:39,000
printf, ví dụ, GetIn, mà là từ các thư viện CS50,

400
00:24:39,000 --> 00:24:43,000
và các chức năng khác như toupper.

401
00:24:43,000 --> 00:24:46,000
Tất cả những chức năng được thực sự thực hiện trong các thư viện khác,

402
00:24:46,000 --> 00:24:49,000
và khi bạn đặt các tập tin tether trong phần đầu của chương trình của bạn

403
00:24:49,000 --> 00:24:53,000
bạn nói rằng bạn có thể xin vui lòng cho tôi mã cho những chức năng

404
00:24:53,000 --> 00:24:57,000
vì vậy tôi không có để thực hiện chúng của bản thân mình?

405
00:24:57,000 --> 00:25:00,000
Và bạn cũng có thể viết các chức năng riêng của bạn, vì vậy khi bạn bắt đầu lập trình

406
00:25:00,000 --> 00:25:04,000
bạn nhận ra rằng các thư viện không có tất cả các chức năng mà bạn cần.

407
00:25:04,000 --> 00:25:10,000
Cho pset cuối cùng, ví dụ, chúng tôi đã viết vẽ, tranh giành, và tra cứu,

408
00:25:10,000 --> 00:25:13,000
và nó rất, rất quan trọng để có thể viết các chức năng

409
00:25:13,000 --> 00:25:17,000
bởi vì họ là hữu ích, và chúng tôi sử dụng tất cả thời gian trong lập trình,

410
00:25:17,000 --> 00:25:19,000
và nó tiết kiệm rất nhiều mã.

411
00:25:19,000 --> 00:25:21,000
Các định dạng của một hàm là một trong những điều này.

412
00:25:21,000 --> 00:25:24,000
Chúng tôi có loại trả lại trong đầu. Kiểu trả về là gì?

413
00:25:24,000 --> 00:25:27,000
Nó chỉ là khi chức năng của bạn sẽ quay trở lại.

414
00:25:27,000 --> 00:25:29,000
Nếu bạn có một chức năng, ví dụ, thừa,

415
00:25:29,000 --> 00:25:31,000
có nghĩa là sẽ tính toán một nhân tố của một số nguyên,

416
00:25:31,000 --> 00:25:34,000
có lẽ nó sẽ trả lại một số nguyên.

417
00:25:34,000 --> 00:25:37,000
Sau đó, các kiểu trả về sẽ là int.

418
00:25:37,000 --> 00:25:41,000
Printf thực sự có một khoảng trống kiểu trả về

419
00:25:41,000 --> 00:25:43,000
bởi vì bạn không quay trở lại bất cứ điều gì.

420
00:25:43,000 --> 00:25:45,000
Bạn chỉ cần in ra màn hình

421
00:25:45,000 --> 00:25:48,000
và bỏ chức năng sau đó.

422
00:25:48,000 --> 00:25:51,000
Sau đó, bạn có tên của các chức năng mà bạn có thể chọn.

423
00:25:51,000 --> 00:25:55,000
Bạn sẽ có một chút hợp lý, giống như không chọn một cái tên như xyz

424
00:25:55,000 --> 00:25:58,000
hoặc như x2f.

425
00:25:58,000 --> 00:26:02,000
Cố gắng làm cho một tên có ý nghĩa.

426
00:26:02,000 --> 00:26:04,000
>> Ví dụ, nếu đó là thừa, nói thừa.

427
00:26:04,000 --> 00:26:08,000
Nếu đó là một chức năng có nghĩa là sẽ vẽ một cái gì đó, đặt tên nó vẽ.

428
00:26:08,000 --> 00:26:11,000
Và sau đó chúng tôi có các thông số, còn được gọi là đối số,

429
00:26:11,000 --> 00:26:14,000
mà cũng giống như các nguồn tài nguyên mà chức năng của bạn cần

430
00:26:14,000 --> 00:26:17,000
từ mã của bạn để thực hiện nhiệm vụ của mình.

431
00:26:17,000 --> 00:26:20,000
Nếu bạn muốn tính giai thừa của một số

432
00:26:20,000 --> 00:26:23,000
có thể là bạn cần phải có một số để tính toán một thừa.

433
00:26:23,000 --> 00:26:27,000
Một trong những lý luận mà bạn sẽ phải là số chính nó.

434
00:26:27,000 --> 00:26:31,000
Và sau đó nó sẽ làm điều gì đó và trả về giá trị ở cuối

435
00:26:31,000 --> 00:26:35,000
trừ khi đó là một hàm void.

436
00:26:35,000 --> 00:26:37,000
Hãy xem một ví dụ.

437
00:26:37,000 --> 00:26:40,000
Nếu tôi muốn viết một chức năng mà tổng tất cả các số trong một mảng các số nguyên,

438
00:26:40,000 --> 00:26:43,000
đầu tiên của tất cả, kiểu trả về sẽ là int

439
00:26:43,000 --> 00:26:46,000
vì tôi có một mảng các số nguyên.

440
00:26:46,000 --> 00:26:51,000
Và sau đó tôi sẽ có tên chức năng như sumArray,

441
00:26:51,000 --> 00:26:54,000
và sau đó nó sẽ mất các mảng chính nó, nums int,

442
00:26:54,000 --> 00:26:58,000
và sau đó chiều dài của mảng vì vậy tôi biết tôi có bao nhiêu số tổng hợp.

443
00:26:58,000 --> 00:27:02,000
Sau đó, tôi phải khởi tạo một khoản tiền gọi là biến, ví dụ, để 0,

444
00:27:02,000 --> 00:27:08,000
và mỗi lần tôi thấy một phần tử trong mảng tôi nên thêm nó để tổng hợp, do đó, tôi đã làm một vòng lặp for.

445
00:27:08,000 --> 00:27:15,000
Cũng giống như Lexi nói, bạn làm int i = 0, i <chiều dài và i + +.

446
00:27:15,000 --> 00:27:20,000
Và đối với tất cả các phần tử trong mảng, tôi đã làm tổng + = nums [i],

447
00:27:20,000 --> 00:27:24,000
và sau đó tôi trả lại số tiền, vì vậy nó rất đơn giản, và nó tiết kiệm rất nhiều mã

448
00:27:24,000 --> 00:27:28,000
nếu bạn đang sử dụng chức năng này rất nhiều lần.

449
00:27:28,000 --> 00:27:32,000
Sau đó, chúng tôi đã xem xét ở điều kiện.

450
00:27:32,000 --> 00:27:38,000
Chúng tôi có nếu, khác, và nếu người nào khác.

451
00:27:38,000 --> 00:27:42,000
Hãy xem sự khác biệt giữa những người là những gì.

452
00:27:42,000 --> 00:27:45,000
Hãy nhìn vào 2 mã này. Sự khác biệt giữa chúng là gì?

453
00:27:45,000 --> 00:27:49,000
Người đầu tiên đã về cơ bản các mã muốn cậu nói

454
00:27:49,000 --> 00:27:51,000
nếu một số là +, -, hoặc 0.

455
00:27:51,000 --> 00:27:55,000
Người đầu tiên nói rằng nếu nó> 0 thì đó là tích cực.

456
00:27:55,000 --> 00:28:00,000
Nếu đó là = là 0 sau đó nó là 0, và nếu nó <0 thì đó là tiêu cực.

457
00:28:00,000 --> 00:28:04,000
>> Và một trong những khác được thực hiện nếu, khác nếu, khác.

458
00:28:04,000 --> 00:28:07,000
Sự khác biệt giữa hai là một trong những điều này thực sự sẽ

459
00:28:07,000 --> 00:28:13,000
kiểm tra xem> 0, <0 hoặc = 0 ba lần,

460
00:28:13,000 --> 00:28:17,000
vì vậy nếu bạn có số 2, ví dụ, nó sẽ đến đây và nói

461
00:28:17,000 --> 00:28:21,000
if (x> 0), và nó sẽ nói có, vì vậy tôi in tích cực.

462
00:28:21,000 --> 00:28:25,000
Nhưng mặc dù tôi biết rằng đó là> 0 và nó sẽ không là 0 hoặc <0

463
00:28:25,000 --> 00:28:29,000
Tôi vẫn sẽ làm là 0, là nó <0,

464
00:28:29,000 --> 00:28:33,000
vì vậy tôi thực sự đi bên trong của IFS rằng tôi không phải

465
00:28:33,000 --> 00:28:38,000
bởi vì tôi đã biết rằng nó sẽ không đáp ứng bất cứ điều kiện.

466
00:28:38,000 --> 00:28:41,000
Tôi có thể sử dụng nếu, khác nếu, khác tuyên bố.

467
00:28:41,000 --> 00:28:45,000
Về cơ bản nó nói rằng nếu x = 0 tôi in tích cực.

468
00:28:45,000 --> 00:28:48,000
Nếu không, tôi sẽ cũng thử nghiệm này.

469
00:28:48,000 --> 00:28:51,000
Nếu đó là 2 không tôi sẽ làm điều này.

470
00:28:51,000 --> 00:28:54,000
Về cơ bản nếu tôi có x = 2 bạn sẽ nói

471
00:28:54,000 --> 00:28:57,000
if (x> 0), có, do đó in này.

472
00:28:57,000 --> 00:29:00,000
Bây giờ tôi biết rằng đó là> 0 và nó hài lòng đầu tiên nếu

473
00:29:00,000 --> 00:29:02,000
Tôi thậm chí không để chạy mã này.

474
00:29:02,000 --> 00:29:09,000
Mã chạy nhanh hơn, trên thực tế, nhanh gấp 3 lần nếu bạn sử dụng.

475
00:29:09,000 --> 00:29:11,000
Chúng tôi cũng đã học về và.

476
00:29:11,000 --> 00:29:15,000
Tôi sẽ không đi qua điều này bởi vì Lexi đã nói về họ.

477
00:29:15,000 --> 00:29:17,000
Nó chỉ là && và | nhà điều hành |.

478
00:29:17,000 --> 00:29:21,000
>> Điều duy nhất tôi sẽ nói là hãy cẩn thận khi bạn có 3 điều kiện.

479
00:29:21,000 --> 00:29:24,000
Sử dụng dấu ngoặc đơn bởi vì nó rất khó hiểu khi bạn có một điều kiện

480
00:29:24,000 --> 00:29:27,000
và một số khác hoặc một số khác.

481
00:29:27,000 --> 00:29:30,000
Sử dụng dấu ngoặc đơn chỉ để đảm bảo rằng các điều kiện của bạn có ý nghĩa

482
00:29:30,000 --> 00:29:34,000
bởi vì trong trường hợp đó, ví dụ, bạn có thể tưởng tượng rằng

483
00:29:34,000 --> 00:29:38,000
nó có thể là điều kiện đầu tiên và một hay khác

484
00:29:38,000 --> 00:29:41,000
hoặc 2 điều kiện kết hợp trong một

485
00:29:41,000 --> 00:29:45,000
hoặc 1/3, do đó, chỉ cần cẩn thận.

486
00:29:45,000 --> 00:29:48,000
Và cuối cùng, chúng tôi nói chuyện về các thiết bị chuyển mạch.

487
00:29:48,000 --> 00:29:53,000
Bộ chuyển mạch là rất hữu ích khi bạn có một biến.

488
00:29:53,000 --> 00:29:55,000
Hãy nói rằng bạn có một biến như n

489
00:29:55,000 --> 00:29:59,000
có thể là 0, 1, hoặc 2, và cho mỗi người trong số những trường hợp

490
00:29:59,000 --> 00:30:01,000
bạn sẽ thực hiện một nhiệm vụ.

491
00:30:01,000 --> 00:30:04,000
Bạn có thể nói chuyển biến, và nó cho thấy rằng

492
00:30:04,000 --> 00:30:08,000
Sau đó, giá trị là như value1 tôi sẽ để làm điều này,

493
00:30:08,000 --> 00:30:12,000
và sau đó tôi phá vỡ, có nghĩa là tôi sẽ không nhìn bất cứ lúc nào trong các trường hợp khác

494
00:30:12,000 --> 00:30:15,000
bởi vì chúng tôi đã hài lòng trường hợp đó

495
00:30:15,000 --> 00:30:20,000
và sau đó value2 và như vậy, và tôi cũng có thể có một chuyển đổi mặc định.

496
00:30:20,000 --> 00:30:24,000
Điều đó có nghĩa là nếu nó không đáp ứng bất kỳ trong các trường hợp mà tôi đã có

497
00:30:24,000 --> 00:30:29,000
rằng tôi sẽ làm cái gì khác, nhưng đó là tùy chọn.

498
00:30:29,000 --> 00:30:36,000
Đó là tất cả đối với tôi. Bây giờ chúng ta hãy có Tommy.

499
00:30:36,000 --> 00:30:41,000
Được rồi, điều này là có được Tuần 3-ish.

500
00:30:41,000 --> 00:30:45,000
Đây là một số trong những chủ đề chúng tôi sẽ được bao gồm, mật, phạm vi, mảng, vân vân.

501
00:30:45,000 --> 00:30:49,000
Chỉ cần một lời nhanh chóng trên mật. Chúng tôi sẽ không để búa nhà này.

502
00:30:49,000 --> 00:30:52,000
>> Chúng tôi đã làm điều này trong pset 2, nhưng cho bài kiểm tra chắc chắn rằng bạn biết sự khác biệt

503
00:30:52,000 --> 00:30:54,000
giữa mật mã Caesar và mật mã Vigenère,

504
00:30:54,000 --> 00:30:57,000
làm thế nào cả hai người trong số những người làm việc mật mã và những gì nó giống như mã hóa

505
00:30:57,000 --> 00:30:59,000
và giải mã văn bản bằng cách sử dụng những 2 thuật toán mã hóa.

506
00:30:59,000 --> 00:31:03,000
Hãy nhớ rằng, mật mã Caesar chỉ đơn giản là xoay mỗi nhân vật bằng cách cùng một số tiền,

507
00:31:03,000 --> 00:31:06,000
làm cho chắc chắn rằng bạn mod bằng của số chữ cái trong bảng chữ cái.

508
00:31:06,000 --> 00:31:09,000
Và mật mã Vigenère, mặt khác, xoay mỗi nhân vật

509
00:31:09,000 --> 00:31:12,000
bởi một số lượng khác nhau, do đó, thay vì nói:

510
00:31:12,000 --> 00:31:15,000
mỗi luân chuyển nhân vật bằng 3 Vigenère sẽ luân phiên mỗi nhân vật

511
00:31:15,000 --> 00:31:17,000
bởi một số lượng khác nhau tùy thuộc vào một số từ khóa

512
00:31:17,000 --> 00:31:20,000
trong đó mỗi chữ cái trong từ khóa đại diện cho một số lượng khác nhau

513
00:31:20,000 --> 00:31:26,000
để xoay văn bản rõ ràng.

514
00:31:26,000 --> 00:31:28,000
Hãy nói chuyện đầu tiên về phạm vi biến.

515
00:31:28,000 --> 00:31:30,000
Có 2 loại khác nhau của các biến.

516
00:31:30,000 --> 00:31:33,000
Chúng tôi có các biến địa phương, và những điều này sẽ được xác định

517
00:31:33,000 --> 00:31:36,000
bên ngoài của chính hoặc bên ngoài bất kỳ chức năng hoặc khối,

518
00:31:36,000 --> 00:31:39,000
và chúng sẽ có thể truy cập bất cứ nơi nào trong chương trình của bạn.

519
00:31:39,000 --> 00:31:41,000
Nếu bạn có một chức năng và chức năng đó là một vòng lặp while

520
00:31:41,000 --> 00:31:44,000
các biến toàn cầu lớn có thể truy cập ở khắp mọi nơi.

521
00:31:44,000 --> 00:31:48,000
Một biến địa phương, mặt khác, là scoped để nơi nó được định nghĩa.

522
00:31:48,000 --> 00:31:53,000
>> Nếu bạn có một chức năng ở đây, ví dụ, chúng ta có hàm g,

523
00:31:53,000 --> 00:31:56,000
và bên trong g có một biến ở đây gọi là y,

524
00:31:56,000 --> 00:31:58,000
và điều đó có nghĩa rằng đây là một biến địa phương.

525
00:31:58,000 --> 00:32:00,000
Mặc dù biến này được gọi là y

526
00:32:00,000 --> 00:32:03,000
và biến này được gọi là y 2 chức năng này

527
00:32:03,000 --> 00:32:06,000
không có ý tưởng những gì các biến địa phương của nhau.

528
00:32:06,000 --> 00:32:10,000
Mặt khác, ở đây chúng ta nói int x = 5,

529
00:32:10,000 --> 00:32:12,000
và điều này là ngoài phạm vi chức năng bất kỳ.

530
00:32:12,000 --> 00:32:16,000
Đó là bên ngoài phạm vi chính, vì vậy đây là một biến toàn cầu.

531
00:32:16,000 --> 00:32:20,000
Điều đó có nghĩa là bên trong của 2 chức năng này khi tôi nói x - x + +

532
00:32:20,000 --> 00:32:26,000
Tôi đang truy cập cùng x, theo đó y và y này là các biến khác nhau.

533
00:32:26,000 --> 00:32:30,000
Đó là sự khác biệt giữa một biến toàn cầu và một biến địa phương.

534
00:32:30,000 --> 00:32:33,000
Theo như thiết kế là có liên quan, đôi khi nó có thể là một ý tưởng tốt hơn

535
00:32:33,000 --> 00:32:37,000
để giữ cho các biến địa phương bất cứ khi nào bạn có thể có thể

536
00:32:37,000 --> 00:32:39,000
kể từ khi có một loạt các biến toàn cầu có thể nhận được thực sự khó hiểu.

537
00:32:39,000 --> 00:32:42,000
Nếu bạn có một loạt các chức năng tất cả các sửa đổi điều tương tự

538
00:32:42,000 --> 00:32:45,000
bạn có thể quên điều gì sẽ xảy ra nếu chức năng này vô tình thay đổi này trên toàn cầu,

539
00:32:45,000 --> 00:32:47,000
và điều này chức năng khác không biết về nó,

540
00:32:47,000 --> 00:32:50,000
và nó nhận được khá khó hiểu khi bạn nhận được mã nhiều hơn.

541
00:32:50,000 --> 00:32:53,000
Giữ các biến địa phương bất cứ khi nào bạn có thể có thể

542
00:32:53,000 --> 00:32:56,000
là chỉ cần thiết kế tốt.

543
00:32:56,000 --> 00:33:00,000
Mảng, hãy nhớ rằng, chỉ đơn giản là danh sách các phần tử cùng loại.

544
00:33:00,000 --> 00:33:04,000
Bên trong của CI không có thể có một danh sách giống như 1, 2,0, xin chào.

545
00:33:04,000 --> 00:33:06,000
Chúng tôi không thể làm điều đó.

546
00:33:06,000 --> 00:33:11,000
>> Khi chúng ta khai báo một mảng trong C tất cả các yếu tố phải có cùng loại.

547
00:33:11,000 --> 00:33:14,000
Ở đây tôi có một mảng của 3 số nguyên.

548
00:33:14,000 --> 00:33:18,000
Ở đây tôi có chiều dài của mảng, nhưng nếu tôi chỉ cần khai báo nó trong cú pháp này

549
00:33:18,000 --> 00:33:21,000
nơi mà tôi xác định tất cả các yếu tố kỹ thuật tôi không cần này 3.

550
00:33:21,000 --> 00:33:25,000
Trình biên dịch là đủ thông minh để tìm ra các mảng lớn như thế nào.

551
00:33:25,000 --> 00:33:28,000
Bây giờ khi tôi muốn nhận được hoặc thiết lập giá trị của một mảng

552
00:33:28,000 --> 00:33:30,000
đây là cú pháp để làm điều đó.

553
00:33:30,000 --> 00:33:33,000
Điều này thực sự sẽ thay đổi phần tử thứ hai của mảng bởi vì, hãy nhớ,

554
00:33:33,000 --> 00:33:36,000
số bắt đầu từ 0, không phải tại 1.

555
00:33:36,000 --> 00:33:42,000
Nếu tôi muốn đọc giá trị đó, tôi có thể nói một cái gì đó như int x = array [1].

556
00:33:42,000 --> 00:33:44,000
Hoặc nếu tôi muốn thiết lập giá trị đó, giống như tôi đang làm ở đây,

557
00:33:44,000 --> 00:33:47,000
Tôi có thể nói array [1] = 4.

558
00:33:47,000 --> 00:33:50,000
Đó là thời gian truy cập các phần tử bằng cách chỉ mục của họ

559
00:33:50,000 --> 00:33:52,000
hoặc vị trí của họ hoặc nơi họ đang có trong mảng,

560
00:33:52,000 --> 00:33:57,000
và niêm yết bắt đầu từ 0.

561
00:33:57,000 --> 00:34:00,000
Chúng tôi cũng có thể có mảng của mảng,

562
00:34:00,000 --> 00:34:03,000
và điều này được gọi là một mảng đa chiều.

563
00:34:03,000 --> 00:34:05,000
Khi chúng ta có một mảng đa chiều

564
00:34:05,000 --> 00:34:07,000
điều đó có nghĩa là chúng ta có thể có một cái gì đó giống như các hàng và cột,

565
00:34:07,000 --> 00:34:11,000
và điều này chỉ là một cách hình dung này hay suy nghĩ về nó.

566
00:34:11,000 --> 00:34:14,000
Khi tôi có một mảng đa chiều có nghĩa là tôi sẽ bắt đầu cần

567
00:34:14,000 --> 00:34:17,000
hơn 1 chỉ mục bởi vì nếu tôi có một mạng lưới

568
00:34:17,000 --> 00:34:19,000
nói hàng bạn đang ở trong không cung cấp cho chúng tôi một số.

569
00:34:19,000 --> 00:34:22,000
Đó là thực sự chỉ sẽ cung cấp cho chúng tôi một danh sách các số.

570
00:34:22,000 --> 00:34:25,000
Hãy nói rằng tôi có mảng này ở đây.

571
00:34:25,000 --> 00:34:30,000
Tôi có một mảng lưới, và tôi nói rằng đó là 2 dòng và 3 cột,

572
00:34:30,000 --> 00:34:32,000
và vì vậy đây là một cách hình dung nó.

573
00:34:32,000 --> 00:34:37,000
Khi tôi nói rằng tôi muốn để có được những yếu tố [1] [2]

574
00:34:37,000 --> 00:34:41,000
điều đó có nghĩa là bởi vì đây là hàng đầu tiên và sau đó cột

575
00:34:41,000 --> 00:34:44,000
Tôi sẽ nhảy chèo 1 kể từ khi tôi nói 1.

576
00:34:44,000 --> 00:34:49,000
>> Sau đó, tôi sẽ đến đây để cột 2, và tôi sẽ để có được những giá trị 6.

577
00:34:49,000 --> 00:34:51,000
Có ý nghĩa?

578
00:34:51,000 --> 00:34:55,000
Mảng đa chiều, hãy nhớ rằng, về mặt kỹ thuật chỉ là một mảng của các mảng.

579
00:34:55,000 --> 00:34:57,000
Chúng tôi có thể có mảng của mảng của mảng.

580
00:34:57,000 --> 00:35:00,000
Chúng ta có thể tiếp tục đi, nhưng thực sự là một cách để suy nghĩ về

581
00:35:00,000 --> 00:35:03,000
làm thế nào điều này đang được đặt ra và những gì đang xảy ra là để hình dung nó

582
00:35:03,000 --> 00:35:09,000
trong một mạng lưới như thế này.

583
00:35:09,000 --> 00:35:12,000
Khi chúng tôi vượt qua các mảng chức năng, họ sẽ cư xử

584
00:35:12,000 --> 00:35:16,000
một chút khác biệt so với khi chúng tôi vượt qua các biến thông thường chức năng

585
00:35:16,000 --> 00:35:18,000
giống như đi qua một int hoặc float.

586
00:35:18,000 --> 00:35:21,000
Khi chúng tôi vượt qua trong một loại int hoặc char hoặc bất kỳ của những dữ liệu khác

587
00:35:21,000 --> 00:35:24,000
chúng tôi chỉ cần lấy một cái nhìn nếu chức năng chỉnh sửa

588
00:35:24,000 --> 00:35:28,000
giá trị của biến đó mà thay đổi không phải là đi tuyên truyền

589
00:35:28,000 --> 00:35:32,000
chức năng gọi điện thoại.

590
00:35:32,000 --> 00:35:35,000
Với một mảng, mặt khác, đó sẽ xảy ra.

591
00:35:35,000 --> 00:35:39,000
Nếu tôi vượt qua trong một mảng một số chức năng và chức năng mà thay đổi một số yếu tố,

592
00:35:39,000 --> 00:35:43,000
khi tôi trở lại lên đến chức năng mà nó được gọi là

593
00:35:43,000 --> 00:35:47,000
mảng của tôi bây giờ là có được khác nhau, và từ vựng cho rằng

594
00:35:47,000 --> 00:35:50,000
là mảng được thông qua tham khảo, như chúng ta sẽ thấy sau này.

595
00:35:50,000 --> 00:35:53,000
Điều này có liên quan đến con trỏ làm việc như thế nào, các kiểu dữ liệu cơ bản,

596
00:35:53,000 --> 00:35:55,000
Mặt khác, thông qua giá trị.

597
00:35:55,000 --> 00:35:59,000
>> Chúng ta có thể nghĩ rằng như làm một bản sao của biến số và sau đó đi qua trong bản sao.

598
00:35:59,000 --> 00:36:01,000
Nó không quan trọng những gì chúng tôi làm với biến đó.

599
00:36:01,000 --> 00:36:06,000
Các chức năng gọi điện thoại sẽ không nhận thức được rằng nó đã được thay đổi.

600
00:36:06,000 --> 00:36:10,000
Mảng là chỉ là một chút khác nhau trong đó liên quan.

601
00:36:10,000 --> 00:36:13,000
Ví dụ, như chúng ta vừa thấy, chính là chỉ đơn giản là một chức năng

602
00:36:13,000 --> 00:36:15,000
mà có thể mất trong 2 đối số.

603
00:36:15,000 --> 00:36:20,000
Đối số đầu tiên để các chức năng chính là argc, hoặc số của các đối số,

604
00:36:20,000 --> 00:36:23,000
và đối số thứ hai được gọi là argv,

605
00:36:23,000 --> 00:36:27,000
và những người đang có giá trị thực tế của các đối số.

606
00:36:27,000 --> 00:36:30,000
Hãy nói rằng tôi có một chương trình gọi là this.c,

607
00:36:30,000 --> 00:36:34,000
và tôi nói thực hiện điều này, và tôi sẽ chạy này tại dòng lệnh.

608
00:36:34,000 --> 00:36:38,000
Bây giờ để vượt qua trong một số đối số chương trình của tôi gọi như thế này

609
00:36:38,000 --> 00:36:42,000
Tôi có thể nói một cái gì đó như / là cs 50.

610
00:36:42,000 --> 00:36:45,000
Đây là những gì chúng ta tưởng tượng David để làm mỗi ngày tại thiết bị đầu cuối.

611
00:36:45,000 --> 00:36:48,000
Nhưng bây giờ bên trong chức năng chính của chương trình đó

612
00:36:48,000 --> 00:36:52,000
có những giá trị này, do đó, argc là 4.

613
00:36:52,000 --> 00:36:56,000
Nó có thể là một chút bối rối bởi vì thực sự chúng tôi chỉ đi qua trong cs 50.

614
00:36:56,000 --> 00:36:58,000
Đó là chỉ có 3.

615
00:36:58,000 --> 00:37:02,000
Nhưng hãy nhớ rằng yếu tố đầu tiên của argv hoặc đối số đầu tiên

616
00:37:02,000 --> 00:37:05,000
là tên của các chức năng riêng của mình.

617
00:37:05,000 --> 00:37:07,190
Vì vậy, điều đó có nghĩa là chúng ta đã có 4 điều ở đây,

618
00:37:07,190 --> 00:37:10,530
và các yếu tố đầu tiên là có được /..

619
00:37:10,530 --> 00:37:12,970
Và điều này sẽ được thể hiện như một chuỗi.

620
00:37:12,970 --> 00:37:18,590
Sau đó, các yếu tố còn lại là những gì chúng ta gõ vào sau tên của chương trình.

621
00:37:18,590 --> 00:37:22,720
Vì vậy, cũng giống như một sang một bên, như chúng ta có thể nhìn thấy trong pset 2,

622
00:37:22,720 --> 00:37:28,780
hãy nhớ rằng chuỗi 50 ≠ số nguyên 50.

623
00:37:28,780 --> 00:37:32,520
Vì vậy, chúng ta không thể nói một cái gì đó giống như, 'int x = argv 3.

624
00:37:32,520 --> 00:37:36,470
>> Đó chỉ là sẽ không có ý nghĩa, bởi vì đây là một chuỗi, và điều này là một số nguyên.

625
00:37:36,470 --> 00:37:38,510
Vì vậy, nếu bạn muốn chuyển đổi giữa 2, hãy nhớ rằng, chúng ta sẽ

626
00:37:38,510 --> 00:37:40,810
có chức năng này kỳ diệu được gọi là atoi.

627
00:37:40,810 --> 00:37:46,270
Mà phải mất một chuỗi và trả về số nguyên đại diện bên trong của chuỗi đó.

628
00:37:46,270 --> 00:37:48,360
Vì vậy, đó là một sai lầm dễ dàng để làm cho bài kiểm tra,

629
00:37:48,360 --> 00:37:51,590
chỉ nghĩ rằng điều này sẽ tự động được đúng loại.

630
00:37:51,590 --> 00:37:53,860
Nhưng chỉ biết rằng sẽ luôn luôn được chuỗi

631
00:37:53,860 --> 00:38:00,920
ngay cả nếu chuỗi chỉ chứa một số nguyên hoặc một ký tự hoặc một phao.

632
00:38:00,920 --> 00:38:03,380
Vì vậy, bây giờ chúng ta hãy nói về việc chạy thời gian.

633
00:38:03,380 --> 00:38:06,700
Khi chúng tôi có tất cả các thuật toán làm tất cả những điều điên rồ,

634
00:38:06,700 --> 00:38:11,580
nó trở nên thực sự hữu ích để đặt câu hỏi, "bao lâu để họ đi?"

635
00:38:11,580 --> 00:38:15,500
Chúng tôi đại diện cho rằng với một cái gì đó được gọi là tiệm cận ký hiệu.

636
00:38:15,500 --> 00:38:18,430
Vì vậy, điều này có nghĩa là, chúng ta hãy nói rằng chúng tôi cung cấp cho thuật toán của chúng tôi

637
00:38:18,430 --> 00:38:20,840
một số đầu vào thực sự, thực sự, thực sự lớn.

638
00:38:20,840 --> 00:38:23,840
Chúng tôi muốn đặt câu hỏi, "Làm thế nào là nó sẽ mất?

639
00:38:23,840 --> 00:38:26,370
Nó sẽ mất bao nhiêu bước thuật toán của chúng tôi để chạy

640
00:38:26,370 --> 00:38:29,980
như là một chức năng của các kích thước của đầu vào? "

641
00:38:29,980 --> 00:38:33,080
Vì vậy, cách đầu tiên chúng ta có thể mô tả thời gian chạy là với lớn O.

642
00:38:33,080 --> 00:38:35,380
Và đây là trường hợp xấu nhất thời gian chạy của chúng tôi.

643
00:38:35,380 --> 00:38:38,590
Vì vậy, nếu chúng ta muốn sắp xếp một mảng, và chúng tôi cung cấp cho thuật toán của chúng tôi một mảng

644
00:38:38,590 --> 00:38:41,000
đó là thứ tự giảm dần khi nó phải ở trong thứ tự tăng dần,

645
00:38:41,000 --> 00:38:43,130
đó sẽ là trường hợp xấu nhất.

646
00:38:43,130 --> 00:38:49,800
Đây là phía trên của chúng tôi bị ràng buộc trong chiều dài tối đa thời gian thuật toán của chúng tôi sẽ.

647
00:38:49,800 --> 00:38:54,740
Mặt khác, điều này Ω sẽ mô tả phù hợp nhất là thời gian chạy.

648
00:38:54,740 --> 00:38:58,210
Vì vậy, nếu chúng ta cho một mảng đã được sắp xếp vào một thuật toán sắp xếp,

649
00:38:58,210 --> 00:39:00,940
nó sẽ mất bao lâu để sắp xếp nó?

650
00:39:00,940 --> 00:39:06,610
Và điều này, sau đó, mô tả một thấp hơn bị ràng buộc về thời gian chạy.

651
00:39:06,610 --> 00:39:10,980
Vì vậy, đây chỉ là một số từ mô tả một số lần chạy chung.

652
00:39:10,980 --> 00:39:13,120
Đây là những thứ tự tăng dần.

653
00:39:13,120 --> 00:39:16,060
Thời gian nhanh nhất chạy chúng tôi có được gọi là hằng số.

654
00:39:16,060 --> 00:39:19,800
>> Điều đó có nghĩa là không có vấn đề bao nhiêu yếu tố chúng tôi cung cấp cho thuật toán của chúng tôi,

655
00:39:19,800 --> 00:39:22,280
không có vấn đề lớn như thế nào mảng của chúng tôi, phân loại nó

656
00:39:22,280 --> 00:39:26,510
hoặc làm bất cứ điều gì chúng tôi đang làm mảng sẽ luôn luôn có cùng một lượng thời gian.

657
00:39:26,510 --> 00:39:30,270
Vì vậy, chúng ta có thể đại diện cho rằng chỉ với một 1, mà là một hằng số.

658
00:39:30,270 --> 00:39:32,410
Chúng tôi cũng nhìn vào thời gian chạy logarit.

659
00:39:32,410 --> 00:39:34,800
Vì vậy, một cái gì đó giống như tìm kiếm nhị phân là logarit,

660
00:39:34,800 --> 00:39:37,140
nơi mà chúng tôi cắt giảm các vấn đề trong một nửa thời gian mỗi

661
00:39:37,140 --> 00:39:40,970
và sau đó mọi thứ chỉ có được cao hơn từ đó.

662
00:39:40,970 --> 00:39:43,580
Và nếu bạn đã bao giờ viết một O của bất kỳ thuật toán giai thừa,

663
00:39:43,580 --> 00:39:47,850
bạn có lẽ không nên coi đây là công việc của bạn.

664
00:39:47,850 --> 00:39:53,910
Khi chúng ta so sánh các lần chạy điều quan trọng cần ghi nhớ những điều này.

665
00:39:53,910 --> 00:39:57,760
Vì vậy, nếu tôi có một thuật toán là O (n), và ai đó khác

666
00:39:57,760 --> 00:40:03,590
đã một thuật toán O (2n) đây là những thực sự tiệm tương đương.

667
00:40:03,590 --> 00:40:06,590
Vì vậy, nếu chúng ta tưởng tượng n là một số lượng lớn như eleventy tỷ:

668
00:40:06,590 --> 00:40:13,090
do đó, khi chúng ta đang so sánh eleventy tỷ một cái gì đó giống như eleventy tỷ + 3,

669
00:40:13,090 --> 00:40:17,640
đột nhiên 3 mà không thực sự làm cho một sự khác biệt lớn nữa.

670
00:40:17,640 --> 00:40:20,980
Đó là lý do tại sao chúng ta sẽ bắt đầu xem xét những điều này là tương đương.

671
00:40:20,980 --> 00:40:24,220
Vì vậy, những thứ như các hằng số ở đây, có 2 x này, hoặc thêm một 3,

672
00:40:24,220 --> 00:40:27,180
đây chỉ là hằng số, và những điều này sẽ giảm.

673
00:40:27,180 --> 00:40:32,480
Vì vậy, đó là lý do tại sao tất cả 3 của những lần chạy giống như nói rằng họ là O (n).

674
00:40:32,480 --> 00:40:37,490
Tương tự như vậy, nếu chúng ta có 2 lần chạy khác, chúng ta hãy nói O (n + 2n ² ³), chúng ta có thể thêm

675
00:40:37,490 --> 00:40:42,070
+ N, + 7, và sau đó chúng tôi có một thời gian chạy đó chỉ là O (n ³).

676
00:40:42,070 --> 00:40:46,290
một lần nữa, đây là những điều tương tự bởi vì những - đây là không giống nhau.

677
00:40:46,290 --> 00:40:49,840
Đây là những điều tương tự, xin lỗi. Vì vậy đây là giống nhau bởi vì

678
00:40:49,840 --> 00:40:53,090
³ n này sẽ chi phối ² 2n.

679
00:40:53,090 --> 00:40:59,130
>> Những gì không phải là cùng một điều là nếu chúng ta đã chạy như O (n ³) và O (n ²)

680
00:40:59,130 --> 00:41:02,820
bởi vì đây ³ n là lớn hơn nhiều so ² n này.

681
00:41:02,820 --> 00:41:05,470
Vì vậy, nếu chúng ta có số mũ, đột nhiên này bắt đầu quan trọng,

682
00:41:05,470 --> 00:41:08,280
nhưng khi chúng ta chỉ đối phó với các yếu tố như chúng tôi đang ở đây,

683
00:41:08,280 --> 00:41:12,810
sau đó nó sẽ không quan trọng bởi vì họ chỉ cần đi bỏ.

684
00:41:12,810 --> 00:41:16,760
Hãy có một cái nhìn tại một số các thuật toán chúng tôi đã nhìn thấy cho đến nay

685
00:41:16,760 --> 00:41:19,260
và nói chuyện về thời gian chạy của họ.

686
00:41:19,260 --> 00:41:23,850
Cách đầu tiên tìm kiếm một số trong một danh sách, mà chúng ta đã thấy, là tuyến tính tìm kiếm.

687
00:41:23,850 --> 00:41:26,950
Và thực hiện tìm kiếm tuyến tính là siêu đơn giản.

688
00:41:26,950 --> 00:41:30,490
Chúng tôi chỉ có một danh sách, và chúng ta sẽ xem xét tất cả các yếu tố duy nhất trong danh sách

689
00:41:30,490 --> 00:41:34,260
cho đến khi chúng tôi tìm thấy số lượng chúng tôi đang tìm kiếm.

690
00:41:34,260 --> 00:41:38,370
Vì vậy, đó có nghĩa là trong trường hợp xấu nhất, điều này O (n).

691
00:41:38,370 --> 00:41:40,860
Và trường hợp xấu nhất ở đây có thể là nếu phần tử

692
00:41:40,860 --> 00:41:45,710
yếu tố cuối cùng, sau đó sử dụng tìm kiếm tuyến tính, chúng ta phải nhìn vào từng yếu tố duy nhất

693
00:41:45,710 --> 00:41:50,180
cho đến khi chúng tôi nhận được một trong những cuối cùng để biết rằng nó đã thực sự trong danh sách.

694
00:41:50,180 --> 00:41:52,910
Chúng ta không thể bỏ nửa chừng và nói, "Đó có thể là không có."

695
00:41:52,910 --> 00:41:55,980
Với tìm kiếm tuyến tính, chúng ta phải nhìn vào toàn bộ điều.

696
00:41:55,980 --> 00:41:59,090
Thời gian chạy tốt nhất, mặt khác, là không đổi

697
00:41:59,090 --> 00:42:04,200
bởi vì trong trường hợp tốt nhất các yếu tố mà chúng tôi đang tìm kiếm chỉ là một trong những đầu tiên trong danh sách.

698
00:42:04,200 --> 00:42:08,930
Vì vậy, nó sẽ đưa chúng ta chính xác 1 bước, không có vấn đề lớn như thế nào trong danh sách là

699
00:42:08,930 --> 00:42:12,140
nếu chúng ta đang tìm kiếm các yếu tố đầu tiên mỗi lần.

700
00:42:12,140 --> 00:42:15,390
>> Vì vậy, khi bạn tìm kiếm, hãy nhớ rằng, nó không yêu cầu danh sách của chúng tôi được sắp xếp.

701
00:42:15,390 --> 00:42:19,430
Bởi vì chúng tôi chỉ đơn giản là để xem qua tất cả các yếu tố duy nhất, và nó không thực sự quan trọng

702
00:42:19,430 --> 00:42:23,560
thứ tự các yếu tố.

703
00:42:23,560 --> 00:42:28,110
Một thuật toán tìm kiếm thông minh hơn là một cái gì đó giống như tìm kiếm nhị phân.

704
00:42:28,110 --> 00:42:31,500
Hãy nhớ rằng, việc thực hiện tìm kiếm nhị phân là khi bạn đang đi để

705
00:42:31,500 --> 00:42:34,320
tiếp tục tìm kiếm ở giữa danh sách.

706
00:42:34,320 --> 00:42:38,000
Và bởi vì chúng tôi đang tìm kiếm ở giữa, chúng tôi yêu cầu rằng danh sách được sắp xếp

707
00:42:38,000 --> 00:42:40,580
hoặc người nào khác chúng tôi không biết nơi giữa là, và chúng ta phải nhìn qua

708
00:42:40,580 --> 00:42:44,480
toàn bộ danh sách để tìm thấy nó, và sau đó tại thời điểm đó, chúng tôi chỉ đang lãng phí thời gian.

709
00:42:44,480 --> 00:42:48,480
Vì vậy, nếu chúng ta có một danh sách được sắp xếp và chúng tôi tìm thấy giữa, chúng tôi sẽ so sánh giữa

710
00:42:48,480 --> 00:42:51,590
phần tử, chúng tôi đang tìm kiếm.

711
00:42:51,590 --> 00:42:54,640
Nếu đó là quá cao, sau đó chúng ta có thể quên nửa bên phải

712
00:42:54,640 --> 00:42:57,810
bởi vì chúng tôi biết rằng nếu phần tử của chúng tôi là đã quá cao

713
00:42:57,810 --> 00:43:01,080
và tất cả mọi thứ ở bên phải của yếu tố này thậm chí còn cao hơn,

714
00:43:01,080 --> 00:43:02,760
sau đó chúng ta không cần để tìm ở đó nữa.

715
00:43:02,760 --> 00:43:05,430
Mặt khác, nếu phần tử của chúng tôi là quá thấp,

716
00:43:05,430 --> 00:43:08,700
chúng ta biết tất cả mọi thứ để bên trái của phần tử đó cũng là quá thấp,

717
00:43:08,700 --> 00:43:11,390
do đó, nó không thực sự có ý nghĩa để tìm ở đó, một trong hai.

718
00:43:11,390 --> 00:43:15,760
Bằng cách này, với từng bước và mỗi lần chúng ta nhìn vào điểm giữa của danh sách,

719
00:43:15,760 --> 00:43:19,060
chúng ta sẽ cắt giảm vấn đề của chúng tôi trong một nửa vì đột nhiên chúng ta biết

720
00:43:19,060 --> 00:43:23,040
một bó toàn bộ các số mà không thể được mà chúng ta đang tìm kiếm.

721
00:43:23,040 --> 00:43:26,950
>> Trong giả này sẽ giống như thế này,

722
00:43:26,950 --> 00:43:30,990
và bởi vì chúng tôi đang cắt giảm danh sách trong một nửa thời gian mỗi duy nhất,

723
00:43:30,990 --> 00:43:34,920
trường hợp xấu nhất của chúng tôi thời gian chạy nhảy từ tuyến tính logarit.

724
00:43:34,920 --> 00:43:39,260
Vì vậy, đột nhiên chúng tôi có đăng nhập trong các bước để tìm một phần tử trong một danh sách.

725
00:43:39,260 --> 00:43:42,460
Thời gian chạy tốt nhất, mặc dù, vẫn còn liên tục

726
00:43:42,460 --> 00:43:45,180
bởi vì bây giờ, chúng ta hãy chỉ nói rằng các phần tử chúng tôi đang tìm kiếm

727
00:43:45,180 --> 00:43:48,380
luôn luôn giữa chính xác của danh sách ban đầu.

728
00:43:48,380 --> 00:43:52,080
Vì vậy, chúng ta có thể phát triển danh sách của chúng tôi là lớn như chúng tôi muốn, nhưng nếu các yếu tố chúng tôi đang tìm kiếm là ở giữa,

729
00:43:52,080 --> 00:43:54,910
sau đó nó sẽ đưa chúng ta 1 bước.

730
00:43:54,910 --> 00:44:00,920
Vì vậy, đó là lý do tại sao chúng tôi là O (log n) và Ω (1) hoặc liên tục.

731
00:44:00,920 --> 00:44:04,510
Hãy thực sự chạy tìm kiếm nhị phân trong danh sách này.

732
00:44:04,510 --> 00:44:08,020
Vì vậy, chúng ta hãy nói rằng chúng tôi đang tìm kiếm các yếu tố 164.

733
00:44:08,020 --> 00:44:11,650
Điều đầu tiên chúng ta sẽ làm là tìm điểm giữa của danh sách này.

734
00:44:11,650 --> 00:44:15,060
Nó chỉ như vậy sẽ xảy ra rằng trung điểm sẽ rơi vào giữa 2 con số,

735
00:44:15,060 --> 00:44:18,960
vì vậy hãy chỉ cần tùy tiện, mỗi lần trung điểm nằm giữa 2 con số,

736
00:44:18,960 --> 00:44:21,150
chúng ta hãy chỉ làm tròn.

737
00:44:21,150 --> 00:44:24,330
Chúng ta chỉ cần để đảm bảo rằng chúng tôi làm điều này tất cả các bước của con đường.

738
00:44:24,330 --> 00:44:29,040
Vì vậy, chúng tôi đang đi vòng lên, và chúng ta sẽ nói rằng 161 là giữa của danh sách của chúng tôi.

739
00:44:29,040 --> 00:44:34,640
Vì vậy, 161 trang <164, và tất cả các yếu tố bên trái trong tổng số 161

740
00:44:34,640 --> 00:44:39,120
cũng là <164, vì vậy chúng tôi biết rằng nó sẽ không giúp cho chúng ta cả

741
00:44:39,120 --> 00:44:42,690
để bắt đầu tìm kiếm ở đây bởi vì các yếu tố, chúng tôi đang tìm kiếm không thể có mặt.

742
00:44:42,690 --> 00:44:47,060
Vì vậy, những gì chúng ta có thể làm là chúng tôi chỉ có thể quên đi rằng một nửa trái toàn bộ danh sách,

743
00:44:47,060 --> 00:44:51,700
và bây giờ chỉ xem xét từ bên phải trở đi 161.

744
00:44:51,700 --> 00:44:54,050
>> Vì vậy, một lần nữa, điều này là trung điểm, chúng ta hãy chỉ làm tròn.

745
00:44:54,050 --> 00:44:56,260
Bây giờ 175 là quá lớn.

746
00:44:56,260 --> 00:44:59,180
Vì vậy, chúng ta biết nó không phải đi để giúp chúng tôi tìm kiếm ở đây hoặc ở đây,

747
00:44:59,180 --> 00:45:06,610
vì vậy chúng tôi chỉ có thể ném đi, và cuối cùng chúng tôi sẽ tung ra 164.

748
00:45:06,610 --> 00:45:10,560
Bất kỳ câu hỏi về tìm kiếm nhị phân?

749
00:45:10,560 --> 00:45:14,180
Chúng ta hãy chuyển từ việc tìm kiếm thông qua một danh sách đã được sắp xếp

750
00:45:14,180 --> 00:45:17,660
để thực sự tham gia một danh sách các số theo thứ tự bất kỳ

751
00:45:17,660 --> 00:45:20,960
và làm cho rằng danh sách theo thứ tự tăng dần.

752
00:45:20,960 --> 00:45:24,060
Các thuật toán đầu tiên chúng tôi nhìn được gọi là bong bóng sắp xếp.

753
00:45:24,060 --> 00:45:27,300
Và điều này sẽ được đơn giản của các thuật toán chúng ta đã thấy.

754
00:45:27,300 --> 00:45:32,970
Bong bóng sắp xếp nói rằng khi bất kỳ 2 yếu tố bên trong danh sách ra khỏi vị trí,

755
00:45:32,970 --> 00:45:36,500
có nghĩa là có một số lượng cao hơn bên trái của một số thấp hơn,

756
00:45:36,500 --> 00:45:40,190
sau đó chúng ta sẽ trao đổi chúng, bởi vì điều đó có nghĩa rằng danh sách sẽ được

757
00:45:40,190 --> 00:45:42,860
"Sắp xếp" so với trước.

758
00:45:42,860 --> 00:45:45,180
Và chúng tôi sẽ tiếp tục quá trình này một lần nữa và một lần nữa và một lần nữa

759
00:45:45,180 --> 00:45:52,100
cho đến khi cuối cùng các loại nguyên tố của các bong bóng đến vị trí chính xác của họ và chúng tôi có một danh sách được sắp xếp.

760
00:45:52,100 --> 00:45:57,230
>> Thời gian chạy của điều này là có được O (n ²). Tại sao?

761
00:45:57,230 --> 00:46:00,370
Vâng, bởi vì trong trường hợp xấu nhất, chúng tôi sẽ tận dụng mọi yếu tố, và

762
00:46:00,370 --> 00:46:04,570
chúng ta sẽ so sánh nó với tất cả các yếu tố khác trong danh sách.

763
00:46:04,570 --> 00:46:08,030
Tuy nhiên, trong trường hợp tốt nhất, chúng tôi có một danh sách đã được sắp xếp, bong bóng sắp xếp

764
00:46:08,030 --> 00:46:12,230
sẽ phải đi qua một lần, nói "Không. Tôi đã không thực hiện bất kỳ giao dịch hoán đổi, vì vậy tôi thực hiện."

765
00:46:12,230 --> 00:46:17,410
Vì vậy, chúng tôi có một thời gian phù hợp nhất là chạy Ω (n).

766
00:46:17,410 --> 00:46:20,680
Chạy bong bóng Sắp xếp trên một danh sách.

767
00:46:20,680 --> 00:46:23,560
Hoặc đầu tiên, chúng ta hãy nhìn vào một số giả thực sự nhanh chóng.

768
00:46:23,560 --> 00:46:28,160
Chúng tôi muốn nói rằng chúng tôi muốn theo dõi, trong mỗi lần lặp của vòng lặp,

769
00:46:28,160 --> 00:46:32,190
theo dõi hay không, chúng tôi thay đổi bất kỳ yếu tố.

770
00:46:32,190 --> 00:46:37,610
Vì vậy, lý do là, chúng ta sẽ dừng lại khi chúng tôi đã không trao đổi bất kỳ yếu tố.

771
00:46:37,610 --> 00:46:41,980
Vì vậy, khi bắt đầu vòng lặp của chúng tôi, chúng tôi đã không trao đổi bất cứ điều gì, vì vậy chúng tôi sẽ nói rằng đó là sai.

772
00:46:41,980 --> 00:46:47,170
Bây giờ, chúng ta sẽ phải đi qua danh sách và so sánh các yếu tố i vào phần tử i + 1

773
00:46:47,170 --> 00:46:50,310
và nếu nó là trường hợp đó có một số lớn hơn bên trái của một số lượng nhỏ,

774
00:46:50,310 --> 00:46:52,310
sau đó chúng ta sẽ trao đổi chúng.

775
00:46:52,310 --> 00:46:54,490
>> Và sau đó chúng ta sẽ nhớ rằng chúng ta trao đổi một phần tử.

776
00:46:54,490 --> 00:46:58,900
Điều đó có nghĩa là chúng ta cần phải đi qua danh sách ít nhất là 1 lần nữa

777
00:46:58,900 --> 00:47:02,160
bởi vì điều kiện mà chúng tôi dừng lại khi toàn bộ danh sách đã được sắp xếp,

778
00:47:02,160 --> 00:47:04,890
có nghĩa là chúng tôi đã không thực hiện bất kỳ giao dịch hoán đổi.

779
00:47:04,890 --> 00:47:09,960
Vì vậy, đó là lý do tại sao điều kiện của chúng tôi xuống ở đây là trong khi một số yếu tố đã được trao đổi.

780
00:47:09,960 --> 00:47:13,720
Vì vậy, bây giờ chúng ta hãy nhìn này chạy trên một danh sách.

781
00:47:13,720 --> 00:47:16,640
Tôi có danh sách 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
Bong bóng sắp xếp được sẽ bắt đầu tất cả các con đường ở bên trái, và nó sẽ so sánh

783
00:47:19,850 --> 00:47:24,700
các yếu tố i, 0 đến i + 1, là 1 phần tử.

784
00:47:24,700 --> 00:47:29,020
Nó sẽ nói, 5> 0, nhưng ngay bây giờ 5 là bên trái,

785
00:47:29,020 --> 00:47:32,500
vì vậy tôi cần phải trao đổi 5 và 0.

786
00:47:32,500 --> 00:47:35,470
Khi tôi trao đổi chúng, đột nhiên tôi nhận được danh sách này khác nhau.

787
00:47:35,470 --> 00:47:38,260
Bây giờ 5> 1, do đó, chúng ta sẽ trao đổi chúng.

788
00:47:38,260 --> 00:47:42,160
5 không phải là> 6, vì vậy chúng tôi không cần phải làm bất cứ điều gì ở đây.

789
00:47:42,160 --> 00:47:46,690
Nhưng 6> 4, vì vậy chúng tôi cần phải trao đổi.

790
00:47:46,690 --> 00:47:49,740
Một lần nữa, chúng ta cần phải chạy qua danh sách toàn bộ để cuối cùng khám phá ra

791
00:47:49,740 --> 00:47:52,330
rằng đây là những ra khỏi trật tự, chúng tôi trao đổi chúng,

792
00:47:52,330 --> 00:47:57,120
và vào thời điểm này, chúng tôi cần phải chạy qua danh sách 1 thời gian nữa

793
00:47:57,120 --> 00:48:05,390
để đảm bảo rằng tất cả mọi thứ trong trật tự của nó, và ở việc này bong bóng điểm đã hoàn tất.

794
00:48:05,390 --> 00:48:10,720
Một thuật toán khác nhau dành một số yếu tố và phân loại chúng là lựa chọn loại.

795
00:48:10,720 --> 00:48:15,740
Ý tưởng đằng sau lựa chọn loại là chúng ta sẽ xây dựng một phần sắp xếp danh sách

796
00:48:15,740 --> 00:48:18,150
1 phần tử tại một thời điểm.

797
00:48:18,150 --> 00:48:23,170
>> Và cách chúng tôi sẽ làm điều đó bằng cách xây dựng phân khúc bên trái của danh sách.

798
00:48:23,170 --> 00:48:27,510
Và về cơ bản, mỗi trên mỗi bước, chúng tôi đang đi để có những phần tử nhỏ nhất chúng tôi đã để lại

799
00:48:27,510 --> 00:48:32,310
đã không được sắp xếp được nêu ra, và chúng ta sẽ di chuyển nó vào phân khúc được sắp xếp.

800
00:48:32,310 --> 00:48:35,850
Điều đó có nghĩa là chúng ta cần phải liên tục tìm các phần tử tối thiểu được phân loại

801
00:48:35,850 --> 00:48:40,720
và sau đó đi mà yếu tố tối thiểu và trao đổi nó với bất cứ điều gì

802
00:48:40,720 --> 00:48:45,090
trái hầu hết các yếu tố không được sắp xếp.

803
00:48:45,090 --> 00:48:50,890
Thời gian chạy của việc này là sẽ là O (n ²) bởi vì trong trường hợp xấu nhất

804
00:48:50,890 --> 00:48:55,070
chúng ta cần phải so sánh tất cả các yếu tố duy nhất để mọi phần tử khác.

805
00:48:55,070 --> 00:48:59,250
Bởi vì chúng ta đang nói rằng nếu chúng ta bắt đầu ở nửa bên trái của danh sách, chúng ta cần

806
00:48:59,250 --> 00:49:02,970
đi qua toàn bộ các phân đoạn phải tìm các phần tử nhỏ nhất.

807
00:49:02,970 --> 00:49:05,430
Và sau đó, một lần nữa, chúng ta cần phải đi qua toàn bộ mảng bên phải và

808
00:49:05,430 --> 00:49:08,210
tiếp tục đi qua rằng hơn và hơn và hơn một lần nữa.

809
00:49:08,210 --> 00:49:11,350
Đó sẽ là n ². Chúng ta sẽ cần một bên trong vòng lặp của một vòng lặp for

810
00:49:11,350 --> 00:49:13,350
điều này cho thấy n ².

811
00:49:13,350 --> 00:49:16,530
Trong suy nghĩ trường hợp tốt nhất, chúng ta hãy nói rằng chúng tôi cung cấp cho nó một danh sách đã được sắp xếp;

812
00:49:16,530 --> 00:49:19,270
chúng tôi thực sự không làm tốt hơn so với bất kỳ n ².

813
00:49:19,270 --> 00:49:21,730
Bởi vì lựa chọn loại không có cách nào biết được

814
00:49:21,730 --> 00:49:25,540
các yếu tố tối thiểu chỉ là một trong tôi tình cờ được xem xét.

815
00:49:25,540 --> 00:49:28,970
Nó vẫn cần để đảm bảo rằng điều này thực sự là tối thiểu.

816
00:49:28,970 --> 00:49:31,670
>> Và cách duy nhất để đảm bảo rằng đó là tối thiểu, bằng cách sử dụng thuật toán này,

817
00:49:31,670 --> 00:49:34,640
là để xem xét tất cả các yếu tố duy nhất một lần nữa.

818
00:49:34,640 --> 00:49:38,420
Vì vậy, thực sự, nếu bạn cho nó - nếu bạn cho lựa chọn loại một danh sách đã được sắp xếp,

819
00:49:38,420 --> 00:49:42,720
nó sẽ không làm bất kỳ tốt hơn so với cho nó một danh sách không được sắp xếp.

820
00:49:42,720 --> 00:49:46,320
Bằng cách này, nếu nó xảy ra là trường hợp rằng cái gì là O (một cái gì đó)

821
00:49:46,320 --> 00:49:50,640
và omega của một cái gì đó, chúng tôi chỉ có thể nói ngắn gọn hơn rằng đó là θ của một cái gì đó.

822
00:49:50,640 --> 00:49:52,760
Vì vậy, nếu bạn nhìn thấy mà đi lên bất cứ nơi nào, đó là những gì mà chỉ có nghĩa là.

823
00:49:52,760 --> 00:49:57,580
>> Nếu một cái gì đó là theta của n ², nó là cả hai O lớn (n ²) và Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
Vì vậy, trường hợp tốt nhất và trường hợp xấu nhất, nó không tạo sự khác biệt,

825
00:49:59,790 --> 00:50:04,400
các thuật toán sẽ làm điều tương tự mỗi lần.

826
00:50:04,400 --> 00:50:06,610
Vì vậy, đây là mã giả để sắp xếp lựa chọn có thể trông giống như.

827
00:50:06,610 --> 00:50:10,630
Chúng tôi về cơ bản sẽ nói rằng tôi muốn để lặp lại trên danh sách

828
00:50:10,630 --> 00:50:15,180
từ trái sang phải, và mỗi lần lặp của vòng lặp, tôi sẽ di chuyển

829
00:50:15,180 --> 00:50:19,780
các yếu tố tối thiểu thành phần này được sắp xếp danh sách.

830
00:50:19,780 --> 00:50:23,260
Và một khi tôi di chuyển cái gì đó, tôi không bao giờ cần phải xem xét yếu tố đó một lần nữa.

831
00:50:23,260 --> 00:50:28,600
Bởi vì ngay sau khi tôi trao đổi một yếu tố trong phân khúc bên trái của danh sách, nó được sắp xếp

832
00:50:28,600 --> 00:50:32,600
bởi vì chúng tôi đang làm tất cả mọi thứ trong thứ tự tăng dần bằng cách sử dụng tối thiểu.

833
00:50:32,600 --> 00:50:38,740
Vì vậy, chúng tôi đã nói, không sao, chúng tôi đang ở vị trí i, và chúng tôi cần phải xem xét tất cả các yếu tố

834
00:50:38,740 --> 00:50:42,260
ở bên phải của tôi để tìm ra tối thiểu.

835
00:50:42,260 --> 00:50:46,150
Vì vậy, điều đó có nghĩa là chúng ta muốn nhìn từ i + 1 đến cuối danh sách.

836
00:50:46,150 --> 00:50:51,610
Và bây giờ, nếu các yếu tố mà chúng tôi hiện đang xem xét là ít hơn mức tối thiểu của chúng tôi cho đến nay,

837
00:50:51,610 --> 00:50:54,190
đó, hãy nhớ rằng, chúng tôi đang bắt đầu off tối thiểu chỉ là

838
00:50:54,190 --> 00:50:57,020
yếu tố bất cứ điều gì chúng tôi hiện tại, tôi sẽ giả định rằng mức tối thiểu.

839
00:50:57,020 --> 00:51:00,270
Nếu tôi tìm một phần tử có kích thước nhỏ hơn, sau đó tôi sẽ nói, được rồi,

840
00:51:00,270 --> 00:51:02,700
tốt, tôi đã tìm thấy một tối thiểu mới.

841
00:51:02,700 --> 00:51:06,080
Tôi sẽ nhớ nơi mà tối thiểu là.

842
00:51:06,080 --> 00:51:09,560
>> Vì vậy, bây giờ, một khi tôi đã đi qua đó phân khúc phải được phân loại,

843
00:51:09,560 --> 00:51:16,690
Tôi có thể nói tôi sẽ trao đổi các yếu tố tối thiểu với các yếu tố đó là ở vị trí i.

844
00:51:16,690 --> 00:51:21,100
Đó là sẽ xây dựng danh sách của tôi, phần tôi sắp xếp danh sách từ trái sang phải,

845
00:51:21,100 --> 00:51:25,190
và chúng tôi không bao giờ cần phải nhìn vào một phần tử một lần nữa khi nó đã trong phần đó.

846
00:51:25,190 --> 00:51:27,930
Một khi chúng tôi đã đổi chỗ.

847
00:51:27,930 --> 00:51:30,260
Vì vậy, chúng ta hãy chạy loại lựa chọn trong danh sách này.

848
00:51:30,260 --> 00:51:38,220
Các yếu tố màu xanh ở đây là có được tôi, và các yếu tố màu đỏ là có được các yếu tố tối thiểu.

849
00:51:38,220 --> 00:51:41,570
Vì vậy, tôi bắt đầu tất cả các con đường ở bên trái của danh sách, như vậy ở mức 5.

850
00:51:41,570 --> 00:51:44,610
Bây giờ chúng ta cần phải tìm thấy các yếu tố tối thiểu được phân loại.

851
00:51:44,610 --> 00:51:49,480
Vì vậy, chúng ta nói 0 <5, do đó 0 là tối thiểu mới của tôi.

852
00:51:49,480 --> 00:51:53,820
>> Nhưng tôi không thể dừng lại ở đó, bởi vì mặc dù chúng ta có thể nhận ra rằng 0 là nhỏ nhất,

853
00:51:53,820 --> 00:51:59,390
chúng ta cần phải chạy qua mọi phần tử khác của danh sách để đảm bảo.

854
00:51:59,390 --> 00:52:01,760
Vì vậy, 1 là lớn hơn, 6 là lớn hơn, 4 là lớn hơn.

855
00:52:01,760 --> 00:52:05,850
Điều đó có nghĩa là sau khi xem xét tất cả các yếu tố này, tôi đã xác định 0 là nhỏ nhất.

856
00:52:05,850 --> 00:52:09,800
Vì vậy, tôi sẽ trao đổi 5 và 0.

857
00:52:09,800 --> 00:52:15,480
Khi tôi trao đổi đó, tôi sẽ nhận được một danh sách mới, và tôi biết rằng tôi không bao giờ cần phải nhìn vào mà 0 một lần nữa

858
00:52:15,480 --> 00:52:19,380
bởi vì một khi tôi đã đổi chỗ, tôi đã sắp xếp nó và chúng tôi đang thực hiện.

859
00:52:19,380 --> 00:52:22,730
Bây giờ nó chỉ như vậy sẽ xảy ra rằng các phần tử màu xanh là một lần nữa trong 5,

860
00:52:22,730 --> 00:52:26,030
và chúng ta cần phải nhìn vào số 1, 6 và 4 để xác định rằng 1

861
00:52:26,030 --> 00:52:31,520
là yếu tố tối thiểu nhỏ nhất, do đó, chúng tôi sẽ trao đổi 1 và 5.

862
00:52:31,520 --> 00:52:36,890
Một lần nữa, chúng ta cần phải nhìn vào so sánh 5 đến 6 và 4,

863
00:52:36,890 --> 00:52:39,830
và chúng tôi sẽ trao đổi 4 và 5, và cuối cùng, so sánh

864
00:52:39,830 --> 00:52:45,740
những 2 con số và trao đổi chúng cho đến khi chúng tôi nhận được danh sách của chúng tôi được sắp xếp.

865
00:52:45,740 --> 00:52:49,730
Bất kỳ câu hỏi về lựa chọn loại?

866
00:52:49,730 --> 00:52:56,420
Okay. Hãy di chuyển đến chủ đề cuối cùng ở đây, và đó là đệ quy.

867
00:52:56,420 --> 00:52:59,810
>> Đệ quy, hãy nhớ rằng, điều này thực sự là meta điều mà một chức năng

868
00:52:59,810 --> 00:53:02,740
nhiều lần tự gọi mình.

869
00:53:02,740 --> 00:53:05,620
Vì vậy, tại một số điểm, trong khi fuction của chúng tôi là liên tục gọi chính nó,

870
00:53:05,620 --> 00:53:10,100
cần có một số điểm mà tại đó chúng tôi dừng lại gọi mình.

871
00:53:10,100 --> 00:53:13,670
Bởi vì nếu chúng ta không làm điều đó, sau đó chúng tôi chỉ cần đi để tiếp tục làm điều này mãi mãi,

872
00:53:13,670 --> 00:53:16,660
và chương trình của chúng tôi chỉ là sẽ không chấm dứt.

873
00:53:16,660 --> 00:53:19,200
Chúng tôi gọi đây là điều kiện trường hợp cơ sở.

874
00:53:19,200 --> 00:53:22,570
Và trường hợp cơ sở nói, thay vì gọi một chức năng một lần nữa,

875
00:53:22,570 --> 00:53:25,330
Tôi chỉ cần đi để trả lại một số giá trị.

876
00:53:25,330 --> 00:53:28,080
Vì vậy, khi chúng tôi đã trả lại một giá trị, chúng tôi đã không gọi mình,

877
00:53:28,080 --> 00:53:32,550
và phần còn lại của các cuộc gọi chúng tôi đã thực hiện cho đến nay cũng có thể trở lại.

878
00:53:32,550 --> 00:53:36,050
Sự đối lập với trường hợp cơ sở là trường hợp đệ quy.

879
00:53:36,050 --> 00:53:39,050
Và đây là khi chúng ta muốn thực hiện một cuộc gọi đến các chức năng mà chúng tôi hiện đang nhập.

880
00:53:39,050 --> 00:53:44,690
Và chúng ta có thể, mặc dù không phải luôn luôn, muốn sử dụng đối số khác nhau.

881
00:53:44,690 --> 00:53:48,940
>> Vì vậy, nếu chúng ta có một chức năng được gọi là f, e chỉ cần gọi là mất 1 đối số,

882
00:53:48,940 --> 00:53:52,010
và chúng tôi chỉ cần giữ gọi f (1), f (1), f (1), và nó chỉ như vậy sẽ xảy ra rằng

883
00:53:52,010 --> 00:53:56,510
đối số 1 rơi vào trường hợp đệ quy, chúng tôi vẫn sẽ không bao giờ dừng lại.

884
00:53:56,510 --> 00:54:01,620
Thậm chí nếu chúng ta có một trường hợp cơ sở, chúng ta cần để đảm bảo rằng cuối cùng chúng tôi đang đi để đạt trường hợp đó, cơ sở.

885
00:54:01,620 --> 00:54:04,250
Chúng tôi không chỉ ở trong trường hợp này đệ quy.

886
00:54:04,250 --> 00:54:09,870
Nói chung, khi chúng ta gọi chúng ta, chúng ta có thể sẽ có một cuộc tranh luận khác nhau mỗi lần.

887
00:54:09,870 --> 00:54:12,700
Dưới đây là một hàm đệ quy thực sự đơn giản.

888
00:54:12,700 --> 00:54:15,090
Vì vậy, điều này sẽ tính toán giai thừa của một số.

889
00:54:15,090 --> 00:54:17,790
Up đầu ở đây chúng tôi có trường hợp cơ sở của chúng tôi.

890
00:54:17,790 --> 00:54:22,330
Trong trường hợp n ≤ 1, chúng tôi sẽ không gọi thừa một lần nữa.

891
00:54:22,330 --> 00:54:26,490
Chúng ta sẽ dừng lại, chúng tôi chỉ cần đi để trả lại một số giá trị.

892
00:54:26,490 --> 00:54:30,170
Nếu điều này là không đúng sự thật, sau đó chúng tôi đang đi để đạt trường hợp đệ quy của chúng tôi.

893
00:54:30,170 --> 00:54:33,550
Chú ý ở đây rằng chúng tôi không chỉ cần gọi điện thoại thừa (n), bởi vì đó không sẽ rất hữu ích.

894
00:54:33,550 --> 00:54:36,810
Chúng tôi sẽ gọi thừa của cái gì khác.

895
00:54:36,810 --> 00:54:40,850
>> Và như vậy bạn có thể thấy, cuối cùng, nếu chúng tôi vượt qua một cái gì đó thừa (5),

896
00:54:40,850 --> 00:54:45,900
chúng ta sẽ gọi thừa (4) và như vậy, và cuối cùng chúng tôi đang đi để đạt trường hợp này cơ sở.

897
00:54:45,900 --> 00:54:51,730
Vì vậy, điều này có vẻ tốt. Hãy xem những gì sẽ xảy ra khi chúng ta thực sự chạy.

898
00:54:51,730 --> 00:54:57,840
Đây là đống, và hãy nói rằng chính là sẽ gọi chức năng này với một đối số (4).

899
00:54:57,840 --> 00:55:02,200
Vì vậy, một khi thừa thấy và = 4, thừa sẽ gọi chính nó.

900
00:55:02,200 --> 00:55:05,010
Bây giờ, đột nhiên, chúng tôi có thừa (3).

901
00:55:05,010 --> 00:55:10,780
Vì vậy, các chức năng này sẽ tiếp tục phát triển cho đến khi cuối cùng chúng tôi trường hợp cơ sở của chúng tôi.

902
00:55:10,780 --> 00:55:17,830
Tại thời điểm này, giá trị trả lại này là sự trở lại (nx giá trị trả lại này),

903
00:55:17,830 --> 00:55:21,290
giá trị trả lại này là nx giá trị trả lại này.

904
00:55:21,290 --> 00:55:23,290
Cuối cùng, chúng tôi cần phải nhấn một số số.

905
00:55:23,290 --> 00:55:26,560
Ở phía trên ở đây, chúng ta nói trả lại 1.

906
00:55:26,560 --> 00:55:30,650
Điều đó có nghĩa rằng một khi chúng ta trở lại con số đó, chúng ta có thể bật ra khỏi stack.

907
00:55:30,650 --> 00:55:36,570
Vì vậy, điều này thừa (1) được thực hiện.

908
00:55:36,570 --> 00:55:41,190
Khi 1 trả về, điều này (1) trả thừa, trở về 1.

909
00:55:41,190 --> 00:55:46,910
Giá trị trả lại này, hãy nhớ rằng, là nx giá trị trả lại này.

910
00:55:46,910 --> 00:55:50,720
Đột ngột như vậy, anh chàng này biết rằng tôi muốn trở lại 2.

911
00:55:50,720 --> 00:55:55,910
>> Vì vậy, hãy nhớ, trả lại giá trị này chỉ là nx giá trị trả lại ở đây.

912
00:55:55,910 --> 00:56:01,160
Vì vậy, bây giờ chúng ta có thể nói 3 x 2, và cuối cùng, ở đây chúng ta có thể nói

913
00:56:01,160 --> 00:56:04,010
điều này là chỉ cần đi là 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
Và một lần trở lại này, chúng tôi nhận được xuống để một số nguyên duy nhất bên trong của chính.

915
00:56:09,570 --> 00:56:15,460
Bất kỳ câu hỏi về đệ quy?

916
00:56:15,460 --> 00:56:17,090
Được rồi. Vì vậy, có nhiều thời gian hơn cho các câu hỏi ở cuối,

917
00:56:17,090 --> 00:56:23,360
nhưng bây giờ Joseph sẽ bao gồm các chủ đề còn lại.

918
00:56:23,360 --> 00:56:25,590
>> [Joseph Ong] Tất cả các quyền. Vì vậy, bây giờ mà chúng tôi đã nói chuyện về recursions,

919
00:56:25,590 --> 00:56:27,840
chúng ta hãy nói một chút về những gì hợp nhất sắp xếp là.

920
00:56:27,840 --> 00:56:31,740
Kết hợp các loại về cơ bản là một cách khác để sắp xếp một danh sách các số.

921
00:56:31,740 --> 00:56:36,430
Và nó hoạt động như thế nào, với loại hợp nhất, bạn có một danh sách, và những gì chúng tôi làm là

922
00:56:36,430 --> 00:56:39,120
chúng ta nói, chúng ta hãy phân chia này thành 2 nửa.

923
00:56:39,120 --> 00:56:42,750
Đầu tiên chúng ta sẽ chạy hợp nhất loại một lần nữa vào nửa trái,

924
00:56:42,750 --> 00:56:45,040
sau đó chúng tôi sẽ chạy hợp nhất sắp xếp trên nửa bên phải,

925
00:56:45,040 --> 00:56:50,240
và cung cấp cho chúng tôi ngay bây giờ 2 nửa đều được sắp xếp, và bây giờ chúng ta sẽ kết hợp những nửa với nhau.

926
00:56:50,240 --> 00:56:55,010
Đó là một chút khó khăn để xem mà không cần một ví dụ, vì vậy chúng ta sẽ đi qua các chuyển động và xem những gì sẽ xảy ra.

927
00:56:55,010 --> 00:56:59,590
Vì vậy, bạn bắt đầu với danh sách này, chúng tôi chia nó thành 2 nửa.

928
00:56:59,590 --> 00:57:02,300
Chúng tôi chạy hợp nhất trên nửa bên trái đầu tiên.

929
00:57:02,300 --> 00:57:06,660
Vì vậy, đó là một nửa trái, và bây giờ chúng tôi chạy chúng thông qua danh sách này một lần nữa

930
00:57:06,660 --> 00:57:09,800
mà được thông qua vào merge loại, và sau đó chúng ta nhìn, một lần nữa,

931
00:57:09,800 --> 00:57:13,270
ở phía bên trái của danh sách này và chúng tôi chạy hợp nhất sắp xếp trên nó.

932
00:57:13,270 --> 00:57:15,880
Bây giờ, chúng ta sẽ có được một danh sách của 2 con số,

933
00:57:15,880 --> 00:57:19,010
và bây giờ là một nửa trái dài chỉ có 1 phần tử, và chúng ta không thể

934
00:57:19,010 --> 00:57:23,380
chia một danh sách chỉ có 1 phần tử vào một nửa, vì vậy chúng tôi chỉ nói rằng, một khi chúng tôi có 50,

935
00:57:23,380 --> 00:57:26,400
mà chỉ là 1 phần tử, nó đã được sắp xếp.

936
00:57:26,400 --> 00:57:29,860
>> Khi chúng tôi đang thực hiện với điều đó, chúng ta có thể thấy rằng chúng ta có thể

937
00:57:29,860 --> 00:57:32,230
chuyển sang nửa bên phải của danh sách này,

938
00:57:32,230 --> 00:57:36,480
và 3 cũng được sắp xếp, và vì vậy bây giờ cả hai nửa của danh sách này đều được sắp xếp

939
00:57:36,480 --> 00:57:39,080
chúng ta có thể tham gia những con số này lại với nhau.

940
00:57:39,080 --> 00:57:45,320
Vì vậy, chúng ta nhìn vào 50 và 3, 3 là nhỏ hơn 50, do đó, nó đi trong lần đầu tiên và sau đó 50.

941
00:57:45,320 --> 00:57:49,340
Bây giờ, đó là thực hiện, chúng tôi quay trở lại với danh sách và sắp xếp nó nửa bên phải.

942
00:57:49,340 --> 00:57:52,440
42 là số riêng của nó, do đó, nó đã được sắp xếp.

943
00:57:52,440 --> 00:57:57,850
Vì vậy, bây giờ chúng ta so sánh những 2 và 3 là nhỏ hơn 42, vì vậy mà được đặt trong lần đầu tiên,

944
00:57:57,850 --> 00:58:02,340
tại 42 được đưa vào, và 50 được đặt in

945
00:58:02,340 --> 00:58:07,220
Bây giờ, đó là sắp xếp, chúng tôi đi tất cả các cách trở lại để phía trên, 1337 và 15.

946
00:58:07,220 --> 00:58:14,560
Vâng, bây giờ chúng ta nhìn vào nửa bên trái của danh sách này, 1337 là bởi chính nó để nó được sắp xếp và cùng với 15.

947
00:58:14,560 --> 00:58:19,020
Vì vậy, bây giờ chúng tôi kết hợp 2 số này để sắp xếp mà danh sách ban đầu 15 <, 1337,

948
00:58:19,020 --> 00:58:23,060
do đó, nó đi trong lần đầu tiên, sau đó 1337 đi.

949
00:58:23,060 --> 00:58:26,640
Và bây giờ chúng tôi sắp xếp cả hai nửa của danh sách ban đầu lên hàng đầu.

950
00:58:26,640 --> 00:58:30,440
Và tất cả chúng ta phải làm là kết hợp các.

951
00:58:30,440 --> 00:58:36,890
Chúng tôi nhìn vào 2 số đầu tiên của danh sách này, 3 <15, do đó, nó đi vào mảng sắp xếp đầu tiên.

952
00:58:36,890 --> 00:58:44,460
15 <42, vì vậy nó đi. Bây giờ, 42 <1337, mà đi.

953
00:58:44,460 --> 00:58:51,010
50 <1337, vì vậy nó đi. Nhận thấy rằng chúng tôi chỉ mất 2 con số trong danh sách này.

954
00:58:51,010 --> 00:58:53,640
Vì vậy, chúng tôi không chỉ xen kẽ giữa 2 danh sách.

955
00:58:53,640 --> 00:58:56,050
Chúng tôi chỉ tìm kiếm ở đầu, và chúng tôi đang dùng các yếu tố

956
00:58:56,050 --> 00:59:00,270
đó là nhỏ hơn và sau đó đặt nó vào một mảng của chúng tôi.

957
00:59:00,270 --> 00:59:04,080
Bây giờ chúng tôi đã hợp nhất tất cả các nửa và chúng tôi đang thực hiện.

958
00:59:04,080 --> 00:59:07,780
>> Thắc mắc về hợp nhất loại? Vâng?

959
00:59:07,780 --> 00:59:14,190
[Sinh viên] Nếu đó là chia tách thành các nhóm khác nhau, tại sao không phải là họ chỉ cần chia nó một lần

960
00:59:14,190 --> 00:59:19,970
và bạn có 3 và 2 trong một nhóm? Phần còn lại của câu hỏi khó hiểu]

961
00:59:19,970 --> 00:59:24,940
Lý do - vì vậy câu hỏi là lý do tại sao chúng ta không thể hợp nhất chúng ở những bước đầu tiên sau khi chúng tôi có chúng?

962
00:59:24,940 --> 00:59:29,530
Lý do chúng ta có thể làm được điều này, bắt đầu ở các yếu tố trái nhất của cả hai bên,

963
00:59:29,530 --> 00:59:33,040
và sau đó đi một trong những nhỏ hơn và đặt nó trong, là chúng ta biết rằng những

964
00:59:33,040 --> 00:59:35,290
danh sách cá nhân trong đơn đặt hàng được sắp xếp.

965
00:59:35,290 --> 00:59:37,290
Vì vậy, nếu tôi đang nhìn vào các yếu tố trái nhất của cả hai nửa,

966
00:59:37,290 --> 00:59:40,490
Tôi biết họ sẽ là những yếu tố nhỏ nhất của những danh sách.

967
00:59:40,490 --> 00:59:43,930
Vì vậy, tôi có thể đặt chúng vào những điểm yếu tố nhỏ nhất trong danh sách này lớn.

968
00:59:43,930 --> 00:59:47,810
Mặt khác, nếu tôi nhìn vào 2 danh sách ở cấp độ thứ hai ở đó,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 và 15, những người không được sắp xếp.

970
00:59:51,640 --> 00:59:55,770
Vì vậy, nếu tôi nhìn vào 50 và 1337, tôi sẽ đặt 50 vào danh sách của tôi đầu tiên.

971
00:59:55,770 --> 01:00:00,130
Nhưng điều đó không thực sự có ý nghĩa, bởi vì 3 là phần tử nhỏ nhất trong số tất cả những người.

972
01:00:00,130 --> 01:00:04,390
Vì vậy, lý do duy nhất chúng tôi có thể thực hiện bước này kết hợp là bởi vì danh sách của chúng tôi đã được sắp xếp.

973
01:00:04,390 --> 01:00:07,010
Đó là lý do tại sao chúng tôi có để có được tất cả các cách để phía dưới

974
01:00:07,010 --> 01:00:09,800
bởi vì khi chúng ta chỉ có một số duy nhất, bạn biết rằng một số duy nhất

975
01:00:09,800 --> 01:00:14,120
trong và của chính nó đã là một danh sách được sắp xếp.

976
01:00:14,120 --> 01:00:19,360
>> Bất kỳ câu hỏi nào? Không?

977
01:00:19,360 --> 01:00:24,260
Phức tạp? Vâng, bạn có thể thấy rằng tại mỗi bước có số cuối cùng,

978
01:00:24,260 --> 01:00:27,590
và chúng ta có thể phân chia một danh sách trong nhật ký 1/2 n lần,

979
01:00:27,590 --> 01:00:31,700
đó là nơi mà chúng tôi nhận được n x log n phức tạp.

980
01:00:31,700 --> 01:00:34,940
Và bạn sẽ thấy trường hợp tốt nhất cho hợp nhất loại n log n, và nó chỉ như vậy sẽ xảy ra

981
01:00:34,940 --> 01:00:39,340
trường hợp xấu nhất, hoặc Ω ở đó, cũng là n log n.

982
01:00:39,340 --> 01:00:42,480
Cái gì đó để ghi nhớ.

983
01:00:42,480 --> 01:00:45,750
Di chuyển trên, chúng ta hãy đi vào một số tập tin cơ bản siêu I / O.

984
01:00:45,750 --> 01:00:48,830
Nếu bạn nhìn Scramble, bạn sẽ nhận thấy chúng tôi đã có một số loại hệ thống

985
01:00:48,830 --> 01:00:51,270
nơi bạn có thể viết vào một tập tin đăng nhập, nếu bạn đọc thông qua các mã.

986
01:00:51,270 --> 01:00:53,730
Chúng ta hãy xem làm thế nào bạn có thể làm điều đó.

987
01:00:53,730 --> 01:00:57,450
Vâng, chúng tôi có fprintf, mà bạn có thể nghĩ như chỉ printf,

988
01:00:57,450 --> 01:01:01,720
nhưng chỉ cần in vào một tập tin thay vào đó, và do đó f ở đầu.

989
01:01:01,720 --> 01:01:07,570
Loại mã này lên đây, những gì nó là, như bạn có thể nhìn thấy trong Scramble,

990
01:01:07,570 --> 01:01:12,310
nó đi qua in mảng 2-chiều của bạn ra hàng bởi hàng gì các con số.

991
01:01:12,310 --> 01:01:17,850
Trong trường hợp này, printf in ra thiết bị đầu cuối của bạn hoặc những gì chúng ta gọi là đầu ra tiêu chuẩn của phần.

992
01:01:17,850 --> 01:01:22,170
>> Và bây giờ, trong trường hợp này, tất cả chúng ta phải làm là thay thế printf với fprintf,

993
01:01:22,170 --> 01:01:26,770
nói với nó những tập tin mà bạn muốn in, và trong trường hợp này chỉ cần in nó ra đến tập tin đó

994
01:01:26,770 --> 01:01:32,230
thay vì in ấn nó ra để thiết bị đầu cuối của bạn.

995
01:01:32,230 --> 01:01:36,500
Vâng, sau đó đặt ra câu hỏi: Nơi nào chúng ta có được loại này của tập tin, phải không?

996
01:01:36,500 --> 01:01:39,840
Chúng tôi đã thông qua đăng nhập vào fuction fprintf này, nhưng chúng tôi không biết nó đến từ đâu.

997
01:01:39,840 --> 01:01:43,980
Vâng, sớm trong mã, những gì chúng tôi đã có được đoạn mã này ở đây,

998
01:01:43,980 --> 01:01:48,340
về cơ bản nói rằng tập tin mở các cuộc gọi log.txt.

999
01:01:48,340 --> 01:01:53,220
Những gì chúng tôi làm sau đó là chúng ta phải đảm bảo rằng tập tin là thực sự mở thành công.

1000
01:01:53,220 --> 01:01:57,070
Vì vậy, nó có thể thất bại vì nhiều lý do, bạn không có đủ không gian trên máy tính của bạn, ví dụ.

1001
01:01:57,070 --> 01:01:59,790
Vì vậy, nó luôn luôn quan trọng trước khi bạn làm bất kỳ hoạt động với các tập tin

1002
01:01:59,790 --> 01:02:03,300
rằng chúng ta kiểm tra xem tập tin đã được mở thành công.

1003
01:02:03,300 --> 01:02:09,330
Vì vậy, những gì là một, đó là một tham số để fopen, tốt, chúng ta có thể mở một tập tin bằng nhiều cách.

1004
01:02:09,330 --> 01:02:13,510
Những gì chúng tôi có thể làm là, chúng ta có thể vượt qua nó w, có nghĩa là ghi đè lên các tập tin nếu nó thoát ra,

1005
01:02:13,510 --> 01:02:18,070
Chúng tôi có thể vượt qua một một, mà họ thêm vào cuối của tập tin thay vì trọng nó,

1006
01:02:18,070 --> 01:02:22,730
hoặc chúng ta có thể xác định r, có nghĩa là, chúng ta hãy mở tập tin như là chỉ đọc.

1007
01:02:22,730 --> 01:02:24,890
Vì vậy, nếu chương trình cố gắng để thực hiện bất kỳ thay đổi vào tập tin,

1008
01:02:24,890 --> 01:02:30,140
la hét vào họ và không để cho họ làm điều đó.

1009
01:02:30,140 --> 01:02:33,320
Cuối cùng, khi chúng tôi đang thực hiện với các tập tin, thực hiện các hoạt động trên nó,

1010
01:02:33,320 --> 01:02:35,860
chúng ta cần phải chắc chắn rằng chúng tôi đóng file.

1011
01:02:35,860 --> 01:02:38,830
Và như vậy ở phần cuối của chương trình của bạn, bạn sẽ vượt qua chúng một lần nữa

1012
01:02:38,830 --> 01:02:42,120
tập tin này mà bạn đã mở, và chỉ cần đóng nó.

1013
01:02:42,120 --> 01:02:44,650
Vì vậy, đây là một cái gì đó quan trọng là bạn phải chắc chắn rằng bạn làm.

1014
01:02:44,650 --> 01:02:47,180
Vì vậy, nhớ bạn có thể mở một tập tin, sau đó bạn có thể ghi vào tập tin,

1015
01:02:47,180 --> 01:02:51,270
làm các hoạt động trong tập tin, nhưng sau đó bạn phải đóng các tập tin ở cuối.

1016
01:02:51,270 --> 01:02:53,270
>> Bất kỳ câu hỏi về tập tin cơ bản I / O? Vâng?

1017
01:02:53,270 --> 01:02:58,050
[Sinh viên câu hỏi, không thể hiểu]

1018
01:02:58,050 --> 01:03:02,480
Ngay ở đây. Câu hỏi là, tập tin này log.txt xuất hiện nơi nào?

1019
01:03:02,480 --> 01:03:07,890
Vâng, nếu bạn chỉ cần cho nó log.txt, nó tạo ra nó trong cùng thư mục với tập tin thực thi.

1020
01:03:07,890 --> 01:03:10,500
Vì vậy, nếu phổ cập như - >> [Sinh viên câu hỏi, không thể hiểu]

1021
01:03:10,500 --> 01:03:18,830
Vâng. Trong cùng một thư mục, hoặc trong cùng một thư mục, như bạn gọi nó.

1022
01:03:18,830 --> 01:03:21,400
Bây giờ bộ nhớ, ngăn xếp, và một đống.

1023
01:03:21,400 --> 01:03:23,400
Vì vậy, làm thế nào là bộ nhớ đặt ra trong máy tính?

1024
01:03:23,400 --> 01:03:26,270
Vâng, bạn có thể tưởng tượng bộ nhớ sắp xếp của khối này ở đây.

1025
01:03:26,270 --> 01:03:30,260
Và trong bộ nhớ chúng ta có những gì được gọi là heap bị mắc kẹt ở đó, và ngăn xếp ở dưới đó.

1026
01:03:30,260 --> 01:03:34,480
Và heap phát triển đi xuống và ngăn xếp phát triển đi lên.

1027
01:03:34,480 --> 01:03:38,620
Vì vậy, như Tommy đã đề cập - oh, tốt, và chúng tôi có 4 phân đoạn khác mà tôi sẽ nhận được để trong một giây -

1028
01:03:38,620 --> 01:03:42,890
Như Tommy đã nói trước đó, bạn biết chức năng của mình như thế nào tự gọi mình và gọi nhau?

1029
01:03:42,890 --> 01:03:44,930
Họ xây dựng loại này stack frame.

1030
01:03:44,930 --> 01:03:47,360
Vâng, nếu cuộc gọi chính foo foo được đặt trên stack.

1031
01:03:47,360 --> 01:03:52,430
Foo gọi bar, bar được đặt trên stack, mà được đặt trên stack sau.

1032
01:03:52,430 --> 01:03:57,040
Và khi họ trở về, họ từng được đưa ra khỏi stack.

1033
01:03:57,040 --> 01:04:00,140
Mỗi người trong số các địa điểm này và bộ nhớ giữ?

1034
01:04:00,140 --> 01:04:03,110
Vâng, hàng đầu, đó là phân khúc văn bản có chứa các chương trình riêng của mình.

1035
01:04:03,110 --> 01:04:06,390
Vì vậy, các mã máy, đó là có, một khi bạn biên dịch chương trình của bạn.

1036
01:04:06,390 --> 01:04:08,520
Tiếp theo, bất kỳ khởi tạo biến toàn cầu.

1037
01:04:08,520 --> 01:04:12,660
>> Vì vậy, bạn có các biến toàn cầu trong chương trình của bạn, và bạn nói giống như, một 5 =

1038
01:04:12,660 --> 01:04:15,260
được đặt vào phân khúc này, và ngay dưới đó,

1039
01:04:15,260 --> 01:04:18,990
bạn có bất kỳ uninitialized dữ liệu toàn cầu, mà chỉ là int một,

1040
01:04:18,990 --> 01:04:20,990
nhưng bạn không nói nó bằng bất cứ điều gì.

1041
01:04:20,990 --> 01:04:23,870
Nhận ra đây là những biến toàn cầu, vì vậy họ đang ở bên ngoài của chính.

1042
01:04:23,870 --> 01:04:28,560
Vì vậy, điều này có nghĩa là bất kỳ biến toàn cầu được công bố nhưng không được khởi tạo.

1043
01:04:28,560 --> 01:04:32,310
Vì vậy, những gì trong đống này? Cấp phát bộ nhớ bằng cách sử dụng malloc, chúng tôi sẽ nhận được để trong một ít.

1044
01:04:32,310 --> 01:04:35,990
Và cuối cùng, với stack bạn có bất kỳ biến địa phương

1045
01:04:35,990 --> 01:04:39,950
và bất kỳ chức năng, bạn có thể gọi trong bất kỳ các thông số của họ.

1046
01:04:39,950 --> 01:04:43,720
Điều cuối cùng, bạn không thực sự cần phải biết những gì các biến môi trường làm,

1047
01:04:43,720 --> 01:04:46,700
nhưng bất cứ khi nào bạn chạy chương trình, có là một cái gì đó liên quan, như

1048
01:04:46,700 --> 01:04:49,550
đây là tên người dùng của người chạy chương trình.

1049
01:04:49,550 --> 01:04:51,550
Và đó sẽ là loại ở phía dưới.

1050
01:04:51,550 --> 01:04:54,540
Trong điều kiện các địa chỉ bộ nhớ, mà là giá trị thập lục phân,

1051
01:04:54,540 --> 01:04:58,170
các giá trị vào đầu hàng đầu tại 0, và họ đi tất cả các con đường xuống phía dưới.

1052
01:04:58,170 --> 01:05:00,440
Trong trường hợp này, nếu bạn đang ở trên hệ thống 32-bit,

1053
01:05:00,440 --> 01:05:05,390
địa chỉ ở phía dưới là có được 0x, tiếp theo af, bởi vì đó là 32 bit,

1054
01:05:05,390 --> 01:05:10,890
đó là 8 byte, và trong trường hợp này 8 byte tương ứng với 8 chữ số thập lục phân.

1055
01:05:10,890 --> 01:05:20,110
Vì vậy, xuống đây bạn sẽ có, như, 0xffffff, và ở đó bạn sẽ có 0.

1056
01:05:20,110 --> 01:05:23,660
Vì vậy, con trỏ là gì? Một số bạn không có thể đã được bảo hiểm này trong phần trước.

1057
01:05:23,660 --> 01:05:26,660
nhưng chúng tôi đã đi qua nó trong bài giảng, do đó, một con trỏ chỉ là một kiểu dữ liệu

1058
01:05:26,660 --> 01:05:34,030
mà các cửa hàng, thay vì một số loại giá trị như 50, nó lưu các địa chỉ của một số vị trí trong bộ nhớ.

1059
01:05:34,030 --> 01:05:36,020
Giống như là bộ nhớ [khó hiểu].

1060
01:05:36,020 --> 01:05:41,120
Vì vậy, trong trường hợp này, những gì chúng tôi đã, chúng tôi có một con trỏ đến một số nguyên hoặc * một int,

1061
01:05:41,120 --> 01:05:46,210
và nó chứa địa chỉ này thập lục phân của 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> Vì vậy, những gì chúng ta có là, bây giờ, con trỏ điểm tại một số vị trí trong bộ nhớ,

1063
01:05:50,880 --> 01:05:56,020
và đó chỉ là một giá trị 50 là bộ nhớ vị trí.

1064
01:05:56,020 --> 01:06:01,810
Trên một số hệ thống 32-bit, trên tất cả các hệ thống 32-bit, con trỏ mất bit 32 hoặc 4 byte.

1065
01:06:01,810 --> 01:06:06,020
Tuy nhiên, ví dụ, trên một hệ thống 64-bit, con trỏ là 64 bit.

1066
01:06:06,020 --> 01:06:08,040
Vì vậy, đó là một cái gì đó bạn sẽ muốn giữ lại trong tâm trí.

1067
01:06:08,040 --> 01:06:12,310
Vì vậy, trên một hệ thống đầu cuối-bit, con trỏ dài là bit cuối.

1068
01:06:12,310 --> 01:06:17,320
Con trỏ là loại khó tiêu hóa mà không có thêm những điều,

1069
01:06:17,320 --> 01:06:20,300
do đó, chúng ta hãy đi qua một ví dụ về cấp phát bộ nhớ động.

1070
01:06:20,300 --> 01:06:25,130
Cấp phát bộ nhớ động làm cho bạn, hoặc những gì chúng ta gọi malloc,

1071
01:06:25,130 --> 01:06:29,280
nó cho phép bạn phân bổ một số loại dữ liệu bên ngoài của các thiết lập.

1072
01:06:29,280 --> 01:06:31,830
Vì vậy, dữ liệu này là loại lâu dài hơn trong suốt thời gian của chương trình.

1073
01:06:31,830 --> 01:06:36,430
Bởi vì như bạn biết, nếu bạn khai báo x bên trong của một chức năng, và trả về chức năng,

1074
01:06:36,430 --> 01:06:40,910
bạn không còn phải truy cập vào các dữ liệu đã được lưu trữ trong x.

1075
01:06:40,910 --> 01:06:44,420
Những gì con trỏ cho chúng tôi làm là họ cho phép chúng tôi lưu trữ bộ nhớ hoặc lưu trữ các giá trị

1076
01:06:44,420 --> 01:06:46,840
trong một phân đoạn khác nhau của bộ nhớ, cụ thể là các đống.

1077
01:06:46,840 --> 01:06:49,340
Bây giờ khi chúng ta trở lại ra khỏi chức năng, miễn là chúng ta có một con trỏ

1078
01:06:49,340 --> 01:06:54,960
vị trí đó trong bộ nhớ, sau đó những gì chúng ta có thể làm là chúng ta chỉ có thể nhìn vào các giá trị đó.

1079
01:06:54,960 --> 01:06:58,020
Hãy xem một ví dụ: Đây là bố trí bộ nhớ của chúng tôi một lần nữa.

1080
01:06:58,020 --> 01:07:00,050
Và chúng tôi có chức năng này, chính.

1081
01:07:00,050 --> 01:07:06,870
Những gì nó làm là được rồi, rất đơn giản, phải int x = 5, đó chỉ là một biến trên stack chính.

1082
01:07:06,870 --> 01:07:12,450
>> Mặt khác, bây giờ chúng ta khai báo một con trỏ mà các cuộc gọi giveMeThreeInts chức năng.

1083
01:07:12,450 --> 01:07:16,800
Và vì vậy bây giờ chúng ta đi vào chức năng này và chúng tôi tạo ra một khung stack mới cho nó.

1084
01:07:16,800 --> 01:07:20,440
Tuy nhiên, trong khung ngăn xếp, chúng ta khai báo int * temp,

1085
01:07:20,440 --> 01:07:23,210
mà mallocs 3 số nguyên cho chúng ta.

1086
01:07:23,210 --> 01:07:25,880
Vì vậy, kích thước của int sẽ cho chúng ta có bao nhiêu byte int này,

1087
01:07:25,880 --> 01:07:29,620
và malloc cho chúng ta nhiều byte của không gian trên heap.

1088
01:07:29,620 --> 01:07:32,890
Vì vậy, trong trường hợp này, chúng tôi đã tạo ra không gian đủ cho 3 số nguyên,

1089
01:07:32,890 --> 01:07:36,830
và heap là cách lên đó, đó là lý do tại sao tôi đã vẽ nó lên cao hơn.

1090
01:07:36,830 --> 01:07:42,900
Một khi chúng ta đã thực hiện xong, chúng tôi trở lại lên đây, bạn chỉ cần 3 ints quay trở lại,

1091
01:07:42,900 --> 01:07:47,000
và nó trả về địa chỉ, trong trường hợp này trên bộ nhớ mà.

1092
01:07:47,000 --> 01:07:51,250
Và chúng tôi đặt con trỏ = chuyển đổi, và trên đó chúng ta chỉ có một con trỏ.

1093
01:07:51,250 --> 01:07:54,550
Nhưng những gì mà trở về chức năng được xếp chồng lên nhau ở đây và biến mất.

1094
01:07:54,550 --> 01:07:59,250
Vì vậy, tạm thời biến mất, nhưng chúng tôi vẫn duy trì địa chỉ của nơi

1095
01:07:59,250 --> 01:08:01,850
3 số nguyên là bên trong của nguồn điện.

1096
01:08:01,850 --> 01:08:06,180
Vì vậy, trong bộ này, con trỏ scoped tại địa phương cho khung xếp chồng lên nhau,

1097
01:08:06,180 --> 01:08:09,860
nhưng bộ nhớ mà họ tham khảo trong heap.

1098
01:08:09,860 --> 01:08:12,190
>> Điều đó làm cho tinh thần?

1099
01:08:12,190 --> 01:08:14,960
[Sinh viên có thể lặp lại điều đó không? >> [Joseph].

1100
01:08:14,960 --> 01:08:20,270
Vì vậy, nếu tôi đi trở lại chỉ là một chút, bạn thấy rằng tạm thời phân bổ

1101
01:08:20,270 --> 01:08:23,500
một số bộ nhớ trên heap lên đó.

1102
01:08:23,500 --> 01:08:28,680
Vì vậy, khi chức năng này, giveMeThreeInts trở về, chồng này ở đây sẽ biến mất.

1103
01:08:28,680 --> 01:08:35,819
Và với bất kỳ của các biến, trong trường hợp này, con trỏ đã được phân bổ trong khung xếp chồng lên nhau.

1104
01:08:35,819 --> 01:08:39,649
Có nghĩa là sẽ biến mất, nhưng kể từ khi chúng tôi trở về nhiệt độ

1105
01:08:39,649 --> 01:08:46,330
và chúng tôi đặt con trỏ = temp, con trỏ sẽ chỉ cùng một bộ nhớ vị trí như temp.

1106
01:08:46,330 --> 01:08:50,370
Vì vậy, bây giờ, mặc dù chúng ta mất đi tạm thời, mà con trỏ địa phương,

1107
01:08:50,370 --> 01:08:59,109
chúng tôi vẫn giữ lại các địa chỉ bộ nhớ của những gì nó đã chỉ vào bên trong của con trỏ biến.

1108
01:08:59,109 --> 01:09:03,740
Câu hỏi? Đó có thể là của một chủ đề khó hiểu nếu bạn không đi qua nó trong phần.

1109
01:09:03,740 --> 01:09:09,240
Chúng ta có thể, TF của bạn chắc chắn sẽ đi qua nó và dĩ nhiên chúng tôi có thể trả lời các câu hỏi

1110
01:09:09,240 --> 01:09:11,500
ở phần cuối của phiên họp xem xét cho điều này.

1111
01:09:11,500 --> 01:09:14,220
Nhưng đây là sắp xếp của một chủ đề phức tạp, và tôi có nhiều ví dụ hơn sẽ hiển thị

1112
01:09:14,220 --> 01:09:18,790
sẽ giúp làm rõ những gì con trỏ thực sự đang có.

1113
01:09:18,790 --> 01:09:22,500
>> Trong trường hợp này, con trỏ tương đương với mảng,

1114
01:09:22,500 --> 01:09:25,229
vì vậy tôi chỉ có thể sử dụng con trỏ như là cùng một điều như là một mảng int.

1115
01:09:25,229 --> 01:09:29,840
Vì vậy, tôi lập chỉ mục vào 0, và thay đổi số nguyên đầu tiên là 1,

1116
01:09:29,840 --> 01:09:39,689
thay đổi số nguyên thứ hai là 2, và số nguyên thứ 3 đến 3.

1117
01:09:39,689 --> 01:09:44,210
Vì vậy, trên con trỏ. Vâng, nhớ lại Binky.

1118
01:09:44,210 --> 01:09:48,319
Trong trường hợp này, chúng tôi đã phân bổ một con trỏ, hoặc chúng tôi tuyên bố một con trỏ,

1119
01:09:48,319 --> 01:09:52,760
nhưng ban đầu, khi tôi chỉ tuyên bố một con trỏ, nó không chỉ đến bất cứ nơi nào trong bộ nhớ.

1120
01:09:52,760 --> 01:09:54,930
Đó là giá trị rác bên trong của nó.

1121
01:09:54,930 --> 01:09:56,470
Vì vậy, tôi không có ý tưởng, nơi này con trỏ trỏ đến.

1122
01:09:56,470 --> 01:10:01,630
Nó có một địa chỉ mà chỉ là lấp đầy với 0 và 1 nơi mà nó bước đầu đã được tuyên bố.

1123
01:10:01,630 --> 01:10:04,810
Tôi không thể làm bất cứ điều gì với điều này cho đến khi tôi gọi malloc vào nó

1124
01:10:04,810 --> 01:10:08,390
và sau đó nó mang lại cho tôi một không gian nhỏ trên đống, nơi tôi có thể đặt giá trị bên trong.

1125
01:10:08,390 --> 01:10:11,980
Sau đó, một lần nữa, tôi không biết những gì bên trong của bộ nhớ này.

1126
01:10:11,980 --> 01:10:16,780
Vì vậy, điều đầu tiên tôi phải làm là kiểm tra xem hệ thống có đủ bộ nhớ

1127
01:10:16,780 --> 01:10:20,850
để cho tôi 1 số nguyên ở nơi đầu tiên, đó là lý do tại sao tôi làm điều này kiểm tra.

1128
01:10:20,850 --> 01:10:25,020
Nếu con trỏ là null, có nghĩa là nó không có đủ không gian hay một số lỗi khác xảy ra,

1129
01:10:25,020 --> 01:10:26,320
vì vậy tôi phải thoát ra khỏi chương trình của tôi.

1130
01:10:26,320 --> 01:10:29,400
 Nhưng nếu nó đã thành công, bây giờ tôi có thể sử dụng con trỏ

1131
01:10:29,400 --> 01:10:35,020
và những gì * con trỏ theo địa chỉ ở đâu

1132
01:10:35,020 --> 01:10:38,480
nơi mà giá trị đó, và nó đặt nó bằng 1.

1133
01:10:38,480 --> 01:10:41,850
Vì vậy, ở đây, chúng tôi đang kiểm tra nếu là bộ nhớ tồn tại.

1134
01:10:41,850 --> 01:10:45,380
>> Một khi bạn biết nó tồn tại, bạn có thể đưa vào nó

1135
01:10:45,380 --> 01:10:50,460
những gì giá trị mà bạn muốn đưa vào nó, trong trường hợp này 1.

1136
01:10:50,460 --> 01:10:53,060
Khi chúng tôi đang thực hiện với nó, bạn cần phải giải phóng con trỏ

1137
01:10:53,060 --> 01:10:57,160
bởi vì chúng tôi cần để có được trở lại hệ thống mà bộ nhớ mà bạn yêu cầu ở nơi đầu tiên.

1138
01:10:57,160 --> 01:10:59,690
Bởi vì máy tính không biết khi chúng tôi đang thực hiện với nó.

1139
01:10:59,690 --> 01:11:02,510
Trong trường hợp này, chúng tôi đang rõ ràng nói cho nó, không sao, chúng tôi đang thực hiện với bộ nhớ đó.

1140
01:11:02,510 --> 01:11:10,780
Nếu một số quy trình khác cần nó, một số chương trình khác cần nó, cảm thấy tự do để đi trước và mang nó.

1141
01:11:10,780 --> 01:11:15,110
Những gì chúng tôi cũng có thể làm là chúng ta chỉ có thể có được địa chỉ của các biến địa phương thiết lập.

1142
01:11:15,110 --> 01:11:19,080
Vì vậy, int x là bên trong khung xếp chồng lên nhau của chính.

1143
01:11:19,080 --> 01:11:23,060
Và khi chúng ta sử dụng ký hiệu này, và nhà điều hành, những gì nó làm là

1144
01:11:23,060 --> 01:11:27,310
phải mất x, và x là một số dữ liệu trong bộ nhớ, nhưng nó có một địa chỉ.

1145
01:11:27,310 --> 01:11:33,790
Nó nằm ở một nơi nào đó. Vì vậy, bằng cách gọi điện thoại & x, điều này không là nó mang lại cho chúng tôi địa chỉ của x.

1146
01:11:33,790 --> 01:11:38,430
Bằng cách này, chúng tôi đang làm điểm con trỏ trong đó x là trong bộ nhớ.

1147
01:11:38,430 --> 01:11:41,710
Bây giờ chúng ta chỉ cần làm một cái gì đó như * x, chúng ta sẽ nhận được 5 trở lại.

1148
01:11:41,710 --> 01:11:43,820
Ngôi sao này được gọi là dereferencing nó.

1149
01:11:43,820 --> 01:11:46,640
Bạn làm theo các địa chỉ và bạn sẽ có được giá trị của nó được lưu giữ tại đó.

1150
01:11:51,000 --> 01:11:53,310
>> Bất kỳ câu hỏi nào? Vâng?

1151
01:11:53,310 --> 01:11:56,500
[Sinh viên] Nếu bạn không làm điều 3-cánh, nó vẫn biên dịch?

1152
01:11:56,500 --> 01:11:59,490
Vâng. Nếu bạn không làm điều 3-con trỏ, nó vẫn sẽ để biên dịch,

1153
01:11:59,490 --> 01:12:02,720
nhưng tôi sẽ cho bạn thấy những gì xảy ra trong một giây, và không làm điều đó,

1154
01:12:02,720 --> 01:12:04,860
đó là những gì chúng ta gọi là rò rỉ bộ nhớ. Bạn không cho hệ thống

1155
01:12:04,860 --> 01:12:07,850
sao bộ nhớ của nó, vì vậy sau một thời gian chương trình sẽ tích lũy

1156
01:12:07,850 --> 01:12:10,940
nhớ mà nó sử dụng, và không có gì khác có thể sử dụng nó.

1157
01:12:10,940 --> 01:12:15,750
Nếu bạn đã từng nhìn thấy Firefox với 1,5 triệu kilobytes trên máy tính của bạn,

1158
01:12:15,750 --> 01:12:17,840
trong công việc quản lý, đó là những gì đang xảy ra.

1159
01:12:17,840 --> 01:12:20,760
Bạn có một rò rỉ bộ nhớ trong chương trình rằng họ đang không xử lý.

1160
01:12:23,080 --> 01:12:26,240
Vì vậy, làm thế nào để con trỏ số học làm việc?

1161
01:12:26,240 --> 01:12:29,480
Vâng, con trỏ số học là sắp xếp các chỉ mục như vào một mảng.

1162
01:12:29,480 --> 01:12:36,370
Trong trường hợp này, tôi có một con trỏ, và những gì tôi làm là tôi làm cho điểm con trỏ đến các yếu tố đầu tiên

1163
01:12:36,370 --> 01:12:42,100
mảng này của 3 số nguyên mà tôi đã được phân bổ.

1164
01:12:42,100 --> 01:12:46,670
Vì vậy, bây giờ những gì tôi làm, sao con trỏ chỉ thay đổi phần tử đầu tiên trong danh sách.

1165
01:12:46,670 --> 01:12:49,140
Sao con trỏ +1 điểm trên đây.

1166
01:12:49,140 --> 01:12:53,140
Vì vậy, con trỏ là ở đây, con trỏ +1 là ở đây, con trỏ 2 là ở đây.

1167
01:12:53,140 --> 01:12:56,610
>> Vì vậy, chỉ cần thêm 1 điều tương tự như di chuyển dọc theo mảng này.

1168
01:12:56,610 --> 01:12:59,880
Những gì chúng tôi làm là, khi chúng ta làm con trỏ 1 bạn sẽ có được địa chỉ trên đây,

1169
01:12:59,880 --> 01:13:04,180
và để có được giá trị ở đây, bạn đặt một ngôi sao trong toàn bộ biểu thức

1170
01:13:04,180 --> 01:13:05,990
để dereference nó.

1171
01:13:05,990 --> 01:13:09,940
Vì vậy, trong trường hợp này, tôi đang thiết lập vị trí đầu tiên trong mảng này là 1,

1172
01:13:09,940 --> 01:13:13,970
2 vị trí 2, và vị trí thứ ba đến 3.

1173
01:13:13,970 --> 01:13:18,180
Sau đó, những gì tôi đang làm ở đây là tôi đang in con trỏ của chúng tôi 1,

1174
01:13:18,180 --> 01:13:19,970
mà chỉ mang lại cho tôi 2.

1175
01:13:19,970 --> 01:13:23,650
Bây giờ tôi đang incrementing con trỏ, vì vậy con trỏ bằng con trỏ 1,

1176
01:13:23,650 --> 01:13:26,780
trong đó di chuyển nó về phía trước.

1177
01:13:26,780 --> 01:13:30,810
Và vì vậy bây giờ nếu tôi in ra con trỏ 1, con trỏ +1 là 3,

1178
01:13:30,810 --> 01:13:33,990
mà trong trường hợp này in ra 3.

1179
01:13:33,990 --> 01:13:36,560
Và để một cái gì đó miễn phí, con trỏ mà tôi cung cấp cho nó

1180
01:13:36,560 --> 01:13:40,540
phải được trỏ vào đầu của mảng mà tôi nhận được trở lại từ malloc.

1181
01:13:40,540 --> 01:13:43,430
Vì vậy, trong trường hợp này, nếu tôi được gọi 3 ngay tại đây, điều này sẽ không được quyền,

1182
01:13:43,430 --> 01:13:45,070
bởi vì nó ở giữa của mảng.

1183
01:13:45,070 --> 01:13:48,820
Tôi phải trừ đi để có được vị trí ban đầu

1184
01:13:48,820 --> 01:13:50,420
vị trí ban đầu trước khi tôi có thể miễn phí.

1185
01:13:56,300 --> 01:13:58,450
Vì vậy, đây là một ví dụ liên quan đến nhiều hơn.

1186
01:13:58,450 --> 01:14:03,360
Trong trường hợp này, chúng tôi đang phân bổ 7 ký tự trong một mảng ký tự.

1187
01:14:03,360 --> 01:14:06,480
>> Và trong trường hợp này những gì chúng tôi đang làm là chúng ta đang Looping hơn 6 tháng đầu năm của họ,

1188
01:14:06,480 --> 01:14:09,900
và chúng tôi đang thiết lập cho họ đến Z.

1189
01:14:09,900 --> 01:14:13,350
Vì vậy, cho int i = 0, i> 6, i + +,

1190
01:14:13,350 --> 01:14:16,220
Vì vậy, con trỏ + i sẽ chỉ cung cấp cho chúng tôi, trong trường hợp này,

1191
01:14:16,220 --> 01:14:20,860
con trỏ, +1 con trỏ, +2 con trỏ, con trỏ 3, và vv và vv trong vòng lặp.

1192
01:14:20,860 --> 01:14:24,040
Những gì nó sẽ làm gì là nó được địa chỉ đó, dereferences nó để có được giá trị,

1193
01:14:24,040 --> 01:14:27,440
và thay đổi giá trị cho một Z.

1194
01:14:27,440 --> 01:14:30,350
Sau đó, vào cuối nhớ những điều này là một chuỗi, phải không?

1195
01:14:30,350 --> 01:14:33,560
Tất cả các chuỗi có kết thúc với các ký tự chấm dứt vô giá trị.

1196
01:14:33,560 --> 01:14:38,620
Vì vậy, những gì tôi làm là trong con trỏ 6 tôi đặt nhân vật terminator vô giá trị.

1197
01:14:38,620 --> 01:14:43,980
Và bây giờ về cơ bản những gì tôi đang làm ở đây đang thực hiện printf cho một chuỗi, phải không?

1198
01:14:43,980 --> 01:14:46,190
>> Vì vậy, khi printf bây giờ khi nó đạt đến kết thúc của một chuỗi?

1199
01:14:46,190 --> 01:14:48,230
Khi nó chạm vào nhân vật chấm dứt vô giá trị.

1200
01:14:48,230 --> 01:14:52,030
Vì vậy, trong trường hợp này, con trỏ điểm ban đầu của tôi để bắt đầu của mảng này.

1201
01:14:52,030 --> 01:14:56,410
Tôi in các ký tự đầu tiên. Tôi di chuyển nó trên một.

1202
01:14:56,410 --> 01:14:58,420
Tôi in rằng nhân vật. Tôi di chuyển nó trên.

1203
01:14:58,420 --> 01:15:02,180
Và tôi tiếp tục làm điều này cho đến khi tôi đạt được kết thúc.

1204
01:15:02,180 --> 01:15:07,750
Và bây giờ * kết thúc con trỏ dereference này và chấm dứt được những nhân vật vô giá trị trở lại.

1205
01:15:07,750 --> 01:15:11,780
Và do đó, vòng lặp trong khi tôi chỉ chạy khi giá trị đó không phải là các ký tự null chấm dứt.

1206
01:15:11,780 --> 01:15:13,770
Vì vậy, bây giờ tôi thoát ra khỏi vòng lặp này.

1207
01:15:18,780 --> 01:15:21,180
Và vì vậy nếu tôi trừ đi 6 từ con trỏ này,

1208
01:15:21,180 --> 01:15:22,860
Tôi quay trở lại tất cả các cách để bắt đầu.

1209
01:15:22,860 --> 01:15:27,880
Hãy nhớ rằng, tôi đang làm điều này vì tôi phải đi đầu để giải phóng nó.

1210
01:15:27,880 --> 01:15:30,270
>> Vì vậy, tôi biết đó là rất nhiều. Có bất kỳ câu hỏi nào?

1211
01:15:30,270 --> 01:15:31,870
Xin vui lòng, đúng không?

1212
01:15:31,870 --> 01:15:36,610
[Sinh viên câu hỏi khó hiểu]

1213
01:15:36,610 --> 01:15:38,190
Bạn có thể nói to hơn? Xin lôi.

1214
01:15:38,190 --> 01:15:44,140
[Sinh viên] slide cuối cùng ngay trước khi bạn giải phóng con trỏ,

1215
01:15:44,140 --> 01:15:47,300
bạn thực sự thay đổi giá trị của con trỏ?

1216
01:15:47,300 --> 01:15:50,370
[Joseph] Vì vậy, ngay tại đây. >> [Sinh viên] Oh, okay.

1217
01:15:50,370 --> 01:15:51,890
[Joseph] Vì vậy, tôi có một con trỏ trừ trừ, phải,

1218
01:15:51,890 --> 01:15:54,140
trong đó di chuyển trở lại một điều, và sau đó tôi giải phóng nó,

1219
01:15:54,140 --> 01:15:57,000
bởi vì con trỏ này để được chỉ đầu của mảng.

1220
01:15:57,000 --> 01:16:00,420
[Sinh viên] Nhưng điều đó sẽ không cần thiết bạn đã dừng lại sau khi dòng đó.

1221
01:16:00,420 --> 01:16:03,130
[Joseph] Vì vậy, nếu tôi đã dừng lại sau khi điều này, điều này sẽ được xem xét một rò rỉ bộ nhớ,

1222
01:16:03,130 --> 01:16:04,810
bởi vì tôi đã không chạy miễn phí.

1223
01:16:04,810 --> 01:16:11,290
[Sinh viên] [khó hiểu] sau khi ba dòng đầu tiên mà bạn đã có con trỏ 1 [khó hiểu].

1224
01:16:11,290 --> 01:16:13,140
[Joseph] Uh-huh. Vì vậy, câu hỏi có những gì?

1225
01:16:13,140 --> 01:16:14,780
Xin lôi. Không, không. Đi, đi, xin vui lòng.

1226
01:16:14,780 --> 01:16:16,870
[Sinh viên] Vì vậy, bạn không phải thay đổi giá trị của con trỏ.

1227
01:16:16,870 --> 01:16:19,130
Bạn sẽ không phải để làm con trỏ trừ trừ.

1228
01:16:19,130 --> 01:16:19,730
[Joseph] Vâng, chính xác.

1229
01:16:19,730 --> 01:16:21,890
Vì vậy, khi tôi làm con trỏ +1 và con trỏ 2,

1230
01:16:21,890 --> 01:16:24,410
Tôi không làm con trỏ bằng con trỏ 1.

1231
01:16:24,410 --> 01:16:27,260
Vì vậy, con trỏ chỉ những chuyến du lịch chỉ vào đầu của mảng.

1232
01:16:27,260 --> 01:16:31,460
Đó là chỉ khi tôi làm cộng với cộng với nó đặt giá trị trở lại bên trong con trỏ,

1233
01:16:31,460 --> 01:16:33,550
rằng nó thực sự di chuyển này cùng.

1234
01:16:36,860 --> 01:16:37,780
Được rồi.

1235
01:16:40,550 --> 01:16:42,030
Câu hỏi nhiều hơn?

1236
01:16:44,680 --> 01:16:47,790
>> Một lần nữa, nếu điều này là loại áp đảo, điều này sẽ được đề cập trong phiên giao dịch.

1237
01:16:47,790 --> 01:16:50,710
Yêu cầu giáo viên giảng dạy của bạn về nó, và chúng ta có thể trả lời các câu hỏi ở cuối.

1238
01:16:53,510 --> 01:16:56,600
Và thường chúng tôi không muốn làm điều này trừ.

1239
01:16:56,600 --> 01:16:59,760
Điều này có yêu cầu tôi theo dõi bao nhiêu tôi đã bù đắp trong mảng.

1240
01:16:59,760 --> 01:17:04,520
Vì vậy, nói chung, điều này chỉ là để giải thích cách làm việc của con trỏ số học.

1241
01:17:04,520 --> 01:17:07,970
Nhưng những gì chúng ta thường muốn làm là chúng tôi muốn tạo ra một bản sao của con trỏ,

1242
01:17:07,970 --> 01:17:11,640
và sau đó chúng tôi sẽ sử dụng bản sao khi chúng tôi đang di chuyển xung quanh trong chuỗi.

1243
01:17:11,640 --> 01:17:14,660
Vì vậy, trong trường hợp này, bạn sử dụng các bản sao để in toàn bộ chuỗi,

1244
01:17:14,660 --> 01:17:19,040
nhưng chúng tôi không phải làm như con trỏ trừ đi 6 hoặc theo dõi bao nhiêu chúng ta di chuyển này,

1245
01:17:19,040 --> 01:17:22,700
chỉ vì chúng tôi biết rằng bản gốc quan điểm của chúng tôi vẫn chỉ đầu của danh sách

1246
01:17:22,700 --> 01:17:25,340
và tất cả những gì chúng ta thay đổi là bản sao này.

1247
01:17:25,340 --> 01:17:28,250
Vì vậy, nói chung, thay đổi bản sao của con trỏ ban đầu của bạn.

1248
01:17:28,250 --> 01:17:32,350
Đừng cố gắng để sắp xếp như đừng thay đổi bản gốc.

1249
01:17:32,350 --> 01:17:35,290
Đang cố gắng để thay đổi các bản sao duy nhất của ban đầu của bạn.

1250
01:17:41,540 --> 01:17:44,870
Vì vậy, bạn nhận thấy khi chúng tôi vượt qua chuỗi thành printf

1251
01:17:44,870 --> 01:17:48,990
bạn không có để đặt một ngôi sao ở phía trước của nó như chúng tôi đã làm với tất cả các dereferences khác, phải không?

1252
01:17:48,990 --> 01:17:54,180
Vì vậy, nếu bạn in ra toàn bộ chuỗi% s hy vọng sẽ là một địa chỉ,

1253
01:17:54,180 --> 01:17:57,610
và trong trường hợp này là một con trỏ hoặc trong trường hợp này giống như một mảng kí tự.

1254
01:17:57,610 --> 01:18:00,330
>> Ký tự, char * s, và mảng là điều tương tự.

1255
01:18:00,330 --> 01:18:03,690
Con trỏ là ký tự, và mảng ký tự có cùng một điều.

1256
01:18:03,690 --> 01:18:05,720
Và như vậy, tất cả chúng ta phải làm là vượt qua trong con trỏ.

1257
01:18:05,720 --> 01:18:08,150
Chúng tôi không có để vượt qua trong như * con trỏ hoặc bất cứ điều gì như thế.

1258
01:18:13,110 --> 01:18:14,930
Vì vậy, mảng và con trỏ là điều tương tự.

1259
01:18:14,930 --> 01:18:19,160
Khi bạn đang làm một cái gì đó như x [y] trên đây để một mảng,

1260
01:18:19,160 --> 01:18:21,960
những gì nó đang làm dưới mui xe là nó nói rằng, được rồi, đó là một mảng ký tự,

1261
01:18:21,960 --> 01:18:23,690
do đó, nó là một con trỏ.

1262
01:18:23,690 --> 01:18:26,510
Và như vậy x là điều tương tự,

1263
01:18:26,510 --> 01:18:28,650
và do đó, những gì nó làm là nó cho biết thêm y x,

1264
01:18:28,650 --> 01:18:31,820
đó là điều tương tự như di chuyển về phía trước trong bộ nhớ rằng có rất nhiều.

1265
01:18:31,820 --> 01:18:34,930
Và bây giờ x + y cung cấp cho chúng tôi một số loại địa chỉ,

1266
01:18:34,930 --> 01:18:37,570
và chúng tôi dereference địa chỉ hoặc theo các mũi tên

1267
01:18:37,570 --> 01:18:41,640
vị trí đó trong bộ nhớ và chúng tôi nhận được giá trị của vị trí đó trong bộ nhớ.

1268
01:18:41,640 --> 01:18:43,720
Vì vậy, do đó, hai là chính xác những điều tương tự.

1269
01:18:43,720 --> 01:18:45,840
Nó chỉ là một đường cú pháp.

1270
01:18:45,840 --> 01:18:48,090
Họ làm điều tương tự. Họ săn syntactics khác nhau cho nhau.

1271
01:18:51,500 --> 01:18:57,590
>> Vì vậy, những gì có thể đi sai với con trỏ? Giống như, rất nhiều. Okay. Vì vậy, những điều xấu.

1272
01:18:57,590 --> 01:19:02,410
Một số những điều xấu bạn có thể làm được không kiểm tra nếu cuộc gọi malloc của bạn trả về null, phải không?

1273
01:19:02,410 --> 01:19:06,560
Trong trường hợp này, tôi đang yêu cầu hệ thống để cho tôi con số đó là những gì?

1274
01:19:06,560 --> 01:19:11,200
Giống như 2 tỷ lần 4, bởi vì kích thước của một số nguyên là 4 byte.

1275
01:19:11,200 --> 01:19:13,810
Tôi đang yêu cầu nó cho như 8 tỷ byte.

1276
01:19:13,810 --> 01:19:17,270
Tất nhiên máy tính của tôi không phải là đi để có thể cung cấp cho tôi rằng nhiều bộ nhớ trở lại.

1277
01:19:17,270 --> 01:19:20,960
Và chúng tôi đã không kiểm tra nếu điều này là vô giá trị, vì vậy khi chúng ta cố gắng dereference nó ở đó -

1278
01:19:20,960 --> 01:19:24,270
theo các mũi tên đến nơi mà nó sẽ - chúng tôi không có mà bộ nhớ.

1279
01:19:24,270 --> 01:19:27,150
Đây là những gì chúng ta gọi là dereferencing một con trỏ null.

1280
01:19:27,150 --> 01:19:29,710
Và điều này về cơ bản làm bạn segfault.

1281
01:19:29,710 --> 01:19:31,790
Đây là một trong những cách bạn có thể segfault.

1282
01:19:34,090 --> 01:19:38,090
Những điều xấu khác bạn có thể làm tốt.

1283
01:19:38,090 --> 01:19:40,650
Đó là dereferencing một con trỏ null. Okay.

1284
01:19:40,650 --> 01:19:45,160
Những thứ khác xấu - tốt, để sửa chữa mà bạn chỉ cần đặt một kiểm tra trong đó

1285
01:19:45,160 --> 01:19:46,980
để kiểm tra xem con trỏ là null

1286
01:19:46,980 --> 01:19:51,000
và thoát ra khỏi chương trình nếu nó xảy ra malloc trả về một con trỏ null.

1287
01:19:55,110 --> 01:19:59,850
Đó là truyện tranh xkcd. Mọi người sẽ hiểu nó ngay bây giờ. Phân loại của.

1288
01:20:06,120 --> 01:20:09,350
>> Vì vậy, bộ nhớ. Và tôi đã nói về điều này.

1289
01:20:09,350 --> 01:20:12,000
Chúng tôi kêu gọi malloc trong một vòng lặp, nhưng mỗi lần chúng tôi gọi malloc

1290
01:20:12,000 --> 01:20:14,370
chúng ta đang mất đi theo dõi các nơi này con trỏ trỏ đến,

1291
01:20:14,370 --> 01:20:15,750
bởi vì chúng tôi đang clobbering nó.

1292
01:20:15,750 --> 01:20:18,410
Vì vậy, các cuộc gọi ban đầu để malloc mang lại cho tôi bộ nhớ ở đây.

1293
01:20:18,410 --> 01:20:19,990
Con trỏ của tôi con trỏ này.

1294
01:20:19,990 --> 01:20:23,020
Bây giờ, tôi không giải phóng nó, vì vậy bây giờ tôi gọi malloc một lần nữa.

1295
01:20:23,020 --> 01:20:26,070
Bây giờ nó chỉ ở đây. Bây giờ bộ nhớ của tôi là chỉ ở đây.

1296
01:20:26,070 --> 01:20:27,640
Chỉ ở đây. Chỉ ở đây.

1297
01:20:27,640 --> 01:20:31,820
Nhưng tôi đã mất theo dõi các địa chỉ của tất cả các bộ nhớ hơn ở đây mà tôi được phân bổ.

1298
01:20:31,820 --> 01:20:35,100
Và vì vậy bây giờ tôi không có bất kỳ tài liệu tham khảo cho họ nữa.

1299
01:20:35,100 --> 01:20:37,230
Vì vậy, tôi không thể giải thoát họ bên ngoài vòng lặp này.

1300
01:20:37,230 --> 01:20:39,390
Và như vậy để sửa chữa một cái gì đó như thế này,

1301
01:20:39,390 --> 01:20:42,250
nếu bạn quên bộ nhớ miễn phí và bạn sẽ có được bộ nhớ bị rò rỉ này,

1302
01:20:42,250 --> 01:20:45,810
Bạn có để giải phóng bộ nhớ bên trong vòng lặp này một khi bạn đang thực hiện với nó.

1303
01:20:45,810 --> 01:20:51,400
Vâng, đây là những gì xảy ra. Tôi biết rất nhiều bạn ghét này.

1304
01:20:51,400 --> 01:20:55,270
Nhưng bây giờ - yay! Bạn nhận được 44.000 kilobyte.

1305
01:20:55,270 --> 01:20:57,110
Vì vậy, bạn giải phóng nó vào cuối của vòng lặp,

1306
01:20:57,110 --> 01:20:59,770
và đó sẽ chỉ miễn phí bộ nhớ mỗi lần.

1307
01:20:59,770 --> 01:21:03,620
Về cơ bản, chương trình của bạn không có một rò rỉ bộ nhớ nữa.

1308
01:21:03,620 --> 01:21:08,150
>> Và bây giờ cái gì khác bạn có thể làm là miễn phí một số bộ nhớ mà bạn đã yêu cầu hai lần.

1309
01:21:08,150 --> 01:21:11,060
Trong trường hợp này, bạn malloc một cái gì đó, bạn thay đổi giá trị của nó.

1310
01:21:11,060 --> 01:21:13,140
Giải phóng nó một lần bởi vì bạn nói bạn đang thực hiện với nó.

1311
01:21:13,140 --> 01:21:14,940
Nhưng sau đó chúng tôi đã giải phóng một lần nữa.

1312
01:21:14,940 --> 01:21:16,730
Đây là cái gì đó là khá xấu.

1313
01:21:16,730 --> 01:21:18,820
Nó sẽ không ban đầu segfault,

1314
01:21:18,820 --> 01:21:23,350
nhưng sau một thời gian điều này là nhấn đúp giải phóng này corrupts cấu trúc heap của bạn,

1315
01:21:23,350 --> 01:21:27,200
và bạn sẽ tìm hiểu thêm một chút về điều này nếu bạn chọn để có một lớp học như CS61.

1316
01:21:27,200 --> 01:21:30,000
Nhưng về cơ bản sau một thời gian máy tính của bạn sẽ bị lẫn lộn

1317
01:21:30,000 --> 01:21:33,010
về vị trí bộ nhớ là nó được lưu trữ ở đâu và ở đâu -

1318
01:21:33,010 --> 01:21:34,800
nơi dữ liệu được lưu trữ trong bộ nhớ.

1319
01:21:34,800 --> 01:21:38,080
Và do đó giải phóng một con trỏ hai lần là một điều xấu mà bạn không muốn làm.

1320
01:21:38,080 --> 01:21:41,600
>> Những thứ khác có thể đi sai là không sử dụng sizeof.

1321
01:21:41,600 --> 01:21:44,460
Vì vậy, trong trường hợp này bạn malloc 8 byte,

1322
01:21:44,460 --> 01:21:46,700
và đó là điều tương tự như hai số nguyên, phải không?

1323
01:21:46,700 --> 01:21:49,580
Vì vậy, đó là hoàn toàn an toàn, nhưng nó?

1324
01:21:49,580 --> 01:21:52,160
Vâng, như Lucas nói về kiến ​​trúc khác nhau,

1325
01:21:52,160 --> 01:21:54,220
số nguyên là độ dài khác nhau.

1326
01:21:54,220 --> 01:21:57,970
Vì vậy, trên các thiết bị mà bạn đang sử dụng, số nguyên là khoảng 4 byte,

1327
01:21:57,970 --> 01:22:02,370
nhưng trên một số hệ thống khác, họ có thể là 8 byte hoặc họ có thể là 16 byte.

1328
01:22:02,370 --> 01:22:05,680
Vì vậy, nếu tôi chỉ cần sử dụng con số này ở đây,

1329
01:22:05,680 --> 01:22:07,310
chương trình này có thể làm việc trên thiết bị,

1330
01:22:07,310 --> 01:22:10,360
nhưng nó sẽ không phân bổ đủ bộ nhớ trên một số hệ thống khác.

1331
01:22:10,360 --> 01:22:14,020
Trong trường hợp này, đây là những gì được sử dụng cho các nhà điều hành sizeof.

1332
01:22:14,020 --> 01:22:16,880
Khi chúng ta gọi sizeof (int), điều này không

1333
01:22:16,880 --> 01:22:21,910
 nó cho chúng ta kích thước của một số nguyên trên hệ thống mà chương trình đang chạy.

1334
01:22:21,910 --> 01:22:25,490
Vì vậy, trong trường hợp này, sizeof (int) sẽ trở lại 4 trên một cái gì đó giống như thiết bị,

1335
01:22:25,490 --> 01:22:29,980
và bây giờ điều này sẽ 4 * 2 là 8,

1336
01:22:29,980 --> 01:22:32,330
mà chỉ là số lượng không gian cần thiết cho hai số nguyên.

1337
01:22:32,330 --> 01:22:36,710
Trên một hệ thống khác nhau, nếu một int là 16 byte hoặc 8 byte,

1338
01:22:36,710 --> 01:22:39,380
nó chỉ là để trở về byte đủ để lưu trữ số tiền đó.

1339
01:22:41,830 --> 01:22:45,310
>> Và cuối cùng, cấu trúc.

1340
01:22:45,310 --> 01:22:48,340
Vì vậy, nếu bạn muốn để lưu trữ một bảng sudoku trong bộ nhớ, làm thế nào chúng ta có thể làm điều này?

1341
01:22:48,340 --> 01:22:51,570
Bạn có thể nghĩ như một biến cho điều đầu tiên,

1342
01:22:51,570 --> 01:22:53,820
một biến cho điều thứ hai, một biến cho điều thứ ba,

1343
01:22:53,820 --> 01:22:56,420
một biến cho điều thứ tư - xấu, đúng không?

1344
01:22:56,420 --> 01:23:00,750
Vì vậy, một trong những cải tiến bạn có thể thực hiện trên đầu trang này là để thực hiện một mảng 9 x 9.

1345
01:23:00,750 --> 01:23:04,480
Đó là tốt, nhưng những gì nếu bạn muốn kết hợp những thứ khác với Ban sudoku

1346
01:23:04,480 --> 01:23:06,490
thích những gì khó khăn của hội đồng quản trị,

1347
01:23:06,490 --> 01:23:11,740
hay, ví dụ, điểm số của bạn là gì, hoặc có bao nhiêu thời gian nó đã đưa bạn giải quyết hội đồng quản trị này?

1348
01:23:11,740 --> 01:23:14,970
Vâng, những gì bạn có thể làm là bạn có thể tạo ra một cấu trúc.

1349
01:23:14,970 --> 01:23:18,910
Những gì tôi đang về cơ bản nói là tôi xác định cấu trúc này ở đây,

1350
01:23:18,910 --> 01:23:23,230
và tôi xác định một hội đồng quản trị sudoku trong đó bao gồm một hội đồng là 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> Và những gì nó đã có con trỏ đến tên của các cấp.

1352
01:23:26,650 --> 01:23:30,730
Nó cũng có x và y, đó là những tọa độ của tôi ngay bây giờ.

1353
01:23:30,730 --> 01:23:35,980
Nó cũng đã dành thời gian [khó hiểu], và nó có tổng số di chuyển tôi đã đầu vào cho đến nay.

1354
01:23:35,980 --> 01:23:40,010
Và như vậy trong trường hợp này, tôi có thể nhóm một bó toàn bộ dữ liệu vào cơ cấu chỉ là một

1355
01:23:40,010 --> 01:23:42,790
thay vì nó giống như đang bay xung quanh như các biến khác nhau

1356
01:23:42,790 --> 01:23:44,540
mà tôi có thể không thực sự theo dõi.

1357
01:23:44,540 --> 01:23:49,720
Và điều này cho phép chúng tôi có chỉ là cú pháp tốt đẹp cho loại tham khảo những điều khác nhau bên trong của cấu trúc này.

1358
01:23:49,720 --> 01:23:53,430
Tôi chỉ có thể làm board.board, và tôi nhận được hội đồng quản trị sudoku trở lại.

1359
01:23:53,430 --> 01:23:56,320
Board.level, tôi nhận được nó khó khăn như thế nào.

1360
01:23:56,320 --> 01:24:00,540
Board.x và board.y cung cấp cho tôi các tọa độ của nơi mà tôi có thể có trong hội đồng quản trị.

1361
01:24:00,540 --> 01:24:04,730
Và vì vậy tôi đang truy cập những gì chúng ta gọi là các lĩnh vực trong một cấu trúc.

1362
01:24:04,730 --> 01:24:08,840
Này định nghĩa sudokuBoard, mà là một loại mà tôi có.

1363
01:24:08,840 --> 01:24:14,800
Và bây giờ chúng tôi đang ở đây. Tôi có một biến được gọi là "hội đồng" của sudokuBoard loại.

1364
01:24:14,800 --> 01:24:18,820
Và vì vậy bây giờ tôi có thể truy cập vào tất cả các lĩnh vực tạo nên cấu trúc này ở đây.

1365
01:24:20,830 --> 01:24:22,450
>> Bất kỳ câu hỏi về cấu trúc? Vâng?

1366
01:24:22,450 --> 01:24:25,890
[Sinh viên] int x, y, bạn tuyên bố cả hai trên cùng một dòng? >> [Joseph] Uh-huh.

1367
01:24:25,890 --> 01:24:27,400
[Sinh viên] Vì vậy, có thể bạn chỉ cần làm điều đó với tất cả chúng?

1368
01:24:27,400 --> 01:24:31,200
Giống như trong x, y lần dấu phẩy, tổng?

1369
01:24:31,200 --> 01:24:34,460
[Joseph] Có, bạn chắc chắn có thể làm điều đó, nhưng lý do tôi đặt x và y trên cùng một dòng -

1370
01:24:34,460 --> 01:24:36,330
và câu hỏi là tại sao chúng ta có thể chỉ làm điều này trên cùng một dòng?

1371
01:24:36,330 --> 01:24:38,600
Tại sao chúng ta không chỉ cần đặt tất cả các trên cùng một dòng

1372
01:24:38,600 --> 01:24:42,090
x và y có liên quan với nhau,

1373
01:24:42,090 --> 01:24:44,780
và đây chỉ là phong cách chính xác hơn, trong một cảm giác,

1374
01:24:44,780 --> 01:24:46,600
bởi vì nó được nhóm hai điều trên cùng một dòng

1375
01:24:46,600 --> 01:24:49,340
mà loại như của liên quan đến cùng một điều.

1376
01:24:49,340 --> 01:24:51,440
Và tôi chỉ cần chia những ngoài. Nó chỉ là một điều phong cách.

1377
01:24:51,440 --> 01:24:53,720
Nó có chức năng làm cho không có sự khác biệt gì.

1378
01:24:58,150 --> 01:24:59,270
Bất kỳ các câu hỏi về cấu trúc?

1379
01:25:03,030 --> 01:25:06,620
Bạn có thể xác định một Pokédex với một cấu trúc.

1380
01:25:06,620 --> 01:25:11,720
Pokémon có một số và nó có một lá thư, một chủ sở hữu, một loại.

1381
01:25:11,720 --> 01:25:16,990
Và sau đó nếu bạn có một mảng của Pokémon, bạn có thể tạo nên một chiếc Pokédex, phải không?

1382
01:25:16,990 --> 01:25:20,810
Được rồi, mát mẻ. Vì vậy, câu hỏi về cấu trúc. Đó là những liên quan đến cấu trúc.

1383
01:25:20,810 --> 01:25:25,270
>> Cuối cùng, GDB. GDB cho phép bạn làm gì? Nó cho phép bạn gỡ lỗi chương trình của bạn.

1384
01:25:25,270 --> 01:25:27,650
Và nếu bạn đã không sử dụng GDB, tôi sẽ đề nghị xem ngắn

1385
01:25:27,650 --> 01:25:31,250
và chỉ cần đi qua GDB là gì, làm thế nào bạn làm việc với nó, làm thế nào bạn có thể sử dụng nó,

1386
01:25:31,250 --> 01:25:32,900
và thử nghiệm nó trên một chương trình.

1387
01:25:32,900 --> 01:25:37,400
Và vì vậy những gì GDB cho phép bạn làm là nó cho phép tạm dừng [khó hiểu] của bạn chương trình

1388
01:25:37,400 --> 01:25:38,920
và một dòng thực tế.

1389
01:25:38,920 --> 01:25:42,600
Ví dụ, tôi muốn tạm dừng thực hiện tại như dòng 3 của chương trình của tôi,

1390
01:25:42,600 --> 01:25:46,010
và khi tôi đang ở dòng 3, tôi có thể in ra tất cả các giá trị được ở đó.

1391
01:25:46,010 --> 01:25:49,710
Và do đó, những gì chúng ta gọi như tạm dừng trong một dòng

1392
01:25:49,710 --> 01:25:52,350
là chúng tôi gọi đây là đặt một breakpoint tại dòng đó

1393
01:25:52,350 --> 01:25:55,920
và sau đó chúng tôi có thể in ra các biến trạng thái của chương trình tại thời điểm đó.

1394
01:25:55,920 --> 01:25:58,990
>> Sau đó chúng ta có thể từ đó bước thông qua các chương trình dòng-by-line.

1395
01:25:58,990 --> 01:26:03,200
Và sau đó chúng ta có thể nhìn vào tình trạng của chồng lúc đó.

1396
01:26:03,200 --> 01:26:08,600
Và vì vậy để sử dụng GDB, những gì chúng tôi làm là chúng ta gọi là kêu vang trên các tập tin C,

1397
01:26:08,600 --> 01:26:11,290
nhưng chúng ta phải vượt qua nó ggdb-flag.

1398
01:26:11,290 --> 01:26:15,850
Và một khi chúng tôi đang thực hiện với điều đó, chúng tôi chỉ cần chạy gdb trên các tập tin đầu ra kết quả.

1399
01:26:15,850 --> 01:26:18,810
Và như vậy bạn nhận được một số đại chúng như văn bản như thế này,

1400
01:26:18,810 --> 01:26:21,990
nhưng thực sự tất cả những gì bạn phải làm là nhập vào lệnh ngay từ đầu.

1401
01:26:21,990 --> 01:26:24,250
Phá vỡ chính đặt một breakpoint chính.

1402
01:26:24,250 --> 01:26:28,470
Danh sách 400 liệt kê các dòng mã xung quanh dòng 400.

1403
01:26:28,470 --> 01:26:31,410
Và như vậy trong trường hợp này, bạn có thể chỉ cần nhìn xung quanh và nói, oh,

1404
01:26:31,410 --> 01:26:34,360
Tôi muốn thiết lập một breakpoint tại dòng 397, đó là dòng này,

1405
01:26:34,360 --> 01:26:37,170
và sau đó chương trình của bạn chạy vào bước đó và nó sẽ phá vỡ.

1406
01:26:37,170 --> 01:26:41,120
Nó sẽ tạm dừng ở đó, và bạn có thể in ra, ví dụ, giá trị thấp hoặc cao.

1407
01:26:41,120 --> 01:26:46,410
Và do đó, là một loạt các lệnh bạn cần phải biết,

1408
01:26:46,410 --> 01:26:48,660
và xem hình tự động này sẽ đi lên trên trang web,

1409
01:26:48,660 --> 01:26:54,000
vì vậy nếu bạn chỉ muốn tham khảo những hoặc như đặt chúng trên tờ cheat của bạn, cảm thấy tự do.

1410
01:26:54,000 --> 01:27:00,650
>> Cool. Đó là Câu đố Đánh giá 0, và chúng tôi sẽ dính xung quanh nếu bạn có bất kỳ câu hỏi nào.

1411
01:27:00,650 --> 01:27:03,850
Được rồi.

1412
01:27:03,850 --> 01:27:09,030
>>  [Vỗ tay]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]