1
00:00:00,000 --> 00:00:00,499

2
00:00:00,499 --> 00:00:01,395
[MUSIC CHƠI]

3
00:00:01,395 --> 00:00:05,590

4
00:00:05,590 --> 00:00:07,940
>> DOUG LLOYD: OK vậy là một gợi ý
trước khi bắt đầu từ đây.

5
00:00:07,940 --> 00:00:11,660
Nếu bạn không theo dõi các video trên
Con trỏ có thể bạn muốn làm như vậy đầu tiên.

6
00:00:11,660 --> 00:00:15,860
Bởi vì bộ phim này là một
cách làm việc với con trỏ.

7
00:00:15,860 --> 00:00:17,574
>> Vì vậy, nó sẽ nói chuyện
về một số khái niệm

8
00:00:17,574 --> 00:00:19,490
rằng chúng tôi bao gồm trong
Con trỏ video, và chúng tôi

9
00:00:19,490 --> 00:00:21,948
đi bóng qua chúng ngay bây giờ,
giả định rằng họ đã

10
00:00:21,948 --> 00:00:23,090
loại hiểu.

11
00:00:23,090 --> 00:00:25,440
Vì vậy, đó chỉ là cảnh báo công bằng của bạn
rằng nếu bạn nhìn thấy video này

12
00:00:25,440 --> 00:00:27,814
và bạn đã không nhìn thấy
con trỏ video, nó có thể loại

13
00:00:27,814 --> 00:00:29,610
bay trên đầu của bạn một chút.

14
00:00:29,610 --> 00:00:32,080
Và do đó, nó có thể được tốt hơn
để xem nó trong thứ tự đó.

15
00:00:32,080 --> 00:00:34,710
>> Vì vậy, chúng ta đã thấy một
cách để làm việc với con trỏ,

16
00:00:34,710 --> 00:00:37,810
đó là chúng ta khai báo một
biến, và sau đó chúng tôi

17
00:00:37,810 --> 00:00:42,160
khai báo một biến khác, một con trỏ
biến, trỏ đến nó.

18
00:00:42,160 --> 00:00:44,870
Vì vậy, chúng tôi đã tạo ra một
biến với một tên, chúng tôi đã

19
00:00:44,870 --> 00:00:48,480
tạo ra một biến thứ hai với một tên,
và chúng tôi chỉ là biến thứ hai

20
00:00:48,480 --> 00:00:50,220
tại đó đầu tiên.

21
00:00:50,220 --> 00:00:52,370
Loại này có một
vấn đề mặc dù, bởi vì nó

22
00:00:52,370 --> 00:00:54,650
đòi hỏi chúng ta phải biết chính xác
bao nhiêu bộ nhớ chúng tôi

23
00:00:54,650 --> 00:00:57,600
sẽ cần lúc này
Chương trình của chúng tôi được biên dịch.

24
00:00:57,600 --> 00:00:58,220
>> Tại sao vậy?

25
00:00:58,220 --> 00:01:03,338
Bởi vì chúng ta cần phải có khả năng tên hoặc
xác định tất cả các biến thể

26
00:01:03,338 --> 00:01:04,129
chúng ta có thể gặp.

27
00:01:04,129 --> 00:01:07,910
Chúng tôi có thể có một mảng mà có thể là
có thể giữ rất nhiều thông tin,

28
00:01:07,910 --> 00:01:10,110
nhưng nó vẫn không
chính xác, đủ chính xác.

29
00:01:10,110 --> 00:01:12,640
Điều gì nếu chúng ta không biết,
nếu chúng ta không có ý tưởng

30
00:01:12,640 --> 00:01:14,370
bao nhiêu chúng tôi sẽ cần ít thời gian biên dịch?

31
00:01:14,370 --> 00:01:17,020
Hoặc nếu chương trình của chúng tôi sẽ
chạy trong một thời gian rất dài,

32
00:01:17,020 --> 00:01:19,810
chấp nhận sử dụng khác nhau
dữ liệu, và chúng tôi không thể thực sự

33
00:01:19,810 --> 00:01:23,170
ước tính xem chúng tôi
sẽ cần 1.000 đơn vị?

34
00:01:23,170 --> 00:01:26,060
>> Nó không giống như chúng ta có thể
nói tại dòng lệnh

35
00:01:26,060 --> 00:01:28,040
nhập bao nhiêu mục
bạn nghĩ rằng bạn sẽ cần.

36
00:01:28,040 --> 00:01:31,100
Vâng những gì nếu đoán đó là sai?

37
00:01:31,100 --> 00:01:34,300
Cấp phát bộ nhớ động
loại cho phép chúng ta con đường

38
00:01:34,300 --> 00:01:36,867
để có được xung quanh vấn đề này cụ thể.

39
00:01:36,867 --> 00:01:38,700
Và cách nào nó
là bằng cách sử dụng con trỏ.

40
00:01:38,700 --> 00:01:42,140
>> Chúng tôi có thể sử dụng con trỏ để
được tiếp cận với động

41
00:01:42,140 --> 00:01:45,710
cấp phát bộ nhớ, bộ nhớ đó là
phân bổ như chương trình của bạn đang chạy.

42
00:01:45,710 --> 00:01:48,290
Nó không được phân bổ tại thời gian biên dịch.

43
00:01:48,290 --> 00:01:51,570
Khi bạn tự động phân bổ
bộ nhớ nó đến từ một hồ bơi

44
00:01:51,570 --> 00:01:53,795
bộ nhớ được gọi là heap.

45
00:01:53,795 --> 00:01:56,420
Trước đây tất cả các bộ nhớ chúng tôi đã
được làm việc với trong khóa học

46
00:01:56,420 --> 00:01:59,920
đã được phát ra từ một hồ bơi
bộ nhớ được gọi là stack.

47
00:01:59,920 --> 00:02:02,470
Một cách tốt để thường
giữ trong mind-- và quy tắc này

48
00:02:02,470 --> 00:02:04,720
không luôn luôn đúng,
nhưng khá nhiều gần như

49
00:02:04,720 --> 00:02:09,940
luôn giữ true-- là bất kỳ
thời gian bạn đưa ra một tên biến nó

50
00:02:09,940 --> 00:02:12,090
lẽ sống trên stack.

51
00:02:12,090 --> 00:02:14,650
Và bất cứ lúc nào bạn không
cung cấp cho một biến tên,

52
00:02:14,650 --> 00:02:19,160
mà bạn có thể làm với bộ nhớ động
phân bổ, nó sống trên heap.

53
00:02:19,160 --> 00:02:22,190
>> Bây giờ tôi là loại trình bày này là
nếu có hai hồ này của bộ nhớ.

54
00:02:22,190 --> 00:02:24,740
Nhưng bạn có thể đã nhìn thấy điều này
sơ đồ, mà nói chung là

55
00:02:24,740 --> 00:02:27,290
một đại diện của
nhớ những gì trông giống như,

56
00:02:27,290 --> 00:02:30,373
và chúng tôi sẽ không quan tâm đến tất cả
các công cụ ở phía trên và phía dưới.

57
00:02:30,373 --> 00:02:33,580
Phần này trong những gì chúng ta quan tâm là
trung ở đây, heap và stack.

58
00:02:33,580 --> 00:02:35,570
Như bạn có thể nhìn thấy bằng cách
nhìn vào sơ đồ này,

59
00:02:35,570 --> 00:02:38,390
này thực sự không phải là hai
hồ bơi riêng biệt của bộ nhớ.

60
00:02:38,390 --> 00:02:42,757
Đó là một hồ bơi được chia sẻ bộ nhớ
nơi bạn bắt đầu, trong hình ảnh này

61
00:02:42,757 --> 00:02:44,590
bạn bắt đầu ở phía dưới
và bắt đầu điền lên

62
00:02:44,590 --> 00:02:48,040
từ dưới cùng với đống, và bạn
bắt đầu ở đầu và bắt đầu điền lên

63
00:02:48,040 --> 00:02:50,072
từ trên xuống với đống.

64
00:02:50,072 --> 00:02:51,780
Nhưng nó thực sự là
cùng một hồ bơi, nó chỉ

65
00:02:51,780 --> 00:02:56,050
điểm khác nhau, địa điểm khác nhau
trong bộ nhớ đang được phân bổ.

66
00:02:56,050 --> 00:02:59,060
Và bạn có thể chạy ra khỏi
bộ nhớ bằng cách hoặc là có

67
00:02:59,060 --> 00:03:01,240
đống đi tất cả các cách
xuống phía dưới, hoặc có

68
00:03:01,240 --> 00:03:05,440
stack đi tất cả các cách để trên đầu,
hoặc có heap và stack

69
00:03:05,440 --> 00:03:06,740
gặp gỡ với nhau.

70
00:03:06,740 --> 00:03:09,500
Tất cả những người có thể điều kiện
gây ra chương trình của bạn

71
00:03:09,500 --> 00:03:11,030
chạy ra khỏi bộ nhớ.

72
00:03:11,030 --> 00:03:11,952
Vì vậy, giữ cho rằng trong tâm trí.

73
00:03:11,952 --> 00:03:13,660
Khi chúng ta nói về
heap và stack

74
00:03:13,660 --> 00:03:17,880
chúng tôi đang thực sự nói về
cùng một đoạn chung của bộ nhớ, chỉ cần

75
00:03:17,880 --> 00:03:21,930
các phần khác nhau của bộ nhớ đó.

76
00:03:21,930 --> 00:03:24,910
>> Vì vậy, làm thế nào để chúng ta có được tự động
phân bổ bộ nhớ ở nơi đầu tiên?

77
00:03:24,910 --> 00:03:27,740
Làm thế nào để chương trình của chúng tôi có được
nhớ như nó đang chạy?

78
00:03:27,740 --> 00:03:32,660
Vâng C cung cấp một chức năng gọi là
malloc, cấp phát bộ nhớ, mà

79
00:03:32,660 --> 00:03:36,810
bạn thực hiện một cuộc gọi đến, và bạn vượt qua trong
bao nhiêu byte của bộ nhớ mà bạn muốn.

80
00:03:36,810 --> 00:03:39,940
Vì vậy, nếu chương trình của bạn đang chạy
và bạn muốn một thời gian chạy số nguyên,

81
00:03:39,940 --> 00:03:46,040
bạn có thể mallock bốn byte của
bộ nhớ, malloc ngoặc bốn.

82
00:03:46,040 --> 00:03:48,540
>> mallock sẽ đi qua
nhìn qua đống,

83
00:03:48,540 --> 00:03:50,750
bởi vì chúng ta tự động
phân bổ bộ nhớ,

84
00:03:50,750 --> 00:03:53,500
và nó sẽ trở về với bạn
một con trỏ tới bộ nhớ mà.

85
00:03:53,500 --> 00:03:56,180
Nó không cung cấp cho bạn memory-- đó
nó không cho nó một cái tên,

86
00:03:56,180 --> 00:03:57,950
nó mang lại cho bạn một con trỏ đến nó.

87
00:03:57,950 --> 00:04:00,780
Và đó là lý do tại sao một lần nữa tôi nói
rằng điều quan trọng để có thể

88
00:04:00,780 --> 00:04:03,770
đã xem phim con trỏ
trước khi chúng ta đi sâu vào điều này.

89
00:04:03,770 --> 00:04:05,940
Vì vậy, malloc sẽ
cho bạn trở lại một con trỏ.

90
00:04:05,940 --> 00:04:08,950
>> Nếu mallock không thể cung cấp cho bạn bất kỳ
bộ nhớ bởi vì bạn đã chạy ra,

91
00:04:08,950 --> 00:04:10,645
nó sẽ cho bạn trở lại một con trỏ null.

92
00:04:10,645 --> 00:04:15,282
Bạn có nhớ những gì sẽ xảy ra nếu chúng tôi
thử và tới đích của một con trỏ null?

93
00:04:15,282 --> 00:04:17,019
Chúng ta đau khổ một lỗi seg, phải không?

94
00:04:17,019 --> 00:04:18,060
Đó có thể là không tốt.

95
00:04:18,060 --> 00:04:21,579
>> Vì vậy, mỗi khi bạn thực hiện cuộc gọi
để malloc bạn luôn luôn, luôn luôn

96
00:04:21,579 --> 00:04:25,270
cần phải kiểm tra có hay không
con trỏ nó đã cho bạn trở lại là null.

97
00:04:25,270 --> 00:04:28,800
Nếu có, bạn cần phải kết thúc chương trình của bạn
bởi vì nếu bạn cố gắng và tới đích

98
00:04:28,800 --> 00:04:31,360
các con trỏ null bạn đang đi
phải chịu đựng một lỗi phân khúc

99
00:04:31,360 --> 00:04:34,380
và chương trình của bạn
đi đến sụp đổ anyway.

100
00:04:34,380 --> 00:04:37,190
Vì vậy, làm thế nào để chúng ta tĩnh
có được một số nguyên?

101
00:04:37,190 --> 00:04:37,730
>> int x.

102
00:04:37,730 --> 00:04:40,010
Chúng tôi đã có thể làm được điều đó
một loạt các lần, phải không?

103
00:04:40,010 --> 00:04:43,480
Điều này tạo ra một biến gọi là
x sống trên stack.

104
00:04:43,480 --> 00:04:46,190
Làm thế nào để chúng ta tự động lấy một số nguyên?

105
00:04:46,190 --> 00:04:50,010
Int sao px bằng malloc 4.

106
00:04:50,010 --> 00:04:53,050
>> Hoặc một cách thích hợp hơn
chúng tôi muốn nói int sao px

107
00:04:53,050 --> 00:04:57,680
bằng kích thước malloc của int,
chỉ để ném một số ít

108
00:04:57,680 --> 00:04:59,740
con số ma thuật xung quanh chương trình của chúng tôi.

109
00:04:59,740 --> 00:05:04,140
Điều này sẽ cho ta được
bốn byte của bộ nhớ từ đống,

110
00:05:04,140 --> 00:05:06,720
và con trỏ chúng tôi nhận
trở lại để nó được gọi là px.

111
00:05:06,720 --> 00:05:08,430
Và sau đó chỉ như chúng ta đã
thực hiện trước đó chúng tôi

112
00:05:08,430 --> 00:05:13,966
có thể tới đích px
truy cập vào bộ nhớ.

113
00:05:13,966 --> 00:05:15,590
Làm thế nào để chúng ta có được một số nguyên từ người sử dụng?

114
00:05:15,590 --> 00:05:17,970
Chúng tôi có thể nói int x bằng được int.

115
00:05:17,970 --> 00:05:19,930
Đó là khá đơn giản.

116
00:05:19,930 --> 00:05:24,030
Điều gì nếu chúng tôi muốn tạo ra một mảng
của x phao sống trên stack?

117
00:05:24,030 --> 00:05:28,210
nổi stack_array-- đó là tên
các dấu ngoặc vuông array-- chúng tôi x.

118
00:05:28,210 --> 00:05:32,419
Điều đó sẽ tạo cho chúng ta một mảng
của x phao sống trên stack.

119
00:05:32,419 --> 00:05:34,960
Chúng ta có thể tạo ra một mảng phao
sống trên đống, quá.

120
00:05:34,960 --> 00:05:37,330
Các cú pháp có thể xem xét một
ít cồng kềnh hơn,

121
00:05:37,330 --> 00:05:41,740
nhưng chúng ta có thể nói float
sao heap_array bằng

122
00:05:41,740 --> 00:05:44,360
malloc x lần kích thước của phao.

123
00:05:44,360 --> 00:05:48,160
Tôi cần đủ chỗ cho hàng
x giá trị điểm trôi.

124
00:05:48,160 --> 00:05:51,560
Vì vậy, nói tôi cần 100
phao, hoặc 1.000 phao nổi.

125
00:05:51,560 --> 00:05:54,810
Vì vậy, trong trường hợp đó nó sẽ là
400 byte cho 100 phao,

126
00:05:54,810 --> 00:05:59,080
hoặc 4.000 byte cho 1.000 phao,
bởi vì mỗi float chiếm

127
00:05:59,080 --> 00:06:01,230
bốn byte của không gian.

128
00:06:01,230 --> 00:06:05,110
>> Sau khi làm điều này tôi có thể sử dụng
cú pháp khung vuông trên heap_array.

129
00:06:05,110 --> 00:06:08,970
Cũng như tôi làm trên stack_array, tôi
có thể truy cập vào các phần tử riêng lẻ

130
00:06:08,970 --> 00:06:11,590
sử dụng heap_array không, một heap_array.

131
00:06:11,590 --> 00:06:15,800
Nhưng nhớ lại lý do chúng tôi có thể làm điều đó
là bởi vì tên của một mảng trong C

132
00:06:15,800 --> 00:06:19,990
thực sự là một con trỏ trỏ tới
Yếu tố đầu tiên của mảng đó.

133
00:06:19,990 --> 00:06:23,480
Vì vậy, thực tế là chúng ta đang khai báo
mảng phao trên stack đây

134
00:06:23,480 --> 00:06:24,810
thực sự là một chút sai lầm.

135
00:06:24,810 --> 00:06:27,600
Chúng tôi thực sự đang ở trong
dòng thứ hai của mã có

136
00:06:27,600 --> 00:06:32,360
cũng tạo ra một con trỏ đến một đoạn
nhớ rằng sau đó chúng tôi làm một số công việc với.

137
00:06:32,360 --> 00:06:35,620
>> Đây là vấn đề lớn với
cấp phát động bộ nhớ mặc dù,

138
00:06:35,620 --> 00:06:38,360
và đây là lý do tại sao nó thực sự
quan trọng để phát triển một số thói quen tốt

139
00:06:38,360 --> 00:06:39,800
khi bạn đang làm việc với nó.

140
00:06:39,800 --> 00:06:43,060
Không giống như khai báo tĩnh
bộ nhớ, bộ nhớ của bạn

141
00:06:43,060 --> 00:06:46,790
không được tự động trở lại
hệ thống khi chức năng của bạn được thực hiện.

142
00:06:46,790 --> 00:06:49,280
Vì vậy, nếu chúng ta có chính, và
chính gọi hàm

143
00:06:49,280 --> 00:06:53,860
f, f khi kết thúc bất cứ điều gì nó đang làm gì
và trả lại quyền kiểm soát các chương trình

144
00:06:53,860 --> 00:06:58,810
trở lại chính, tất cả các bộ nhớ
f sử dụng được cho trở lại.

145
00:06:58,810 --> 00:07:01,250
Nó có thể được sử dụng một lần nữa
bởi một số chương trình khác,

146
00:07:01,250 --> 00:07:04,250
hoặc một số chức năng khác
được gọi là sau này trong chính.

147
00:07:04,250 --> 00:07:06,970
Nó có thể sử dụng cùng một bộ nhớ trên một lần nữa.

148
00:07:06,970 --> 00:07:09,620
>> Nếu bạn tự động
cấp phát bộ nhớ mặc dù

149
00:07:09,620 --> 00:07:14,380
bạn phải nói cho rõ ràng
hệ thống mà bạn đang thực hiện với nó.

150
00:07:14,380 --> 00:07:18,370
Nó sẽ giữ được nó cho bạn, mà có thể
dẫn đến một vấn đề của bạn chạy ra ngoài

151
00:07:18,370 --> 00:07:19,290
của bộ nhớ.

152
00:07:19,290 --> 00:07:22,179
Và trong thực tế, đôi khi chúng ta tham khảo
Nó như là một rò rỉ bộ nhớ.

153
00:07:22,179 --> 00:07:24,970
Và đôi khi những rò rỉ bộ nhớ
thực sự có thể được thực sự tàn phá

154
00:07:24,970 --> 00:07:27,020
cho hiệu năng hệ thống.

155
00:07:27,020 --> 00:07:31,120
>> Nếu bạn là một người sử dụng internet thường xuyên
bạn có thể sử dụng các trình duyệt web nhất định,

156
00:07:31,120 --> 00:07:35,630
và tôi sẽ không nêu tên ở đây, nhưng
có một số trình duyệt web trên mạng

157
00:07:35,630 --> 00:07:39,150
đó là những tiếng xấu cho thực sự có
rò rỉ bộ nhớ mà không được cố định.

158
00:07:39,150 --> 00:07:44,570
Và nếu bạn rời khỏi trình duyệt của bạn mở
trong một thời gian rất dài của thời gian, ngày

159
00:07:44,570 --> 00:07:48,060
và ngày, hoặc vài tuần, đôi khi bạn
có thể nhận thấy rằng hệ thống của bạn

160
00:07:48,060 --> 00:07:49,790
là chạy thực sự, thực sự chậm.

161
00:07:49,790 --> 00:07:54,640
Và lý do cho rằng là
trình duyệt đã phân bổ bộ nhớ,

162
00:07:54,640 --> 00:07:57,320
nhưng sau đó không nói với hệ thống
mà nó được thực hiện với nó.

163
00:07:57,320 --> 00:08:01,000
Và như vậy, mà lá ít bộ nhớ
có sẵn cho tất cả các chương trình khác của bạn

164
00:08:01,000 --> 00:08:04,480
phải chia sẻ, bởi vì bạn
leaking-- rằng trình duyệt web

165
00:08:04,480 --> 00:08:06,755
chương trình là bị rò rỉ bộ nhớ.

166
00:08:06,755 --> 00:08:08,880
Làm thế nào để chúng tôi cung cấp cho bộ nhớ trở lại
khi chúng tôi đang thực hiện với nó?

167
00:08:08,880 --> 00:08:10,838
Cũng may mắn thay đó là một
cách rất dễ dàng để làm điều đó.

168
00:08:10,838 --> 00:08:11,710
Chúng tôi chỉ giải phóng nó.

169
00:08:11,710 --> 00:08:15,020
Có một chức năng gọi là miễn phí,
nó chấp nhận một con trỏ trỏ tới bộ nhớ,

170
00:08:15,020 --> 00:08:16,010
và chúng tôi đang tốt để đi.

171
00:08:16,010 --> 00:08:18,310
>> Vì vậy, chúng ta hãy nói rằng chúng ta đang ở trong
giữa chương trình của chúng tôi,

172
00:08:18,310 --> 00:08:21,970
chúng tôi muốn để malloc 50 ký tự.

173
00:08:21,970 --> 00:08:25,710
Chúng tôi muốn để malloc một mảng mà có thể
khả năng nắm giữ 50 ký tự.

174
00:08:25,710 --> 00:08:29,109
Và khi chúng ta có được một con trỏ trở lại
rằng, tên của con trỏ đó là từ.

175
00:08:29,109 --> 00:08:30,900
Chúng tôi làm bất cứ điều gì chúng tôi
sẽ làm gì với từ,

176
00:08:30,900 --> 00:08:33,440
và sau đó khi chúng tôi
thực hiện chúng ta chỉ giải phóng nó.

177
00:08:33,440 --> 00:08:37,460
Và bây giờ chúng tôi đã trở lại những người 50
byte của bộ nhớ trở lại vào hệ thống.

178
00:08:37,460 --> 00:08:40,147
Một số chức năng khác có thể sử dụng chúng.

179
00:08:40,147 --> 00:08:43,480
Chúng tôi không cần phải lo lắng về việc bị một
rò rỉ bộ nhớ bởi vì chúng tôi đã giải phóng từ.

180
00:08:43,480 --> 00:08:46,639
Chúng tôi đã cho các bộ nhớ trở lại,
vì vậy chúng tôi đang thực hiện làm việc với nó.

181
00:08:46,639 --> 00:08:48,430
Vì vậy, có ba
nguyên tắc vàng mà nên

182
00:08:48,430 --> 00:08:51,700
được lưu giữ trong tâm trí bất cứ khi nào bạn
tự động phân bổ bộ nhớ

183
00:08:51,700 --> 00:08:52,990
với malloc.

184
00:08:52,990 --> 00:08:56,480
Mỗi khối của bộ nhớ
bạn malloc phải được trả tự do

185
00:08:56,480 --> 00:08:58,430
trước khi chương trình của bạn kết thúc hoạt động.

186
00:08:58,430 --> 00:09:02,029
Bây giờ một lần nữa, trong thiết bị hoặc trong
IDE loại này xảy ra cho bạn anyway

187
00:09:02,029 --> 00:09:04,820
khi you-- này sẽ xảy ra dù sao
khi chương trình của bạn được chấm dứt,

188
00:09:04,820 --> 00:09:06,880
tất cả các bộ nhớ sẽ được phát hành.

189
00:09:06,880 --> 00:09:10,750
Nhưng đó là mã hóa nói chung là tốt
thực hành để mọi khi, khi bạn đang thực hiện,

190
00:09:10,750 --> 00:09:13,810
giải phóng những gì bạn đã mallocd.

191
00:09:13,810 --> 00:09:16,690
>> Điều đó nói rằng, chỉ có những điều mà
bạn đã mallocd nên được giải thoát.

192
00:09:16,690 --> 00:09:19,880
Nếu bạn khai báo một tĩnh
số nguyên, int x dấu chấm phẩy,

193
00:09:19,880 --> 00:09:23,500
sống trên stack, bạn
không thì muốn giải phóng x.

194
00:09:23,500 --> 00:09:25,970
Vì vậy, chỉ có những điều mà bạn đã
mallocd nên được giải thoát.

195
00:09:25,970 --> 00:09:28,960
>> Và cuối cùng, không một cái gì đó miễn phí hai lần.

196
00:09:28,960 --> 00:09:31,170
Điều đó có thể dẫn đến
một tình huống kỳ lạ.

197
00:09:31,170 --> 00:09:33,530
Vì vậy, tất cả mọi thứ mà bạn đã
mallocd phải được trả tự do.

198
00:09:33,530 --> 00:09:36,000
Chỉ có những điều mà bạn đã
malloc nên được giải thoát.

199
00:09:36,000 --> 00:09:38,730
Và không một cái gì đó miễn phí hai lần.

200
00:09:38,730 --> 00:09:43,660
>> Vì vậy, hãy đi qua một ví dụ ở đây
của những gì một số phân bổ tự động

201
00:09:43,660 --> 00:09:46,122
bộ nhớ có thể trông giống như hỗn hợp
với một số bộ nhớ tĩnh.

202
00:09:46,122 --> 00:09:47,080
Điều gì có thể xảy ra ở đây?

203
00:09:47,080 --> 00:09:48,913
Xem nếu bạn có thể làm theo
dọc và đoán những gì

204
00:09:48,913 --> 00:09:51,720
sẽ xảy ra khi chúng ta đi
qua tất cả các dòng mã.

205
00:09:51,720 --> 00:09:53,980
>> Vì vậy, chúng ta nói int m.

206
00:09:53,980 --> 00:09:54,840
chuyện gì xảy ra ở đây thế?

207
00:09:54,840 --> 00:09:56,339
Vâng điều này là khá đơn giản.

208
00:09:56,339 --> 00:09:59,650
Tôi tạo ra một biến số nguyên được gọi là m.

209
00:09:59,650 --> 00:10:01,400
Tôi màu nó màu xanh lá cây,
bởi vì đó là màu sắc

210
00:10:01,400 --> 00:10:03,730
mà tôi sử dụng khi tôi đang nói
về các biến số nguyên.

211
00:10:03,730 --> 00:10:05,160
Đó là một hộp.

212
00:10:05,160 --> 00:10:08,400
Nó được gọi là m, và bạn có thể
cửa hàng số nguyên bên trong của nó.

213
00:10:08,400 --> 00:10:12,400
>> Nếu tôi sau đó nói int sao a?

214
00:10:12,400 --> 00:10:13,530
Vâng đó là khá tương tự.

215
00:10:13,530 --> 00:10:15,780
Tôi đang tạo ra một hộp gọi là a.

216
00:10:15,780 --> 00:10:19,100
Nó có khả năng nắm giữ int
sao, con trỏ đến số nguyên.

217
00:10:19,100 --> 00:10:21,570
Vì vậy, tôi tô màu nó xanh-ish là tốt.

218
00:10:21,570 --> 00:10:24,140
>> Tôi biết nó có cái gì
để làm với một số nguyên,

219
00:10:24,140 --> 00:10:25,852
nhưng nó không phải tự nó là một số nguyên.

220
00:10:25,852 --> 00:10:27,310
Nhưng nó là khá nhiều ý tưởng tương tự.

221
00:10:27,310 --> 00:10:28,101
Tôi đã tạo ra một hộp.

222
00:10:28,101 --> 00:10:30,070
Cả hai bên phải
hiện đang sống trên stack.

223
00:10:30,070 --> 00:10:32,520
Tôi đã cho họ cả hai tên.

224
00:10:32,520 --> 00:10:36,750
>> int sao b bằng kích thước của malloc int.

225
00:10:36,750 --> 00:10:38,560
Điều này có thể là một chút khó khăn.

226
00:10:38,560 --> 00:10:44,110
Mất một giây và suy nghĩ về những gì bạn
sẽ mong đợi xảy ra trên sơ đồ này.

227
00:10:44,110 --> 00:10:50,210
int sao b bằng kích thước của malloc int.

228
00:10:50,210 --> 00:10:51,940
>> Vâng điều này không chỉ tạo ra một hộp.

229
00:10:51,940 --> 00:10:53,800
Điều này thực sự tạo ra hai hộp.

230
00:10:53,800 --> 00:10:58,670
Và nó quan hệ, nó cũng thiết lập
một điểm trong một mối quan hệ.

231
00:10:58,670 --> 00:11:02,240
Chúng tôi đã phân bổ một khối
bộ nhớ trên heap.

232
00:11:02,240 --> 00:11:05,940
Lưu ý rằng hộp trên bên phải
ở đó không có tên.

233
00:11:05,940 --> 00:11:06,760
>> Chúng tôi mallocd nó.

234
00:11:06,760 --> 00:11:08,050
Nó tồn tại trên heap.

235
00:11:08,050 --> 00:11:10,090
Nhưng b có một tên.

236
00:11:10,090 --> 00:11:11,950
Đó là một biến con trỏ được gọi là b.

237
00:11:11,950 --> 00:11:13,910
Sống trên stack.

238
00:11:13,910 --> 00:11:18,250
>> Vì vậy, nó là một phần của bộ nhớ
trỏ đến nhau.

239
00:11:18,250 --> 00:11:21,840
b chứa địa chỉ
trong đó khối của bộ nhớ.

240
00:11:21,840 --> 00:11:23,757
Nó không có một tên khác.

241
00:11:23,757 --> 00:11:24,590
Nhưng nó chỉ vào nó.

242
00:11:24,590 --> 00:11:29,760
Vì vậy, khi chúng ta nói sao int b bằng
kích thước malloc của int, mà ngay tại đó,

243
00:11:29,760 --> 00:11:33,490
rằng mũi tên đó hiện lên trên
bên phải có, mà toàn bộ điều,

244
00:11:33,490 --> 00:11:36,740
Tôi sẽ có nó xuất hiện
một lần nữa, là những gì sẽ xảy ra.

245
00:11:36,740 --> 00:11:39,341
Tất cả điều đó sẽ xảy ra trong
mà dòng mã.

246
00:11:39,341 --> 00:11:41,340
Bây giờ chúng ta sẽ nhận được ít hơn
đơn giản một lần nữa.

247
00:11:41,340 --> 00:11:43,330
một bằng ký hiệu m.

248
00:11:43,330 --> 00:11:46,280
Bạn có nhớ những gì một
bằng ký hiệu m là?

249
00:11:46,280 --> 00:11:48,920
Vâng đó là một địa chỉ được m.

250
00:11:48,920 --> 00:11:54,150
Hoặc đặt diagrammatically hơn,
một điểm đến m.

251
00:11:54,150 --> 00:11:56,360
>> một bằng b.

252
00:11:56,360 --> 00:11:57,560
OK vì vậy đây là một số khác.

253
00:11:57,560 --> 00:11:59,230
A bằng b.

254
00:11:59,230 --> 00:12:02,260
Điều gì sẽ xảy ra
sơ đồ thời gian này?

255
00:12:02,260 --> 00:12:04,330
>> Cũng nhớ lại rằng
công trình nhà điều hành phân

256
00:12:04,330 --> 00:12:08,960
bằng cách gán giá trị trên
đúng với giá trị trên bên trái.

257
00:12:08,960 --> 00:12:14,820
Vì vậy, thay vì một trỏ đến m, một doanh nghiệp
trỏ đến cùng một nơi mà điểm b.

258
00:12:14,820 --> 00:12:18,900
một không trỏ đến b, một
chỉ điểm nơi b.

259
00:12:18,900 --> 00:12:25,280
>> Nếu một nhọn để b mà có
đã là một bằng ký hiệu b.

260
00:12:25,280 --> 00:12:28,150
Nhưng thay vì một bằng b chỉ
có nghĩa là b và bây giờ

261
00:12:28,150 --> 00:12:31,770
trỏ đến cùng một địa chỉ, bởi vì
bên trong của b chỉ là một địa chỉ.

262
00:12:31,770 --> 00:12:35,004
Và bây giờ bên trong của một là cùng một địa chỉ.

263
00:12:35,004 --> 00:12:37,170
m tương đương với 10, có lẽ là
điều đơn giản nhất

264
00:12:37,170 --> 00:12:38,690
chúng tôi đã thực hiện trong một chút.

265
00:12:38,690 --> 00:12:40,460
Đặt 10 trong hộp.

266
00:12:40,460 --> 00:12:45,640
Sao b bằng m + 2, nhớ lại từ
con trỏ video của chúng tôi những gì sao b có nghĩa.

267
00:12:45,640 --> 00:12:50,230
Chúng tôi đang đi để tới đích của b và put
một số giá trị trong đó vị trí bộ nhớ.

268
00:12:50,230 --> 00:12:51,860
Trong trường hợp này 12.

269
00:12:51,860 --> 00:12:55,300
>> Vì vậy, khi chúng tôi tới đích của một điểm
nhớ lại chúng tôi chỉ đi xuống mũi tên.

270
00:12:55,300 --> 00:12:58,205
Hay nói một cách khác, chúng ta
đi đến địa chỉ bộ nhớ

271
00:12:58,205 --> 00:12:59,580
và chúng ta vận dụng nó một cách nào đó.

272
00:12:59,580 --> 00:13:00,830
Chúng tôi đặt một số giá trị trong đó.

273
00:13:00,830 --> 00:13:03,960
Trong trường hợp này sao b
bằng m cộng với 2 chỉ là

274
00:13:03,960 --> 00:13:08,230
đi đến các biến được trỏ đến bởi b,
đi vào bộ nhớ được trỏ đến bởi b,

275
00:13:08,230 --> 00:13:11,750
và đưa m cộng với 2 trong đó, 12.

276
00:13:11,750 --> 00:13:14,970
>> Bây giờ tôi tự do b.

277
00:13:14,970 --> 00:13:16,490
Điều gì xảy ra khi tôi tự do b?

278
00:13:16,490 --> 00:13:18,800
Hãy nhớ những gì tôi đã nói phương tiện miễn phí.

279
00:13:18,800 --> 00:13:21,920
Tôi nói gì khi tôi phóng b?

280
00:13:21,920 --> 00:13:23,410
>> Tôi đang làm việc được với nó, phải không?

281
00:13:23,410 --> 00:13:25,702
Tôi chủ yếu cung cấp lên bộ nhớ.

282
00:13:25,702 --> 00:13:26,910
Tôi cho nó trở lại vào hệ thống.

283
00:13:26,910 --> 00:13:33,010
Tôi không cần cái này nữa là
những gì tôi đang nói với họ, OK?

284
00:13:33,010 --> 00:13:37,390
>> Bây giờ nếu tôi nói sao một
bằng 11 bạn có thể có thể

285
00:13:37,390 --> 00:13:40,460
đã nói rằng một cái gì đó xấu
sẽ xảy ra ở đây, phải không?

286
00:13:40,460 --> 00:13:44,160
Và quả thực nếu tôi cố gắng mà tôi có lẽ
sẽ phải chịu đựng một lỗi phân khúc.

287
00:13:44,160 --> 00:13:47,140
Bởi vì bây giờ, mặc dù
trước đây rằng đoạn bộ nhớ

288
00:13:47,140 --> 00:13:50,220
là một cái gì đó mà tôi đã có
truy cập vào, vào thời điểm này

289
00:13:50,220 --> 00:13:54,590
bây giờ tôi đang truy cập vào bộ nhớ
là không hợp pháp cho tôi để truy cập.

290
00:13:54,590 --> 00:13:57,330
>> Và như chúng ta có thể sẽ
nhớ lại, khi chúng ta truy cập vào bộ nhớ

291
00:13:57,330 --> 00:14:00,000
rằng chúng tôi không phải để liên lạc,
đó là nguyên nhân phổ biến nhất

292
00:14:00,000 --> 00:14:01,860
của một phân khúc
lỗi. Và do đó, chương trình của tôi

293
00:14:01,860 --> 00:14:05,170
sẽ sụp đổ nếu tôi cố gắng để làm điều này.

294
00:14:05,170 --> 00:14:09,910
Vì vậy, một lần nữa nó là một ý tưởng tốt để có được tốt
thói quen thực hành và tốt ăn sâu

295
00:14:09,910 --> 00:14:12,920
khi làm việc với malloc và miễn phí,
do đó bạn không bị phân

296
00:14:12,920 --> 00:14:15,310
lỗi lầm, và rằng bạn sử dụng
động của bạn được phân bổ

297
00:14:15,310 --> 00:14:17,370
bộ nhớ có trách nhiệm.

298
00:14:17,370 --> 00:14:20,300
>> Tôi Doug Lloyd này là CS50.

299
00:14:20,300 --> 00:14:21,947