1
00:00:00,000 --> 00:00:03,381
>> [음악 재생]

2
00:00:03,381 --> 00:00:10,626

3
00:00:10,626 --> 00:00:11,610
>> [비디오 재생]

4
00:00:11,610 --> 00:00:13,640
>> - 그는 거짓말.

5
00:00:13,640 --> 00:00:14,380
>> 무엇 대략 125?

6
00:00:14,380 --> 00:00:17,182
>> - 난 몰라.

7
00:00:17,182 --> 00:00:19,990
>> 우리는 무엇을 알 수 있습니까 - 그래서?

8
00:00:19,990 --> 00:00:23,145
>> 9시 15분, 레이에 - 그건
산토는 ATM에 있었다.

9
00:00:23,145 --> 00:00:23,644
- 네.

10
00:00:23,644 --> 00:00:27,030
그래서 질문은, 무엇을
그는 9:16에서 일을했다?

11
00:00:27,030 --> 00:00:29,720
>> 뭔가 9mm를 -Shooting.

12
00:00:29,720 --> 00:00:31,540
어쩌면 그는 저격수를 보았다.

13
00:00:31,540 --> 00:00:33,412
>> - 아니면 그와 함께 작업했다.

14
00:00:33,412 --> 00:00:34,340
>> 잠깐.

15
00:00:34,340 --> 00:00:36,200
다시 한 이동합니다.

16
00:00:36,200 --> 00:00:36,975
>> - 무슨 볼 수 있습니까?

17
00:00:36,975 --> 00:00:44,400

18
00:00:44,400 --> 00:00:47,805
>> 전체 화면으로 그의 얼굴을 데려 오라고.

19
00:00:47,805 --> 00:00:48,680
>> - 그의 안경.

20
00:00:48,680 --> 00:00:50,060
>> 반사 저기입니다.

21
00:00:50,060 --> 00:01:00,455

22
00:01:00,455 --> 00:01:02,280
>> - 그것은 Nuevitas 야구 팀이다.

23
00:01:02,280 --> 00:01:03,110
즉, 자신의 로고입니다.

24
00:01:03,110 --> 00:01:05,820
>> - 그리고 그는에 얘기
누구든지 그 재킷을 입고있다.

25
00:01:05,820 --> 00:01:06,670
>> [END 재생]

26
00:01:06,670 --> 00:01:07,628
>> 데이비드 마란 : 좋아.

27
00:01:07,628 --> 00:01:11,210
이 CS50이며,이 조금 더
의 [들림]있는 당신이있어

28
00:01:11,210 --> 00:01:12,890
문제를 취미 삼아 네 가지를 설정합니다.

29
00:01:12,890 --> 00:01:16,606
오늘 우리는 더 조금보고 시작
깊이 포인터라고 이런 일에,

30
00:01:16,606 --> 00:01:18,480
그것이 비록 한
꽤 난해한 주제,

31
00:01:18,480 --> 00:01:20,813
그것이 무슨 밝혀
수단이 될하는 우리

32
00:01:20,813 --> 00:01:24,320
건설 및 조립을 시작할 수 있습니다
훨씬 더 정교한 프로그램.

33
00:01:24,320 --> 00:01:28,150
그러나 우리는 지난 수요일에 그것을했다
우선 몇 가지 클레이 메이션의 방법으로.

34
00:01:28,150 --> 00:01:30,190
그래서이, 리콜이며,
빙키 우리는 그를 사용

35
00:01:30,190 --> 00:01:33,148
프로그램을 살펴보고 그
정말 아무것도 재미하지 않았다,

36
00:01:33,148 --> 00:01:34,950
하지만 몇 가지 문제를 공개했다.

37
00:01:34,950 --> 00:01:38,570
그런데 왜 우리가 걷지 않는다, 오늘을 시작합니다
빨리 다음 단계 중 몇 가지를 통해,

38
00:01:38,570 --> 00:01:41,920
인간의 용어로 증류하려고
정확히 여기에 무슨

39
00:01:41,920 --> 00:01:45,410
왜이 나쁜, 다음에 이동
실제로 무언가를 구축 시작

40
00:01:45,410 --> 00:01:46,309
이 기술?

41
00:01:46,309 --> 00:01:48,350
따라서 이러한 제했다
이 프로그램에 두 줄로

42
00:01:48,350 --> 00:01:51,340
그리고 시민들의에서 무엇을
이 두 라인은 뭐하는거야?

43
00:01:51,340 --> 00:01:55,600
합리적으로 편안 사람
어떤 화면에 선언 한 것으로?

44
00:01:55,600 --> 00:01:58,340

45
00:01:58,340 --> 00:02:00,120
일이 두 라인은 무엇입니까?

46
00:02:00,120 --> 00:02:02,070
그것은 모두가 아니다 그
주와는 다른,

47
00:02:02,070 --> 00:02:03,611
하지만 몇 가지 새로운 특수 기호가있다.

48
00:02:03,611 --> 00:02:04,152
그래?

49
00:02:04,152 --> 00:02:05,628
다시 거기.

50
00:02:05,628 --> 00:02:07,092
>> 청중 : 포인터를 선언?

51
00:02:07,092 --> 00:02:08,050
데이비드 마란은 : 다시 말?

52
00:02:08,050 --> 00:02:08,860
청중 : 포인터를 선언?

53
00:02:08,860 --> 00:02:11,776
데이비드 마란 : 선언 포인터와
이제 조금 더를 수정 할 수 있습니다.

54
00:02:11,776 --> 00:02:14,050
청중 : [들리지]
주소 X와 Y를.

55
00:02:14,050 --> 00:02:15,300
데이비드 마란 : 그리고 해결합니다.

56
00:02:15,300 --> 00:02:18,550
그래서 특별히 우리가 무슨 일을하는지
우리는 두 개의 변수를 선언되어있다.

57
00:02:18,550 --> 00:02:21,252
이러한 변수는하지만,가는거야
int 형 스타,이어야 할

58
00:02:21,252 --> 00:02:23,210
더 구체적으로 의미
그들은 저장하는거야

59
00:02:23,210 --> 00:02:26,450
INT의 주소,
각각 x 및 y.

60
00:02:26,450 --> 00:02:27,660
이제 어떤 값이 있습니까?

61
00:02:27,660 --> 00:02:32,621
이들의 실제 주소가 있습니까
이 시점에서 두 변수?

62
00:02:32,621 --> 00:02:33,120
아니.

63
00:02:33,120 --> 00:02:35,030
그냥 쓰레기 값을 소위입니다.

64
00:02:35,030 --> 00:02:38,120
당신은 실제로 할당하지 않는 경우
RAM에 있었다 어떤 변수

65
00:02:38,120 --> 00:02:42,224
이전에 제로로 채울 것입니다
그리고 사람들이 변수 모두.

66
00:02:42,224 --> 00:02:44,140
그러나 우리는 아직 모른다
무엇이며 그건

67
00:02:44,140 --> 00:02:47,060
왜 빙키의 열쇠가 될 것
지난 주 그의 머리를 잃었다.

68
00:02:47,060 --> 00:02:49,980
>> 그래서이 클레이 메이션했다
이것의 화신

69
00:02:49,980 --> 00:02:53,580
이에 당신은 단지 두 개의 변수를 가지고,
점토의 작은 원형 조각,

70
00:02:53,580 --> 00:02:57,330
그 변수를 저장하지만, 같은 수 있습니다
싸서 화살표 제안

71
00:02:57,330 --> 00:03:00,640
그들은 실제로 가리키는하지 않을
아무 곳이나 공지.

72
00:03:00,640 --> 00:03:03,670
그래서 우리는이 라인을 가지고 있었고,이
메모리이었다 새로운 지난 주, malloc에

73
00:03:03,670 --> 00:03:07,130
단지 멋진 방법입니다 할당,
운영 체제를 말하고, 리눅스

74
00:03:07,130 --> 00:03:09,750
또는 Mac OS 또는 Windows,
이봐, 나에게 약간의 메모리를 제공,

75
00:03:09,750 --> 00:03:11,780
당신이해야하는 것은 말할
운영체제

76
00:03:11,780 --> 00:03:14,699
메모리를 요구하는 경우 것입니다.

77
00:03:14,699 --> 00:03:16,990
그것은 무슨 상관 없을거야
당신이 함께 할거야

78
00:03:16,990 --> 00:03:19,786
하지만 당신은 운영 말할 필요합니까
무엇의 malloc의 방법으로 시스템.

79
00:03:19,786 --> 00:03:20,286
그래?

80
00:03:20,286 --> 00:03:21,078
>> 청중 : 얼마?

81
00:03:21,078 --> 00:03:21,994
데이비드 마란 : 얼마?

82
00:03:21,994 --> 00:03:25,280
얼마나 많은 바이트 등이, 다시,
인위적인 예, 그냥, 말하고

83
00:03:25,280 --> 00:03:27,360
나에게 INT의 크기를 제공합니다.

84
00:03:27,360 --> 00:03:30,550
INT의 지금, 크기
4 바이트 또는 32 비트입니다.

85
00:03:30,550 --> 00:03:32,850
그래서 이것은 단지 방법입니다
말, 헤이, 운영 체제,

86
00:03:32,850 --> 00:03:37,290
나에게 4 바이트의 메모리를 제공
내 처분에 사용할 수있는,

87
00:03:37,290 --> 00:03:40,560
구체적으로 무엇을 수행
대한 malloc에​​ 반환

88
00:03:40,560 --> 00:03:41,795
4 바이트의 덩어리로?

89
00:03:41,795 --> 00:03:44,110

90
00:03:44,110 --> 00:03:44,860
청중 : 주소?

91
00:03:44,860 --> 00:03:45,901
데이비드 마란 : 주소.

92
00:03:45,901 --> 00:03:47,580
4 바이트의 덩어리의 주소입니다.

93
00:03:47,580 --> 00:03:48,190
정확히.

94
00:03:48,190 --> 00:03:51,430
그리고 그것은 궁극적으로 저장된 무엇
우리가 정말하지 않는 이유는 X와 그이다

95
00:03:51,430 --> 00:03:55,240
관심 무슨 수
이 OX1 또는 OX2 여부 주소이며,

96
00:03:55,240 --> 00:03:57,110
또는 일부 애매한 진수 주소입니다.

97
00:03:57,110 --> 00:03:59,850
우리는 단지 그림으로 관심을
그 변수 x가 지금 그

98
00:03:59,850 --> 00:04:01,630
메모리의 덩어리를 가리키는.

99
00:04:01,630 --> 00:04:05,570
따라서 화살표 포인터를 나타내고, 또는
보다 구체적으로, 메모리 주소.

100
00:04:05,570 --> 00:04:09,120
그러나 다시, 우리는 일반적으로 상관 없어
그 실제 주소는 무엇인지.

101
00:04:09,120 --> 00:04:11,780
자,이 라인은 말한다
무엇 쉽게 설명하자면?

102
00:04:11,780 --> 00:04:14,330
스타 X 42 세미콜론을 가져옵니다.

103
00:04:14,330 --> 00:04:17,390
이것은 무엇을 의미 하는가?

104
00:04:17,390 --> 00:04:18,200
당신은 가고 싶어?

105
00:04:18,200 --> 00:04:20,102
당신의 목을 긁지 마세요.

106
00:04:20,102 --> 00:04:22,360
>> 청중 : X의 주소는 42입니다.

107
00:04:22,360 --> 00:04:24,300
>> 데이비드 마란 : X의 주소는 42입니다.

108
00:04:24,300 --> 00:04:25,190
꽤하지 않습니다.

109
00:04:25,190 --> 00:04:28,485
너무 가까이,하지만 확실히,이 때문에
이 X 접두어 년대 스타.

110
00:04:28,485 --> 00:04:29,860
그래서 우리는 조금 조정할 필요가있다.

111
00:04:29,860 --> 00:04:31,032
그래?

112
00:04:31,032 --> 00:04:36,044
>> 청중 : 값이
포인터 X는 42입니다 가리키는있다.

113
00:04:36,044 --> 00:04:36,710
데이비드 마란 : OK.

114
00:04:36,710 --> 00:04:40,840
포인터가 있음 X 값
42 일,의 말할 수 있도록해야한다 가리키는

115
00:04:40,840 --> 00:04:44,165
또는, 스타 달리 말하면
X는 어떤 주소로 이동 말한다

116
00:04:44,165 --> 00:04:48,340
은 1 옥스포드 여부, X에
거리 또는 33 옥스포드 스트리트 (Oxford Street)

117
00:04:48,340 --> 00:04:51,850
또는 OX1 또는 ox33, 어떤
숫자 주소입니다

118
00:04:51,850 --> 00:04:54,380
스타 X는 x의 역 참조입니다.

119
00:04:54,380 --> 00:04:57,297
그래서 그 주소로 이동
다음이 숫자 42을 넣어.

120
00:04:57,297 --> 00:04:59,380
그래서 것
그 말의 동등한 방법.

121
00:04:59,380 --> 00:05:01,860
그래서 모든 괜찮아요 다음
우리는 이미지를 나타내는 것

122
00:05:01,860 --> 00:05:05,370
다음과 같이 우리는 추가 한 경우
네의 덩어리로 (42)

123
00:05:05,370 --> 00:05:09,370
, 오른쪽에 바이트지만
상황이 틀려서 갔던 곳이 줄을이었다

124
00:05:09,370 --> 00:05:11,120
와 빙키의​​ 머리가 튀어
이 시점에서 해제,

125
00:05:11,120 --> 00:05:15,290
나쁜 일 때 발생하기 때문에
당신이 쓰레기 값을 역 참조

126
00:05:15,290 --> 00:05:18,210
잘못된 역 참조 당신이나
포인터는, 내가 잘못 말

127
00:05:18,210 --> 00:05:21,020
때문에이 시점에서
이야기 Y 안에 무엇인가?

128
00:05:21,020 --> 00:05:24,440
기반 Y의 값은 무엇인가
지난 몇 단계에?

129
00:05:24,440 --> 00:05:25,360
그래?

130
00:05:25,360 --> 00:05:26,115
그게 뭔데?

131
00:05:26,115 --> 00:05:26,990
>> 청중 : 주소.

132
00:05:26,990 --> 00:05:28,460
데이비드 마란 : 주소.

133
00:05:28,460 --> 00:05:31,910
이 주소 여야합니다
하지만 난 그것을 초기화가?

134
00:05:31,910 --> 00:05:32,800
그래서 나는 아직하지 않았습니다.

135
00:05:32,800 --> 00:05:35,430
그래서 거기에 무엇을 알고 있는가?

136
00:05:35,430 --> 00:05:37,590
그것은 그냥 쓰레기 값입니다.

137
00:05:37,590 --> 00:05:41,500
그것은 0에서 어떤 주소가 될 수
20 억이 RAM의 두 기가있는 경우,

138
00:05:41,500 --> 00:05:44,289
제로 4000000000에 당신은했습니다 경우
RAM의 사기가바이트을 얻었다.

139
00:05:44,289 --> 00:05:46,080
그것은, 일부 쓰레기 값이다
그러나 문제는

140
00:05:46,080 --> 00:05:48,200
운영체제 것을
그것은 당신을 제공하지 않은 경우

141
00:05:48,200 --> 00:05:51,140
메모리의 덩어리 특히
당신이 이동하려는 것으로,

142
00:05:51,140 --> 00:05:54,650
그것은 일반적으로 무엇을 일으킬 것
우리는 세그먼트 오류로 보았다.

143
00:05:54,650 --> 00:05:57,810
그래서 사실, 당신의 어떤이있는 사람
근무 시간의 문제에서 고생

144
00:05:57,810 --> 00:06:00,393
또는 문제가 그 더
일반적으로 알아 내려고와

145
00:06:00,393 --> 00:06:02,150
세그먼트 오류,
즉, 일반적으로 의미

146
00:06:02,150 --> 00:06:05,017
당신의 세그먼트를 만지고있어
당신이 안 메모리.

147
00:06:05,017 --> 00:06:07,350
당신은 메모리를 접촉하고 그
운영체제 않았습니다

148
00:06:07,350 --> 00:06:10,450
그것의 여부, 당신이 만져 허용
배열에서 너무 멀리 이동하여

149
00:06:10,450 --> 00:06:12,870
여부, 이제 시작
당신이 접촉하고 있기 때문에 그것은이다

150
00:06:12,870 --> 00:06:14,780
그냥 쓰레기 값 메모리.

151
00:06:14,780 --> 00:06:18,230
>> 그래서 여기에 스타 X이다하고
정의되지 않은 동작의 종류.

152
00:06:18,230 --> 00:06:22,030
당신은 그것을 확률 때문에 결코한다
프로그램이 바로 충돌 것있다,

153
00:06:22,030 --> 00:06:24,050
당신이 말하는 것 때문에,
이 주소로 이동

154
00:06:24,050 --> 00:06:27,000
그리고 당신은 아무 생각이 곳이 없다
그 주소는 사실이다.

155
00:06:27,000 --> 00:06:30,300
그래서 운영체제 가능성
프로그램을 중단 예정

156
00:06:30,300 --> 00:06:33,840
그 결과 실제로으로, 그건
무슨 일이 빙키에이 일어났다.

157
00:06:33,840 --> 00:06:37,210
그래서 궁극적으로, 빙키는 고정
이이 문제.

158
00:06:37,210 --> 00:06:38,909
이 프로그램 그래서 그 자체가 결함이되었다.

159
00:06:38,909 --> 00:06:41,450
하지만 당신은 종류의 점진 경우
대신이 줄을 실행,

160
00:06:41,450 --> 00:06:45,580
Y는 X와 동일한 의미대로
주소가 x는, 또한 Y에 넣어.

161
00:06:45,580 --> 00:06:48,740
>> 그리고 그림으로, 우리는했습니다
두 개의 화살표와 함께이 대표

162
00:06:48,740 --> 00:06:51,570
X로부터 Y 좌표에서
같은 장소에.

163
00:06:51,570 --> 00:06:55,760
그래서 의미, X는 동일
Y에 그 모두 때문에

164
00:06:55,760 --> 00:07:00,300
동일한 저장되고
주소, ERGO 42 가리키는

165
00:07:00,300 --> 00:07:04,910
그리고 지금, 때 당신은 별을 말한다
Y는 Y에있는 주소로 이동

166
00:07:04,910 --> 00:07:06,790
이것은 흥미로운 부작용을 갖는다.

167
00:07:06,790 --> 00:07:10,320
따라서 Y의 주소 인
X에있는 주소와 같은 일.

168
00:07:10,320 --> 00:07:15,060
그래서 만약 당신이 주소로 이동 말
와 y에 13 값을 변경,

169
00:07:15,060 --> 00:07:17,140
누가 다른 영향을 받습니까?

170
00:07:17,140 --> 00:07:21,100
X는 점 D, 그래서, 말을하는 것입니다
뿐만 아니라 영향을해야합니다.

171
00:07:21,100 --> 00:07:24,340
>> 그리고 실제로, 방법에게 닉이 그림을 그린
클레이 메이션에 정확히이었다.

172
00:07:24,340 --> 00:07:28,665
우리는 포인터를 따라해도
Y는, 우리는 같은 장소에 종료

173
00:07:28,665 --> 00:07:32,780
그래서 우리는 인쇄 할 수 있다면
X 또는 Y의 pointee 아웃,

174
00:07:32,780 --> 00:07:35,720
우리는 13의 값을 볼 것입니다.

175
00:07:35,720 --> 00:07:37,927
지금, 나는 pointee가 될 말
비디오와 일치.

176
00:07:37,927 --> 00:07:39,760
프로그래머, 내
지식, 결코 실제로

177
00:07:39,760 --> 00:07:42,460
단어 pointee 말,
뾰족 것을

178
00:07:42,460 --> 00:07:44,650
에서, 그러나 일관성을 위해
비디오, 실현

179
00:07:44,650 --> 00:07:47,520
그이었다 모두의
그 상황에서 의미했다.

180
00:07:47,520 --> 00:07:54,190
클레이 메이션에 따라서 질문
또는 포인터 또는 malloc에​​ 아직?

181
00:07:54,190 --> 00:07:54,850
아니?

182
00:07:54,850 --> 00:07:55,470
괜찮아.

183
00:07:55,470 --> 00:07:58,560
>> 그래서 더없이
ADO, 이제 살펴 보자

184
00:07:58,560 --> 00:08:00,700
이 실제로이 곳에서
일정 시간 동안 사용되었다.

185
00:08:00,700 --> 00:08:03,580
그래서 우리는이 CS50 라이브러리를 했어
즉, 이러한 모든 기능을 가지고.

186
00:08:03,580 --> 00:08:06,810
우리는,의 getInt를하여 GetString을 많이 사용했습니다
아마 이전 GetLongLong

187
00:08:06,810 --> 00:08:09,840
내 PSET에 하나 정도,하지만
실제로 무슨 일 됐어요?

188
00:08:09,840 --> 00:08:12,920
음, 잠깐 살펴 보자
프로그램에서 후드 아래에 그

189
00:08:12,920 --> 00:08:17,017
우리는 당신이 CS50 줄 왜 고무
도서관, 참으로 지난 주와 같은,

190
00:08:17,017 --> 00:08:18,850
우리는 사람들을 복용하기 시작
훈련 바퀴 끕니다.

191
00:08:18,850 --> 00:08:21,080
그래서 지금 정렬
의 사후의 어떤

192
00:08:21,080 --> 00:08:23,690
이 일 된
CS50 라이브러리 내부,

193
00:08:23,690 --> 00:08:27,250
우리는 지금 움직이기 시작한다하더라도
멀리에서 대부분의 프로그램.

194
00:08:27,250 --> 00:08:29,460
>> 그래서이 0는 scanf라는 프로그램입니다.

195
00:08:29,460 --> 00:08:30,510
그것은 매우 짧다.

196
00:08:30,510 --> 00:08:33,909
단지 이들 라인이 있지만
라는 함수는 scanf를 소개합니다

197
00:08:33,909 --> 00:08:36,909
우리는 사실에서 볼 거라고
CS50 라이브러리 내부의 순간,

198
00:08:36,909 --> 00:08:38,600
약간 다른 형태이기는하지만.

199
00:08:38,600 --> 00:08:41,330
라인 (16)에 따라서이 프로그램
변수 x를 선언한다.

200
00:08:41,330 --> 00:08:43,150
그래서 나에게 인터넷 용 4 바이트를 제공합니다.

201
00:08:43,150 --> 00:08:45,750
그것은 사용자를 말하고있어
수하십시오, 다음

202
00:08:45,750 --> 00:08:49,010
이 흥미로운 라인입니다
실제로 지난 주 함께 묶어

203
00:08:49,010 --> 00:08:49,790
이.

204
00:08:49,790 --> 00:08:53,230
scanf와 다음은 소요 알
형식 문자열, 그냥 printf와 같은,

205
00:08:53,230 --> 00:08:57,480
% 내가 int를 의미하고, 그것은 소요
조금 보이는 두 번째 인수

206
00:08:57,480 --> 00:08:58,260
펑키.

207
00:08:58,260 --> 00:09:01,880
그것은 앰퍼샌드 X, 그리고 리콜,
우리는이 한 번 지난 주 보았다.

208
00:09:01,880 --> 00:09:03,465
앰퍼샌드 X는 무엇을 상징 하는가?

209
00:09:03,465 --> 00:09:06,210

210
00:09:06,210 --> 00:09:08,450
앰퍼샌드는 C에서 무엇입니까?

211
00:09:08,450 --> 00:09:08,950
그래?

212
00:09:08,950 --> 00:09:10,024
>> 청중 :의 주소입니다.

213
00:09:10,024 --> 00:09:11,190
데이비드 마란 :의 주소입니다.

214
00:09:11,190 --> 00:09:13,190
그래서 반대이다
스타 연산자,

215
00:09:13,190 --> 00:09:17,270
스타의 운영자는 말한다 반면,로 이동
이 주소, 앰퍼샌드 연산자

216
00:09:17,270 --> 00:09:20,280
알아낼 말한다
이 변수의 주소,

217
00:09:20,280 --> 00:09:23,530
그래서이 있기 때문에 중요하다
인생에서 scanf와의 목적

218
00:09:23,530 --> 00:09:26,320
사용자를 검색하는 것입니다
키보드로 입력,

219
00:09:26,320 --> 00:09:29,970
무엇에 따라 그 또는 그녀
종류 및 해당 사용자의 입력을 읽어

220
00:09:29,970 --> 00:09:32,970
변수로,하지만 우리
지난 2 주 보았다

221
00:09:32,970 --> 00:09:36,080
그 스왑 기능이 그 우리
구현하기 쉽게 시도

222
00:09:36,080 --> 00:09:37,110
단지 부서졌다.

223
00:09:37,110 --> 00:09:42,470
스왑 기능으로 그 리콜,
우리가 정수로 A와 B를 선언하는 경우,

224
00:09:42,470 --> 00:09:47,040
우리는 성공적으로 교체 않았다
스왑의 내부에 두 개의 변수

225
00:09:47,040 --> 00:09:50,080
그냥 우유와 OJ와 같은,
하지만 스왑, 반환 마자

226
00:09:50,080 --> 00:09:55,200
대한 결과가 무엇 이었습니까
x와 y에, 원래 값?

227
00:09:55,200 --> 00:09:55,700
아무것도.

228
00:09:55,700 --> 00:09:56,200
그래.

229
00:09:56,200 --> 00:09:59,754
아무것도하기 때문에, 그 시간을 일어나지 않았다
스왑 만의 로컬 복사본을 변경

230
00:09:59,754 --> 00:10:01,670
모든 말을하다
이 때, 때마다 우리가했습니다

231
00:10:01,670 --> 00:10:04,010
인수 전달 된
기능에, 우리는있어

232
00:10:04,010 --> 00:10:05,939
단지 그 인수의 복사본을 전달합니다.

233
00:10:05,939 --> 00:10:07,980
당신은 그와 함께 할 수있는
당신이 그들과 함께 원하는대로,

234
00:10:07,980 --> 00:10:10,890
하지만 그들은 더 할거야
원래 값에 영향을.

235
00:10:10,890 --> 00:10:13,650
그래서이는 경우에 문제가된다
scanf와 같은 기능을 갖고 싶어

236
00:10:13,650 --> 00:10:17,170
인생에서, 그 목적은 검사하는 것입니다
키보드로부터의 사용자 입력

237
00:10:17,170 --> 00:10:22,010
다음에 있으므로 빈칸을 채워
말, 즉, X 같은 변수를 제공

238
00:10:22,010 --> 00:10:25,410
값, 내가 있다면 때문에
단지을 scanf X를 전달하려면,

239
00:10:25,410 --> 00:10:28,790
당신은 마지막의 논리를 고려하는 경우
주, scanf와는 원하는 무엇이든 할 수 있습니다

240
00:10:28,790 --> 00:10:33,100
X의 사본하지만 수 없었다
우리가 제공하지 않는 한 영구적으로 X를 변경

241
00:10:33,100 --> 00:10:37,120
말하자면, 보물지도를을 scanf
x는 자리를 표시하는 경우, 이에

242
00:10:37,120 --> 00:10:41,860
우리는 그래서 x의 주소를 전달
scanf와이 실제로 변화 갈 수

243
00:10:41,860 --> 00:10:42,920
x의 값.

244
00:10:42,920 --> 00:10:45,080
그리고 실제로, 모든
이 프로그램은 않는다는 것을

245
00:10:45,080 --> 00:10:53,180
내 소스에 scanf와 0을 만들 경우
500 만 디렉토리, scanf와 0을,

246
00:10:53,180 --> 00:10:57,730
점은 scanf와 슬래시, 수
50하시기 바랍니다, 50 주셔서 감사합니다.

247
00:10:57,730 --> 00:11:01,020
>> 그래서, 모든 관심이 아니에요
그러나 실제로 무슨 일이야

248
00:11:01,020 --> 00:11:04,820
최대한 빨리 부르는 것입니다
여기에서 x의 값을을 scanf

249
00:11:04,820 --> 00:11:06,410
영구적으로 변경되고있다.

250
00:11:06,410 --> 00:11:08,335
자,이 좋은 보인다
좋은, 그리고에 사실, 그것을

251
00:11:08,335 --> 00:11:11,200
우리가 정말 필요가없는 것 같아
모든 이상에서 CS50 라이브러리.

252
00:11:11,200 --> 00:11:13,960
예를 들어, 실행하자
여기 한 번 더.

253
00:11:13,960 --> 00:11:15,750
내가 초를 다시 보자.

254
00:11:15,750 --> 00:11:20,600
의 숫자를 시도해 주시기 바랍니다과
대신 이전과 같은 50을 말하는,

255
00:11:20,600 --> 00:11:22,810
그냥 '아니오'라고 할 수 있습니다.

256
00:11:22,810 --> 00:11:24,000
좋아, 그건 좀 이상해.

257
00:11:24,000 --> 00:11:25,270
그래.

258
00:11:25,270 --> 00:11:28,680
그리고 여기 좀 넌센스.

259
00:11:28,680 --> 00:11:31,170
그래서하지 않는 것
잘못된 상황을 처리합니다.

260
00:11:31,170 --> 00:11:33,620
그래서 우리는 시작을 최소​​한으로해야
일부 오류 검사를 추가

261
00:11:33,620 --> 00:11:37,460
사용자가 있는지 확인합니다
(50)처럼 실제 번호를 입력,

262
00:11:37,460 --> 00:11:40,720
분명히 입력 단어 때문에
문제로 감지되지 않고,

263
00:11:40,720 --> 00:11:42,020
그러나 그것은 아마해야합니다.

264
00:11:42,020 --> 00:11:46,450
>> 의는 지금은이 버전을 살펴 보자
내 시도하여 GetString을 구현할 수 있습니다.

265
00:11:46,450 --> 00:11:48,437
scanf와 모든이가있는 경우
기능, 내장

266
00:11:48,437 --> 00:11:51,270
왜 우리는이와 취미 삼아왔다
하여 GetString 같은 교육 바퀴?

267
00:11:51,270 --> 00:11:55,450
음, 여기 아마 내 자신의
에서 getString 간단한 버전

268
00:11:55,450 --> 00:12:00,766
이에 주 전, 나는 말했다 수도,
나에게 문자열을 제공하고 버퍼를 호출합니다.

269
00:12:00,766 --> 00:12:03,390
오늘, 난 그냥 시작하는거야
, 문자 스타, 리콜 말

270
00:12:03,390 --> 00:12:04,400
그냥 동의어입니다.

271
00:12:04,400 --> 00:12:06,629
그것은 무서운 보이지만이다
똑같은 일이.

272
00:12:06,629 --> 00:12:09,420
그래서 나에게 변수라고 버퍼를 제공
그 문자열을 저장하는 것,

273
00:12:09,420 --> 00:12:12,780
사용자 문자열을하시기 바랍니다 말해
다음, 직전처럼,

274
00:12:12,780 --> 00:12:17,760
의이 교훈을 빌려 해보자는 scanf
%의이 시간 후 버퍼에 전달합니다.

275
00:12:17,760 --> 00:12:19,310
이제, 빠른 전성 검사.

276
00:12:19,310 --> 00:12:22,120
왜 말을하고 있지 않다
앰퍼샌드는이 시간을 버퍼?

277
00:12:22,120 --> 00:12:25,190

278
00:12:25,190 --> 00:12:26,625
앞의 예에서 추론.

279
00:12:26,625 --> 00:12:28,000
청중 : 샤아 스타 포인터입니다.

280
00:12:28,000 --> 00:12:29,920
데이비드 마란 : 정확히,
이 때, 문자 때문에

281
00:12:29,920 --> 00:12:34,080
스타 이미 포인터, 주소
거기 그 스타의 정의에 의해.

282
00:12:34,080 --> 00:12:37,530
및 scanf가 주소를 기대하는 경우,
그냥 버퍼에 전달하는 데 충분하다.

283
00:12:37,530 --> 00:12:39,260
나는 앰퍼샌드 버퍼를 말할 필요가 없습니다.

284
00:12:39,260 --> 00:12:42,177
호기심를 들어, 당신은 할 수
이런 일을한다.

285
00:12:42,177 --> 00:12:43,510
그것은 다른 의미를 가질 것이다.

286
00:12:43,510 --> 00:12:47,240
이것은 당신에게 포인터를 줄 것이다
실제로 포인터에

287
00:12:47,240 --> 00:12:50,050
C에서,하지만에 대한 유효한 것
자, 간단하게하자

288
00:12:50,050 --> 00:12:51,750
일관된 이야기를 유지한다.

289
00:12:51,750 --> 00:12:54,100
나는 그냥 통과 할거야
버퍼 및 그 맞습니다.

290
00:12:54,100 --> 00:12:56,487
문제는 비록 이것이다.

291
00:12:56,487 --> 00:12:58,820
내가 가서이 실행하자
그것을 컴파일 후 프로그램.

292
00:12:58,820 --> 00:13:00,902
scanf와 1을 확인합니다.

293
00:13:00,902 --> 00:13:02,610
젠장, 내 컴파일러의
내 오류를 잡기.

294
00:13:02,610 --> 00:13:04,090
나에게 1 초 준다.

295
00:13:04,090 --> 00:13:05,460
연타.

296
00:13:05,460 --> 00:13:06,990
의는 scanf와 - 1.C를 가정 해 봅시다.

297
00:13:06,990 --> 00:13:10,880

298
00:13:10,880 --> 00:13:11,380
그래.

299
00:13:11,380 --> 00:13:12,720
우리는 거기에 갈.

300
00:13:12,720 --> 00:13:14,280
나는 그것을해야합니다.

301
00:13:14,280 --> 00:13:16,750
CS50 ID는 여러가
구성 설정

302
00:13:16,750 --> 00:13:18,280
그 자신에 대해 당신을 보호.

303
00:13:18,280 --> 00:13:21,300
나는에 의해 그를 해제하는 데 필요한
수동으로 시간을 연타를 실행.

304
00:13:21,300 --> 00:13:22,140
그래서 문자열하시기 바랍니다.

305
00:13:22,140 --> 00:13:25,560
내가 가서 입력거야
내가 좋아하는 헬로 세계.

306
00:13:25,560 --> 00:13:26,490
널 (null), 확인을 클릭합니다.

307
00:13:26,490 --> 00:13:27,700
그게 내가 입력 한 내용이 아니다.

308
00:13:27,700 --> 00:13:29,690
그래서 나타내는이다
뭔가 잘못되고.

309
00:13:29,690 --> 00:13:33,920
내가 가서 입력하자
정말로 긴 문자열.

310
00:13:33,920 --> 00:13:37,210
널에 대한 감사 모르겠어요
있다면 그것을 충돌 할 수있을거야.

311
00:13:37,210 --> 00:13:40,240
의 약간 사본을 해보자
붙여 넣기이 도움이되는지 확인합니다.

312
00:13:40,240 --> 00:13:43,290
그냥이 많이 붙여 넣습니다.

313
00:13:43,290 --> 00:13:47,310
그것은 확실히 더 큰
평소보다 문자열입니다.

314
00:13:47,310 --> 00:13:51,450
그냥 정말 쓰기 보자.

315
00:13:51,450 --> 00:13:51,950
아니.

316
00:13:51,950 --> 00:13:52,650
젠장.

317
00:13:52,650 --> 00:13:53,480
명령을 찾을 수 없습니다.

318
00:13:53,480 --> 00:13:54,550
그래서는 무관합니다.

319
00:13:54,550 --> 00:13:56,440
내가 붙여 넣기 때문이다
나쁜 자,

320
00:13:56,440 --> 00:13:59,780
하지만이 밝혀 작동하지 않을.

321
00:13:59,780 --> 00:14:03,510
>> 때문에의이 한 번 더 해보자
우리가 실제로 충돌하는 경우가 더 재미 있어요.

322
00:14:03,510 --> 00:14:09,116
의이을 입력하자 지금은 해요
정말 긴 문자열을 복사하는 것

323
00:14:09,116 --> 00:14:10,990
지금의이 있는지 확인하자 우리
이 일을 중단 할 수 있습니다.

324
00:14:10,990 --> 00:14:14,235
내가 공간을 생략 주목
새로운 라인과 세미콜론

325
00:14:14,235 --> 00:14:16,035
모든 펑키 문자.

326
00:14:16,035 --> 00:14:16,535
입력합니다.

327
00:14:16,535 --> 00:14:21,090

328
00:14:21,090 --> 00:14:22,880
이제 네트워크는 느린입니다.

329
00:14:22,880 --> 00:14:27,460
나는 명확하게, 너무 오래 명령-V를 누르고.

330
00:14:27,460 --> 00:14:28,190
젠장!

331
00:14:28,190 --> 00:14:29,260
명령을 찾을 수 없습니다.

332
00:14:29,260 --> 00:14:29,780
>> 그래.

333
00:14:29,780 --> 00:14:32,240
음, 포인트입니다
그럼에도 불구하고 다음.

334
00:14:32,240 --> 00:14:36,910
그래서 실제로 무슨 일이 일어나고 있는지
이 선언에

335
00:14:36,910 --> 00:14:39,240
라인 (16)에 문자 스타 버퍼의?

336
00:14:39,240 --> 00:14:41,820
그래서 점점 무엇입니다
나는 포인터를 선언 할 때?

337
00:14:41,820 --> 00:14:47,440
내가 갖는 모든는 4 바이트 값입니다
버퍼라고하지만, 그 안에 무엇을

338
00:14:47,440 --> 00:14:49,540
순간?

339
00:14:49,540 --> 00:14:50,930
그것은 그냥 쓰레기 값입니다.

340
00:14:50,930 --> 00:14:54,170
언제든지 때문에 당신은 변수를 선언
C에서, 그것은 그냥 쓰레기 값이다,

341
00:14:54,170 --> 00:14:56,220
우리는 시작하고
이 현실을 통해 여행.

342
00:14:56,220 --> 00:14:59,720
지금, scanf와 말할 때,
이 주소로 이동

343
00:14:59,720 --> 00:15:01,520
과에서 어떤 사용자 유형을했습니다.

344
00:15:01,520 --> 00:15:06,400
사용자의 유형 경우 헬로
세계, 음, 나는 그것을 어디에 배치해야합니까?

345
00:15:06,400 --> 00:15:07,750
버퍼는 쓰레기 값입니다.

346
00:15:07,750 --> 00:15:11,510
>> 그래서 화살표 같은 종류의
그 위치를 알고있는 사람을 가리키는 것.

347
00:15:11,510 --> 00:15:13,880
아마 가리키는 것
바로 여기 내 기억에.

348
00:15:13,880 --> 00:15:16,560
그래서 때 사용자
안녕하세요 세계의 유형,

349
00:15:16,560 --> 00:15:22,380
프로그램을 배치하려고 시도
문자열 안녕하세요 백 슬래시 0

350
00:15:22,380 --> 00:15:23,910
메모리의 덩어리입니다.

351
00:15:23,910 --> 00:15:27,070
그러나 높은 확률로하지만,
분명 100 % 확률,

352
00:15:27,070 --> 00:15:30,440
컴퓨터는 충돌 것입니다
프로그램이 없기 때문에

353
00:15:30,440 --> 00:15:32,490
기억 나는 만져 허용해야합니다.

354
00:15:32,490 --> 00:15:36,330
그래서 짧은에,이 프로그램은
바로이 때문에 결함.

355
00:15:36,330 --> 00:15:38,070
나는 근본적으로 일을하고 있지 않다?

356
00:15:38,070 --> 00:15:42,366
어떤 단계를 내가처럼 생략이
우리는 빙키의 첫 번째 예제로 처리?

357
00:15:42,366 --> 00:15:42,866
그래?

358
00:15:42,866 --> 00:15:43,710
>> 청중 : 메모리 할당?

359
00:15:43,710 --> 00:15:45,001
>> 데이비드 마란 : 메모리 할당.

360
00:15:45,001 --> 00:15:48,400
나는 실제로 할당되지 않은
해당 문자열에 대한 메모리.

361
00:15:48,400 --> 00:15:50,270
그래서 우리는 몇 가지 방법으로이 문제를 해결할 수 있습니다.

362
00:15:50,270 --> 00:15:52,700
하나, 우리는 간단하게 할 수 있습니다
사실, 지금은있어

363
00:15:52,700 --> 00:15:55,116
흐림을보고 시작할 것
것 사이의 라인

364
00:15:55,116 --> 00:15:58,520
배열, 문자열이 무엇인지, 무엇이다
문자 스타 문자 어떤 배열입니다

365
00:15:58,520 --> 00:15:59,020
이다.

366
00:15:59,020 --> 00:16:02,450
여기에 두 번째 예이다
문자열 통지 포함

367
00:16:02,450 --> 00:16:05,690
모든 I 라인에서 수행 한
(16) 대신 말하는입니다

368
00:16:05,690 --> 00:16:09,530
그 버퍼는 문자가 될 것입니다
스타 메모리 청크 포인터,

369
00:16:09,530 --> 00:16:14,057
나는 매우 적극적으로 줄거야
16 자에 대한 자신 버퍼,

370
00:16:14,057 --> 00:16:16,390
사실, 당신은 익숙하다면
용어 버퍼링,

371
00:16:16,390 --> 00:16:20,570
아마 동영상의 세계에서,
동영상 버퍼링, 버퍼링이고,

372
00:16:20,570 --> 00:16:21,175
버퍼링.

373
00:16:21,175 --> 00:16:22,550
음, 연결이 여기에 무엇입니까?

374
00:16:22,550 --> 00:16:24,960
유튜브의 음, 내부
비디오 플레이어의 내부

375
00:16:24,960 --> 00:16:27,200
일반적으로 배열입니다
즉, 16보다 더 큰.

376
00:16:27,200 --> 00:16:30,340
크기는 하나의 배열 수 있습니다
메가 바이트, 어쩌면 10메가바이트,

377
00:16:30,340 --> 00:16:34,330
그 배열로 브라우저를 않습니다
바이트의 전체 무리를 다운로드

378
00:16:34,330 --> 00:16:37,500
메가 바이트의 전체 무리
비디오, 비디오 플레이어,

379
00:16:37,500 --> 00:16:40,930
YouTube의 또는 누구의은, 시작
그 배열에서 바이트를 읽어 들이기,

380
00:16:40,930 --> 00:16:43,530
언제든지 당신을 참조
워드 버퍼링, 버퍼링,

381
00:16:43,530 --> 00:16:46,350
즉, 플레이어가 의미
그 배열의 끝에 얻었다.

382
00:16:46,350 --> 00:16:50,430
네트워크는 그렇지 갖도록 느리다
더 바이트 배열을 리필

383
00:16:50,430 --> 00:16:55,610
그래서 당신은 비트 나간다
사용자에게 표시합니다.

384
00:16:55,610 --> 00:16:59,430
>> 그래서 버퍼는 적절한 용어는 점에서 여기에
그냥 배열, 메모리의 덩어리입니다.

385
00:16:59,430 --> 00:17:02,530
그리고이 문제를 해결할 것
이 밝혀 때문에

386
00:17:02,530 --> 00:17:07,410
당신은 배열을 처리 할 수​​ 있다는 생각으로
그들은 심지어 버퍼 불구하고, 주소입니다

387
00:17:07,410 --> 00:17:10,710
단지 상징, 그것은이다이다
문자의 순서, 버퍼,

388
00:17:10,710 --> 00:17:14,760
그 날을 위해 유용, 프로그래머,
당신은 주위에 그 이름을 전달할 수 있습니다

389
00:17:14,760 --> 00:17:17,079
그 것처럼
포인터로 그것을 생각

390
00:17:17,079 --> 00:17:21,000
청크의 주소했다
16 문자의 메모리.

391
00:17:21,000 --> 00:17:24,530
즉, 그래서 나는 통과 할 수있다
정확하게는 scanf 그 단어

392
00:17:24,530 --> 00:17:30,670
그래서 지금, 나는이 프로그램을 만들 경우,
scanf와 2을, 도트 슬래시 scanf와 2,

393
00:17:30,670 --> 00:17:35,386
및 입력 안녕하세요 세계,
그 time--를 입력

394
00:17:35,386 --> 00:17:37,590
>> 흠, 무슨 일?

395
00:17:37,590 --> 00:17:39,340
문자열하시기 바랍니다.

396
00:17:39,340 --> 00:17:41,430
내가 잘못 무슨 짓을 한거야?

397
00:17:41,430 --> 00:17:43,800
안녕하세요 세계, 버퍼.

398
00:17:43,800 --> 00:17:44,705
안녕하세요 세계.

399
00:17:44,705 --> 00:17:48,201

400
00:17:48,201 --> 00:17:49,420
아, 나는 무엇을하고 있는지 알고있다.

401
00:17:49,420 --> 00:17:49,920
그래.

402
00:17:49,920 --> 00:17:51,628
그래서 독서 것
첫 번째 공간까지.

403
00:17:51,628 --> 00:17:55,680
그래서 그냥 잠시 속임수하자
난 그냥 뭔가를 입력하고 싶었다 말

404
00:17:55,680 --> 00:18:01,408
정말 긴이 긴 문장처럼
그건 하나, 둘, 셋, 넷, 다섯,

405
00:18:01,408 --> 00:18:04,420
여섯, 일곱, 여덟, 아홉,
10, 11, 12, 13, 14, 15, 16.

406
00:18:04,420 --> 00:18:05,300
그래.

407
00:18:05,300 --> 00:18:07,600
그것은 참으로 긴 문장이다.

408
00:18:07,600 --> 00:18:10,710
그래서이 문장은
이상 16 자

409
00:18:10,710 --> 00:18:13,670
그래서 나는, Enter 키를 누르 때
무슨 일이 일어날?

410
00:18:13,670 --> 00:18:16,940
음,이 경우에
이야기, 내가 선언했다 버퍼

411
00:18:16,940 --> 00:18:22,190
실제로 배열 인에
갈 16 문자 준비가.

412
00:18:22,190 --> 00:18:27,426
그래서 하나, 둘, 셋, 넷, 다섯, 여섯,
7, 8, 9, 10, 11, 12, 13, 14,

413
00:18:27,426 --> 00:18:29,440
(15, 16).

414
00:18:29,440 --> 00:18:34,410
그래서 16 자, 이제, 때
이 긴처럼 뭔가를 읽고

415
00:18:34,410 --> 00:18:43,950
문장, 무슨 일이됩니다거야
나는이 읽을거야 있다는 것은 긴

416
00:18:43,950 --> 00:18:49,660
S-E-N-T-E-N-C-E, 문장.

417
00:18:49,660 --> 00:18:52,270
>> 그래서 일부러이다
나쁜 일이 내가

418
00:18:52,270 --> 00:18:55,060
이상 기록 유지
내 배열의 경계,

419
00:18:55,060 --> 00:18:56,660
내 버퍼의 경계를 넘어.

420
00:18:56,660 --> 00:19:00,100
나는 운이 프로그램 얻을 수
관심 실행에 유지되지 않습니다,

421
00:19:00,100 --> 00:19:03,450
그러나 일반적으로,이 말하기
참으로 내 프로그램을 충돌합니다,

422
00:19:03,450 --> 00:19:06,440
그것은 버그가 내
내가 단계 순간을 코딩

423
00:19:06,440 --> 00:19:08,576
경계를 넘어
그 배열의, 나는 때문에

424
00:19:08,576 --> 00:19:10,450
그것의 알고하지 않습니다
반드시 충돌 것

425
00:19:10,450 --> 00:19:12,120
또는 그냥 운거야 경우.

426
00:19:12,120 --> 00:19:15,750
그래서이 문제가에 있기 때문에
이 경우, 그것은 작동하도록 보인다

427
00:19:15,750 --> 00:19:20,931
과의에도 불구하고, 여기에 운명을 유혹하자
IDE는 꽤 견딜 것

428
00:19:20,931 --> 00:19:21,430
의--

429
00:19:21,430 --> 00:19:22,040
>> 우리는 거기에 갈.

430
00:19:22,040 --> 00:19:23,240
마지막으로.

431
00:19:23,240 --> 00:19:26,470
그래서 나는이 볼 수있는 유일한 사람입니다.

432
00:19:26,470 --> 00:19:29,630
그래서 난 그냥 재미 타이핑을 많이했다
정말로 긴 실제 구문 밖으로

433
00:19:29,630 --> 00:19:32,800
확실히 초과했음을
16 바이트, 나는 때문에

434
00:19:32,800 --> 00:19:38,050
이 미친 긴 여러 줄에 입력
문구, 다음 무슨 일이 있었는지 알 수 있습니다.

435
00:19:38,050 --> 00:19:41,110
프로그램을 인쇄하려고
다음 세그먼트 오류를​​ 가지고

436
00:19:41,110 --> 00:19:44,430
및 분할 오류는 때입니다
이 같은 일이 발생

437
00:19:44,430 --> 00:19:47,650
및 운영 체제를 말한다
아니, 그 메모리를 건드릴 수 없어.

438
00:19:47,650 --> 00:19:49,570
우리는 죽일거야
모두 프로그램.

439
00:19:49,570 --> 00:19:51,180
>> 그래서이 문제가 보인다.

440
00:19:51,180 --> 00:19:54,540
나는 프로그램이있다을 개선했습니다
적어도, 일부 메모리가

441
00:19:54,540 --> 00:19:58,000
그러나 이것은 한정 할 것 같다
점점로 기능하여 GetString

442
00:19:58,000 --> 00:20:00,780
어떤 유한 한 길이 16의 문자열.

443
00:20:00,780 --> 00:20:04,200
당신은 더 이상 지원 싶다면
16 자보다 문장,

444
00:20:04,200 --> 00:20:04,880
당신은 무엇을 하는가?

445
00:20:04,880 --> 00:20:07,970
글쎄, 당신을 증가시킬 수
(32)이 버퍼의 크기

446
00:20:07,970 --> 00:20:09,190
또는 그 종류의 짧은 보인다.

447
00:20:09,190 --> 00:20:12,260
왜 우리는하지 않습니다
그것은 1000하지만 다시 밀어 넣습니다.

448
00:20:12,260 --> 00:20:17,100
직관적으로의 응답은 무엇인가
다만함으로써이 문제를 회피

449
00:20:17,100 --> 00:20:20,660
1000 문자처럼, 더 큰 내 버퍼?

450
00:20:20,660 --> 00:20:23,470
이 방법을 getString에 구현함으로써.

451
00:20:23,470 --> 00:20:27,130
어떻게 여기에 좋거나 나쁜?

452
00:20:27,130 --> 00:20:28,033
그래?

453
00:20:28,033 --> 00:20:30,574
청중 : 당신은 많이 결합하는 경우
공간의 당신이 그것을 사용하지 않는,

454
00:20:30,574 --> 00:20:33,500
당신은 그 공간을 재 할당 할 수 없습니다.

455
00:20:33,500 --> 00:20:34,500
데이비드 마란 : 물론입니다.

456
00:20:34,500 --> 00:20:38,480
당신이하지 않는 한, 그것은 마치 낭비이다
실제로 그 바이트 (900)가 필요

457
00:20:38,480 --> 00:20:41,057
아직 당신을 요구하고
어쨌든 총 1,000

458
00:20:41,057 --> 00:20:44,140
당신은 더 많은 메모리를 사용하고 있습니다
당신이 필요한 것보다 사용자의 컴퓨터,

459
00:20:44,140 --> 00:20:45,740
그리고 모든, 일부 후
당신은 이미 발생했습니다

460
00:20:45,740 --> 00:20:47,620
인생에서 당신이있을 때 그
많은 프로그램을 실행

461
00:20:47,620 --> 00:20:50,470
그들은, 많은 양의 메모리를 먹고있어
이것은 실제로 성능에 영향을 미칠 수 있습니다

462
00:20:50,470 --> 00:20:52,220
사용자의 경험
컴퓨터.

463
00:20:52,220 --> 00:20:56,090
그래서 종류의 게으른 솔루션입니다,
확실히, 반대로,

464
00:20:56,090 --> 00:21:00,140
이뿐만 아니라 낭비이다, 무슨 문제
아직도 내가 내 버퍼를 만들 경우에도 유지

465
00:21:00,140 --> 00:21:02,100
1,000?

466
00:21:02,100 --> 00:21:02,600
그래?

467
00:21:02,600 --> 00:21:04,475
>> 청중 : 문자열의 길이는 1,001입니다.

468
00:21:04,475 --> 00:21:05,350
데이비드 마란 : 맞아요.

469
00:21:05,350 --> 00:21:08,280
당신의 문자열 길이 1,001이면
당신은 동일한 문제를 가지고,

470
00:21:08,280 --> 00:21:10,705
내 인수로, 나는 것
다만 다음 2,000 확인

471
00:21:10,705 --> 00:21:12,830
하지만 당신은 알고하지 않습니다
어떻게해야 큰 사전,

472
00:21:12,830 --> 00:21:16,890
그럼에도 불구하고, 나는 내 프로그램을 컴파일해야합니까
사람들이 사용시키는 전과 다운로드

473
00:21:16,890 --> 00:21:17,390
그것.

474
00:21:17,390 --> 00:21:21,490
그래서 이것은 정확히 종류
물건 CS50 라이브러리 시도는

475
00:21:21,490 --> 00:21:24,750
우리를 도와 우리는 눈에 거 야
기본이되는 구현의 일부에

476
00:21:24,750 --> 00:21:29,790
여기서, 그러나 이것은 CS50 점이다 C.
CS50 IDE에있었습니다 파일입니다

477
00:21:29,790 --> 00:21:31,420
당신이 사용했던 모든 주.

478
00:21:31,420 --> 00:21:34,280
그것은 미리 컴파일 된 그리고 당신은했습니다
자동으로 사용하고

479
00:21:34,280 --> 00:21:38,780
를 갖는 자연에 의해
그 소리와 L의 CS50 플래그를 대시,

480
00:21:38,780 --> 00:21:42,300
그러나 나는 모두를 아래로 스크롤하면
이러한 기능, 여기하여 GetString있어,

481
00:21:42,300 --> 00:21:44,636
단지 당신에게를 제공합니다
무엇의 맛, 무슨 일

482
00:21:44,636 --> 00:21:46,760
의가에 대해 간략히 살펴 보겠습니다
상대적 복잡성.

483
00:21:46,760 --> 00:21:48,870
그것은하지 슈퍼 길어
기능,하지만 우리는하지 않았다

484
00:21:48,870 --> 00:21:52,530
모든 하드에 대한 생각해야
어떻게 문자열을 방법에 대해 이동합니다.

485
00:21:52,530 --> 00:21:55,660
>> 그래서 여기 내 버퍼와 나는이다
분명히 null로 초기화.

486
00:21:55,660 --> 00:21:57,990
이것은 물론,
문자 스타 같은 일,

487
00:21:57,990 --> 00:22:00,585
그러나 나는 결정
CS50 라이브러리를 구현

488
00:22:00,585 --> 00:22:02,460
우리가려고하는 경우에 그
완전히 동적

489
00:22:02,460 --> 00:22:05,770
내가 얼마나 큰 사전에 몰라
문자열 사용자가 얻고 싶은 것입니다.

490
00:22:05,770 --> 00:22:08,140
그래서 시작하는거야
그냥 빈 문자열

491
00:22:08,140 --> 00:22:11,507
나는 많은 구축거야
기억 나는 사용자 문자열에 맞게 필요에 따라

492
00:22:11,507 --> 00:22:13,340
나는이없는 경우
충분히, 내가 물어 갈거야

493
00:22:13,340 --> 00:22:15,010
더 많은 메모리에 대한 운영 체제.

494
00:22:15,010 --> 00:22:17,510
나는 그들의 캐릭터를 이동하는거야
메모리의 큰 덩어리로

495
00:22:17,510 --> 00:22:21,847
내가 해제 또는 해제거야
메모리가 불충분 큰 덩어리

496
00:22:21,847 --> 00:22:23,680
그리고 우리는 단지거야
반복적으로이 작업을 수행합니다.

497
00:22:23,680 --> 00:22:25,570
>> 그래서 빠른 눈,
여기에 단지 변수의

498
00:22:25,570 --> 00:22:28,780
있는 난을 추적 할거야
내 버퍼의 용량.

499
00:22:28,780 --> 00:22:30,071
나는 얼마나 많은 바이트를 맞게 할 수 있습니까?

500
00:22:30,071 --> 00:22:32,070
여기에 변수가 n입니다
내가 지키려고하는

501
00:22:32,070 --> 00:22:36,200
사실에 얼마나 많은 바이트를 추적
사용자가 입력 한 또는 버퍼.

502
00:22:36,200 --> 00:22:39,900
당신은 전에 본 적이 없다, 당신을
지정할 수있는 int 같은 변수

503
00:22:39,900 --> 00:22:46,370
이름에서 알 수 있듯이, 이는 부호이다
의미는 음이 아닌, 그리고 왜 것

504
00:22:46,370 --> 00:22:50,590
나는 이제까지 지정을 귀찮게 할
INT 그냥 INT 아니라고,

505
00:22:50,590 --> 00:22:52,540
그러나 서명되지 않은 INT는입니까?

506
00:22:52,540 --> 00:22:55,064
또한 음이 아닌 INT이다.

507
00:22:55,064 --> 00:22:56,355
[들리지]은 무엇을 의미합니까?

508
00:22:56,355 --> 00:22:58,910
>> 청중 : 그것은 양을 설명하는 것
메모리 [들림] 될 수있다.

509
00:22:58,910 --> 00:22:59,660
>> 데이비드 마란 : 그래.

510
00:22:59,660 --> 00:23:03,710
내가 서명되지 않은 말한다면, 이것은 실제로
당신에게 여분의 메모리를 하나의 비트를주는

511
00:23:03,710 --> 00:23:07,440
당신이 경우 그것은 바보의 종류 보이지만,
, 추가적인 메모리의 비트가

512
00:23:07,440 --> 00:23:09,940
당신이 많은 두 배 것을 의미합니다
당신이 나타낼 수있는 값,

513
00:23:09,940 --> 00:23:11,570
는 0 또는 1이 될 수 있기 때문이다.

514
00:23:11,570 --> 00:23:14,660
그래서 기본적으로 INT는 약이 될 수 있습니다
마이너스 20 억 모든 방법

515
00:23:14,660 --> 00:23:16,030
긍정적 인 20 억까지.

516
00:23:16,030 --> 00:23:18,540
이러한 큰 범위이지만
그것은 여전히​​ 종류의 낭비이다

517
00:23:18,540 --> 00:23:21,280
당신은 단지 걱정하는 경우
크기, 이는 단지 직관적으로

518
00:23:21,280 --> 00:23:24,620
음이 아닌이어야한다 또는
양수 또는 0, 그럼,

519
00:23:24,620 --> 00:23:28,884
왜 20 억을 낭비
음수에 사용할 수있는 값

520
00:23:28,884 --> 00:23:30,300
당신은 결코 그들을 사용하려고하지한다면?

521
00:23:30,300 --> 00:23:35,350
그래서 할 수있는 부호, 지금 내 INT 말하여
4000000000 0과 약을합니다.

522
00:23:35,350 --> 00:23:39,280
>> 그래서 여기 이유로 그냥 INT의 C이다
우리는 지금과 같은으로받지 않습니다

523
00:23:39,280 --> 00:23:42,280
대신 INT 이유에
문자의,하지만 여기에

524
00:23:42,280 --> 00:23:44,630
무슨 일이 일어나고 있는지의 요지
당신의 일부에

525
00:23:44,630 --> 00:23:48,340
예를 들어, 사용하고있는,
심지어 PSET 사에는 fgetc 함수

526
00:23:48,340 --> 00:23:51,580
또는 그 후, 우리는 그것을 볼 수 있습니다
다시 문제에 다섯 설정

527
00:23:51,580 --> 00:23:55,410
는 fgetc 때문에 이름으로 좋은
가지, 일종의 arcanely, 제안

528
00:23:55,410 --> 00:23:57,940
이 함수의 그
, 문자를 가져옵니다 그래서

529
00:23:57,940 --> 00:24:00,690
무엇을 근본적으로 다르​​다
우리하여 GetString에서 무슨 일을하는지에 대한

530
00:24:00,690 --> 00:24:03,110
우리가 사용하지 않는 것입니다
같은 방법으로는 scanf.

531
00:24:03,110 --> 00:24:07,550
우리는 단계별로 따라 들어온다
어떤을 통해 사용자는에 입력하고있다,

532
00:24:07,550 --> 00:24:10,970
우리는 항상 하나를 할당 할 수 있기 때문에
문자, 그래서 우리는 항상 안전하게 수

533
00:24:10,970 --> 00:24:15,599
한 번에 하나의 문자에보고,
마법은 여기에 일이 시작됩니다.

534
00:24:15,599 --> 00:24:17,890
나는 아래로 스크롤거야
이 함수의 중간

535
00:24:17,890 --> 00:24:20,360
그냥 간단하게이 기능을 소개합니다.

536
00:24:20,360 --> 00:24:22,670
많은 거기에 같은
함수 malloc에​​, 거기

537
00:24:22,670 --> 00:24:27,740
realloc을 기능 곳 realloc을
당신은 메모리의 덩어리를 재 할당 할 수 있습니다

538
00:24:27,740 --> 00:24:29,570
그것이 더 큰 또는 작은합니다.

539
00:24:29,570 --> 00:24:33,060
그래서 길고도 짧은 이야기와 함께
오늘 내 손의 물결,

540
00:24:33,060 --> 00:24:35,620
그 어떤하여 GetString을 알고
하고있는 것은 일종의입니다

541
00:24:35,620 --> 00:24:39,720
의 마술 성장 또는
사용자로 버퍼를 축소

542
00:24:39,720 --> 00:24:41,440
자신의 문자열의 종류.

543
00:24:41,440 --> 00:24:43,962
>> 경우에 따라서 사용자 유형
짧은 문자열이 코드

544
00:24:43,962 --> 00:24:45,920
만 충분히 할당
메모리는 캐릭터에 맞게.

545
00:24:45,920 --> 00:24:48,086
사용자가 입력을 유지하는 경우
나는 다시 다시처럼

546
00:24:48,086 --> 00:24:50,330
다시, 잘, 경우
버퍼의 처음이 큰

547
00:24:50,330 --> 00:24:53,310
프로그램은에, 실현
잠깐, 내가 공간이 부족 해요

548
00:24:53,310 --> 00:24:55,410
그것은 두 배로 것
버퍼 크기

549
00:24:55,410 --> 00:24:59,110
다음 버퍼의 크기를 두 배로
그리고 배가을 수행하는 코드,

550
00:24:59,110 --> 00:25:03,170
우리는 여기에서 보면, 그것은이다
다만이 영리한 한 줄.

551
00:25:03,170 --> 00:25:06,830
이 구문을 보았다하지 않을 수 있습니다
전에,하지만 당신은 스타가 동일 말한다면,

552
00:25:06,830 --> 00:25:10,470
이 같은 일을있는 그대로
용량의 2 배를 말하는.

553
00:25:10,470 --> 00:25:13,390
그래서 그냥 배로 유지
버퍼의 용량

554
00:25:13,390 --> 00:25:17,480
다음으로 realloc을 말하고주는
자체 훨씬 더 많은 메모리.

555
00:25:17,480 --> 00:25:19,720
>> 지금과 같은 옆으로,이
여기에 다른 기능은 다음과 같습니다

556
00:25:19,720 --> 00:25:23,680
우리는 어떤 세부 사항으로 보이지 않는 것
의 getInt에 표시하는 것보다 다른,

557
00:25:23,680 --> 00:25:26,150
우리의 getInt로하여 GetString을 사용합니다.

558
00:25:26,150 --> 00:25:28,192
우리는 그렇지 않은 것을 확인
널 (null), 이는 리콜,

559
00:25:28,192 --> 00:25:30,400
특수 값은 그
뭔가 잘못된 것을 의미한다.

560
00:25:30,400 --> 00:25:31,233
우리는 메모리 부족입니다.

561
00:25:31,233 --> 00:25:32,310
더 나은 것을 확인합니다.

562
00:25:32,310 --> 00:25:33,710
그리고 우리는 감시 값을 반환합니다.

563
00:25:33,710 --> 00:25:37,850
하지만 난에 관한 의견을 연기합니다
왜 우리는 scanf와의 사촌을 사용

564
00:25:37,850 --> 00:25:42,100
sscanf를 호출 그것은 밝혀
그 sscanf를, 또는 문자열 scanf와,

565
00:25:42,100 --> 00:25:45,310
당신은 라인을 살펴 수 있다는
사용자가에 입력하고을 할 수있다

566
00:25:45,310 --> 00:25:49,610
본질적를 분석하고 난 무엇을
여기서 뭐 내가 sscanf를 말하고있다,

567
00:25:49,610 --> 00:25:54,440
사용자가 가지고있는 어떤 분석
에 입력하고 확인 %의 난을,

568
00:25:54,440 --> 00:25:59,250
거기에있는 정수이며, 우리 못해
또한 거기에 이유를 정확하게 오늘에 들어가

569
00:25:59,250 --> 00:26:03,760
간단히 말해서 %의 여기에 C,하지만 수 있습니다
사용자가 입력 한 경우 우리는 감지

570
00:26:03,760 --> 00:26:06,050
수 후 가짜 뭔가.

571
00:26:06,050 --> 00:26:11,766
그래서 이유가의 getInt 및하여 GetString
다시 시도, 다시 시도하는 방법을 알려, 다시 시도

572
00:26:11,766 --> 00:26:13,640
때문에 모든입니다
우리가 작성한 코드,

573
00:26:13,640 --> 00:26:17,900
그것은 종류의 사용자의 입력에서 찾고
확인하고 그것을 완전히 숫자이다

574
00:26:17,900 --> 00:26:21,700
또는 실제 떠
포인트 값 등에

575
00:26:21,700 --> 00:26:24,233
어떤 값에 따라
당신이 사용하는 기능을 수행합니다.

576
00:26:24,233 --> 00:26:25,060
>> 휴.

577
00:26:25,060 --> 00:26:25,710
그래.

578
00:26:25,710 --> 00:26:27,592
즉 입이었다
하지만 포인트는 여기

579
00:26:27,592 --> 00:26:29,550
우리가했던 이유
그 훈련 바퀴

580
00:26:29,550 --> 00:26:32,880
때문에 가장 낮은 수준에있다
너무 많은 일이 있다는 것을

581
00:26:32,880 --> 00:26:35,674
우리가 원하는 것을 잘못 될 수
선제 적으로 처리하는

582
00:26:35,674 --> 00:26:38,090
에 확실히 것들
클래스의 초기 주,

583
00:26:38,090 --> 00:26:42,230
하지만 지금은 PSET 사 및 PSET 다섯와
이후 당신은에게 더 볼 것

584
00:26:42,230 --> 00:26:45,570
당신은 또한 당신은 더 할 수있어
의 문제의 그 종류를 해결

585
00:26:45,570 --> 00:26:47,180
자신.

586
00:26:47,180 --> 00:26:51,770
하여 GetString 또는의 getInt에 대한 질문?

587
00:26:51,770 --> 00:26:52,630
그래?

588
00:26:52,630 --> 00:26:55,130
>> 청중 : 왜 당신은 두 번 것
버퍼의 용량

589
00:26:55,130 --> 00:26:57,630
오히려 단지 증가보다
그것은 정확한 양만큼?

590
00:26:57,630 --> 00:26:58,100
>> 데이비드 마란 : 좋은 질문입니다.

591
00:26:58,100 --> 00:27:00,474
왜 우리는 용량을 두 배로 것
버퍼의 반대

592
00:27:00,474 --> 00:27:02,800
그냥 증가에
몇 가지 상수 값으로?

593
00:27:02,800 --> 00:27:03,900
그것은 디자인 결정이었다.

594
00:27:03,900 --> 00:27:08,590
우리는 그냥하는 경향이 있기 때문에 결정
시간적 비용이 조금 물어 수

595
00:27:08,590 --> 00:27:10,440
운영체제
메모리, 우리는하지 않았다

596
00:27:10,440 --> 00:27:13,210
로 점점 종료 할
큰 문자열에 대한 상황

597
00:27:13,210 --> 00:27:14,960
우리는 묻고 있다고
또 다시 OS

598
00:27:14,960 --> 00:27:17,500
다시하고 다시
메모리의 빠른 연속.

599
00:27:17,500 --> 00:27:20,387
그래서 우리는 단지 약간, 결정
임의로 그러나 우리는 합리적으로 희망을,

600
00:27:20,387 --> 00:27:22,720
즉, 당신은,하자 무엇인지
앞서 자신의 가려고

601
00:27:22,720 --> 00:27:25,520
단지 있도록 배로 유지
우리는 시간의 양을 최소화

602
00:27:25,520 --> 00:27:29,010
우리가 malloc에​​ 전화를하거나
realloc을하지만 총 판단

603
00:27:29,010 --> 00:27:31,820
알 수없는 전화
어떤 사용자가 입력 할 수 있습니다.

604
00:27:31,820 --> 00:27:33,600
두 가지 방법이 논란의 여지가있을 수 있습니다.

605
00:27:33,600 --> 00:27:35,430
틀림없이 좋은.

606
00:27:35,430 --> 00:27:39,240
>> 그럼 몇 가지를 살펴 보자
메모리의 다른 부작용,

607
00:27:39,240 --> 00:27:41,610
잘못 될 수있는 것들
및 도구 당신이 할 수있는

608
00:27:41,610 --> 00:27:43,880
실수의 이러한 종류를 잡을 때 사용합니다.

609
00:27:43,880 --> 00:27:47,800
그것은 비록 당신의 모든 밝혀
check50은 당신에게 많은 것을 이야기하지 않았습니다

610
00:27:47,800 --> 00:27:50,050
버그를 쓰고있다
주 한 이후 코드,

611
00:27:50,050 --> 00:27:53,630
심지어 모든 check50 테스트를하는 경우
통과, 그리고 경우에도 당신과 당신의 TF

612
00:27:53,630 --> 00:27:56,010
그 슈퍼 확신
의도 한대로 코드가 작동합니다.

613
00:27:56,010 --> 00:27:59,190
귀하의 코드는 버그가되었거나
당신의 모든에 결함,

614
00:27:59,190 --> 00:28:02,540
CS50 라이브러리를 사용하는데,
메모리가 누수되고있다.

615
00:28:02,540 --> 00:28:06,040
당신은 운영 체제를 물어 봤는데
대부분의 프로그램에서 메모리

616
00:28:06,040 --> 00:28:08,850
당신은 서면으로 작성했습니다,하지만 당신은했습니다
실제로 그것을 다시 주어지지 않는다.

617
00:28:08,850 --> 00:28:12,110
당신하여 GetString라고했습니다
과의 getInt와 GetFloat,

618
00:28:12,110 --> 00:28:15,270
하지만하여 GetString, 당신은했습니다
unGetString 또는 보내기 호출되지 않습니다

619
00:28:15,270 --> 00:28:19,890
문자열 맨 등, 그러나 우리는 보았다
하여 GetString는 메모리를 할당한다는 것을

620
00:28:19,890 --> 00:28:22,810
malloc에​​의 방법 또는이로
그냥 함수 realloc을,

621
00:28:22,810 --> 00:28:25,670
정신에 매우 유사,
그럼에도 불구하고, 우리는 봤는데

622
00:28:25,670 --> 00:28:28,629
운영 체제를 묻는
메모리 및 메모리 또 다시

623
00:28:28,629 --> 00:28:29,670
하지만 다시 제공하지 않습니다.

624
00:28:29,670 --> 00:28:33,550
>> 지금, 옆으로, 그것은 밝혀
프로그램은 메모리를 모두 종료 할 때

625
00:28:33,550 --> 00:28:34,870
자동으로 해제됩니다.

626
00:28:34,870 --> 00:28:36,150
그래서 큰 거래를하지입니다.

627
00:28:36,150 --> 00:28:38,590
그것은 휴식 않을거야
IDE 또는 느린 것 아래로,

628
00:28:38,590 --> 00:28:40,670
하지만 때 프로그램 수행
일반적으로 메모리가 누수

629
00:28:40,670 --> 00:28:42,170
이들은 장시간 동안 실행하고있다.

630
00:28:42,170 --> 00:28:45,640
혹시 바보 거의 본 적이있는 경우
맥 OS 또는 모래 시계에서 비치 볼

631
00:28:45,640 --> 00:28:51,160
Windows에서이 종류의 어디
감속 또는 생각이나 사고

632
00:28:51,160 --> 00:28:53,770
또는 정말 시작
크롤 링을 천천히,

633
00:28:53,770 --> 00:28:56,960
그것은 매우 가능성이 될 수있다
메모리 누수의 결과.

634
00:28:56,960 --> 00:28:59,970
쓴 프로그래머
사용중인 소프트웨어

635
00:28:59,970 --> 00:29:03,570
메모리 운영 체제를 물어
몇 분마다, 매 시간마다.

636
00:29:03,570 --> 00:29:05,570
그러나 실행하는 경우
이 경우에도 소프트웨어,

637
00:29:05,570 --> 00:29:08,680
컴퓨터에 최소화
끝 시간, 일,

638
00:29:08,680 --> 00:29:11,980
당신은 더 많은 요구 될 수 있습니다
메모리와 결코 실제로 그것을 사용

639
00:29:11,980 --> 00:29:15,180
그래서 당신의 코드는, 또는 수
프로그램은 메모리가 누수 될 수 있습니다

640
00:29:15,180 --> 00:29:18,350
당신은 메모리 누수가 시작하면,
다른 프로그램보다 적은 메모리가있다,

641
00:29:18,350 --> 00:29:21,220
및 효과에있다
모든 것을 천천히.

642
00:29:21,220 --> 00:29:23,600
>> 자,이 훨씬 하나입니다
가장 극악한 프로그램

643
00:29:23,600 --> 00:29:26,350
당신은 기회가있을 것이다
CS50에서 실행 한,

644
00:29:26,350 --> 00:29:31,650
출력은보다 더 난해한 그대로
그 소리의 또는의를하거나 명령의

645
00:29:31,650 --> 00:29:35,930
우리가 전에 실행 한 줄 프로그램하지만
다행히도, 그 출력에 포함

646
00:29:35,930 --> 00:29:39,810
일부 슈퍼 유용한 정보입니다
유용 하나 PSET 네이 될 것입니다

647
00:29:39,810 --> 00:29:41,510
또는 확실히 다섯 PSET.

648
00:29:41,510 --> 00:29:44,250
그래서 Valgrind의는 도구입니다
즉 볼 수 있습니다

649
00:29:44,250 --> 00:29:46,930
프로그램에서 메모리 누수.

650
00:29:46,930 --> 00:29:48,570
그것은 실행하기가 비교적 간단합니다.

651
00:29:48,570 --> 00:29:51,420
당신은, Valgrind의 다음 실행
조금 자세한 정보는 비록,

652
00:29:51,420 --> 00:29:54,440
대시 대시 누출 점검
전체에 해당하고 점

653
00:29:54,440 --> 00:29:56,320
슬래시 및 프로그램의 이름입니다.

654
00:29:56,320 --> 00:30:00,010
그래서 Valgrind의 다음 프로그램을 실행합니다
그리고 프로그램의 끝에서

655
00:30:00,010 --> 00:30:02,240
이 종료하기 전에 실행
당신에게 다른 프롬프트를 제공합니다

656
00:30:02,240 --> 00:30:04,980
이 분석거야 당신의
프로그램이 실행 된 것 동안

657
00:30:04,980 --> 00:30:07,740
당신은 당신이 누출 않은 이야기
더 나은 아직 메모리와,

658
00:30:07,740 --> 00:30:10,610
당신은 메모리를 만지지 않았다
당신에 속하지 않았다?

659
00:30:10,610 --> 00:30:13,700
그것은 모든 것을 잡을 수 있지만, 그것은이다
대부분의 물건을 잡기에 꽤 좋은.

660
00:30:13,700 --> 00:30:19,700
>> 그래서 여기 내 가진 실행의 예
이 프로그램을 실행 Valgrind의를 가진,

661
00:30:19,700 --> 00:30:21,470
라는 프로그램에
메모리 및 I는거야

662
00:30:21,470 --> 00:30:24,730
있는 라인을 강조
궁극적으로 우리에게 관심을.

663
00:30:24,730 --> 00:30:27,690
그래서 더 산만있다
나는 슬라이드에서 삭제 한 것을.

664
00:30:27,690 --> 00:30:30,930
하지만 그냥 어떤이를 보자
프로그램은 우리에게 이야기 할 수있다.

665
00:30:30,930 --> 00:30:34,800
그것은 우리에게 일을 이야기 할 수 있어요
크기 4의 잘못된 쓰기 등을들 수있다.

666
00:30:34,800 --> 00:30:38,020
즉, 메모리를 터치하면,
메모리의 구체적 4 바이트

667
00:30:38,020 --> 00:30:40,350
당신은 안된다고,
Valgrind의 당신이 말할 수 있습니다.

668
00:30:40,350 --> 00:30:41,660
크기 4의 잘못된 쓰기.

669
00:30:41,660 --> 00:30:43,640
당신은 4 바이트 감동
당신은 안된다고.

670
00:30:43,640 --> 00:30:44,840
당신은 어디에서 그 짓을 한거야?

671
00:30:44,840 --> 00:30:45,900
이 아름다움입니다.

672
00:30:45,900 --> 00:30:50,000
메모리 도트 C 라인 (21)은 어디입니까
망쳐하고 도움이 이유입니다.

673
00:30:50,000 --> 00:30:53,410
많은 GDB처럼, 그것은 도움이 될 수 있습니다
실제 오류에서 당신을 가리 킵니다.

674
00:30:53,410 --> 00:30:57,170
>> 자,이 사람은 조금 더입니다
자세한 혼란 아니라면.

675
00:30:57,170 --> 00:31:01,307
1 블록에 40 바이트는 확실히 있습니다
손실 기록 (1) (1)에 잃었다.

676
00:31:01,307 --> 00:31:02,140
그게 무슨 뜻 이죠?

677
00:31:02,140 --> 00:31:05,920
글쎄, 그것은 단지 당신이 질문을 의미합니다
40 바이트 그리고 당신은 다시 그것을 포기하지 않았다.

678
00:31:05,920 --> 00:31:08,930
당신은 malloc을 호출하거나 호출
하여 GetString 및 운영체제

679
00:31:08,930 --> 00:31:12,450
당신이 40 바이트,하지만 당신을 결코 포기하지
해제 또는 메모리를 출시,

680
00:31:12,450 --> 00:31:15,400
그리고 공정하게, 우리는 보여 적이
어떻게 메모리를 다시 제공합니다.

681
00:31:15,400 --> 00:31:17,910
슈퍼 거기에 밝혀
간단한 기능은 무료라고합니다.

682
00:31:17,910 --> 00:31:21,170
하나의 인수, 일이 걸린다
당신은 무료 또는 다시주고 싶어

683
00:31:21,170 --> 00:31:23,430
하지만 40 바이트, 분명히,
이 프로그램에

684
00:31:23,430 --> 00:31:27,300
줄에서 손실 된
메모리 (20)는 C 점을 찍는다.

685
00:31:27,300 --> 00:31:28,650
>> 그래서이 프로그램을 보자.

686
00:31:28,650 --> 00:31:31,020
그것은 매우 쓸모.

687
00:31:31,020 --> 00:31:33,980
그것은 단지 보여줍니다
이 특정 오류가 발생했습니다.

688
00:31:33,980 --> 00:31:34,920
그럼 살펴 보자.

689
00:31:34,920 --> 00:31:39,920
여기에 메인 주, 공지, 전화입니다
함수 f를 다음 반환했다.

690
00:31:39,920 --> 00:31:41,550
그래서 모든 재미 있지.

691
00:31:41,550 --> 00:31:42,664
F는 어떤 기능을 수행합니까?

692
00:31:42,664 --> 00:31:44,330
내가 프로토 타입 신경 쓰지 않았다 알 수 있습니다.

693
00:31:44,330 --> 00:31:46,520
나는 코드를 유지하고 싶었
가능한 한 최소한의.

694
00:31:46,520 --> 00:31:49,530
그래서 주 이상 F를 넣어
즉, 확실히, 괜찮아요

695
00:31:49,530 --> 00:31:51,500
이 같은 짧은 프로그램.

696
00:31:51,500 --> 00:31:56,910
그래서 F 아무것도를 반환하지 않습니다
아무것도하지를 가지고 있지만,이 작업을 수행 않습니다.

697
00:31:56,910 --> 00:31:59,620
그것은 많은처럼 선언
빙키의 예에서,

698
00:31:59,620 --> 00:32:02,682
X가라는 포인터는거야
INT의 주소를 저장합니다.

699
00:32:02,682 --> 00:32:03,890
그래서 왼쪽이다.

700
00:32:03,890 --> 00:32:07,230
영어로, 무슨입니다
하고 오른쪽?

701
00:32:07,230 --> 00:32:09,770
누구?

702
00:32:09,770 --> 00:32:13,665
이 우리를 위해 무엇을하고 있는가?

703
00:32:13,665 --> 00:32:14,651
그래?

704
00:32:14,651 --> 00:32:16,623
>> 청중 : [들리지]
시간 INT의 크기

705
00:32:16,623 --> 00:32:19,175
인 10 배 [들림]

706
00:32:19,175 --> 00:32:20,800
데이비드 마란 : 좋은 날이 요약 할 수 있습니다.

707
00:32:20,800 --> 00:32:25,480
그래서 10 정수에 대한 충분한 공간을 할당
10, INT의 크기는 무엇입니까

708
00:32:25,480 --> 00:32:29,340
그것은 4 인 4 바이트이므로 10 배의
40, 나는했습니다 그 오른쪽 그래서

709
00:32:29,340 --> 00:32:33,930
강조는 나에게 40 바이트를 제공하고
첫번째 바이트의 주소를 저장

710
00:32:33,930 --> 00:32:34,940
X에.

711
00:32:34,940 --> 00:32:38,380
그리고 이제 마지막으로, 여기 어디
이 프로그램은 버그가 무엇이야입니다

712
00:32:38,380 --> 00:32:41,540
라인 (21) 문제는 그 논리를 기반으로?

713
00:32:41,540 --> 00:32:45,197

714
00:32:45,197 --> 00:32:46,280
무엇 라인 (21) 잘못?

715
00:32:46,280 --> 00:32:46,780
그래?

716
00:32:46,780 --> 00:32:49,550
청중 : 당신은 할 수 없습니다
[들림] X에 인덱스입니다.

717
00:32:49,550 --> 00:32:50,300
데이비드 마란 : 그래.

718
00:32:50,300 --> 00:32:52,270
나는 그런 X로 인덱스는 안된다.

719
00:32:52,270 --> 00:32:53,850
그래서 구문, 그 괜찮아요.

720
00:32:53,850 --> 00:32:56,990
어떤 좋은 것은 당신처럼 많이있다
어레이의 이름을 치료할 수

721
00:32:56,990 --> 00:33:01,080
것처럼 마찬가지로, 포인터의
그것의 것처럼 당신은 포인터를 처리 할 수

722
00:33:01,080 --> 00:33:06,425
배열, 그리고 나는 구문 수
X 브래킷 뭔가 말, X 브래킷 나는,

723
00:33:06,425 --> 00:33:07,800
그러나도 10은 문제점이있다.

724
00:33:07,800 --> 00:33:09,096
왜?

725
00:33:09,096 --> 00:33:10,910
>> 청중 : 그것은 내부 아니니까.

726
00:33:10,910 --> 00:33:12,390
>> 데이비드 마란 : 그것은 아니에요
메모리의 덩어리 내부.

727
00:33:12,390 --> 00:33:15,306
가장 큰 값은 내가해야이다
그 대괄호로 퍼팅?

728
00:33:15,306 --> 00:33:16,870
9 9 0.

729
00:33:16,870 --> 00:33:18,160
제로 인덱싱 때문에.

730
00:33:18,160 --> 00:33:20,190
그래서 0 ~ 9 괜찮을 것입니다.

731
00:33:20,190 --> 00:33:23,960
브래킷 (10)이 잘되지 않고,
하지만, 때마다 비록 기억

732
00:33:23,960 --> 00:33:27,017
나는 CS50 IDE를 만들려고하는 것
가짜 값을 입력하여 충돌,

733
00:33:27,017 --> 00:33:29,100
항상 협조하지 않습니다
실제로, 당신이 자주

734
00:33:29,100 --> 00:33:31,460
운 얻으려면, 그 때문에
운영 체제는하지 않는다

735
00:33:31,460 --> 00:33:35,467
알 당신 이제까지 약간
일부 메모리 덩어리를 통과,

736
00:33:35,467 --> 00:33:38,300
당신이 기술적으로 내 머물렀다 때문에
당신의 세그먼트하지만, 더 그에

737
00:33:38,300 --> 00:33:40,940
운영체제 클래스,
이 같은 그래서 뭔가

738
00:33:40,940 --> 00:33:43,000
아주 쉽게 발견되지 않을 수 있습니다.

739
00:33:43,000 --> 00:33:48,120
여러분의 프로그램은 결코 충돌 않을 것
일관하지만 어쩌면 한 번 잠시에서.

740
00:33:48,120 --> 00:33:50,610
>> 그리고의는 Valgrind의를 해보자
이에, 그리고 여기

741
00:33:50,610 --> 00:33:52,870
여기서 우리가 압도 할 것이다
순간적으로 산출.

742
00:33:52,870 --> 00:34:00,810
그래서 메모리 Valgrind의 누출 점검을
전체 도트 슬래시 메모리 같습니다.

743
00:34:00,810 --> 00:34:03,040
내가 약속 왜 여기
이 압도한다.

744
00:34:03,040 --> 00:34:05,700
여기에 Valgrind의, 무슨 무슨이다
프로그래머, 몇 년 전 -

745
00:34:05,700 --> 00:34:08,469
그것은 좋은 생각이 될 것이다라고 정했다
같은 출력을 볼위한.

746
00:34:08,469 --> 00:34:09,750
그럼 이것의 의미를 보자.

747
00:34:09,750 --> 00:34:13,120
왼쪽에 그래서 모든 방법
더 좋은 이유 측면

748
00:34:13,120 --> 00:34:16,620
프로그램의 프로세스 ID이다
우리는 단지, 고유 식별자를 실행

749
00:34:16,620 --> 00:34:18,030
프로그램에 우리는 단지 달렸다.

750
00:34:18,030 --> 00:34:19,738
우리는에서 그것을 삭제
슬라이드,하지만이

751
00:34:19,738 --> 00:34:22,190
여기에서 유용한 정보이다.

752
00:34:22,190 --> 00:34:24,684
>> 의는 매우 정상까지 이동하자.

753
00:34:24,684 --> 00:34:25,600
우리가 시작된 곳 여기입니다.

754
00:34:25,600 --> 00:34:27,040
그래서 모든 것을 훨씬 출력이 아니다.

755
00:34:27,040 --> 00:34:30,429
여기에 잘못된 기록이다
라인 21 사이즈 4.

756
00:34:30,429 --> 00:34:31,760
음, 라인 (21)은 무엇입니까?

757
00:34:31,760 --> 00:34:34,500
선 (21)는 정확하게이었다
이과는 의미가 있습니다

758
00:34:34,500 --> 00:34:37,290
나는 유효에있어 것을
난 때문에 4 바이트를 작성

759
00:34:37,290 --> 00:34:40,389
이 정수를 넣어하려고,
이는, 무엇이든 될 수있다

760
00:34:40,389 --> 00:34:42,370
그냥 될 일이
제로,하지만 난 노력하고있어

761
00:34:42,370 --> 00:34:44,940
위치에 그것을 넣어
그 날에 속하지 않습니다.

762
00:34:44,940 --> 00:34:50,900
하나 또한, 여기 아래, 40 바이트
블록은 확실히 기록 1 손실됩니다.

763
00:34:50,900 --> 00:34:56,500
그게 내가 malloc을 호출 할 때 때문이다
여기에, 나는 실제로 메모리를 해제하지 마십시오.

764
00:34:56,500 --> 00:34:58,140
>> 그래서 우리는 어떻게이 문제를 해결할 수 있습니까?

765
00:34:58,140 --> 00:35:02,970
내가 앞서 가자 조금 더 안전 할
거기에 9를하고 여기에 무료 X 날 수 있습니다.

766
00:35:02,970 --> 00:35:04,820
이것은 오늘날의 새로운 기능입니다.

767
00:35:04,820 --> 00:35:11,520
지금 메모리 점 슬래시을 다시 실행하면,
,의 다시에 Valgrind의 실행하자

768
00:35:11,520 --> 00:35:14,990
내 창을 최대화하고 Enter를 누르십시오.

769
00:35:14,990 --> 00:35:16,900
지금, 그것은 좋다.

770
00:35:16,900 --> 00:35:19,590
그들은 좋은 소식을 묻어
이 모든 출력한다.

771
00:35:19,590 --> 00:35:20,810
모든 힙 블록은 무료했다.

772
00:35:20,810 --> 00:35:23,604
우리는 무엇을 힙에 돌아올 것이다
하지만, 누출이 가능합니다.

773
00:35:23,604 --> 00:35:25,520
그래서 이것은 또 다른입니다
당신의 도구 키트 도구

774
00:35:25,520 --> 00:35:30,220
있는 당신을 시작할 수 있습니다
지금 같은 오류를 찾을 수 있습니다.

775
00:35:30,220 --> 00:35:34,532
>> 그러나 보자 무엇
더 잘못 여기에 갈 수 있습니다.

776
00:35:34,532 --> 00:35:38,890
지금의 전환을하자
실제로 문제를 해결.

777
00:35:38,890 --> 00:35:42,440
여담으로,이 해소 경우
혼란 또는 긴장의 조금,

778
00:35:42,440 --> 00:35:43,430
이 지금은 재미있다.

779
00:35:43,430 --> 00:35:46,400

780
00:35:46,400 --> 00:35:46,900
그래.

781
00:35:46,900 --> 00:35:49,040
그건 꽤 좋은입니다.

782
00:35:49,040 --> 00:35:50,890
포인터이기 때문에
주소 및 주소

783
00:35:50,890 --> 00:35:53,098
규칙에 따라 일반적으로
진수 작성.

784
00:35:53,098 --> 00:35:54,650
하, 하,이 지금은 재미있다.

785
00:35:54,650 --> 00:35:58,390
어쨌든, 그래서 지금하자
실제로 문제를 해결한다.

786
00:35:58,390 --> 00:36:00,840
이것은, 슈퍼왔다
슈퍼 지금까지 낮은 수준,

787
00:36:00,840 --> 00:36:03,950
우리는 실제로 유용 할 수 있습니다
이러한 낮은 수준의 세부 사항을 가진 것.

788
00:36:03,950 --> 00:36:06,710
>> 그래서 우리는 몇 주 소개
전 배열의 개념.

789
00:36:06,710 --> 00:36:09,177
배열은 좋은 때문에
그것은 우리의 코드를 정리하기 어렵다

790
00:36:09,177 --> 00:36:11,760
우리가 쓰기 원한다면 때문에
여러 학생들과 함께 프로그램

791
00:36:11,760 --> 00:36:15,270
또는 여러 이름과 주택과
기숙사 및 대학과 그 모든,

792
00:36:15,270 --> 00:36:19,430
우리는 모든 것을 더 저장할 수
깔끔하게 배열의 내부.

793
00:36:19,430 --> 00:36:23,039
하지만 하나의 단점을 제안한다
어레이의 지금까지.

794
00:36:23,039 --> 00:36:26,080
당신은 스스로를 고통 적이 없다하더라도
프로그램에서, 단지 본능적으로,

795
00:36:26,080 --> 00:36:30,870
나쁜 일이 무엇입니까
배열에 대한, 아마?

796
00:36:30,870 --> 00:36:32,337
나는 약간의 속삭임을들을 수 있습니다.

797
00:36:32,337 --> 00:36:34,170
청중 : 그것은 어렵다
크기를 변경합니다.

798
00:36:34,170 --> 00:36:36,128
데이비드 마란 : 그것은 어렵다
크기를 변경합니다.

799
00:36:36,128 --> 00:36:38,660
사용자는 크기를 변경할 수 없다
어레이, 사실, 그 자체

800
00:36:38,660 --> 00:36:43,040
C에서 당신은 다른 배열을 할당 할 수 있습니다,
이전에 이르기까지 모든 이동

801
00:36:43,040 --> 00:36:45,380
이제 새로운, 그리고에
몇 가지 여분의 공간이,

802
00:36:45,380 --> 00:36:47,469
하지만 달라요
자바 나 파이썬 같은 언어

803
00:36:47,469 --> 00:36:49,760
또는 기타 임의의 개수
와 언어 당신의 일부

804
00:36:49,760 --> 00:36:52,070
익숙 할 수있는 곳을
그냥 일을 계속 추가 할 수 있습니다

805
00:36:52,070 --> 00:36:53,930
배열의 마지막에 싫증.

806
00:36:53,930 --> 00:36:57,880
당신의 배열이있을 때
그 크기가 크기 6,,

807
00:36:57,880 --> 00:37:01,970
하고 생각 이전 같은 많은
일정한 크기의 버퍼를 갖는,

808
00:37:01,970 --> 00:37:05,940
당신은 게이트에서 생각해야
어떤 크기 당신이 원하는 무엇입니까?

809
00:37:05,940 --> 00:37:07,880
당신이 너무 큰 것 같아요 경우,
당신은 공간을 낭비하고 있습니다.

810
00:37:07,880 --> 00:37:10,950
당신은 너무 작은 것 같아요 경우를
적어도, 데이터를 저장할 수 없다

811
00:37:10,950 --> 00:37:12,940
더 많은 작업없이.

812
00:37:12,940 --> 00:37:18,180
>> 포인터에 그래서 오늘, 덕분에, 우리는 할 수
함께 우리 자신의 정의를 바느​​질 시작

813
00:37:18,180 --> 00:37:20,989
데이터 구조, 및 예약
사실, 여기에 뭔가

814
00:37:20,989 --> 00:37:23,030
그건 좀 더 본다
언뜻보기에 애매한,

815
00:37:23,030 --> 00:37:26,440
그러나 이것은 우리가 링크 된 전화 할게 무엇인가
목록 및 요약되어의 이름 종류

816
00:37:26,440 --> 00:37:26,940
그것.

817
00:37:26,940 --> 00:37:29,550
그것은에서 번호 목록, 또는
이 경우, 번호 목록,

818
00:37:29,550 --> 00:37:33,480
그러나 어떤 목록 될 수 있지만
그것은 함께 화살표의 방향으로 연결된 것

819
00:37:33,480 --> 00:37:36,380
단지 추측을
어떤 기술과

820
00:37:36,380 --> 00:37:38,310
우리는 할 수있는거야
함께 스티치,

821
00:37:38,310 --> 00:37:42,540
종류의 스레드와 팝콘처럼,
여기리스트 사각형 연결?

822
00:37:42,540 --> 00:37:43,936
그 숫자?

823
00:37:43,936 --> 00:37:45,560
기본 언어 기능은 무엇입니까?

824
00:37:45,560 --> 00:37:46,350
>> 청중 : 포인터.

825
00:37:46,350 --> 00:37:47,308
>> 데이비드 마란 : 포인터.

826
00:37:47,308 --> 00:37:51,700
그래서 이러한 화살표는 각각 여기에 나타냅니다
포인터하거나 주소를 입력합니다.

827
00:37:51,700 --> 00:37:54,590
그래서 다른 말로하면, 내가 원하는 경우
번호의리스트를 저장하는,

828
00:37:54,590 --> 00:37:59,040
내가 원하는 경우 나는 단지 그것을 저장할 수 없습니다
성장하고 축소 할 수있는 기능

829
00:37:59,040 --> 00:38:00,990
배열 내 데이터 구조.

830
00:38:00,990 --> 00:38:03,000
그래서 조금이 필요합니다
더 세련,

831
00:38:03,000 --> 00:38:05,720
하지만이 통지
사진 종류의 제안

832
00:38:05,720 --> 00:38:08,650
당신은 단지 작은 스레드 가지고있는 경우에 그
모든 것을 함께 연결,

833
00:38:08,650 --> 00:38:13,100
아마 공간을 확보하기 위해 그 어려운 일이 아니다
그 사각형의 사이에 두

834
00:38:13,100 --> 00:38:16,750
또는 그 노드의 두 가지로에게 우리는 시작합니다
새 노드에 넣어 그들을 호출,

835
00:38:16,750 --> 00:38:19,547
다음 몇 가지 새로운 스레드, 단지
함께 세 개의 노드 도랑,

836
00:38:19,547 --> 00:38:22,880
처음, 마지막 하나는 하나
당신은 단지 중간에 삽입있다.

837
00:38:22,880 --> 00:38:26,000
>> 그리고 실제로 연결리스트,
배열과는 달리 동적입니다.

838
00:38:26,000 --> 00:38:27,840
그것은 성장할 수 있으며 수
축소 당신은하지 않습니다

839
00:38:27,840 --> 00:38:32,434
알고 있거나 사전 방법에 신경이
많은 데이터 당신이 저장 될거야,

840
00:38:32,434 --> 00:38:35,600
하지만 우리가 조금 있어야 밝혀
이를 구현하는 방법에 대한주의.

841
00:38:35,600 --> 00:38:39,070
그래서 처음의 우리가 구현하는 방법을 살펴 보자
이 작은 사각형 중 하나.

842
00:38:39,070 --> 00:38:40,690
그것은 int를 구현하기 쉽다.

843
00:38:40,690 --> 00:38:44,000
당신은 다음 INT n 및 말
당신은 INT 4 바이트를 얻을,

844
00:38:44,000 --> 00:38:49,089
하지만 int를 얻는 방법, N 호출
다음 포인터,의 옆을 호출 할 수 있습니다.

845
00:38:49,089 --> 00:38:50,880
우리는이를 호출 할 수 있습니다
일 아무것도 우리가 원하는

846
00:38:50,880 --> 00:38:53,590
하지만 사용자 정의 데이터 구조가 필요합니다.

847
00:38:53,590 --> 00:38:54,257
그래?

848
00:38:54,257 --> 00:38:57,020
>> 청중 : 앰퍼샌드 [들림].

849
00:38:57,020 --> 00:39:00,940
>> 데이비드 마란 : 그래서 앰퍼샌드 우리는에 사용
잠재적 노드의 주소를 얻는다.

850
00:39:00,940 --> 00:39:02,740
그러나 우리는 서로를 필요
C의 기능을 위해

851
00:39:02,740 --> 00:39:06,700
저 작성하는 기능을 제공하는
이 사용자 정의 사각형이 사용자 지정

852
00:39:06,700 --> 00:39:08,919
변수는 메모리에,됩니다.

853
00:39:08,919 --> 00:39:09,710
청중 : 구조체.

854
00:39:09,710 --> 00:39:10,626
데이비드 마란 : 구조체.

855
00:39:10,626 --> 00:39:14,310
지난 주부터 기억, 우리는 도입
구조체,이 비교적 간단한 키워드

856
00:39:14,310 --> 00:39:16,254
즉, 우리가 이런 일을 할 수 있습니다.

857
00:39:16,254 --> 00:39:18,420
C는 데이터와 함께 제공되지 않은
구조는 학생이라고합니다.

858
00:39:18,420 --> 00:39:22,190
그것은 INT와 플로트와 문자와 함께 제공
이러한하지만 학생되어 있지 않습니다,

859
00:39:22,190 --> 00:39:26,750
그러나 우리는 학생 데이터 유형을 만들 수 있습니다,
이 구문을 사용하여 학생의 구조,

860
00:39:26,750 --> 00:39:27,250
여기에.

861
00:39:27,250 --> 00:39:28,350
그리고 당신은 또 다시이 표시됩니다.

862
00:39:28,350 --> 00:39:30,426
그래서 걱정하지 마
키워드를 암기,

863
00:39:30,426 --> 00:39:33,300
하지만 중요한 키워드이다
우리가 말한 바로는 사실 구조체

864
00:39:33,300 --> 00:39:37,590
그리고, 우리는 그것을 학생에게 전화를 내부
학생의 이름과 집이었다

865
00:39:37,590 --> 00:39:39,390
기숙사 등 나.

866
00:39:39,390 --> 00:39:41,980
>> 그리고 지금, 오늘의이 제안 할 수 있습니다.

867
00:39:41,980 --> 00:39:45,240
나는 몇 마디를 추가,하지만 내가 원하는 경우했습니다
의이 사각형을 구현하는

868
00:39:45,240 --> 00:39:48,440
INT와 모두를 가지고
포인터, 당신은, 내가 뭘 해요 알고

869
00:39:48,440 --> 00:39:51,540
노드라는 구조체를 선언 할 것.

870
00:39:51,540 --> 00:39:55,630
나는 말을하려고, 그 안에도 해요
노드,이 사각형은 int를 가지고

871
00:39:55,630 --> 00:39:59,730
우리가 전화 할게 n 및
그것은 다음 포인터를 가지고있다.

872
00:39:59,730 --> 00:40:02,540
그리고 이것은, 조금 장황
하지만 당신이 그것에 대해 생각하면,

873
00:40:02,540 --> 00:40:07,300
사진에 있던 화살표
잠시 전에 어떤 데이터 유형입니까?

874
00:40:07,300 --> 00:40:12,330
어디 그 화살표의 각각 가리키는
데이터 구조의 유형에?

875
00:40:12,330 --> 00:40:14,332
그냥 그 자체를 int를 가리키는 아니에요.

876
00:40:14,332 --> 00:40:16,165
그것은을 가리키는 것
전체 직사각형 일

877
00:40:16,165 --> 00:40:18,720
그 직사각형의 것,
우리는 노드라고 말했다.

878
00:40:18,720 --> 00:40:21,720
그래서 우리는 가지에있다
재귀 적으로이 같은 정의

879
00:40:21,720 --> 00:40:26,270
노드, 우리는 말할 것이다
N이라는 INT를 포함합니다

880
00:40:26,270 --> 00:40:31,070
및 포인터는 다음과 호출
데이터 구조의 유형

881
00:40:31,070 --> 00:40:35,770
그 포인터 점이 명백하게
구조체 노드가 될 것.

882
00:40:35,770 --> 00:40:41,550
>> 그래서이 귀찮게 장황
다만, 학자 연하는 할 수

883
00:40:41,550 --> 00:40:44,100
이유는 우리가 할 수 없습니다
다만이 말을, 어떤 솔직히

884
00:40:44,100 --> 00:40:46,860
많이 더 읽기 보인다
리콜 읽고 C가 있기 때문이다

885
00:40:46,860 --> 00:40:48,710
일이 위에서 아래로, 왼쪽에서 오른쪽으로.

886
00:40:48,710 --> 00:40:54,120
우리가 세미콜론을 얻을 때까지이 아니다
키워드 노드가 실제로 존재한다는 것을.

887
00:40:54,120 --> 00:40:57,980
우리는 이런 종류의를 갖고 싶다면
데이터의 내부 순환 참조

888
00:40:57,980 --> 00:41:02,120
구조, 우리는이 작업을 수행해야 할 곳
우리는 정상에서 구조체 노드 말을하는

889
00:41:02,120 --> 00:41:06,770
우리에게이 기술의 긴 방법을 제공합니다
일, 우리가 구조체 노드 말을 한 후 내부,

890
00:41:06,770 --> 00:41:09,560
다음 맨 마지막 줄에
우리 말, 모든 권리, C, 그런데,

891
00:41:09,560 --> 00:41:12,060
그냥이 망할 전화
일 노드 및 중지

892
00:41:12,060 --> 00:41:14,360
모두 키워드 구조체를 사용하여.

893
00:41:14,360 --> 00:41:18,030
그래서 이것은 단지 종류의 구문이다
궁극적으로 우리가 만들 수 있습니다 트릭

894
00:41:18,030 --> 00:41:21,370
정확히처럼 보이는 뭔가.

895
00:41:21,370 --> 00:41:25,010
>> 우리가 지금 가정하면 우리가 할 수있는 그래서
C에서이 일을 구현,

896
00:41:25,010 --> 00:41:28,040
어떻게 실제로 우리가 할
이 이송 시작?

897
00:41:28,040 --> 00:41:32,360
음, 사실, 우리가해야 할 모든입니다
오른쪽으로 그냥 왼쪽에서 반복

898
00:41:32,360 --> 00:41:35,960
종류의 노드를 삽입하거나 노드를 삭제
또는 우리가 원하는 목적지 것들에 대한 검색,

899
00:41:35,960 --> 00:41:39,560
하지만이 작업을 수행하기 위해, 앞서 가서 만들어 보자
일 좀 더 현실이 있기 때문에

900
00:41:39,560 --> 00:41:42,560
지금까지 슈퍼 낮은 수준이었다.

901
00:41:42,560 --> 00:41:45,700
사람은 말 그대로 먼저 하시겠습니까?

902
00:41:45,700 --> 00:41:46,200
그래.

903
00:41:46,200 --> 00:41:47,092
최대 어서.

904
00:41:47,092 --> 00:41:47,800
당신의 이름은 무엇입니까?

905
00:41:47,800 --> 00:41:48,499
>> 데이비드 : 데이비드.

906
00:41:48,499 --> 00:41:49,290
데이비드 마란 : 데이비드.

907
00:41:49,290 --> 00:41:49,998
만나서 반갑습니다.

908
00:41:49,998 --> 00:41:50,960
나도.

909
00:41:50,960 --> 00:41:52,450
괜찮아.

910
00:41:52,450 --> 00:41:53,990
그리고 우리는 숫자 9가 필요합니다.

911
00:41:53,990 --> 00:41:55,240
좋은하지 첫 번째로, 아마.

912
00:41:55,240 --> 00:41:56,430
OK (확인), 수 (9).

913
00:41:56,430 --> 00:41:59,667
숫자 17하시기 바랍니다.

914
00:41:59,667 --> 00:42:01,000
내가 조금 더 멀리 돌아가 보자.

915
00:42:01,000 --> 00:42:03,980
번호 22, 제발, 그리고
얼마나 더 뒤로 약

916
00:42:03,980 --> 00:42:06,344
나는 어떤 손을 볼 수있는 경우
모든 빛 또는 아니오.

917
00:42:06,344 --> 00:42:08,010
누군가가 바로 거기에 자원 봉사를하고있다.

918
00:42:08,010 --> 00:42:08,968
당신은 올 하시겠습니까?

919
00:42:08,968 --> 00:42:10,450
당신의 팔뚝은 강제적으로 올라가고있다.

920
00:42:10,450 --> 00:42:12,340
17 확인.

921
00:42:12,340 --> 00:42:13,690
(22).

922
00:42:13,690 --> 00:42:15,120
26 내려오고있다.

923
00:42:15,120 --> 00:42:18,450
다른 사람이하고 싶습니다
forcefully-- 업 어서.

924
00:42:18,450 --> 00:42:21,030
실제 자원 봉사.

925
00:42:21,030 --> 00:42:23,330
>> 그래서 매우 빠르게, 경우
너희들 준비 할 수

926
00:42:23,330 --> 00:42:26,550
자신은 좋아
화면상의 노드.

927
00:42:26,550 --> 00:42:27,510
고맙습니다.

928
00:42:27,510 --> 00:42:29,234
그리고 당신은 (26)을 수 있습니다.

929
00:42:29,234 --> 00:42:30,650
좋아하고 신속하게 소개.

930
00:42:30,650 --> 00:42:32,139
그래서 다윗 해요 당신은 또한입니까?

931
00:42:32,139 --> 00:42:32,680
데이비드 : 데이비드.

932
00:42:32,680 --> 00:42:33,721
데이비드 마란 : 그리고 당신은?

933
00:42:33,721 --> 00:42:34,229
제이크 : 제이크.

934
00:42:34,229 --> 00:42:34,729
고소 : 고소.

935
00:42:34,729 --> 00:42:35,229
알렉스 : 알렉스.

936
00:42:35,229 --> 00:42:36,475
라파엘 : 라파엘.

937
00:42:36,475 --> 00:42:37,100
테일러 : 테일러.

938
00:42:37,100 --> 00:42:37,466
데이비드 마란 : 테일러.

939
00:42:37,466 --> 00:42:37,590
우수.

940
00:42:37,590 --> 00:42:39,810
그래서 이러한 우리의 자원 봉사자는
오늘날과 진행

941
00:42:39,810 --> 00:42:43,090
그리고, 그런 식으로 조금 이동
그냥 가서 계속

942
00:42:43,090 --> 00:42:47,024
당신이 또는을로 번호를 유지
첫 징후 및 왼손을 사용하여,

943
00:42:47,024 --> 00:42:48,940
가서 그냥 구현
이 화살표, 단지

944
00:42:48,940 --> 00:42:51,360
왼손은 그대로되도록
당신이 가리켜 야 무엇을 가리키는

945
00:42:51,360 --> 00:42:54,610
,과에서하는 것은 자신에게 있기 때문에 약간의 공간을 제공
우리는 시각적으로 실제로 팔을 볼 수 있습니다

946
00:42:54,610 --> 00:42:58,120
포인팅, 당신은 단지 가리킬 수 있습니다
일종의 지상에서 괜찮습니다.

947
00:42:58,120 --> 00:43:03,040
>> 그래서 여기에 우리는 하나의 연결리스트를 가지고
둘, 셋, 넷, 다섯 노드 처음

948
00:43:03,040 --> 00:43:05,860
우리는이 특별한을 알
의 시작 부분에 포인터

949
00:43:05,860 --> 00:43:09,770
키 우리는 추적해야하기 때문에
전체 길이 목록 어떻게 든.

950
00:43:09,770 --> 00:43:13,590
그들이 남겨에도이 녀석,
오른쪽으로, 다시 메모리에 백업하려면

951
00:43:13,590 --> 00:43:15,950
그들은 실제로 어디에서나 할 수 있습니다
컴퓨터 메모리.

952
00:43:15,950 --> 00:43:18,240
그래서이 사람이 될 수있다
무대에 어디 서

953
00:43:18,240 --> 00:43:20,960
그 때문에 그들이있는 한, 괜찮아요
실제로 서로를 가리키는

954
00:43:20,960 --> 00:43:22,770
하지만 물건을 유지하는
깨끗하고 단순한, 우리는거야

955
00:43:22,770 --> 00:43:25,728
단지 그들을 그리는 것은처럼 왼쪽에서 오른쪽
이,하지만 엄청난 차이가있을 수 있습니다

956
00:43:25,728 --> 00:43:26,790
그 노드 사이에서.

957
00:43:26,790 --> 00:43:30,710
>> 지금, 나는 실제로 몇 가지를 삽입 할 경우
새 값의이 가서 이렇게하자.

958
00:43:30,710 --> 00:43:33,720
우리는 지금 기회를
다른 노드를 선택합니다.

959
00:43:33,720 --> 00:43:39,820
의 55 mallocing로 시작하자 말.

960
00:43:39,820 --> 00:43:41,320
누군가가 malloc에​​있는시겠습니까?

961
00:43:41,320 --> 00:43:42,280
OK (확인), 최대 어서.

962
00:43:42,280 --> 00:43:42,992
당신의 이름은 무엇입니까?

963
00:43:42,992 --> 00:43:43,700
레인보우 : 무지개.

964
00:43:43,700 --> 00:43:44,050
데이비드 마란 : 무지개?

965
00:43:44,050 --> 00:43:44,810
괜찮아.

966
00:43:44,810 --> 00:43:46,600
malloc에​​ 무지개입니다.

967
00:43:46,600 --> 00:43:47,450
최대 어서.

968
00:43:47,450 --> 00:43:51,610
이제 우리는 우리 자신에게 물어
알고리즘 우리는 (55)를 넣을 수있는 곳.

969
00:43:51,610 --> 00:43:53,610
그래서 우리 모두는 알고있다,
물론, 여기서 그녀 아마

970
00:43:53,610 --> 00:43:55,401
우리가하려고하는 경우에 속한다
이 정렬 유지

971
00:43:55,401 --> 00:43:58,299
그리고 너희들은 하나를 수행 할 수 있다면
한 걸음 뒤로 물러나 그래서 우리는 떨어지지 않습니다

972
00:43:58,299 --> 00:43:59,590
단계, 즉 좋은 것입니다.

973
00:43:59,590 --> 00:44:01,420
그래서 실제로, 레인보우,
여기에 나와 함께 시작,

974
00:44:01,420 --> 00:44:04,200
때문에 우리가 지금 할 수있는 컴퓨터와
한 번에 하나의 변수를 참조.

975
00:44:04,200 --> 00:44:05,190
이 첫 번째 노드의 경우 그래서.

976
00:44:05,190 --> 00:44:07,160
그는 노드 아니다 주목
그는 단지 포인터의

977
00:44:07,160 --> 00:44:10,270
그가로 그려 이유입니다
포인터의 크기 만이 아니라

978
00:44:10,270 --> 00:44:11,780
그 전체 사각형 중 하나.

979
00:44:11,780 --> 00:44:16,650
그래서 우리는 각각의 체크거야
반복은 9 55 이하?

980
00:44:16,650 --> 00:44:17,150
아니.

981
00:44:17,150 --> 00:44:19,060
17 이상 55 이하인가?

982
00:44:19,060 --> 00:44:19,720
아니.

983
00:44:19,720 --> 00:44:20,800
22 미만?

984
00:44:20,800 --> 00:44:22,020
26 미만?

985
00:44:22,020 --> 00:44:23,390
34 미만?

986
00:44:23,390 --> 00:44:25,890
그리고 지금, 분명히
레인보우 단부에 속한다.

987
00:44:25,890 --> 00:44:27,270
그래서 명확하게하고, 무엇을
당신의 이름, 테일러이었다?

988
00:44:27,270 --> 00:44:27,895
>> 테일러 : 테일러.

989
00:44:27,895 --> 00:44:32,510
데이비드 마란 : 테일러의 사이에 그래서
왼쪽 손과 여기에 레인보우의 손,

990
00:44:32,510 --> 00:44:38,324
누구의 손에 무엇을 가리 키도록해야합니다
이 목록에 (55)를 삽입 주문?

991
00:44:38,324 --> 00:44:39,240
우리는 무엇을 어떻게해야합니까?

992
00:44:39,240 --> 00:44:39,700
그래?

993
00:44:39,700 --> 00:44:41,140
>> 청중 : 테일러의 손
왼쪽을 가리 키도록해야합니다.

994
00:44:41,140 --> 00:44:41,680
>> 데이비드 마란 : 맞아요.

995
00:44:41,680 --> 00:44:43,800
따라서 노드를 삽입
리스트의 끝으로

996
00:44:43,800 --> 00:44:47,140
아주 간단하기 때문에 테일러 단지
지상에서 대신에, 가리가

997
00:44:47,140 --> 00:44:49,640
또는 우리는 널 (null)를 호출합니다
null가 부재의 일종이다

998
00:44:49,640 --> 00:44:51,640
포인터 나 특수의
제로 포인터, 당신이있어

999
00:44:51,640 --> 00:44:53,740
왼쪽으로 가리려고
손 무지개와 다음 레인보우에서,

1000
00:44:53,740 --> 00:44:55,910
어디는 왼쪽을해야
손은 아마 가리?

1001
00:44:55,910 --> 00:44:56,570
아래로.

1002
00:44:56,570 --> 00:45:00,140
그녀의 손이 종류의 경우는 좋지 않다
여기에 또는 종류의 오프 가리키는

1003
00:45:00,140 --> 00:45:00,640
어떤 방법으로.

1004
00:45:00,640 --> 00:45:02,407
즉 간주 될
쓰레기 값,

1005
00:45:02,407 --> 00:45:04,240
하지만 그녀가 가리키는 경우
몇 가지 알려진 값, 우리는거야

1006
00:45:04,240 --> 00:45:07,360
제로 또는 널 (null)를 호출, 그 괜찮아요
우리는이에 기간을 가지고 있기 때문에

1007
00:45:07,360 --> 00:45:09,390
우리는 목록이 완료 알고있다.

1008
00:45:09,390 --> 00:45:11,550
>> 그렇다면 다른 사람의
비교적 간단한 경우?

1009
00:45:11,550 --> 00:45:13,125
우리는 5 malloc을 수 있을까요?

1010
00:45:13,125 --> 00:45:14,010
최대 어서.

1011
00:45:14,010 --> 00:45:14,782
당신의 이름은 무엇입니까?

1012
00:45:14,782 --> 00:45:15,490
티파니 : 티파니.

1013
00:45:15,490 --> 00:45:16,000
데이비드 마란 : 미안 해요?

1014
00:45:16,000 --> 00:45:16,470
티파니 : 티파니.

1015
00:45:16,470 --> 00:45:16,880
데이비드 마란 : 티파니.

1016
00:45:16,880 --> 00:45:17,110
괜찮아.

1017
00:45:17,110 --> 00:45:19,071
티파니는 malloc으로 할당 된
값 5.

1018
00:45:19,071 --> 00:45:19,570
최대 어서.

1019
00:45:19,570 --> 00:45:23,820
이 하나, 너무 비교적 쉽게하지만,
의 현재 작업의 순서를 생각해 보자.

1020
00:45:23,820 --> 00:45:25,820
그것은 꽤 쉬웠다
끝에 테일러와.

1021
00:45:25,820 --> 00:45:30,302
번호 5, 9 코스 미만이며
그래서 우리는 우리가 티파니를, 다윗이

1022
00:45:30,302 --> 00:45:31,260
당신의 이름은 무엇입니까?

1023
00:45:31,260 --> 00:45:31,680
>> 제이크 : 제이크.

1024
00:45:31,680 --> 00:45:32,470
>> 데이비드 마란 : 제이크.

1025
00:45:32,470 --> 00:45:34,300
티파니, 제이크, 데이비드.

1026
00:45:34,300 --> 00:45:36,580
누구의 손이 먼저 업데이트해야합니까?

1027
00:45:36,580 --> 00:45:39,260

1028
00:45:39,260 --> 00:45:40,590
당신은 여기에 수행 할 수 있습니까?

1029
00:45:40,590 --> 00:45:45,244
몇 가지 방법이 있습니다 만
하나 이상의 잘못된 방법도 있습니다.

1030
00:45:45,244 --> 00:45:46,620
>> 청중 : 왼쪽 시작합니다.

1031
00:45:46,620 --> 00:45:47,800
>> 데이비드 마란은 : 왼쪽 시작합니다.

1032
00:45:47,800 --> 00:45:49,008
누가 여기에 왼쪽있어?

1033
00:45:49,008 --> 00:45:49,700
청중 : 첫째.

1034
00:45:49,700 --> 00:45:50,366
>> 데이비드 마란 : OK.

1035
00:45:50,366 --> 00:45:53,781
그래서 처음으로 시작하고 어디에서 할
다윗의 손으로 업데이트 할?

1036
00:45:53,781 --> 00:45:54,780
청중 : 5쪽으로.

1037
00:45:54,780 --> 00:45:55,446
데이비드 마란 : OK.

1038
00:45:55,446 --> 00:45:59,026
다섯에서 다윗, 포인트
또는 티파니 여기, 지금?

1039
00:45:59,026 --> 00:46:01,072
>> 청중 : 티파니는 9 점?

1040
00:46:01,072 --> 00:46:04,030
데이비드 마란 : 완벽한, 빙키의 제외
머리는 종류의 오른쪽 떨어졌다?

1041
00:46:04,030 --> 00:46:06,820
뭐가 잘못 때문에
말 그대로이 그림?

1042
00:46:06,820 --> 00:46:08,070
청중 : 아무것도 가리키는되지 않습니다.

1043
00:46:08,070 --> 00:46:09,945
데이비드 마란 : 아무것도 없다
지금은 제이크를 가리키는.

1044
00:46:09,945 --> 00:46:13,360
우리는 문자 그대로 9 고아했습니다
17, 우리는 문자 그대로했습니다

1045
00:46:13,360 --> 00:46:18,450
이 모든 메모리를 유출로 인해
먼저 다윗의 손을 업데이트, 그건

1046
00:46:18,450 --> 00:46:21,660
제대로의로 한, 좋은
지금 티파니에서 가리키는

1047
00:46:21,660 --> 00:46:25,410
하지만 아무도 없었다 경우
제이크 가리 키도록 선견,

1048
00:46:25,410 --> 00:46:27,490
우리가 잃어 버렸어요
그 목록의 전체.

1049
00:46:27,490 --> 00:46:28,200
그럼 취소 할 수 있습니다.

1050
00:46:28,200 --> 00:46:30,950
그래서 좋은 일에 있었다
걸려 넘어 그러나의 지금 해결 할 수 있습니다.

1051
00:46:30,950 --> 00:46:33,624
우리는 처음으로 대신해야합니까?

1052
00:46:33,624 --> 00:46:34,124
그래?

1053
00:46:34,124 --> 00:46:35,791
>> 청중 : 티파니가 9시를 가리켜 야?

1054
00:46:35,791 --> 00:46:37,582
데이비드 마란 : 나는 할 수 없습니다
당신이 가까이 얻을.

1055
00:46:37,582 --> 00:46:38,720
9시에 누구를 가리켜 야?

1056
00:46:38,720 --> 00:46:39,220
>> 청중 : 티파니.

1057
00:46:39,220 --> 00:46:39,390
>> 데이비드 마란 : 좋아.

1058
00:46:39,390 --> 00:46:41,200
그래서 티파니는 9에서 첫 번째 포인트는해야한다.

1059
00:46:41,200 --> 00:46:43,550
그래서 티파니해야
동일한 값에

1060
00:46:43,550 --> 00:46:45,820
다윗에게, 어떤 보인다
잠시 중복,

1061
00:46:45,820 --> 00:46:48,820
하지만 두 번째, 때문에 지금은 괜찮아요
단계, 우리는 다윗의 손을 업데이트 할 수 있습니다

1062
00:46:48,820 --> 00:46:52,680
티파니에서, 다음의 경우를 가리 키도록
우리 단지 종류의 청소 일까지

1063
00:46:52,680 --> 00:46:55,740
이 봄과 같은 종류 인 것처럼,
지금은 정확한 삽입합니다.

1064
00:46:55,740 --> 00:46:56,700
그래서 우수한.

1065
00:46:56,700 --> 00:46:57,970
그래서 지금 우리는 거의 다 왔어.

1066
00:46:57,970 --> 00:47:01,075
이제 마지막을 삽입하자
값 (20)와 같은 값.

1067
00:47:01,075 --> 00:47:03,010
우리는 마지막으로 자원 봉사를 malloc을 할 수 있다면?

1068
00:47:03,010 --> 00:47:04,140
최대 어서.

1069
00:47:04,140 --> 00:47:06,224
그래서이 사람은 좀 더 까다로운.

1070
00:47:06,224 --> 00:47:08,390
하지만 실제로는, 코드 우리는있어
서면, 구두이기는하지만,

1071
00:47:08,390 --> 00:47:10,610
다만 무리를하는 것과 같다
지금 조건, 권리 경우?

1072
00:47:10,610 --> 00:47:12,318
우리는 조건을 가지고 있었다
속해 있다면 검사

1073
00:47:12,318 --> 00:47:13,840
결국, 아마 처음에.

1074
00:47:13,840 --> 00:47:15,940
우리는 루프의 어떤 종류에 필요
중간에 자리를 찾을 수 있습니다.

1075
00:47:15,940 --> 00:47:17,400
그럼 당신의 이름을 무엇으로 그렇게 할 수 있습니다?

1076
00:47:17,400 --> 00:47:17,700
>> 에릭 : 에릭.

1077
00:47:17,700 --> 00:47:18,340
>> 데이비드 마란 : 에릭?

1078
00:47:18,340 --> 00:47:18,660
에릭.

1079
00:47:18,660 --> 00:47:19,368
만나서 반갑습니다.

1080
00:47:19,368 --> 00:47:20,490
그래서 우리는 (20)이있다.

1081
00:47:20,490 --> 00:47:21,220
다섯 미만?

1082
00:47:21,220 --> 00:47:21,530
아니.

1083
00:47:21,530 --> 00:47:22,160
아홉 미만?

1084
00:47:22,160 --> 00:47:22,410
아니.

1085
00:47:22,410 --> 00:47:23,050
17 미만?

1086
00:47:23,050 --> 00:47:23,550
아니.

1087
00:47:23,550 --> 00:47:23,740
그래.

1088
00:47:23,740 --> 00:47:25,701
그는 여기에 속하고
당신의 이름은 다시입니까?

1089
00:47:25,701 --> 00:47:26,200
고소 : 고소.

1090
00:47:26,200 --> 00:47:26,880
데이비드 마란 : 고소.

1091
00:47:26,880 --> 00:47:27,379
알렉스 : 알렉스.

1092
00:47:27,379 --> 00:47:28,790
데이비드 마란 : 슈, 알렉스, 그리고?

1093
00:47:28,790 --> 00:47:29,290
에릭 : 에릭.

1094
00:47:29,290 --> 00:47:30,120
데이비드 마란 : 에릭.

1095
00:47:30,120 --> 00:47:32,140
누구의 손을 먼저 업데이트하는 데 필요한?

1096
00:47:32,140 --> 00:47:32,930
>> 청중 : 에릭.

1097
00:47:32,930 --> 00:47:33,429
그래.

1098
00:47:33,429 --> 00:47:35,200
그래서 에릭의이 곳을 가리켜 야?

1099
00:47:35,200 --> 00:47:35,930
22.

1100
00:47:35,930 --> 00:47:36,430
좋다.

1101
00:47:36,430 --> 00:47:38,180
이제 다음은 뭐지?

1102
00:47:38,180 --> 00:47:40,800
고소는 에릭에 가리킬 수 있습니다
지금, 만약 너희들 단지

1103
00:47:40,800 --> 00:47:44,077
괜찮 일부 공간을 만들
시각적으로, 지금 우리는 삽입을했습니다.

1104
00:47:44,077 --> 00:47:47,160
그럼 이제 질문을 생각해 보자하지만,
자원 봉사자 주셔서 정말 감사합니다.

1105
00:47:47,160 --> 00:47:48,090
아주 잘.

1106
00:47:48,090 --> 00:47:50,831
만약 당신이 좋아하면, 당신은 사람들을 유지할 수 있습니다.

1107
00:47:50,831 --> 00:47:54,140
그리고 우리는 사랑스러운 이별 선물하는 경우가
각 스트레스 볼을하고 싶습니다.

1108
00:47:54,140 --> 00:47:56,030
나 그냥이를 통과 할 수 있습니다.

1109
00:47:56,030 --> 00:47:58,430
그래서이의 테이크 아웃은 무엇인가?

1110
00:47:58,430 --> 00:48:02,430
이 놀라운 것 같다
우리가 지금해야하는 한

1111
00:48:02,430 --> 00:48:06,360
대안으로 도입
그래서 국한되지 않은 배열

1112
00:48:06,360 --> 00:48:07,780
일부 고정 된 크기의 배열.

1113
00:48:07,780 --> 00:48:09,380
그들은 동적으로 증가 할 수 있습니다.

1114
00:48:09,380 --> 00:48:13,220
>> 그러나 우리와 같은 많은 주 동안 검색된
과거, 우리는 무료로 아무것도 얻을 수 없다

1115
00:48:13,220 --> 00:48:15,740
같은 확실히 여기에 트레이드 - 오프 (trade-off)이있다.

1116
00:48:15,740 --> 00:48:18,890
링크의 상승에 따라서
목록이 동력은?

1117
00:48:18,890 --> 00:48:21,590
이 기능은, 솔직히 성장하는
우리는 삭제 할 수 있었다

1118
00:48:21,590 --> 00:48:23,570
필요에 따라 우리는 줄어들 수있다.

1119
00:48:23,570 --> 00:48:24,710
우리는 무엇 가격을 지불하고있다?

1120
00:48:24,710 --> 00:48:28,510

1121
00:48:28,510 --> 00:48:30,340
두 번 모두의 많은 공간, 같은.

1122
00:48:30,340 --> 00:48:34,010
당신이 사진을 보면, 더 이상
오전 I는 정수의 목록을 저장하는 단계를 포함한다.

1123
00:48:34,010 --> 00:48:36,740
난의리스트를 저장하고있어
정수 플러스 포인터.

1124
00:48:36,740 --> 00:48:38,240
그래서 공간의 양을 두 배로하고 있습니다.

1125
00:48:38,240 --> 00:48:40,740
지금, 어쩌면는 아니다
큰 문제가 4 바이트, 8 바이트,

1126
00:48:40,740 --> 00:48:43,160
그러나 그것은 확실히 추가 할 수 있습니다
대용량 데이터 세트에 대한 최대.

1127
00:48:43,160 --> 00:48:45,570
또 다른 단점은 무엇입니까?

1128
00:48:45,570 --> 00:48:46,070
그래?

1129
00:48:46,070 --> 00:48:48,010
>> 청중 : 우리는해야
그들에게 하나씩을 통과.

1130
00:48:48,010 --> 00:48:48,760
데이비드 마란 : 그래.

1131
00:48:48,760 --> 00:48:50,260
우리는 그들에게 하나씩을 통과해야합니다.

1132
00:48:50,260 --> 00:48:53,860
당신은 우리가 최고를 준 것을 알고있다
대괄호의 편리한 기능

1133
00:48:53,860 --> 00:48:57,240
표기법, 더 제대로
랜덤 액세스라고도

1134
00:48:57,240 --> 00:48:59,280
우리는 점프 할 수있는
개별 요소에

1135
00:48:59,280 --> 00:49:01,470
하지만 지금은 아직이 있다면
여기 내 자원 봉사자,

1136
00:49:01,470 --> 00:49:04,660
나는를 찾기 위해 원하는 경우
수 (22), 난 그냥 수 없습니다

1137
00:49:04,660 --> 00:49:06,620
브래킷 뭔가 뭔가로 이동합니다.

1138
00:49:06,620 --> 00:49:10,530
나는 많은,리스트를 볼 필요가
선형 우리의 검색의 예처럼,

1139
00:49:10,530 --> 00:49:12,260
숫자 22를 찾을 수 있습니다.

1140
00:49:12,260 --> 00:49:14,340
그래서 우리는이 가격을 지불 한 것으로 보인다.

1141
00:49:14,340 --> 00:49:16,430
그러나 우리는 그럼에도 불구하고 수
다른 문제를 해결한다.

1142
00:49:16,430 --> 00:49:18,587
>> 사실, 나를 소개하자
영상 단지 몇.

1143
00:49:18,587 --> 00:49:20,920
당신이 아래에 간 적이 있다면
메이의 식당 최근,

1144
00:49:20,920 --> 00:49:23,320
당신은 리콜합니다 그들의
이 같은 트레이의 스택,

1145
00:49:23,320 --> 00:49:26,300
우리는에서 이러한 빌려
수업 전에 애넌 버그.

1146
00:49:26,300 --> 00:49:28,930
그래서 트레이의 스택하지만,
담당자가 실제로

1147
00:49:28,930 --> 00:49:30,860
컴퓨터 과학 데이터 구조.

1148
00:49:30,860 --> 00:49:32,910
데이터 구조가
컴퓨터 과학

1149
00:49:32,910 --> 00:49:38,010
스택으로 알려져있는 아주 멋지게
바로이 시각에 빌려 준다.

1150
00:49:38,010 --> 00:49:41,380
이러한 트레이 각각은 아닌 경우 그래서
트레이하지만 숫자와 같은 내가 원

1151
00:49:41,380 --> 00:49:45,010
번호를 저장하기 위해, 나는
여기에 아래로 둘 수 있었다,

1152
00:49:45,010 --> 00:49:48,320
나는, 여기에 또 다른을 넣을 수
숫자를 쌓아 계속

1153
00:49:48,320 --> 00:49:53,180
서로, 그리고 무엇의 위에
이것에 대해 잠재적으로 도움이

1154
00:49:53,180 --> 00:49:55,450
무슨 의미라는 것이다
이 데이터 구조의?

1155
00:49:55,450 --> 00:49:58,045
내가 꺼내 수있는 수
먼저 가장 편리?

1156
00:49:58,045 --> 00:50:00,640

1157
00:50:00,640 --> 00:50:03,030
거기에 가장 최근에 하나 넣어.

1158
00:50:03,030 --> 00:50:06,430
>> 그래서 이것은 우리가 전화를 할 것입니다
컴퓨터 과학 LIFO 데이터 구조.

1159
00:50:06,430 --> 00:50:08,070
, 첫 번째 아웃 지속됩니다.

1160
00:50:08,070 --> 00:50:10,800
그리고 우리는 긴 이유 전에 볼 수 있습니다
즉, 지금은 유용하지만이 될 수 있습니다

1161
00:50:10,800 --> 00:50:12,200
단지 특성을 고려한다.

1162
00:50:12,200 --> 00:50:15,158
당신이 생각하는 경우 그리고 그것은 종류의 바보
식당이 그것을 수행하는 방법에 대한.

1163
00:50:15,158 --> 00:50:17,910
때마다 그들은 깨끗한 트레이 및
위에 신선한 것들을 넣어,

1164
00:50:17,910 --> 00:50:22,160
당신은 이전에 청소를 할 수
하지만 결국 매우 더러운 먼지 투성이

1165
00:50:22,160 --> 00:50:24,360
매우 하단에 트레이
당신이 경우 결코 실제로

1166
00:50:24,360 --> 00:50:26,820
그 하단에 도착
스택, 당신 때문에 단지

1167
00:50:26,820 --> 00:50:29,380
새로운 퍼팅 유지
그 위에 깨끗한 것.

1168
00:50:29,380 --> 00:50:31,840
같은 일이 일어날 수
슈퍼마켓에서 너무.

1169
00:50:31,840 --> 00:50:35,450
는 디스플레이 케이스가 있다면
우유와마다 CVS의

1170
00:50:35,450 --> 00:50:37,610
이상의 우유를 얻을 누구든지,
당신은 단지 우유를 밀어

1171
00:50:37,610 --> 00:50:39,880
이미 다시해야하고
당신은, 정면 새로 넣어

1172
00:50:39,880 --> 00:50:43,088
당신은 꽤 불쾌한을 할 겁니다
데이터 구조의 끝에서 우유

1173
00:50:43,088 --> 00:50:46,390
이 하단에 항상 있기 때문에 또는
동등 그것은 뒤에 항상.

1174
00:50:46,390 --> 00:50:50,407
>> 그러나 생각하는 또 다른 방법이있다
데이터 및 예를 들어,이 일렬.

1175
00:50:50,407 --> 00:50:53,490
당신이 그 사람들 중 하나라면 누가 좋아
애플 매장 밖에서 줄을

1176
00:50:53,490 --> 00:50:55,610
때 새 제품이 온다
아웃, 당신은 아마있어

1177
00:50:55,610 --> 00:50:58,780
스택 데이터를 사용하지
구조 당신 때문에

1178
00:50:58,780 --> 00:51:03,070
모든 사람이 다른 사람이 멀리 것
안감은 새로운 장난감을 구입.

1179
00:51:03,070 --> 00:51:06,610
오히려, 당신은 아마 사용하고
데이터 구조의 어떤

1180
00:51:06,610 --> 00:51:10,050
시스템의 또는 어떤 종류의
현실 세계에서?

1181
00:51:10,050 --> 00:51:13,493
잘하면 라인, 또는 더욱
제대로 이상의 영국과 같은, 큐.

1182
00:51:13,493 --> 00:51:17,700
그리고 큐도있다 밝혀
컴퓨터 과학 데이터 구조,

1183
00:51:17,700 --> 00:51:19,700
그러나 큐를 가지고 매우
다른 속성입니다.

1184
00:51:19,700 --> 00:51:20,820
그것은 LIFO 아니다.

1185
00:51:20,820 --> 00:51:21,990
, 첫 번째 아웃 지속됩니다.

1186
00:51:21,990 --> 00:51:22,800
신 금지.

1187
00:51:22,800 --> 00:51:24,280
대신 FIFO이다.

1188
00:51:24,280 --> 00:51:26,110
먼저 첫 번째 출력,.

1189
00:51:26,110 --> 00:51:27,970
그리고 그것은 좋은 일
공정성 '을 위해

1190
00:51:27,970 --> 00:51:30,428
확실히 때 안감있어
아침에 슈퍼 초.

1191
00:51:30,428 --> 00:51:33,400
당신은, 당신이 먼저 거기에 도착하면
첫 번째로 잘 싶어.

1192
00:51:33,400 --> 00:51:35,880
>> 그리고 이러한 모든 데이터
구조, 큐와 스택

1193
00:51:35,880 --> 00:51:39,220
다른 사람의 움큼, 당신 밝혀
이처럼 배열을 생각할 수 있습니다.

1194
00:51:39,220 --> 00:51:41,820
이것은 어쩌면, 배열
고정 크기 4 있지만 좋겠

1195
00:51:41,820 --> 00:51:44,990
우리가 쌓아 수 있다면 가지 좋은
트레이 거의 무한히 높은 우리의 경우

1196
00:51:44,990 --> 00:51:46,780
많은 트레이 또는 숫자가 있습니다.

1197
00:51:46,780 --> 00:51:48,840
그래서 어쩌면 우리가 원하는
여기에 링크 된 목록을 사용하여,

1198
00:51:48,840 --> 00:51:51,800
하지만 트레이드 오프가 될 것입니다
잠재적으로 우리가 더 많은 메모리를 필요,

1199
00:51:51,800 --> 00:51:55,930
좀 더 시간이 필요하지만, 우리
스택의 높이를 제한하는 것은 아니다,

1200
00:51:55,930 --> 00:51:59,550
많은 메이의 디스플레이 케이스 등
스택의 크기를 제한 할 수있다,

1201
00:51:59,550 --> 00:52:03,117
그래서 이러한 디자인 결정 또는이다
궁극적으로 우리에게 사용할 수있는 옵션.

1202
00:52:03,117 --> 00:52:04,950
이러한 데이터 그래서
구조, 우리는 시작했습니다

1203
00:52:04,950 --> 00:52:09,360
잠재적으로 새로운 상한을보고
무엇에 이전에 슈퍼 빠른했다

1204
00:52:09,360 --> 00:52:11,260
우리는 떠나 볼 수있는 곳
오프 오늘 어디

1205
00:52:11,260 --> 00:52:13,200
우리는에 도착 희망합니다
수요일에, 우리는거야

1206
00:52:13,200 --> 00:52:15,740
데이터를보고 시작
우리가 검색 할 수 있습니다 구조

1207
00:52:15,740 --> 00:52:18,260
로그 종료 시각 데이터를 통해 다시.

1208
00:52:18,260 --> 00:52:21,470
그리고 우리는 주 제로에, 기억, 보았다
이진 검색 또는 분할과 하나

1209
00:52:21,470 --> 00:52:22,180
정복.

1210
00:52:22,180 --> 00:52:26,240
그것은 아직 다시 더 나은오고
이 수요일 성배

1211
00:52:26,240 --> 00:52:29,510
을 마련하는 것
진정으로 실행 데이터 구조

1212
00:52:29,510 --> 00:52:32,070
또는 이론적에서
일정 시간, 이에

1213
00:52:32,070 --> 00:52:34,760
그것은 얼마나 많은 문제가되지 않습니다
수백만 또는 사물의 수십억

1214
00:52:34,760 --> 00:52:38,470
우리는 데이터 구조 내에 가지고, 윌
우리에게 일정한 시간을, 어쩌면 한 단계

1215
00:52:38,470 --> 00:52:41,387
단계 또는 2 단계 또는 제 10 단계,
그러나 단계의 일정 번호

1216
00:52:41,387 --> 00:52:42,970
해당 데이터 구조를 통해 검색 할 수 있습니다.

1217
00:52:42,970 --> 00:52:46,300
즉 실제로 성배 될 것입니다
하지만 수요일에 해당에 대한 자세한.

1218
00:52:46,300 --> 00:52:49,045
다음 나중에 참조하십시오.

1219
00:52:49,045 --> 00:52:53,704
>> [음악 재생]

1220
00:52:53,704 --> 00:56:08,448