1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [주 4]

2
00:00:03,000 --> 00:00:05,000
[데이비드 J. Malan] [하버드 대학]

3
00:00:05,000 --> 00:00:08,000
[이 CS50 수 있습니다.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> , 좋아, 이쪽은 CS50이며,이 주 (4)의 시작입니다

5
00:00:12,000 --> 00:00:16,000
이는 가장 느린 가능한 정렬 알고리즘 중 하나입니다.

6
00:00:16,000 --> 00:00:19,000
어떤 사람은 우리가 그냥 본 것을 해?

7
00:00:19,000 --> 00:00:24,000
즉, (N ^ 2) + 합계 큰 O 위해, 버블 정렬했습니다

8
00:00:24,000 --> 00:00:28,000
그리고 실제로 우리가 아는 것 할 수이 세상에서 유일한 사람 아닙니다

9
00:00:28,000 --> 00:00:30,000
어떤 버블 정렬은 또는 실행 시간.

10
00:00:30,000 --> 00:00:33,000
사실,이 Google의 에릭 슈미트 (Eric Sc​​hmidt)과 인터뷰

11
00:00:33,000 --> 00:00:45,000
그리고 전 상원 의원이 버락 오바마 대통령 불과 몇 년 전에.

12
00:00:45,000 --> 00:00:48,000
>> 지금, 상원 의원, 당신은 Google에 당신

13
00:00:48,000 --> 00:00:54,000
나는 면접으로 대통령을 생각하는 거지.

14
00:00:54,000 --> 00:00:58,000
이제 대통령으로 일을하기는 어렵지만, 당신은 지금 엄격함을거야.

15
00:00:58,000 --> 00:01:00,000
그것은 Google에서 일을하는 것도 어렵습니다.

16
00:01:00,000 --> 00:01:05,000
, 우리는 질문이 있고, 우리는 후보자의 질문

17
00:01:05,000 --> 00:01:10,000
이 하나는 래리 Schwimmer에서입니다.

18
00:01:10,000 --> 00:01:14,000
너희들이 내가 장난 치는 거 같냐? 바로 여기.

19
00:01:14,000 --> 00:01:18,000
만 32 비트 정수를 정렬 할 수있는 가장 효율적인 방법은 무엇입니까?

20
00:01:18,000 --> 00:01:21,000
[웃음]

21
00:01:21,000 --> 00:01:24,000
잘

22
00:01:24,000 --> 00:01:26,000
죄송합니다. >> 안돼, 안돼, 안돼, 안돼.

23
00:01:26,000 --> 00:01:34,000
나는 버블 정렬을 선택하는 잘못된 길 것 같아요.

24
00:01:34,000 --> 00:01:39,000
>> 그 이런 말 누가 그래?

25
00:01:39,000 --> 00:01:43,000
지난 주에 우리가 적어도 하루, 코드에서 휴식을했다 기억

26
00:01:43,000 --> 00:01:46,000
더 일반적으로 해결 일부 높은 수준의 아이디어와 문제에 초점을 시작

27
00:01:46,000 --> 00:01:49,000
검색 및 정렬의 맥락에서,

28
00:01:49,000 --> 00:01:53,000
우리는, 우리가 지난 주에이 이름을 때리는하지 않은 무언가를 도입

29
00:01:53,000 --> 00:01:56,000
하지만 점근 표기법, 빅 O, 빅 오메가,

30
00:01:56,000 --> 00:02:00,000
때로는 빅 세타 표기법,이 단순히 방법이었다

31
00:02:00,000 --> 00:02:02,000
알고리즘의 실행 시간을 설명하는,

32
00:02:02,000 --> 00:02:05,000
가 실행할 수있는 알고리즘에 걸리는 시간.

33
00:02:05,000 --> 00:02:08,000
>> 그리고 당신은 크기의 관점에서 당신은 실행 시간에 대해 얘기하는 기억 할 수 있습니다

34
00:02:08,000 --> 00:02:11,000
우리가 일반적으로 문제가있을 수 있습니다간에, n을 호출 입력의,

35
00:02:11,000 --> 00:02:13,000
여기서 n은 방에 사람들의 숫자입니다

36
00:02:13,000 --> 00:02:17,000
전화 번호부의 페이지 수, 우리는 세상을 쓰기 시작

37
00:02:17,000 --> 00:02:21,000
O와 같은 (N ^ 2) 또는 O (N) 또는 O (N 로그 N),

38
00:02:21,000 --> 00:02:24,000
그리고 수학은 아주 아주 완벽하게 해결하지 않은 경우

39
00:02:24,000 --> 00:02:28,000
그리고 N했습니다 ² - N / 2 또는 그런 일

40
00:02:28,000 --> 00:02:31,000
우리는 대신, 낮은 주문 조건의 일부를 멀리 던져 것

41
00:02:31,000 --> 00:02:34,000
과 동기가 우리가 정말 원하는이

42
00:02:34,000 --> 00:02:37,000
평가 목적 방법의 종류

43
00:02:37,000 --> 00:02:39,000
프로그램의 성능과 알고리즘의 성능

44
00:02:39,000 --> 00:02:42,000
그건 하루의 끝에서, 예를 들어, 상관없는 일

45
00:02:42,000 --> 00:02:45,000
컴퓨터의 속도가 오늘날과.

46
00:02:45,000 --> 00:02:47,000
>> 예를 들어, 당신은 거품 정렬을 구현하는 경우,

47
00:02:47,000 --> 00:02:50,000
또는 당신은 오늘날의 컴퓨터에 정렬 또는 선택 정렬 병합 구현

48
00:02:50,000 --> 00:02:53,000
2 GHz의 컴퓨터, 그리고 당신은 그것을 실행

49
00:02:53,000 --> 00:02:56,000
그리고 3 GHz의가 내년 초 일부 번호를 걸립니다

50
00:02:56,000 --> 00:02:59,000
또는 4 GHz의 컴퓨터, 당신은 해당 "우와, 내 알고리즘 청구 할 수

51
00:02:59,000 --> 00:03:03,000
실제로 그런 경우가 분명하지 않으면 "두 번 빠른 속도로 지금이다.

52
00:03:03,000 --> 00:03:06,000
단지 하드웨어가 빠르게 얻었다하지만 컴퓨터

53
00:03:06,000 --> 00:03:10,000
등 우리가 정말 같은 것들을 버리려하고하지 않았습니다

54
00:03:10,000 --> 00:03:13,000
2 배수 또는 3의 배수가 설명 할

55
00:03:13,000 --> 00:03:17,000
얼마나 빨리 또는 방법을 느린 알고리즘이며, 단지 초점을

56
00:03:17,000 --> 00:03:20,000
n 또는 그 일부 요소에

57
00:03:20,000 --> 00:03:24,000
권력과 그 지난 주에서 정렬의 경우에서와 같이.

58
00:03:24,000 --> 00:03:27,000
그리고 병합 정렬의 도움으로 그렇게 기억

59
00:03:27,000 --> 00:03:31,000
우리는 거품 정렬 및 선택 정렬보다 훨씬 더 잘 할 수 있었다

60
00:03:31,000 --> 00:03:33,000
그리고 삽입 정렬.

61
00:03:33,000 --> 00:03:36,000
>> 우리는 다시 N 로그 N에 도착하고,

62
00:03:36,000 --> 00:03:39,000
로그 n은 일반적으로 성장 뭔가 의미있는 기억

63
00:03:39,000 --> 00:03:43,000
더 느리게 다음에 n, 그래서 N 로그 N 지금까지 잘 했어

64
00:03:43,000 --> 00:03:45,000
는 N 개의 ² 미만 때문입니다.

65
00:03:45,000 --> 00:03:47,000
그러나 병합 정렬로 n을 달성 N 로그인하기

66
00:03:47,000 --> 00:03:51,000
우리가 활용해야한다고 생각의 기본 배아는 무엇 이었습니까

67
00:03:51,000 --> 00:03:54,000
우리는 주 0에 다시 활용할 것을?

68
00:03:54,000 --> 00:03:58,000
우리가 어떻게 병합 정렬을 교묘하게 정렬 문제를 해결 했어?

69
00:03:58,000 --> 00:04:04,000
아마, 키 통찰력 무엇입니까?

70
00:04:04,000 --> 00:04:07,000
누구나 천만에.

71
00:04:07,000 --> 00:04:09,000
자, 다시 단계를 보자.

72
00:04:09,000 --> 00:04:11,000
자신의 말로 정렬 병합 설명합니다.

73
00:04:11,000 --> 00:04:15,000
어떻게 할건데 요?

74
00:04:15,000 --> 00:04:17,000
그래, 우리는 주 다시 0으로 행합니다.

75
00:04:17,000 --> 00:04:19,000
그래, 그래.

76
00:04:19,000 --> 00:04:22,000
[안 들리게 - 학생이]

77
00:04:22,000 --> 00:04:26,000
좋아요,, 그래서 우리는 2 조각으로 숫자의 배열을 나눈 값입니다.

78
00:04:26,000 --> 00:04:29,000
, 우리는 그 조각을 각각 정렬 한 후 우리는 그들을 병합

79
00:04:29,000 --> 00:04:33,000
이 커요 문제를 복용하기 전에 우리는이 아이디어를 봤어요

80
00:04:33,000 --> 00:04:36,000
이 큰 또는이 크지 문제에를 자르고.

81
00:04:36,000 --> 00:04:38,000
>> 전화 번호부 예를 연상케합니다.

82
00:04:38,000 --> 00:04:42,000
전에 주에서 자기 계산 알고리즘을 리콜

83
00:04:42,000 --> 00:04:45,000
그래서 병합 정렬은 여기에 의사에 의해 요약되었다.

84
00:04:45,000 --> 00:04:48,000
당신이 N 요소를 제공 할 때, 먼저 그 정신이 확인했습니다.

85
00:04:48,000 --> 00:04:51,000
N <2는 전혀 아무 짓도하지 않는 경우

86
00:04:51,000 --> 00:04:55,000
N <2 다음에 n 분명 0 또는 1 인 경우 때문에,

87
00:04:55,000 --> 00:04:57,000
그날이 있는지 등 0 또는 1 정렬 것도 없습니다.

88
00:04:57,000 --> 00:04:59,000
넌 끝이야.

89
00:04:59,000 --> 00:05:01,000
귀하의 목록에 이미 trivially 정렬됩니다.

90
00:05:01,000 --> 00:05:04,000
하지만 당신이 2 개 이상 요소를이있어 그렇지 않으면 가서 그들에게 나누어

91
00:05:04,000 --> 00:05:06,000
두 반쪽에, 왼쪽 및 오른쪽.

92
00:05:06,000 --> 00:05:09,000
그 절반을 각각 정렬 한 다음 정렬 절반을 병합합니다.

93
00:05:09,000 --> 00:05:13,000
하지만, 여기에 문제는 우리가 punting 것처럼 한눈에이 느끼는 것입니다.

94
00:05:13,000 --> 00:05:17,000
난이 N 요소를 정렬 부탁 한 경우 그에 원형 정의입니다

95
00:05:17,000 --> 00:05:22,000
당신은 "좋아, 좋아, 우리가 그 N / 2, 그 N / 2 요소를 정렬합니다"말씀이신가요

96
00:05:22,000 --> 00:05:27,000
그리고 내 다음 질문이 될 것입니다 "어떻게 N / 2 요소를 정렬합니까, 좋아?"

97
00:05:27,000 --> 00:05:30,000
>> 그러나,이 프로그램의 구조,

98
00:05:30,000 --> 00:05:33,000
이 기본 경우가 있기 때문에, 그래서, 말씀

99
00:05:33,000 --> 00:05:39,000
n은 즉시이 반환 같은 고정 값을 <하는 경우라고이 특별한 케이스.

100
00:05:39,000 --> 00:05:42,000
같은 원형 답변 응답하지 않습니다.

101
00:05:42,000 --> 00:05:46,000
이 과정이 cyclicity 결국 종료됩니다.

102
00:05:46,000 --> 00:05:50,000
난 "정렬이 N 요소"를 요청하고, 말한다면 "그래,이 N / 2 정렬"

103
00:05:50,000 --> 00:05:53,000
다음은 "좋아, 정렬이 N / 4, N / 8, n/16,"말

104
00:05:53,000 --> 00:05:56,000
결국 당신은 충분히 큰 번호로 분할됩니다

105
00:05:56,000 --> 00:05:59,000
당신은, 당신이 말할 수있는 시점에서 단 1 요소 왼쪽 할 것

106
00:05:59,000 --> 00:06:02,000
"여기, 여기 정렬 한 요소입니다."

107
00:06:02,000 --> 00:06:06,000
그런 다음이 알고리즘의 빛은 여기까지 사실에서 파생하는 것입니다

108
00:06:06,000 --> 00:06:09,000
그 일단이 개별적으로 정렬 목록을 모두 가지고

109
00:06:09,000 --> 00:06:12,000
쓸모없는 것 같습니다 어떤 크기 1의되어있는 모든

110
00:06:12,000 --> 00:06:15,000
당신이 그들을 통합하고이를 병합을 시작하면

111
00:06:15,000 --> 00:06:19,000
롭이 동영상 마지막으로 정렬 목록에서 그랬던 것처럼 당신이 마침내 구축 할 수 있습니다.

112
00:06:19,000 --> 00:06:22,000
>> 그러나이 아이디어는 지금까지 정렬 초과합니다.

113
00:06:22,000 --> 00:06:26,000
재귀로 알려진이 프로그램에 포함 된이 아이디어가,

114
00:06:26,000 --> 00:06:29,000
당신은 프로그램 아르 상기 아이디어,

115
00:06:29,000 --> 00:06:32,000
당신이 자신을 부르는 몇 가지 문제를 해결하기 위해,

116
00:06:32,000 --> 00:06:36,000
또는, 당신은 함수 아르 프로그래밍 언어의 맥락에 넣어

117
00:06:36,000 --> 00:06:39,000
하고 문제를 해결하기 위해, 당신은 함수가 자신을 호출

118
00:06:39,000 --> 00:06:42,000
또 한번, 또 한번 다시하지만, 기능

119
00:06:42,000 --> 00:06:44,000
자신에게 무한 여러 번 호출 할 수 없습니다.

120
00:06:44,000 --> 00:06:47,000
결국은, 말하자면, 바닥에서해야

121
00:06:47,000 --> 00:06:49,000
다음과 같이 말한다 일부 하드 코딩 된 기본 조건이

122
00:06:49,000 --> 00:06:53,000
이 시점에서 이렇게 자신을 부르지 마 전체 과정

123
00:06:53,000 --> 00:06:56,000
마지막으로 실제로 중지 않습니다.

124
00:06:56,000 --> 00:06:58,000
이게 정말 재귀 호출로, 무엇을 의미합니까?

125
00:06:58,000 --> 00:07:01,000
>> 우리가 말과 함께 간단한 사소한 예를 할 수 있다면, 어디 보자

126
00:07:01,000 --> 00:07:03,000
여기까지 무대에서 저와 3 인 사람이 편안합니다.

127
00:07:03,000 --> 00:07:06,000
최대, 2, 3에서 1을, 있습니다.

128
00:07:06,000 --> 00:07:09,000
당신이 3 여기에오고 싶어합니다.

129
00:07:09,000 --> 00:07:12,000
당신은 줄에 여기 바로 옆에 서려면 가정이 손에 문제가

130
00:07:12,000 --> 00:07:15,000
매우 trivially 여기있는 사람들의 수를 계산합니다.

131
00:07:15,000 --> 00:07:18,000
솔직히 난이 모든 계산 예제 피곤 해요.

132
00:07:18,000 --> 00:07:21,000
이 시간, 1, 2, 점, 점, 점을 데려 갈 수 있습니다.

133
00:07:21,000 --> 00:07:23,000
그것은 영원히 걸릴 겁니다.

134
00:07:23,000 --> 00:07:25,000
난 그냥 도움을 모두 펀트이 문제를의 - 당신의 이름은? 차라리

135
00:07:25,000 --> 00:07:27,000
사라. >> 사라, 좋아.

136
00:07:27,000 --> 00:07:29,000
켈리. >> 켈리와?

137
00:07:29,000 --> 00:07:31,000
>> 윌리. >> 윌리, 사라, 켈리, 그리고 윌리.

138
00:07:31,000 --> 00:07:34,000
지금 나는 누군가가 질문을했습니다

139
00:07:34,000 --> 00:07:37,000
얼마나 많은 사람들이이 단계에 있으며, 난 아무 생각이 없습니다.

140
00:07:37,000 --> 00:07:40,000
이 정말 긴 목록입니다, 그래서 대신이 트릭을 할거야.

141
00:07:40,000 --> 00:07:43,000
나는 작업의 대부분을 수행하는 내 옆에있는 사람을 요구하려고

142
00:07:43,000 --> 00:07:46,000
한 번 그녀는 거의 모든 일을 이루어

143
00:07:46,000 --> 00:07:49,000
나는 가능한 작업의 최소 금액을하려하고 불과 1을 추가 해요

144
00:07:49,000 --> 00:07:51,000
여기가 우리가 가고 무엇이든 그녀의 대답합니다.

145
00:07:51,000 --> 00:07:54,000
나는 무대에서 얼마나 많은 사람들이 물어왔다했습니다.

146
00:07:54,000 --> 00:07:57,000
얼마나 많은 사람들이 당신의 왼쪽에있는 무대에 있습니까?

147
00:07:57,000 --> 00:08:00,000
좋아요 >>? 나 왼쪽,하지만 속임수하지 않습니다.

148
00:08:00,000 --> 00:08:04,000
맞습니다 즉, 좋은 만, 우리는이 논리를 계속하려면

149
00:08:04,000 --> 00:08:08,000
당신은 마찬가지로 당신의 왼쪽에있는 펀트이 문제를 처리 할가 가정을 해 보면,

150
00:08:08,000 --> 00:08:11,000
그래서 오히려 답변보다 직접 가서 그냥 책임을 전달합니다.

151
00:08:11,000 --> 00:08:14,000
오, 왼쪽에있는 사람이 얼마 지?

152
00:08:14,000 --> 00:08:16,000
왼쪽에있는 사람이 얼마나 있죠?

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

154
00:08:18,000 --> 00:08:27,000
[웃음]

155
00:08:27,000 --> 00:08:30,000
좋아요, 0, 그래서 뭐 지금은 윌리 했어요,

156
00:08:30,000 --> 00:08:33,000
귀하의 답변 0 명 소리를 방향을 반환 한합니다.

157
00:08:33,000 --> 00:08:36,000
자, 이제 어떻게해야하나요? >> 1.

158
00:08:36,000 --> 00:08:39,000
좋아요, 그럼 당신은 하나, 그러니 당신이 말하는 "좋아, 1를 추가 할거야

159
00:08:39,000 --> 00:08:41,000
에 무엇이든 윌리의 수였다 "고 1 + 0.

160
00:08:41,000 --> 00:08:43,000
오른쪽에 답이 있으므로 지금은 한거야 지금 -

161
00:08:43,000 --> 00:08:45,000
1. >> 그리고 제 2 것입니다.

162
00:08:45,000 --> 00:08:48,000
, 그래서 당신은 1의 이전 답변을 잘 복용

163
00:08:48,000 --> 00:08:51,000
당신이 원하는 일의 최소한의 금액을 추가하는 +1입니다.

164
00:08:51,000 --> 00:08:55,000
이제이 있고, 그 다음 날 값을 하죠?

165
00:08:55,000 --> 00:08:57,000
3, 죄송합니다,, 2를 의미합니다.

166
00:08:57,000 --> 00:08:59,000
좋아.

167
00:08:59,000 --> 00:09:02,000
>> 음, 우리는 왼쪽에 0을했다.

168
00:09:02,000 --> 00:09:05,000
, 우리는 1했고, 다음에 2를 추가

169
00:09:05,000 --> 00:09:07,000
그리고 지금 당신은 나에게 숫자 2를 다루는 것

170
00:09:07,000 --> 00:09:10,000
그래서 나는 3 +1, 좋아, 말.

171
00:09:10,000 --> 00:09:13,000
이 단계에서 내 옆에 서 삼명는 정말이

172
00:09:13,000 --> 00:09:16,000
그래서 우리는 분명 매우 선형 이런 짓을 수

173
00:09:16,000 --> 00:09:19,000
분명 패션에 많이하지만, 우리가 정말 무슨 짓을 한거야?

174
00:09:19,000 --> 00:09:21,000
우리는 처음에 크기 3의 문제를했습니다.

175
00:09:21,000 --> 00:09:24,000
우리는 크기 2의 문제로 냈어요

176
00:09:24,000 --> 00:09:27,000
다음 크기 (1)의 문제를 한 다음, 기본 케이스 마지막으로

177
00:09:27,000 --> 00:09:29,000
정말, 아, 거기 아무도 없었

178
00:09:29,000 --> 00:09:33,000
되는 지점 윌리는 하드 코딩 된 답변 두어 번 효율적으로 반환

179
00:09:33,000 --> 00:09:36,000
두 번째 하나는 다음 떠오르, 떠오르, 떠오르되었습니다

180
00:09:36,000 --> 00:09:39,000
다음이 하나의 추가 1 추가

181
00:09:39,000 --> 00:09:41,000
우리는 재귀의 기본 아이디어를 구현했습니다.

182
00:09:41,000 --> 00:09:44,000
>> 자,이 경우에는 정말 문제를 해결할 수 없습니다

183
00:09:44,000 --> 00:09:46,000
더 효과적으로 다음에 우리가 지금까지 본 적이.

184
00:09:46,000 --> 00:09:48,000
하지만 우리가 지금까지 무대에서 한 알고리즘에 대해 생각합니다.

185
00:09:48,000 --> 00:09:51,000
우리는 칠판에 종이를 8 조각을했다

186
00:09:51,000 --> 00:09:55,000
비디오에 션이 7 번을 찾고 있었어요 그리고 그는 정말 무슨 짓을 한거야 때?

187
00:09:55,000 --> 00:09:58,000
음, 분리 모든 종류의 작업을 수행하고 정복 없습니다.

188
00:09:58,000 --> 00:10:01,000
그는 재귀 모든 종류의 안 했어요.

189
00:10:01,000 --> 00:10:03,000
오히려 그는이 선형 알고리즘을 했어요.

190
00:10:03,000 --> 00:10:07,000
하지만 우리가 무대에서 정렬 숫자의 아이디어를 소개 할 때 지난 주에 살고

191
00:10:07,000 --> 00:10:09,000
그러면 우리는, 중간에가는이 본능이

192
00:10:09,000 --> 00:10:13,000
어떤 시점에서 우리는, 크기 4 크기 4 다른 목록의 작은 목록을 가지고 있었어요

193
00:10:13,000 --> 00:10:17,000
그리고 우리가 동일한 문제를했다, 그래서 우리는 반복 반복 반복.

194
00:10:17,000 --> 00:10:19,000
즉, 우리는 recursed.

195
00:10:19,000 --> 00:10:24,000
우리와 함께 재귀를 시연은 여기 우리 셋 자원 봉사자 매우 감사합니다.

196
00:10:24,000 --> 00:10:28,000
>> 지금 우리가 좀 더 구체적이 일을 할 수없는 경우 봅시다,

197
00:10:28,000 --> 00:10:30,000
다시 아주 쉽게 할 수있는 문제를 해결,

198
00:10:30,000 --> 00:10:34,000
그러나 우리는이 기본 아이디어를 구현하는 디딤돌로 사용합니다.

199
00:10:34,000 --> 00:10:37,000
나는 숫자의 무리의 합계를 계산하려면

200
00:10:37,000 --> 00:10:39,000
예를 들어, 당신이 수 3 통과하면,

201
00:10:39,000 --> 00:10:42,000
내가 진정으로 너희에게 시그마 3의 값을 얻으려면

202
00:10:42,000 --> 00:10:46,000
그래서 3의 합 + 2 + 1 + 0.

203
00:10:46,000 --> 00:10:48,000
나는 답 6 돌아가려면

204
00:10:48,000 --> 00:10:51,000
그래서 우리는이 시그마 기능이 합류 기능을 구현합니다

205
00:10:51,000 --> 00:10:54,000
즉, 다시 입력에 소요 한 다음 합계를 반환

206
00:10:54,000 --> 00:10:57,000
아래 0 그 번호의 모든 방법입니다.

207
00:10:57,000 --> 00:10:59,000
우린 아주 간단하게 이럴 수 있지?

208
00:10:59,000 --> 00:11:01,000
우리는 반복 구조의 어떤으로이 작업을 수행 할 수

209
00:11:01,000 --> 00:11:04,000
그럼 내가 가서이 시작하자.

210
00:11:04,000 --> 00:11:07,000
>> stdio.h를 포함합니다.

211
00:11:07,000 --> 00:11:09,000
여기 함께 작동하도록 나를 메인으로 자신을 보자.

212
00:11:09,000 --> 00:11:12,000
하자 sigma.c로 저장합니다.

213
00:11:12,000 --> 00:11:14,000
그럼 여기에 가서, 나는, 정수 n을 선언거야

214
00:11:14,000 --> 00:11:18,000
그리고 사용자가 협조하지 않을 동안 다음을 수행 할거야.

215
00:11:18,000 --> 00:11:22,000
사용자는 나에게 긍정적 인 번호를 부여하지 않았습니다 없지만

216
00:11:22,000 --> 00:11:26,000
내가 가서 N =의 GetInt을 위해 메시지를 표시합시다

217
00:11:26,000 --> 00:11:28,000
그리고, 제가 그들에게 무엇을해야 것과 같은 일부 지침을 해주지

218
00:11:28,000 --> 00:11:33,000
그래서 printf ( "양의 정수 해주십시오").

219
00:11:33,000 --> 00:11:39,000
시간이 우리가 라인 14를 누르 있도록 같은 비교적 간단한 뭔가를

220
00:11:39,000 --> 00:11:42,000
우리는 이제 N의 아마 양의 정수가 있습니다.

221
00:11:42,000 --> 00:11:44,000
>> 지금에 뭔가 의미있는 일을 해보자 구.

222
00:11:44,000 --> 00:11:50,000
내가 가서 합류을 계산하자, 그래서 int는 합계 = 시그마 (N).

223
00:11:50,000 --> 00:11:54,000
시그마는 합계입니다, 그럼 난 그냥 애호가 방법을 드리고자합니다.

224
00:11:54,000 --> 00:11:56,000
우리는 그냥이 시그마 전화 할게.

225
00:11:56,000 --> 00:11:58,000
그건 합, 그리고 지금은, 결과를 인쇄거야

226
00:11:58,000 --> 00:12:08,000
printf (합계 "합 D, \ N %입니다").

227
00:12:08,000 --> 00:12:11,000
그리고 좋은 측정을 위해 0을 반환합니다.

228
00:12:11,000 --> 00:12:15,000
우리는 흥미로운 부분을 제외하고이 프로그램에 필요한 건 다 했어요

229
00:12:15,000 --> 00:12:18,000
이는 실제로 시그마 기능을 구현하는 것입니다.

230
00:12:18,000 --> 00:12:22,000
>> 저 아래로 내려 가서 저 기능 시그마를 선언 해 보자.

231
00:12:22,000 --> 00:12:26,000
이 입력 정수의 야 변수를하려는거야

232
00:12:26,000 --> 00:12:30,000
과 데이터 형식에는 어떤 것이 시그마에서 아마 돌아 하시겠습니까?

233
00:12:30,000 --> 00:12:34,000
INT, 내가 줄 15 일 내 기대를 일치시킬 때문입니다.

234
00:12:34,000 --> 00:12:37,000
여기에 내가 가서이을 구현하게

235
00:12:37,000 --> 00:12:41,000
아주 간단 방법 인치

236
00:12:41,000 --> 00:12:45,000
>> 가 가서 INT 합계주세요 = 0라고하자,

237
00:12:45,000 --> 00:12:47,000
지금은 여기에 루프 조금 더 갈거야

238
00:12:47,000 --> 00:12:50,000
즉, 같은 말 거에요

239
00:12:50,000 --> 00:13:01,000
합계 + = I (,, 나는 <= 번호 전 + + int는 전 = 0)에 대한.

240
00:13:01,000 --> 00:13:05,000
그리고 나서 합계를 반환하는거야.

241
00:13:05,000 --> 00:13:07,000
여러 가지 방법의 수에서이 작업을 구현 수 있습니다.

242
00:13:07,000 --> 00:13:09,000
잠시 동안 루프를 사용했습니다 수 있습니다.

243
00:13:09,000 --> 00:13:11,000
난 정말로 원한다면 합계 변수를 사용하여 생략 수

244
00:13:11,000 --> 00:13:15,000
하지만 짧은에, 우리는 안 그랬 으면 바보짓은 합이 0 인 선언하는 기능을 갖추고 있습니다.

245
00:13:15,000 --> 00:13:18,000
그럼, 수 통해에 0부터 반복

246
00:13:18,000 --> 00:13:23,000
각 반복에 그 금액에 해당 현재 값을 추가 한 다음 합계를 반환합니다.

247
00:13:23,000 --> 00:13:25,000
>> 자, 여기에 약간의 최적화가 있습니다.

248
00:13:25,000 --> 00:13:29,000
이게 아마 낭비 단계이지만, 그래서 수. 지금은이게 좋아요.

249
00:13:29,000 --> 00:13:32,000
우리는 적어도있어 물어과 최대의 공 모든 길을 가고.

250
00:13:32,000 --> 00:13:34,000
매우 딱딱하고 매우 간단 아니라,

251
00:13:34,000 --> 00:13:37,000
하지만 시그마 기능을 우리가 기회를 동일하게 밝혀

252
00:13:37,000 --> 00:13:39,000
우리가 무대에서 여기 그랬던 것처럼.

253
00:13:39,000 --> 00:13:42,000
무대에서 우리는, 내 옆에 얼마나 많은 사람들이 계산

254
00:13:42,000 --> 00:13:47,000
대신 우리는 번호 3 + 2 + 1을 계산하고자 할 경우

255
00:13:47,000 --> 00:13:51,000
로 떨어 0에 우리는 함수와 비슷하게 펀트 수

256
00:13:51,000 --> 00:13:55,000
내가 대신 재귀하다고 설명 할게요.

257
00:13:55,000 --> 00:13:57,000
다음의 간단한 정신 검사 내가 바보짓하지 않았는지 확인하자.

258
00:13:57,000 --> 00:14:00,000
>> 내가 잘못 했어요되는이 프로그램에서 적어도 한 가지가 알아요.

259
00:14:00,000 --> 00:14:04,000
I 입력을 누르 때 나 한테 소리를 질러 모든 종류의를 얻을 할까?

260
00:14:04,000 --> 00:14:06,000
난 막 소리 질렀어요 할 무엇을 할까?

261
00:14:06,000 --> 00:14:11,000
그래, 프로토 타입을 잊어, 내가 줄 15 시그마라는 기능을 사용하므로

262
00:14:11,000 --> 00:14:16,000
그러나 그 라인 22 일까지 신고, 그래서 가장 적극적으로 여기에 갈거야

263
00:14:16,000 --> 00:14:22,000
그리고 프로토 타입을 선언, 나는 INT 시그마을 (INT 번호) 말씀 드리죠, 그게 전부예요.

264
00:14:22,000 --> 00:14:24,000
그것은 하단에 구현있어.

265
00:14:24,000 --> 00:14:27,000
>> 또는 내가이 문제를 해결 수있는 다른 방법

266
00:14:27,000 --> 00:14:30,000
나는, 그 나쁜 아니라, 위에서 함수를 옮길 수

267
00:14:30,000 --> 00:14:32,000
하지만 적어도 당신의 프로그램은, 솔직히, 긴 얻을 시작할 때

268
00:14:32,000 --> 00:14:35,000
항상 상단에있는 메인을 갖는의 일부 값이있는 것 같은데

269
00:14:35,000 --> 00:14:38,000
당신은 리더에서 파일을 연 다음 바로 볼 수 있도록

270
00:14:38,000 --> 00:14:40,000
이 프로그램은 그것을 통해 검색 할 필요없이 무엇을하고 있는지

271
00:14:40,000 --> 00:14:42,000
그 주요 기능을 찾고 있어요.

272
00:14:42,000 --> 00:14:49,000
의 여기 내 터미널 창으로 가자, 시그마는 시그마를 만들어보세요

273
00:14:49,000 --> 00:14:51,000
그리고 나도 여기 했거든요.

274
00:14:51,000 --> 00:14:55,000
기능 GetInt의 암시 적 선언은 내가 무슨 다른 할 잊어 버린 의미?

275
00:14:55,000 --> 00:14:57,000
[안 들리게 - 학생이]

276
00:14:57,000 --> 00:15:00,000
좋은 하니까, 일반적인 실수 때문에, 여기서이 일을 놓고

277
00:15:00,000 --> 00:15:04,000
cs50.h, 지금의 내 터미널 창으로 돌아 가자.

278
00:15:04,000 --> 00:15:08,000
>> 나는 화면을 지우거야, 그리고 당신 시그마를 다시 실행합니다.

279
00:15:08,000 --> 00:15:11,000
그것은 컴파일 한 것 같습니다. 내가 지금 시그마를 실행 봅시다.

280
00:15:11,000 --> 00:15:15,000
, 내가 3 번에 입력합니다, 나는 6 거지, 그렇게하지 ​​엄격한 검사

281
00:15:15,000 --> 00:15:18,000
하지만 적어도이 한눈에 작동하는 것 같군, 지금하자 찢어 버리곤

282
00:15:18,000 --> 00:15:21,000
그리고 시작하자, 사실은 다시 재귀의 아이디어를 활용

283
00:15:21,000 --> 00:15:24,000
아주 간단한 컨텍스트에 해당하므로 몇 주 '시간에

284
00:15:24,000 --> 00:15:27,000
우리는 배열보다 애호가 데이터 구조를 탐구 시작할 때

285
00:15:27,000 --> 00:15:30,000
우리는에있는 툴킷에서 다른 도구를 가지고

286
00:15:30,000 --> 00:15:33,000
우리가 보게 될 그 데이터 구조를 조작.

287
00:15:33,000 --> 00:15:36,000
이것은 반복적 접근, 루프 기반의 접근 방식입니다.

288
00:15:36,000 --> 00:15:39,000
>> 지금은이 작업을 수행하는 대신 저를 보자.

289
00:15:39,000 --> 00:15:44,000
대신 말 좀 보자 그 번호의 합계

290
00:15:44,000 --> 00:15:48,000
정말 같은 일 0 다운에 있습니다

291
00:15:48,000 --> 00:15:53,000
번호 + 시그마 (수 - 1).

292
00:15:53,000 --> 00:15:57,000
즉, 그냥 무대에서 같은 날 옆에있는 사람들의 각 punted

293
00:15:57,000 --> 00:16:00,000
그리고 결과적으로, 우리는 드디어 윌리에서 바닥을 때까지 punting 유지

294
00:16:00,000 --> 00:16:03,000
사람은 0과 같은 하드 코딩 된 답변을 반환했습니다.

295
00:16:03,000 --> 00:16:07,000
여기 지금 우리는 유사 시그마에 punting하고

296
00:16:07,000 --> 00:16:10,000
같은 기능이 아니라 원래이라고하지만, 키 통찰력 여기 있었

297
00:16:10,000 --> 00:16:12,000
우리가 동일 시그마를 호출하지 것입니다.

298
00:16:12,000 --> 00:16:14,000
우리는 N에 전달하지.

299
00:16:14,000 --> 00:16:17,000
우리는 명확하게 번호를 치고 - 1,

300
00:16:17,000 --> 00:16:20,000
그래서 약간 작은 문제 약간 작은 문제가 발생했습니다.

301
00:16:20,000 --> 00:16:23,000
>> 불행하게도,이이 아직 해결하지, 우리는 수정하기 전에

302
00:16:23,000 --> 00:16:26,000
당신의 일부를 명백한로 무엇을 얻을 수있을

303
00:16:26,000 --> 00:16:28,000
내가 가서 확인 다시 실행 보자.

304
00:16:28,000 --> 00:16:30,000
괜찮 컴파일 할 것 같습니다.

305
00:16:30,000 --> 00:16:32,000
저 6 시그마를 다시 실행 보자.

306
00:16:32,000 --> 00:16:37,000
죄송합니다, 제가 6 시그마를 다시 실행 보자.

307
00:16:37,000 --> 00:16:42,000
우리는뿐만 아니라 실수로 마지막이라도 전에 본 적이 있어요.

308
00:16:42,000 --> 00:16:48,000
왜이 암호화 된 분류 오류 거죠? 그래.

309
00:16:48,000 --> 00:16:50,000
[안 들리게 - 학생이]

310
00:16:50,000 --> 00:16:53,000
보다 구체적가 더 기본 케이스가없는, 그리고, 무슨 일이 일어?

311
00:16:53,000 --> 00:16:58,000
이 어떤 행동의 증상인가요?

312
00:16:58,000 --> 00:17:00,000
크게 말해봐.

313
00:17:00,000 --> 00:17:02,000
[안 들리게 - 학생이]

314
00:17:02,000 --> 00:17:05,000
그것은 효과적으로 무한 루프, 그리고 무한 루프가있는 문제

315
00:17:05,000 --> 00:17:08,000
사람들이이 경우에 재귀를 포함하면, 함수는 자신을 호출

316
00:17:08,000 --> 00:17:10,000
어떻게 당신이 함수를 호출 할 때마다 어떻게됩니까?

317
00:17:10,000 --> 00:17:13,000
음, 우리는 컴퓨터의 메모리를 배치하는 방법에 다시 생각합니다.

318
00:17:13,000 --> 00:17:16,000
우리는 하단에 스택이라는 메모리의 덩어리가 말했다

319
00:17:16,000 --> 00:17:19,000
그리고 조금 더 많은 메모리 함수 호출 때마다 넣어됩니다

320
00:17:19,000 --> 00:17:24,000
그 함수의 지역 변수 나 매개 변수를 포함하는이 소위 스택에,

321
00:17:24,000 --> 00:17:27,000
시그마는 시그마 전화를 호출하므로 경우에 시그마는 시그마 호출

322
00:17:27,000 --> 00:17:29,000
 시그마를 호출 곳이 이야기의 끝 주던가요?

323
00:17:29,000 --> 00:17:31,000
>> 음, 결국 오버런 총 금액

324
00:17:31,000 --> 00:17:33,000
귀하의 컴퓨터에서 사용할 수 있다고 메모리가 부족합니다.

325
00:17:33,000 --> 00:17:37,000
당신은 당신이 내에 있어야한다는 세그먼트를 오버런

326
00:17:37,000 --> 00:17:40,000
그리고이 분류 오류를 얻을 코어, 버려진

327
00:17:40,000 --> 00:17:43,000
그리고 버려진 어떤 핵심을 의미하는 것은 지금 코어라는 파일이 있다는 것입니다

328
00:17:43,000 --> 00:17:46,000
이는 제로와 사람을 포함하는 파일입니다

329
00:17:46,000 --> 00:17:49,000
그건 실제로 미래에 diagnostically 도움이 될 것입니다.

330
00:17:49,000 --> 00:17:52,000
당신의 버그를 어디에 당신에게 그러는 건 경우

331
00:17:52,000 --> 00:17:54,000
당신은 실제로 말하자면, 법정 분석을 조금 할 수

332
00:17:54,000 --> 00:17:58,000
이 코어 덤프 파일에 어느, 다시, 단지 제로와 사람들의 전체 무리입니다

333
00:17:58,000 --> 00:18:02,000
그 본질적 메모리에 프로그램의 상태를 나타냅니다

334
00:18:02,000 --> 00:18:05,000
현재는이 방법으로 추락했습니다.

335
00:18:05,000 --> 00:18:11,000
>> 여기서 수정 우리가 맹목적으로, 시그마를 반환하지 수 있다는 것입니다

336
00:18:11,000 --> 00:18:14,000
수 + 약간 작은 문제 시그마.

337
00:18:14,000 --> 00:18:16,000
우리는 여기에 기본 케이스 일종의이 필요합니다

338
00:18:16,000 --> 00:18:19,000
와베이스 케이스는 아마도대로해야하나요?

339
00:18:19,000 --> 00:18:22,000
[안 들리게 - 학생이]

340
00:18:22,000 --> 00:18:25,000
그래, 그럼 긴 번호가 긍정적으로 우리는 실제로이를 반환해야합니다

341
00:18:25,000 --> 00:18:29,000
또는 다른 방법을 넣어, 숫자 인 경우, 말, <= 0

342
00:18:29,000 --> 00:18:32,000
당신은, 내가 가서 0을 반환할지 알

343
00:18:32,000 --> 00:18:36,000
윌리가 한 많은처럼, 그리고 다른, 내가 먼저 갈거야

344
00:18:36,000 --> 00:18:41,000
이을 반환 때문에 그렇게 짧은 아닙니다

345
00:18:41,000 --> 00:18:44,000
우리가 처음 루프에를 사용하여 휘핑하는 반복 버전보다,

346
00:18:44,000 --> 00:18:48,000
하지만 거기에 우아함이 종류가 사실을 알아야한다.

347
00:18:48,000 --> 00:18:51,000
대신 번호를 제공하고 모든 계산을 수행

348
00:18:51,000 --> 00:18:54,000
및 지역 변수 일을 추가

349
00:18:54,000 --> 00:18:57,000
대신 말은 "자,이 아주 쉽게 문제가있는 경우는,

350
00:18:57,000 --> 00:19:01,000
번호가 <0처럼, 제가 즉시 0을 반환하게. "

351
00:19:01,000 --> 00:19:03,000
>> 우리는 지원 음수를 방해 할 수 없어

352
00:19:03,000 --> 00:19:05,000
그래서 하드 코드로 0의 값을거야.

353
00:19:05,000 --> 00:19:08,000
그러나 그렇지 않으면, 합계의 아이디어를 구현

354
00:19:08,000 --> 00:19:11,000
이러한 숫자의 모든 함께 효과적으로 작은 식사를 취할 수

355
00:19:11,000 --> 00:19:14,000
문제의 중에 많은처럼 우리는 무대에 여기 한

356
00:19:14,000 --> 00:19:18,000
다음 버리면 다음 사람에게 문제의 나머지,

357
00:19:18,000 --> 00:19:20,000
하지만이 경우에는 다음 사람은 바로 자기 자신이다.

358
00:19:20,000 --> 00:19:22,000
그것은 동일한 이름 기능입니다.

359
00:19:22,000 --> 00:19:25,000
그냥은 작고 작고 작은 문제를 할 때마다 통과

360
00:19:25,000 --> 00:19:28,000
우리는 여기에 코드별로 공식화 일이 있어도

361
00:19:28,000 --> 00:19:33,000
이 전화 번호부와 주 공에 무슨 일이 정확히 것입니다.

362
00:19:33,000 --> 00:19:36,000
이 션과 함께 지난 주에 무슨 일이 정확히 무엇

363
00:19:36,000 --> 00:19:39,000
와 숫자를 검색 우리의 데모가 있습니다.

364
00:19:39,000 --> 00:19:42,000
이 문제를 복용하고 다시하고 다시 나누어있어.

365
00:19:42,000 --> 00:19:44,000
>> 즉, 번역의 지금 방법이

366
00:19:44,000 --> 00:19:47,000
이 실제 구조이 높은 수준의 구조

367
00:19:47,000 --> 00:19:51,000
분열과 정복하고 다시하고 다시 일을하는

368
00:19:51,000 --> 00:19:56,000
코드에서, 그래서 우리가 시간이 지남에 다시 볼 수 일입니다.

369
00:19:56,000 --> 00:20:00,000
당신은 재귀을 처음 해보신다면 지금, 옆으로, 적어도 지금은 이해한다

370
00:20:00,000 --> 00:20:02,000
왜 웃기다.

371
00:20:02,000 --> 00:20:05,000
나는 google.com에 갈거야

372
00:20:05,000 --> 00:20:17,000
내가 재귀에 대한 몇 가지 팁 및 유용한 정보를 검색 할 거예요, 입력합니다.

373
00:20:17,000 --> 00:20:21,000
그들은 단지 지금은 웃지되지 않은 경우 옆에있는 사람을 알려주십시오.

374
00:20:21,000 --> 00:20:23,000
당신은 재귀을 (를) 입력하셨습니까?

375
00:20:23,000 --> 00:20:25,000
당신이 한 말 - 아, 여기 있어요.

376
00:20:25,000 --> 00:20:28,000
자, 이제 모든 사람들의 나머지 부분입니다.

377
00:20:28,000 --> 00:20:30,000
작은 부활절 달걀은 Google에 어딘가에 내장.

378
00:20:30,000 --> 00:20:33,000
옆, 우리는 코스의 웹 사이트에 넣어 링크 중 하나로서

379
00:20:33,000 --> 00:20:36,000
오늘은 다양한 정렬 알고리즘의 이번 격자는,

380
00:20:36,000 --> 00:20:39,000
우리는 지난 주를 바라 보았다,하지만이 시각화에 대해 좋네요 일부의

381
00:20:39,000 --> 00:20:43,000
당신은 알고리즘에 관한 여러 가지 주변에 마음을 포장하려고으로

382
00:20:43,000 --> 00:20:46,000
당신은 아주 쉽게 현재 입력의 종류와 시작할 수 알아요.

383
00:20:46,000 --> 00:20:50,000
입력은 모든 입력이 임의 등등의 입력은 대부분 정렬, 반전.

384
00:20:50,000 --> 00:20:53,000
다시로 시도로서, 마음으로 이러한 사항들을 구별

385
00:20:53,000 --> 00:20:57,000
커다란 강의 페이지에서 코스의 웹 사이트에서이 URL

386
00:20:57,000 --> 00:21:00,000
당신이 그 중 일부를 이유로하는 데 도움이.

387
00:21:00,000 --> 00:21:05,000
>> 오늘 우리는 마침내 다시 잠시이 문제를 해결할 수

388
00:21:05,000 --> 00:21:08,000
어떤이 스왑 기능이 제대로 작동하지 않았다고했다

389
00:21:08,000 --> 00:21:12,000
그리고,이 기능을 스왑으로 근본적인 문제가 뭔지

390
00:21:12,000 --> 00:21:15,000
여기와 여기에 값을 교환하기 위해 다시있는 목표 중

391
00:21:15,000 --> 00:21:17,000
당신이이 일을 예?

392
00:21:17,000 --> 00:21:20,000
이와 같은 사실은 실제로 작동하지 않습니다. 이유는 무엇입니까?

393
00:21:20,000 --> 00:21:22,000
그래.

394
00:21:22,000 --> 00:21:28,000
[안 들리게 - 학생이]

395
00:21:28,000 --> 00:21:31,000
이 bugginess에 정확히 설명

396
00:21:31,000 --> 00:21:34,000
당신은 C에서 함수를 호출 할 때 때문에 간단하게했다

397
00:21:34,000 --> 00:21:38,000
그리고 그 기능은, a와 b 여기에 같은 인수를

398
00:21:38,000 --> 00:21:42,000
당신은 그 함수에 제공하는 어떤 가치의 사본을 전달하고 있습니다.

399
00:21:42,000 --> 00:21:46,000
당신은 원래 값 스스로를 제공하지 않습니다

400
00:21:46,000 --> 00:21:49,000
그래서 우리는 buggyc의 맥락에서이 모습을 봤다면

401
00:21:49,000 --> 00:21:52,000
이와 같은 작은 선물을 보았다 buggy3.c.

402
00:21:52,000 --> 00:21:57,000
>> 우리는 x와 y는 각각 1과 2로 초기화한다고 기억합니다.

403
00:21:57,000 --> 00:21:59,000
우리는 그들에 대해서 출력한다.

404
00:21:59,000 --> 00:22:03,000
그때 나는 X, Y의 스왑을 호출하여이를 교환 있다는 주장했다.

405
00:22:03,000 --> 00:22:06,000
그러나 문제는, 교환이 일 였어요

406
00:22:06,000 --> 00:22:10,000
만 스왑의 범위에서 그 자체로 기능을 수행합니다.

407
00:22:10,000 --> 00:22:13,000
우리는 라인 40 그 바꾼 값을 누르 자마자

408
00:22:13,000 --> 00:22:16,000
버려진 된, 그래서 아무것도

409
00:22:16,000 --> 00:22:21,000
원래 함수에서 주는 실제로 전혀 변경되었습니다

410
00:22:21,000 --> 00:22:26,000
이 우리의 기억의 관점에서 어떻게 생겼는지에 관해서 후 다시 생각 때문에 경우

411
00:22:26,000 --> 00:22:29,000
보드의 왼쪽에 나타냅니다-IF

412
00:22:29,000 --> 00:22:33,000
그래서 난보고 모든 사람을 위해 최선을 다하겠습니다이-IF 보드의 왼쪽

413
00:22:33,000 --> 00:22:37,000
대표, 당신의 RAM 말을하고, 스택이 올라 오는 길에 성장 것입니다

414
00:22:37,000 --> 00:22:43,000
우리는 주와 같은 함수를 호출하고, 주요 2 지역 변수 x와 y를 가지고

415
00:22:43,000 --> 00:22:48,000
의는 여기에 X로 사람들을 설명하게하고, 주자는 여기에 Y 이러한을 설명,

416
00:22:48,000 --> 00:22:55,000
과가 값 1과 2에 놓고,이 사람은 주입니다 때문에

417
00:22:55,000 --> 00:22:58,000
와 주요은 스왑 기능을 운영 체제 호출하면

418
00:22:58,000 --> 00:23:02,000
, 스택에 스왑 기능 할 메모리 자체의 주위를 제공합니다

419
00:23:02,000 --> 00:23:04,000
스택의 자체 프레임은, 말하자면합니다.

420
00:23:04,000 --> 00:23:08,000
또한 이러한 ints 32 비트를 할당합니다.

421
00:23:08,000 --> 00:23:11,000
그것은 그와 b 전화 일이 있지만, 완전히 임의의입니다.

422
00:23:11,000 --> 00:23:13,000
그것은 원하는대로 그들에게 전화를 수 있지만 때 주요 무슨 일이 벌어 지

423
00:23:13,000 --> 00:23:19,000
통화 스왑은이 일이 소요가 사본을 놓고, 거기에 복사본을두고 있습니다.

424
00:23:19,000 --> 00:23:23,000
>> 스왑 1 기타 지역 변수가 있습니다,하지만, 뭐라고? >>의 TMP이 있습니다.

425
00:23:23,000 --> 00:23:27,000
tmp를, 그래서 내가 스스로 여기에서 다른 32 비트를 해주지

426
00:23:27,000 --> 00:23:29,000
내가이 함수에서 무슨 짓을 한거야?

427
00:23:29,000 --> 00:23:34,000
나는 INT TMP는, 그래서 1가 도착했다, 그래서 우리가 마지막으로이 예제와 함께 연기 할 때 난 이런 짓을.

428
00:23:34,000 --> 00:23:39,000
그리고 a는 b를 얻을 수 있으므로 B는 2, 그래서이게는 2가되고,

429
00:23:39,000 --> 00:23:42,000
지금, B는 온도를 얻을 수 있으므로 온도가 1

430
00:23:42,000 --> 00:23:44,000
그래서 지금 B가됩니다.

431
00:23:44,000 --> 00:23:46,000
잘 됐네요. 이했다.

432
00:23:46,000 --> 00:23:49,000
하지만 즉시 함수의 반환 등

433
00:23:49,000 --> 00:23:52,000
스왑 메모리 효율적는 재사용 할 수 있도록 사라

434
00:23:52,000 --> 00:23:58,000
미래의 어떤 다른 기능에 의해, 그리고 메인은 분명 완전히 변경되지 것입니다.

435
00:23:58,000 --> 00:24:00,000
우리는 근본적으로이 문제를 해결하는 방법이 필요합니다

436
00:24:00,000 --> 00:24:03,000
그리고 오늘은 드디어된다이 일을하는 방법을해야합니다

437
00:24:03,000 --> 00:24:06,000
우리는 포인터라는 것을 소개 할 수 있습니다.

438
00:24:06,000 --> 00:24:09,000
우리가이 문제를 해결 할 수 밝혀

439
00:24:09,000 --> 00:24:12,000
x와 y의 사본을 전달하지 않음으로써

440
00:24:12,000 --> 00:24:18,000
대신 무엇에 전달하여, 당신은 스왑 함수를 생각합니까?

441
00:24:18,000 --> 00:24:20,000
네, 주소는 어떤가요?

442
00:24:20,000 --> 00:24:22,000
우리는 정말 많은 세부 주소에 대해 얘기하지 않은

443
00:24:22,000 --> 00:24:25,000
하지만 칠판이 내 컴퓨터의 메모리를 나타냅니다 경우

444
00:24:25,000 --> 00:24:28,000
우리는 확실히 내 RAM의 바이트를 번호 시작할 수

445
00:24:28,000 --> 00:24:31,000
그리고는이 바이트 # 1 말,이 바이트 # 3, # 2 바이트입니다

446
00:24:31,000 --> 00:24:35,000
바이트 # 4 바이트 # 2000000000 나 RAM의 2 기가 바이트가있는 경우,

447
00:24:35,000 --> 00:24:38,000
그래서 우리는 확실히 어떤 임의의 번호 체계 마련 할 수

448
00:24:38,000 --> 00:24:41,000
내 컴퓨터의 메모리에있는 모든 개별 바이트.

449
00:24:41,000 --> 00:24:43,000
>> 나는 스왑 만약 대신 호출 할 때

450
00:24:43,000 --> 00:24:47,000
x와 y의 사본에서보다는 패스

451
00:24:47,000 --> 00:24:51,000
왜 내가 대신 여기에 X의 주소에 전달하지 않습니다

452
00:24:51,000 --> 00:24:55,000
여기 y의 주소, 본질적 우편 주소

453
00:24:55,000 --> 00:24:59,000
그가 정보되는 경우 X와 Y 때문에이 후, 교환

454
00:24:59,000 --> 00:25:01,000
x와 y의 메모리에 주소,

455
00:25:01,000 --> 00:25:04,000
우리가 그에게 조금 훈련하면,, 스왑

456
00:25:04,000 --> 00:25:07,000
그는 잠재적으로 말하자면, 해당 주소로 운전할 수

457
00:25:07,000 --> 00:25:11,000
X, 그리고 번호를 변경 한 다음, y의 주소로 유도

458
00:25:11,000 --> 00:25:16,000
실제로 그 값이 자신의 사본을 받고도 못하면서,이 번호를 변경

459
00:25:16,000 --> 00:25:19,000
우리는 메인 메모리하다고이 얘기를 그렇게하더라도

460
00:25:19,000 --> 00:25:23,000
이 같은 것 스왑 메모리 강력하고 C의 위험한 부분

461
00:25:23,000 --> 00:25:28,000
모든 기능이 어디서든 컴퓨터의 메모리를 만져 볼 수 있다는 것입니다

462
00:25:28,000 --> 00:25:32,000
이는 C.의 컴퓨터 프로그램과 매우 멋진 일을 할 수 있다는 점에서 강력하다

463
00:25:32,000 --> 00:25:36,000
당신은 매우 쉽게 실수 할 수 있기 때문에이 위험합니다.

464
00:25:36,000 --> 00:25:39,000
사실, 프로그램의 가장 일반적인 방법 요즘 중 하나가 악용 할

465
00:25:39,000 --> 00:25:42,000
프로그래머는 실현하지에 아직

466
00:25:42,000 --> 00:25:45,000
그 또는 그녀가 데이터를 수 있다는

467
00:25:45,000 --> 00:25:49,000
의도되지 않은 메모리에 위치에 쓸 수 있습니다.

468
00:25:49,000 --> 00:25:51,000
>> 예를 들어, 그 또는 그녀는 10 사이즈의 배열을 선언

469
00:25:51,000 --> 00:25:56,000
하지만 실수로 메모리의 배열로 11 바이트를 넣어하려고

470
00:25:56,000 --> 00:25:59,000
그리고 당신은 더 이상 유효하지 않습니다 메모리의 일부를 만지고 시작합니다.

471
00:25:59,000 --> 00:26:02,000
문맥이 일에, 당신의 일부가 알 수도있는 그

472
00:26:02,000 --> 00:26:06,000
소프트웨어는 종종 일련 번호 또는 등록 키를 묻는 메시지를 표시

473
00:26:06,000 --> 00:26:08,000
포토샵 및 Word와 같은 프로그램.

474
00:26:08,000 --> 00:26:12,000
, 당신은 약간의 프로그램을 실행할 수 있습니다 온라인 어디 있는지의 일부가 알다시피, 균열이 존재

475
00:26:12,000 --> 00:26:14,000
그리고 여기에도, 일련 번호에 대한 더 요청.

476
00:26:14,000 --> 00:26:16,000
그는 어떻게 작동합니까?

477
00:26:16,000 --> 00:26:21,000
대부분의 경우 이런 일이 단순히 컴퓨터에서 찾아 아르

478
00:26:21,000 --> 00:26:24,000
컴퓨터의 실제 제로과 사랑하는 사람들의 텍스트 세그먼트

479
00:26:24,000 --> 00:26:28,000
일련 번호가 요청되는 기능은, 어디에

480
00:26:28,000 --> 00:26:31,000
프로그램이 실행되는 동안 당신은 그 공간을 덮어, 또는

481
00:26:31,000 --> 00:26:33,000
키가 실제로 저장되는 위치를 알아 알아낼 수

482
00:26:33,000 --> 00:26:37,000
무언가를 사용하여 디버거라고, 당신은 소프트웨어를 그런 식으로 해킹 할 수 있습니다.

483
00:26:37,000 --> 00:26:40,000
이것은 며칠이 우리의 목표입니다 말할 수 없습니다

484
00:26:40,000 --> 00:26:42,000
하지만 매우 실제 파급 효과가 있습니다.

485
00:26:42,000 --> 00:26:45,000
하나는 소프트웨어의 도난을 포함 한테 무슨 일이

486
00:26:45,000 --> 00:26:47,000
그러나 전체 기계의 타협도 있습니다.

487
00:26:47,000 --> 00:26:50,000
>> 사실 때, 웹 사이트 요즘엔 악용 아르

488
00:26:50,000 --> 00:26:53,000
그리고 손상 및 데이터 유출과 비밀번호를 도난

489
00:26:53,000 --> 00:26:58,000
이 자주 사람의 기억의 가난한 관리에 관한 것으로,

490
00:26:58,000 --> 00:27:01,000
또는, 데이터베이스의 경우, 실패는 예상 할 수

491
00:27:01,000 --> 00:27:03,000
올 주에 해당에서도 이렇게 많은 적대 입력,,

492
00:27:03,000 --> 00:27:07,000
하지만 지금은 당신이 할 수있는 손상의 종류의 단지 미리

493
00:27:07,000 --> 00:27:11,000
상당히 일이 후드 아래에 어떻게 작동하는지 이해하지 않는 방법으로.

494
00:27:11,000 --> 00:27:14,000
가 고장 이유를 이해 가자

495
00:27:14,000 --> 00:27:17,000
도구를 사용하여 그 더 유용한 될 것이다

496
00:27:17,000 --> 00:27:19,000
우리의 프로그램은 더 복잡한 얻을 있습니다.

497
00:27:19,000 --> 00:27:21,000
귀하의 프로그램에서 버그를 했어 지금까지 때

498
00:27:21,000 --> 00:27:23,000
어떻게 디버깅에 대해 갔나 요?

499
00:27:23,000 --> 00:27:25,000
당신의 기술은 당신의 TF에 의해 진행 여부, 지금까지되었습니다

500
00:27:25,000 --> 00:27:27,000
또는 독학?

501
00:27:27,000 --> 00:27:29,000
[학생] Printf.

502
00:27:29,000 --> 00:27:31,000
니가보고 싶어하는 경우 Printf, 그래서 printf 아마에 친구있다

503
00:27:31,000 --> 00:27:33,000
프로그램 속에 무슨 일이 일어나는 거지

504
00:27:33,000 --> 00:27:36,000
당신은 printf 여기 printf 여기 printf 여기를 넣어.

505
00:27:36,000 --> 00:27:38,000
그런 다음 당신은 그걸 실행하고 화면에 물건을 왕창를

506
00:27:38,000 --> 00:27:43,000
당신은 실제로 당신의 프로그램에 문제가 무슨 일 추론하는 데 사용할 수있는.

507
00:27:43,000 --> 00:27:45,000
>> Printf, 매우 강력한 일이 될 경향이

508
00:27:45,000 --> 00:27:47,000
하지만 매우 수동 프로세스입니다.

509
00:27:47,000 --> 00:27:49,000
당신은 printf 여기, 여기에 printf를 넣어해야

510
00:27:49,000 --> 00:27:51,000
및 루프 내부 넣어 경우는 100 선을 수

511
00:27:51,000 --> 00:27:53,000
그런 다음을 통해 선별해야한다는 출력.

512
00:27:53,000 --> 00:27:58,000
그것은 디버깅 프로그램에 대한 매우 사용자 친화적 인 또는 대화 형 메커니즘 아닙니다

513
00:27:58,000 --> 00:28:00,000
하지만 다행히도 대안이 존재한다.

514
00:28:00,000 --> 00:28:03,000
GDB라는 예를 들어 프로그램,,, GNU 디버거가 있어요

515
00:28:03,000 --> 00:28:06,000
어떤 당신이 사용하는 방법에 약간의 마법입니다.

516
00:28:06,000 --> 00:28:08,000
그것은 솔직히 조금 복잡하지만,

517
00:28:08,000 --> 00:28:11,000
여러분이 이번 주에 넣어 경우 것들 중 하나이며 옆에 있습니다

518
00:28:11,000 --> 00:28:14,000
GDB 같은 것을 이해하는 여분의 시간

519
00:28:14,000 --> 00:28:18,000
그것은 장기적으로 당신에게 시간의 아마도 수십 저장됩니다

520
00:28:18,000 --> 00:28:21,000
그래서 함께, 내가 이일을 어떻게 티저 줘.

521
00:28:21,000 --> 00:28:23,000
>> 내 터미널 창에서입니다.

522
00:28:23,000 --> 00:28:26,000
내가 가서이 프로그램 buggy3을 컴파일한다.

523
00:28:26,000 --> 00:28:28,000
이 최신 이미 있습니다.

524
00:28:28,000 --> 00:28:31,000
우리가 잠시을 다시 한, 그리고 실제로, 고장이에요처럼 저를 실행할 수 있습니다.

525
00:28:31,000 --> 00:28:34,000
하지만 왜인가요? 아마 내가 스왑 기능을 망 쳤어.

526
00:28:34,000 --> 00:28:37,000
아마도 a와 b입니다. 나는 제대로 그 주위에 떠나지 않을거야.

527
00:28:37,000 --> 00:28:39,000
내가 가서이를 보자.

528
00:28:39,000 --> 00:28:43,000
보다는, 제가 대신이 프로그램 GDB를 실행하게 buggy3 실행

529
00:28:43,000 --> 00:28:48,000
그리고 난 buggy3을 실행하도록 말 하겠어요

530
00:28:48,000 --> 00:28:52,000
나는 명령 줄 인수,-tui를 포함 할거야

531
00:28:52,000 --> 00:28:55,000
우리는 상기시키기 사양에서 향후 문제에 넣으면됩니다.

532
00:28:55,000 --> 00:28:57,000
그리고 지금은 검은 색과 흰색 인터페이스는, 다시 그 부분을 꼬

533
00:28:57,000 --> 00:28:59,000
이 있기 때문에 처음에는 약간 압도 수 있습니다

534
00:28:59,000 --> 00:29:02,000
여기에 보증 정보,하지만 적어도 잘 알고있는 게있다.

535
00:29:02,000 --> 00:29:04,000
창 상단에서 내 실제 코드입니다

536
00:29:04,000 --> 00:29:08,000
내가 여기까지 스크롤하는 경우는, 내 파일의 맨 위에로 이동하게

537
00:29:08,000 --> 00:29:11,000
그리고 실제로,이 창 하단의 buggy3.c 및 통지가

538
00:29:11,000 --> 00:29:13,000
이 GDB 프롬프트를 갖추고 있습니다.

539
00:29:13,000 --> 00:29:16,000
>> 이건 내 일반 존 하버드 프롬프트와 동일하지 않습니다.

540
00:29:16,000 --> 00:29:19,000
이 날 GDB를 제어 할 수 있도록거야 프롬프트입니다.

541
00:29:19,000 --> 00:29:21,000
GDB는 디버거입니다.

542
00:29:21,000 --> 00:29:24,000
디버거가 통과 할 수있는 프로그램입니다

543
00:29:24,000 --> 00:29:27,000
선으로 선으로 프로그램 라인의 실행,

544
00:29:27,000 --> 00:29:30,000
방법은 당신이 프로그램을 개발하고자하는 아무 짓도 함께

545
00:29:30,000 --> 00:29:33,000
심지어 더 중요한 것은 함수를 호출하거나, 찾고

546
00:29:33,000 --> 00:29:35,000
다양한 변수의 값에.

547
00:29:35,000 --> 00:29:37,000
가 진행이 짓을 보자.

548
00:29:37,000 --> 00:29:40,000
나는 가서 GDB의 프롬프트에 실행에 입력 할거야

549
00:29:40,000 --> 00:29:43,000
그래서 입력 실행 한 화면의 왼쪽 하단에있는 것을,

550
00:29:43,000 --> 00:29:45,000
그리고 입력을 눌렀 는데도, 그게 무슨 짓을 한거야?

551
00:29:45,000 --> 00:29:50,000
그것은 그대로 내 프로그램을 실행하지만, 실제로 이곳에서는 계속 보지 못 했어

552
00:29:50,000 --> 00:29:55,000
사실은 디버거에게하지 않았기 때문에

553
00:29:55,000 --> 00:29:57,000
시간에 특정 순간을 일시 중지합니다.

554
00:29:57,000 --> 00:29:59,000
그냥 실행을 입력하면 프로그램을 실행합니다.

555
00:29:59,000 --> 00:30:01,000
사실은 아무 것도 표시되지 않습니다. 난 조작 할 수 없습니다.

556
00:30:01,000 --> 00:30:03,000
>> 대신 저를 내버려 두세요.

557
00:30:03,000 --> 00:30:08,000
이 GDB 프롬프트에서 나를 대신 입력 휴식을 입력 보자.

558
00:30:08,000 --> 00:30:10,000
그게 내가 입력 할 뜻이 아니고.

559
00:30:10,000 --> 00:30:13,000
휴식 시간이 주 입력 대신합시다.

560
00:30:13,000 --> 00:30:15,000
즉, 나는 중단 점이라는 것을, 설정하려면

561
00:30:15,000 --> 00:30:18,000
부러 또는 일시 중지되므로 aptly라는 이름있는

562
00:30:18,000 --> 00:30:21,000
특정 장소에서 프로그램의 실행.

563
00:30:21,000 --> 00:30:23,000
주요 내 함수의 이름입니다.

564
00:30:23,000 --> 00:30:25,000
GDB은 꽤 영리 것을 확인할 수 있습니다.

565
00:30:25,000 --> 00:30:28,000
이 메인 줄 18 약 시작하는 일이 있다고 알아 냈어

566
00:30:28,000 --> 00:30:32,000
buggy3.c의 후 왼쪽 상단 여기 발견

567
00:30:32,000 --> 00:30:34,000
B + 라인 18 바로 옆에 위치해 있습니다.

568
00:30:34,000 --> 00:30:38,000
그게 내가 줄 18 중단 점을 설정 한 나를 괴롭게있어.

569
00:30:38,000 --> 00:30:42,000
이번에는 제가 실행을 입력 할 때, 난 내 프로그램을 실행거야

570
00:30:42,000 --> 00:30:45,000
최대 때까지, 그 정지 점에 도달

571
00:30:45,000 --> 00:30:48,000
그래서이 프로그램은 라인 18 나를 위해 일시​​ 중지됩니다.

572
00:30:48,000 --> 00:30:50,000
여기, 시작 실행합니다.

573
00:30:50,000 --> 00:30:53,000
아무 일도 것 같습니다 없지만, 하단에 통지 왼쪽으로

574
00:30:53,000 --> 00:30:58,000
시작 프로그램 buggy3, buggy3.c 라인 18 주에 중단 점 1.

575
00:30:58,000 --> 00:31:00,000
지금은 무엇을 할 수 있을까요?

576
00:31:00,000 --> 00:31:03,000
>> 주의 나는, 인쇄 등을 입력하기 시작하면

577
00:31:03,000 --> 00:31:08,000
하지 printf, 인쇄 X, 지금 이상입니다.

578
00:31:08,000 --> 00:31:11,000
우리가 보게 될 $ 1, 단지 호기심입니다

579
00:31:11,000 --> 00:31:14,000
당신이 뭔가를 인쇄 할 때마다 당신은 새로운 $ 값을 얻을.

580
00:31:14,000 --> 00:31:18,000
즉, 방금 경우 이전 값으로 참조 할 수 있도록입니다

581
00:31:18,000 --> 00:31:21,000
하지만 지금은 어떤 인쇄가 나에게 말해주고있는 것은 그 이야기의이 시점에서 X의 값

582
00:31:21,000 --> 00:31:26,000
분명 134,514,032입니다.

583
00:31:26,000 --> 00:31:29,000
왜? 그조차 어디에서 왔는가?

584
00:31:29,000 --> 00:31:31,000
[안 들리게 - 학생이]

585
00:31:31,000 --> 00:31:34,000
사실, 우리가 쓰레기 값을 뭐라고 부를이며, 우리는 아직 얘기를 못 했어

586
00:31:34,000 --> 00:31:37,000
하지만 변수를 초기화하는 이유

587
00:31:37,000 --> 00:31:40,000
분명 그들 당신이 그들을 가지고 싶은 어떤 값을 가지고 있다는 것입니다.

588
00:31:40,000 --> 00:31:44,000
그러나 캐치는 변수를 선언 할 수있는 기억입니다

589
00:31:44,000 --> 00:31:46,000
내 시그마 예에서 잠시 전에 그랬던 것처럼

590
00:31:46,000 --> 00:31:48,000
실제로 그들에게 가치를 제공하지 않고.

591
00:31:48,000 --> 00:31:50,000
제가 시그마에 여기에 무슨 짓을했는지 기억합니다.

592
00:31:50,000 --> 00:31:52,000
난 상을 선언하지만, 난 어떤 가치를 줬나요?

593
00:31:52,000 --> 00:31:56,000
없음, 내가 알았 기 때문에 그 다음 몇 줄의

594
00:31:56,000 --> 00:31:59,000
GetInt은 n의 내부 값을 퍼팅의 문제를 해결할 것입니다.

595
00:31:59,000 --> 00:32:02,000
>> 그러나 라인 (11)의 이야기이 시점에서

596
00:32:02,000 --> 00:32:05,000
그리고 라인 12 라인 13 라인 14

597
00:32:05,000 --> 00:32:08,000
이러한 여러 줄에 걸쳐 n의 값은 무엇인가?

598
00:32:08,000 --> 00:32:10,000
C에서 당신은 아직 잘 몰라요.

599
00:32:10,000 --> 00:32:14,000
그것은 일반적으로 어떤 쓰레기 값 일부를 완전히 임의의 숫자입니다

600
00:32:14,000 --> 00:32:17,000
일부 이전 함수에서 기본적으로 남은 그

601
00:32:17,000 --> 00:32:21,000
프로그램이 실행만큼 실행 된 것으로

602
00:32:21,000 --> 00:32:24,000
기능은 기능, 기능, 함수를 얻을 수 있다는 연상케합니다.

603
00:32:24,000 --> 00:32:27,000
모든 프레임 다음 해당 함수 수익을 메모리에 넣어 질

604
00:32:27,000 --> 00:32:31,000
불과 같은 자신의 메모리가 결국 재사용되는 지우개를 제안했습니다.

605
00:32:31,000 --> 00:32:37,000
뭐, 그냥이 프로그램에 해당이 변수 x를 발생

606
00:32:37,000 --> 00:32:41,000
134,514,032 같은 쓰레기 값을 포함 것 같습니다

607
00:32:41,000 --> 00:32:44,000
일부 이전 함수에서, 없어 내가 쓴 것을.

608
00:32:44,000 --> 00:32:47,000
그것은 운영 체제와 효과적으로 제공 것일 수도

609
00:32:47,000 --> 00:32:49,000
후드 아래에 몇 가지 기능입니다.

610
00:32:49,000 --> 00:32:52,000
>> 그래, 좋아, 그러나 다음 줄로 넘어 지금 보자.

611
00:32:52,000 --> 00:32:55,000
내 GDB 프롬프트에서 "다음"을 입력하고면, 입력을 누르

612
00:32:55,000 --> 00:32:58,000
주의 그, 라인 (19)으로 이동을 강조

613
00:32:58,000 --> 00:33:01,000
하지만 논리적 의미는 라인 18

614
00:33:01,000 --> 00:33:06,000
이제 완료가 다시 입력하면, 실행 "인쇄 X"

615
00:33:06,000 --> 00:33:10,000
지금은 1 참조하고, 실제로, 알아.

616
00:33:10,000 --> 00:33:14,000
다시 말하지만, $ 물건은 GDB가 당신을 상기의 방법입니다

617
00:33:14,000 --> 00:33:17,000
인쇄물의 역사는 당신이 한 것이 무엇입니까.

618
00:33:17,000 --> 00:33:21,000
지금 내가 진행와 y를 인쇄하게, 그리고 실제로, y는뿐만 아니라 어떤 미친 가치입니다

619
00:33:21,000 --> 00:33:24,000
하지만 큰 거래는 라인 (19)에 우리는 약을 할당 할 수없고 때문에

620
00:33:24,000 --> 00:33:27,000
값 2, 그래서 다시 "다음"을 입력 보자.

621
00:33:27,000 --> 00:33:29,000
그리고 지금 우리는 printf 라인에서하고 있습니다.

622
00:33:29,000 --> 00:33:31,000
나 인쇄 X를 보자.

623
00:33:31,000 --> 00:33:34,000
나 인쇄 Y를 보자. 솔직히,이 인쇄를 약간 지겨워 요.

624
00:33:34,000 --> 00:33:38,000
나 대신 "표시 X"와 "Y 표시"를 입력하자

625
00:33:38,000 --> 00:33:41,000
지금 때마다 나는 미래에 명령을 입력

626
00:33:41,000 --> 00:33:45,000
나는 어떤의 알림 메시지가 표시됩니다 어떤 x와 y, x와 y, x와 y는거야.

627
00:33:45,000 --> 00:33:48,000
>> I 또한에 따로 입력으로 "정보 주민들."

628
00:33:48,000 --> 00:33:50,000
정보는 특별한 명령입니다.

629
00:33:50,000 --> 00:33:52,000
주민들은 저에게 지역 변수를 보여줍니다 의미합니다.

630
00:33:52,000 --> 00:33:55,000
잊지 또는이 미친, 복잡한 기능입니다 만 경우에

631
00:33:55,000 --> 00:33:57,000
I 또는 다른 사람이 정보 현지인을 알려드립니다 썼다

632
00:33:57,000 --> 00:34:00,000
이 로컬 함수 안의 모든 지역 변수는 무엇입니까

633
00:34:00,000 --> 00:34:03,000
당신이 주변에 찔러하려는 경우 신경 수도.

634
00:34:03,000 --> 00:34:07,000
이제 printf 그러니 내가 앞서 불과 유형 놓아을 실행하는 약 "다음."

635
00:34:07,000 --> 00:34:10,000
이 상황에서 우리가이기 때문 우리는 실제로 표시되지 않는

636
00:34:10,000 --> 00:34:14,000
여기에 실행하지만, 여기에 약간의 맹 글링지고납니다.

637
00:34:14,000 --> 00:34:17,000
하지만,이 화면을 오버 라이딩있어 발견

638
00:34:17,000 --> 00:34:21,000
그래서 여기에 완벽한 프로그램은 아니지만, 난 항상 주위에 찌른 할 수 있기 때문에 괜찮아요

639
00:34:21,000 --> 00:34:23,000
내가 원하는 경우 인쇄를 사용합니다.

640
00:34:23,000 --> 00:34:26,000
>> 나 다음 다시 입력하자, 이제 여기가 흥미로운 부분입니다.

641
00:34:26,000 --> 00:34:29,000
이야기의이 시점에서, Y는 2이고, x는 1

642
00:34:29,000 --> 00:34:32,000
여기에 제안, 다시로

643
00:34:32,000 --> 00:34:35,000
나는 명령을 사용하기 때문에 자동으로 현재 표시되는 이유는

644
00:34:35,000 --> 00:34:40,000
디스플레이 x와 y를 표시, 다음 입력 있으므로 순간

645
00:34:40,000 --> 00:34:43,000
이론 x와 y에 스왑 수있게됩니다.

646
00:34:43,000 --> 00:34:45,000
이제, 우리는 이미 경우가되지 않을 거라는 것 알고,

647
00:34:45,000 --> 00:34:49,000
그러나 우리는 그 사실을했는지 생각해 보는 깊이 잠수 할 수있는 방법을 순간에 표시됩니다.

648
00:34:49,000 --> 00:34:54,000
불행하게도 다음, 그리고 y는 여전히 2와 x는 여전히 1, 내가 많이 확인할 수 있습니다.

649
00:34:54,000 --> 00:34:56,000
인쇄 X, Y 인쇄.

650
00:34:56,000 --> 00:34:59,000
사실, 교환도 실제로 일어난 있으므로이 시작하자 없습니다.

651
00:34:59,000 --> 00:35:01,000
분명 스왑이 고장 났어요.

652
00:35:01,000 --> 00:35:04,000
의 대신 다시 "실행"을 입력 보자.

653
00:35:04,000 --> 00:35:07,000
내가 네 말을하자, 나는 처음부터 다시 시작하려면, 입력합니다.

654
00:35:07,000 --> 00:35:09,000
>> 지금은 백업 라인 18입니다.

655
00:35:09,000 --> 00:35:11,000
지금 x와 y가 다시 쓰레기​​ 값입니다 확인합니다.

656
00:35:11,000 --> 00:35:15,000
다음 다음, 다음, 다음.

657
00:35:15,000 --> 00:35:17,000
제가 지루해지면 또 바로 옆에 n을 입력 할 수 있습니다.

658
00:35:17,000 --> 00:35:21,000
당신은 문자 중 가장 짧은 가능한 순서로 생략 할 수 있습니다.

659
00:35:21,000 --> 00:35:23,000
스왑은 지금 고장 났어요.

660
00:35:23,000 --> 00:35:25,000
대신 옆에 입력하는 그래서에의 다이빙을하자,

661
00:35:25,000 --> 00:35:30,000
내가이 함수의 내부 스테핑는 .. 그래서 지금은 단계를 입력 할거야

662
00:35:30,000 --> 00:35:33,000
내가 통과 할 수 있도록 I 단계를 누르 입력 한 다음 Enter 때문에.

663
00:35:33,000 --> 00:35:37,000
공지 라인 36 내 프로그램에서 강조 점프가 다운 낮은 그.

664
00:35:37,000 --> 00:35:39,000
이제 지역 변수은 무엇입니까?

665
00:35:39,000 --> 00:35:41,000
정보 주민들.

666
00:35:41,000 --> 00:35:43,000
우리가 선에 미치지 못하는 하였기 때문에 아직 아무 것도 아니에요,

667
00:35:43,000 --> 00:35:47,000
그러니 어서 가서 말을 들어 "다음을."

668
00:35:47,000 --> 00:35:50,000
이제 우리는 tmp를 인쇄 TMP을 갖고있는 것 같다.

669
00:35:50,000 --> 00:35:52,000
쓰레기 값을, 그렇지? 그런 것 같아요.

670
00:35:52,000 --> 00:35:55,000
방법에 대해, 인쇄 B, 1과 2를 인쇄?

671
00:35:55,000 --> 00:35:58,000
순간에 최대한 빨리 다음 다시 입력 할 때

672
00:35:58,000 --> 00:36:02,000
tmp를이 희망, 1의 값을 걸릴 것입니다

673
00:36:02,000 --> 00:36:05,000
TMP는 a의 값을 할당 할 것입니다 때문입니다.

674
00:36:05,000 --> 00:36:08,000
>> 이제 한, 인쇄 B를 인쇄하자하면,

675
00:36:08,000 --> 00:36:11,000
지금 tmp를 인쇄하고는 실제로 1.

676
00:36:11,000 --> 00:36:14,000
내가 다음에하자. 내가 다음에하자.

677
00:36:14,000 --> 00:36:16,000
나는 스왑 기능을 완료했습니다.

678
00:36:16,000 --> 00:36:19,000
I 줄 40에서 내부 아직, 그럼 내가를 인쇄 해,

679
00:36:19,000 --> 00:36:22,000
인쇄 B, 그리고 TMP이 무슨 상관 없어요.

680
00:36:22,000 --> 00:36:27,000
는 a와 b를 교환 할 때 스왑이 올바른지 것 같습니다.

681
00:36:27,000 --> 00:36:31,000
하지만 지금 옆에 입력하면, 전 라인 25 다시 이동

682
00:36:31,000 --> 00:36:34,000
그리고 물론, x와 y를 인쇄에 입력 한 경우

683
00:36:34,000 --> 00:36:38,000
그들은 여전히​​ 변경되지 않은거야, 자, 우리가 문제를 해결하지 않았습니다.

684
00:36:38,000 --> 00:36:41,000
그러나 diagnostically 지금은 아마도이 G​​DB 프로그램

685
00:36:41,000 --> 00:36:44,000
우리는 적어도 이해에 한 걸음 더 가까이 늘어 놓던

686
00:36:44,000 --> 00:36:47,000
무슨 일이 여기에 printf를 넣어 쓰레기에 우리의 코드를하지 않고 잘못된거야,

687
00:36:47,000 --> 00:36:50,000
printf 여기 printf 여기 다시하고 다시 실행

688
00:36:50,000 --> 00:36:52,000
잘못 무슨 일이야 알아 내려고.

689
00:36:52,000 --> 00:36:55,000
>> 그만 둘과 모두 가서이 빠져 종료거야.

690
00:36:55,000 --> 00:36:57,000
그렇다면 말을거야 "어쨌든 종료?" 예.

691
00:36:57,000 --> 00:37:00,000
지금은 내 정상적인 프롬프트에서 돌아왔다, 나는이 GDB를 사용하여 완료했습니다.

692
00:37:00,000 --> 00:37:03,000
옆으로,이 - tui 플래그를 사용할 필요가 없습니다.

693
00:37:03,000 --> 00:37:07,000
당신이 그것을 생략하는 경우 사실, 당신은 기본적으로 화면의 절반 아랫 부분을.

694
00:37:07,000 --> 00:37:11,000
그때 나는 한 다음 실행 휴식 시간이 주요 입력하고있는 경우

695
00:37:11,000 --> 00:37:15,000
난 아직 내 프로그램을 실행,하지만해야 할 것은 더 textually입니다 수 있습니다

696
00:37:15,000 --> 00:37:18,000
단 시간에 저에게 현재의 라인을 보여줍니다.

697
00:37:18,000 --> 00:37:21,000
- tui, 텍스트 사용자 인터페이스,

698
00:37:21,000 --> 00:37:25,000
단 한 번, 아마 조금 개념적으로 쉽게되는 프로그램의 자세한 보여줍니다.

699
00:37:25,000 --> 00:37:27,000
그러나 사실은, 그냥 다음 다음 다음을 수행 할 수

700
00:37:27,000 --> 00:37:30,000
나는 한 번에 한 라인을 볼거야, 난 정말 무슨 일이 보려는 경우

701
00:37:30,000 --> 00:37:35,000
나는 목록을 입력하고 이웃 라인의 전체 무리를 볼 수 있습니다.

702
00:37:35,000 --> 00:37:39,000
>> 우리가 문제가 3 설정에 감상 것을 요구 한 비디오가

703
00:37:39,000 --> 00:37:43,000
있는 네이트는 GDB의 복잡한의 일부를 포함

704
00:37:43,000 --> 00:37:46,000
이 방법은, 솔직히 그런 것들 중 하나입니다 당신의 일부가 아닌 하찮은 비율

705
00:37:46,000 --> 00:37:49,000
GDB를 터치하지 않습니다, 그건 나쁜 일이 될 것입니다

706
00:37:49,000 --> 00:37:53,000
말 그대로이 학기 나중에 더 많은 시간을 보내고 결국 때문에

707
00:37:53,000 --> 00:37:56,000
버그를 추격하고 다음은 그 반 시간 / 시간에 넣어 싶다면

708
00:37:56,000 --> 00:38:00,000
이번 주하고 다음 학습은 GDB와 편안하게합니다.

709
00:38:00,000 --> 00:38:02,000
Printf 친구였다.

710
00:38:02,000 --> 00:38:05,000
GDB는 이제 친구가 있습니다.

711
00:38:05,000 --> 00:38:08,000
>> GDB에 대한 질문?

712
00:38:08,000 --> 00:38:12,000
여기에서 가장 강력하고 유용한 명령 중 일부에 대한 간단한 목록입니다.

713
00:38:12,000 --> 00:38:15,000
네. >> 당신은 문자열을 인쇄 할 수 있습니까?

714
00:38:15,000 --> 00:38:17,000
당신은 문자열을 인쇄 할 수 있습니까? 물론입니다.

715
00:38:17,000 --> 00:38:19,000
단지 정수가되어야 할 필요는 없습니다.

716
00:38:19,000 --> 00:38:22,000
변수 s은 (는) 인쇄 s의 단지 유형 문자열입니다 경우.

717
00:38:22,000 --> 00:38:24,000
그렇게 문자열 변수가 뭔지를 보여줍니다.

718
00:38:24,000 --> 00:38:26,000
[안 들리게 - 학생이]

719
00:38:26,000 --> 00:38:28,000
그것은 당신에게 주소와 문자열 자체를 제공합니다.

720
00:38:28,000 --> 00:38:32,000
그것은 당신이 모두 표시됩니다.

721
00:38:32,000 --> 00:38:34,000
그리고 마지막 한가지는, 다음도 알려 줘서 때문입니다.

722
00:38:34,000 --> 00:38:37,000
역 추적 및 프레임, 날이 마지막으로에 뛰어하게

723
00:38:37,000 --> 00:38:39,000
GDB와 같은 정확한 프로그램입니다.

724
00:38:39,000 --> 00:38:44,000
내가 가서 텍스트 사용자 인터페이스 버전을 실행하자

725
00:38:44,000 --> 00:38:46,000
주요하다.

726
00:38:46,000 --> 00:38:49,000
내가 가서 다시 실행할 수 있습니다. 난 여기입니다.

727
00:38:49,000 --> 00:38:55,000
내가 그 다음 다음, 다음, 다음, 다음 가게, 스텝, 입력합니다.

728
00:38:55,000 --> 00:39:00,000
>> 그리고 지금 내가 의도적으로 스왑하에 가정하지만, 내가 그랬지 "이런, X의 값이 뭐지?"

729
00:39:00,000 --> 00:39:02,000
난 더 이상 X을 수행 할 수 없습니다.

730
00:39:02,000 --> 00:39:05,000
그들은 범위에 않아서 Y을 수행 할 수 없습니다.

731
00:39:05,000 --> 00:39:07,000
그들은 맥락에서 수 없어,하지만 문제가 발생했습니다.

732
00:39:07,000 --> 00:39:09,000
나는 추적 (backtrace)를 입력 할 수 있습니다.

733
00:39:09,000 --> 00:39:13,000
그게 날 시간에이 시점까지 수행 한 모든 기능을 보여줍니다.

734
00:39:13,000 --> 00:39:16,000
공지 사항이 주요와 메인 하단의 하나는, 선까지

735
00:39:16,000 --> 00:39:18,000
여기 사진의 하단에 존재.

736
00:39:18,000 --> 00:39:22,000
스왑 스왑는 여기에 메모리에 위에 있는게 그 선 위에 있다는 사실,

737
00:39:22,000 --> 00:39:26,000
그리고 일시적으로 주로 돌아 가야 할 경우 "프레임"를 말합니다.

738
00:39:26,000 --> 00:39:30,000
몇호? 메인 프레임 # 1입니다.

739
00:39:30,000 --> 00:39:32,000
나는 가서 말할거야 "프레임 1."

740
00:39:32,000 --> 00:39:36,000
>> 지금은 주에 돌아왔다, 나는 X를 인쇄 할 수 있습니다, 난, y를 인쇄 할 수 있습니다

741
00:39:36,000 --> 00:39:40,000
하지만 A 또는 B를 인쇄 할 수 없습니다.

742
00:39:40,000 --> 00:39:43,000
내가 무슨 말을하면 난 "좋아, 잠깐만. 어디 스왑은 어땠어?"할 수 있습니다

743
00:39:43,000 --> 00:39:46,000
내가 가서 말을하자 "프레임 0."

744
00:39:46,000 --> 00:39:48,000
지금 내가 있기를 원하는 곳 돌아왔다, 그리고 옆으로

745
00:39:48,000 --> 00:39:52,000
당신이 정말로 심심 입력 다음, 다음, 다음, 다음을 받고있는 경우 등의 다른 명령은도 있어요

746
00:39:52,000 --> 00:39:56,000
당신은 일반적으로 "다음 10"같은 일을 말할 수 있으며 그 다음 10 라인을 통해 단계 것입니다.

747
00:39:56,000 --> 00:39:59,000
당신은 또한 당신이 정말 그것을 통해 스테핑 불만을 품고 때 "계속"을 쓸 수 있습니다.

748
00:39:59,000 --> 00:40:05,000
이 다른 중단 점에 도달 할 때까지 계속이 중단없이 프로그램을 실행합니다

749
00:40:05,000 --> 00:40:07,000
루프의 여부 또는 프로그램에 내려.

750
00:40:07,000 --> 00:40:11,000
>> 이 경우 우리는 끝까지 계속,이 프로그램은 정상적으로 종료.

751
00:40:11,000 --> 00:40:13,000
이 멋진 방법, 열악한 과정입니다.

752
00:40:13,000 --> 00:40:16,000
당신의 프로그램이 정상적으로 종료.

753
00:40:16,000 --> 00:40:24,000
비디오 및 온 세션을 디버깅은 그 말에 더.

754
00:40:24,000 --> 00:40:26,000
그건 많이했습니다.

755
00:40:26,000 --> 00:40:35,000
자, 여기 우리의 5 분 휴식을 취, 우리는 structs와 파일에 반환합니다.

756
00:40:35,000 --> 00:40:38,000
>> 당신은 이미 이번 주 pset에 잠수 한 경우

757
00:40:38,000 --> 00:40:41,000
당신은 우리가 배포 코드에서 사용하는 알 수 있습니다

758
00:40:41,000 --> 00:40:45,000
우리가 출발점, 새로운 기술로 귀하에게 제공하는 소스 코드입니다.

759
00:40:45,000 --> 00:40:50,000
특히, 우리는 구조를 들어, 구조체라는 새로운 키워드를 도입

760
00:40:50,000 --> 00:40:53,000
수 있도록 우리는 종류의 사용자 정의 변수를 만들 수 있습니다.

761
00:40:53,000 --> 00:40:57,000
또한, 파일 I / O, 파일 입력 및 출력의 개념을 도입

762
00:40:57,000 --> 00:41:00,000
이 우리가 상태를 저장할 수 있도록합니다

763
00:41:00,000 --> 00:41:03,000
귀하의 출격 보드의 디스크에 파일을

764
00:41:03,000 --> 00:41:06,000
교육 친구들과 난 이해할 수 있도록

765
00:41:06,000 --> 00:41:09,000
어떻게 수동으로 플레이 할 필요없이 프로그램의 내부의

766
00:41:09,000 --> 00:41:11,000
출격의 게임 수십.

767
00:41:11,000 --> 00:41:13,000
우리는 더 automatedly이 작업을 수행 할 수 있습니다.

768
00:41:13,000 --> 00:41:18,000
>> 구조체의이 아이디어는 상당히 설득력있는 문제를 해결합니다.

769
00:41:18,000 --> 00:41:21,000
우리가 어떤 프로그램을 구현하려는 가정

770
00:41:21,000 --> 00:41:25,000
그 든, 학생에 대한 정보를 추적

771
00:41:25,000 --> 00:41:28,000
그리고 학생들은, 예를 들어, 이름을 ID가 있습니다

772
00:41:28,000 --> 00:41:31,000
하버드 같은 곳에서 집 있으므로 이러한 정보 3 조각

773
00:41:31,000 --> 00:41:34,000
우리가 곁에 두려고하는 거예요, 그럼 내가 가서 여기 좀 프로그램을 작성할하게,

774
00:41:34,000 --> 00:41:38,000
stdio.h 포함되어 있습니다.

775
00:41:38,000 --> 00:41:42,000
저 cs50.h.을 포함하자

776
00:41:42,000 --> 00:41:44,000
그리고 내 main 함수를 시작합니다.

777
00:41:44,000 --> 00:41:46,000
나는 모든 명령 줄 인수와 함께 귀찮게하지 않을거야

778
00:41:46,000 --> 00:41:49,000
그리고 여기 당신이 학생을하려는, 그래서 제가 말할거야

779
00:41:49,000 --> 00:41:54,000
학생은 이름이, 그래서 말할거야 "문자열의 이름을."

780
00:41:54,000 --> 00:41:59,000
그럼, 학생도 있으므로 INT ID를 ID가 말할거야

781
00:41:59,000 --> 00:42:03,000
그리고 학생은 집에 있고, 그래서도 말할거야 "문자열의 집."

782
00:42:03,000 --> 00:42:06,000
그리고 이런 식으로 더 깨끗하게이 조금 주문합니다.

783
00:42:06,000 --> 00:42:11,000
자, 이제 정말 "학생."되는 학생을 대표하는 3 개의 변수가

784
00:42:11,000 --> 00:42:15,000
>> 그리고 지금은 이러한 값을 입력하려면, 그럼 내가 이런 일을 가서 말을 해

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

786
00:42:18,000 --> 00:42:21,000
이름 데이비드를 얻을 것이다.

787
00:42:21,000 --> 00:42:24,000
하자 집, 메이를 얻을 것이다라고

788
00:42:24,000 --> 00:42:31,000
그럼 내가 ( "% s의, 임의의 printf처럼 뭔가를해야 겠어

789
00:42:31,000 --> 00:42:37,000
그의 ID % d 개입니다는 % s이 (가)에 살고있다.

790
00:42:37,000 --> 00:42:41,000
그리고 지금, 난 여기에 연결하기 위해 다른 후 하나를 무엇을 원하는 겁니까?

791
00:42:41,000 --> 00:42:47,000
이름, ID, 집, 반환 0.

792
00:42:47,000 --> 00:42:50,000
좋아요,하지 않는 한 나는 여기 어딘가 망 쳤어

793
00:42:50,000 --> 00:42:54,000
나는 우리가 한 학생을 저장 상당히 좋은 프로그램이있는 것 같아.

794
00:42:54,000 --> 00:42:57,000
물론,이 모든 재미 없습니다. 내가이 학생을시키고 자한다면 어떻게해야 할까?

795
00:42:57,000 --> 00:42:59,000
더 큰 문제는 없습니다. I은 2 명을 지원할 수 있습니다.

796
00:42:59,000 --> 00:43:03,000
내가 가서이를 강조 표시하고 여기로 가자,

797
00:43:03,000 --> 00:43:09,000
나는 커크 랜드에 살고있는 롭 같은 사람 "ID = 456"라고 할 수 있습니다.

798
00:43:09,000 --> 00:43:12,000
>> 자, 잠깐,하지만이 같은 호출 할 수 없습니다

799
00:43:12,000 --> 00:43:15,000
그리고이 일을 복사 할 말이 있어요 같은데,

800
00:43:15,000 --> 00:43:19,000
그러니이 다윗의 변수가 될 것으로 가정 해 보겠습니다,

801
00:43:19,000 --> 00:43:23,000
이 날 남편이 중 일부 사본을 가자.

802
00:43:23,000 --> 00:43:27,000
이러한 롭 전화 할게하지만 지금은 안 먹힌다

803
00:43:27,000 --> 00:43:33,000
난 - 기다릴 때문에, 어디 NAME1과 house1, ID1 저를 변경할.

804
00:43:33,000 --> 00:43:35,000
롭, 2 2 될 것입니다.

805
00:43:35,000 --> 00:43:42,000
여기, 여기, 여기, 여기, 여기, 여기를 변경해야 해.

806
00:43:42,000 --> 00:43:45,000
잠깐만, 무슨 토미는? 다시이 작업을 수행하자.

807
00:43:45,000 --> 00:43:49,000
그래도이이 일을하는 좋은 방법이라고 생각 분명히있는 경우는, 안

808
00:43:49,000 --> 00:43:52,000
그래서 복사 / 나쁜 붙여 넣습니다.

809
00:43:52,000 --> 00:43:55,000
하지만 우리는 일주일 전이 해결.

810
00:43:55,000 --> 00:43:59,000
>> 우리가 동일한 데이터 유형의 여러 인스턴스를 얻고 싶었을 때 우리의 솔루션은 무엇입니까?

811
00:43:59,000 --> 00:44:01,000
[학생] 배열입니다.

812
00:44:01,000 --> 00:44:03,000
배열, 그럼 내가이 일을 청소 해 봅시다.

813
00:44:03,000 --> 00:44:07,000
제가 상단에 자신을위한 자리를 마련, 나 대신 여기에이 작업을 수행하게 보자.

814
00:44:07,000 --> 00:44:12,000
우리는이 사람들을 부를께요, 대신 나는 "정수 ID를"말할거야

815
00:44:12,000 --> 00:44:14,000
그리고 지금 우리의 3을 지원하기 위해거야.

816
00:44:14,000 --> 00:44:18,000
나는, "문자열 이름을"말을하고 우리의 3을 지원합니다 갈거야

817
00:44:18,000 --> 00:44:22,000
그럼 내가 "문자열 하우스"를 말을하고 우리의 3을 지원하기 위해 갈거야.

818
00:44:22,000 --> 00:44:26,000
지금 여기에 대신 다윗이 자신의 지역 변수를 가져 오는에

819
00:44:26,000 --> 00:44:28,000
우리가 그 제거 할 수 있습니다.

820
00:44:28,000 --> 00:44:30,000
우리가이 청소하고 있는지 좋아요.

821
00:44:30,000 --> 00:44:35,000
그때 다윗이 [0] 및 이름 [0] 될 것입니다 말할 수

822
00:44:35,000 --> 00:44:38,000
그리고 집 [0].

823
00:44:38,000 --> 00:44:41,000
그리고 우리는 유사 이것에 저장할 수 있습니다 롭.

824
00:44:41,000 --> 00:44:46,000
의이 여기하자, 그래서 임의로 ID가 [1]거야.

825
00:44:46,000 --> 00:44:50,000
그는 이름이 될거에요 [1],

826
00:44:50,000 --> 00:44:53,000
그리고 마지막으로, 집 [1].

827
00:44:53,000 --> 00:44:57,000
>> 아직 조금 지루한, 그리고 지금은이 일을 해결하기 위해 필요

828
00:44:57,000 --> 00:45:03,000
그렇게 말을 두자 "이름 [0], ID [0], 주택 [0]

829
00:45:03,000 --> 00:45:06,000
과의이를 복수형 보자.

830
00:45:06,000 --> 00:45:09,000
IDS, 신분증, ID입니다.

831
00:45:09,000 --> 00:45:12,000
또, 내가 할거야, 그래서, 난 이미 다시 붙여 넣기 / 복사 의존 해요

832
00:45:12,000 --> 00:45:14,000
그래서 아이가 다른 솔루션은 여기가 있습니다.

833
00:45:14,000 --> 00:45:18,000
아마 그런 식으로 루프 나 뭐 따라 추가이 청소를 할 수 있습니다

834
00:45:18,000 --> 00:45:21,000
그래서 짧은에, 조금 더 좋아하지만 여전히 같은 느낌

835
00:45:21,000 --> 00:45:24,000
전 / 붙여 넣기 복사에 의존하는데,이도, 내​​가 주장

836
00:45:24,000 --> 00:45:27,000
정말 근본적으로 올바른 솔루션이 아니거든요

837
00:45:27,000 --> 00:45:29,000
언젠가는 우리가 결정하면 무슨 알아?

838
00:45:29,000 --> 00:45:32,000
우리는 정말 다윗과 남편의 이메일 주소를 저장 한 것

839
00:45:32,000 --> 00:45:34,000
이 프로그램의 다른 모든.

840
00:45:34,000 --> 00:45:36,000
우리는 전화 번호를 저장해야합니다.

841
00:45:36,000 --> 00:45:39,000
우리는 또한 비상 연락 번호를 저장해야합니다.

842
00:45:39,000 --> 00:45:41,000
우리는 우리가 저장하고자하는 데이터의 모든 조각을 가지고

843
00:45:41,000 --> 00:45:43,000
그래서 어떻게 그런 일에 대해 가지?

844
00:45:43,000 --> 00:45:46,000
>> 당신은 상단에 다른 배열을 선언 한 다음 수동으로 추가

845
00:45:46,000 --> 00:45:49,000
이메일 주소 [0], 이메일 주소 [1]

846
00:45:49,000 --> 00:45:51,000
다윗과 남편 등등.

847
00:45:51,000 --> 00:45:56,000
그러나이 디자인의 근간이 단지 가정 정말이

848
00:45:56,000 --> 00:45:59,000
저를 알고 명예 시스템을 사용하고 있다는 것을

849
00:45:59,000 --> 00:46:03,000
[I] 여러 배열의 각

850
00:46:03,000 --> 00:46:06,000
그냥 같은 사람을 참조 할 일이

851
00:46:06,000 --> 00:46:10,000
그래서 [0] 승급에 번호가 123입니다

852
00:46:10,000 --> 00:46:13,000
그리고 난 그 이름을 거라 생각 해요 [0]

853
00:46:13,000 --> 00:46:16,000
이 동일한 사람의 이름과 집 [0]

854
00:46:16,000 --> 00:46:21,000
제가 만드는 다양한 배열의 모든 동일한 사람의 집, 등등입니다.

855
00:46:21,000 --> 00:46:24,000
그러나 근본적인 연계가 없다는 것을

856
00:46:24,000 --> 00:46:27,000
정보, ID, 이름, 집의 그 3 조각들,

857
00:46:27,000 --> 00:46:32,000
우리가이 프로그램에 모델하려는 개체가 배열하지 않은 경우에도 마찬가지입니다.

858
00:46:32,000 --> 00:46:35,000
배열은이 일을 중 이러한 프로그래밍 방법입니다.

859
00:46:35,000 --> 00:46:38,000
우리는 우리의 프로그램에 모델링하고자하는 것은 사람입니다

860
00:46:38,000 --> 00:46:41,000
데이비드, 그 내부의 로브 같은 사람이 같은

861
00:46:41,000 --> 00:46:46,000
또는 캡슐화는 이름과 ID 및 집입니다.

862
00:46:46,000 --> 00:46:49,000
>> 우리는 어떻게 든 캡슐화의 생각을 표현할 수

863
00:46:49,000 --> 00:46:52,000
사람이 ID, 이름과 집이된다

864
00:46:52,000 --> 00:46:55,000
그리고이 해킹에 의지하지된다 우리는 그냥

865
00:46:55,000 --> 00:46:58,000
그 브래킷 뭔가를 신뢰

866
00:46:58,000 --> 00:47:02,000
이러한 서로 다른 배열의 각에서 동일한 인간 주체를 의미?

867
00:47:02,000 --> 00:47:04,000
우리는 실제로이 작업을 수행 할 수 있습니다.

868
00:47:04,000 --> 00:47:08,000
제가 지금 위의 주요 이동하여 내 자신의 데이터 형식을 만들하자

869
00:47:08,000 --> 00:47:10,000
처음으로 정말하십시오.

870
00:47:10,000 --> 00:47:14,000
우리는 스크램블에이 기법을 사용

871
00:47:14,000 --> 00:47:17,000
하지만 여기서 내가이 가서 데이터 형식을 만들거다

872
00:47:17,000 --> 00:47:19,000
당신은 무엇을 알아, 학생 또는 개인 전화해서 알아

873
00:47:19,000 --> 00:47:23,000
나는 유형을 정의에 대한 typedef 사용하는거야.

874
00:47:23,000 --> 00:47:25,000
나는이 구조이다 이렇게 말할거야

875
00:47:25,000 --> 00:47:29,000
다음이 구조는 입력 학생의 것으로, 우리는이 뭐라고거야

876
00:47:29,000 --> 00:47:31,000
저를 위해 지금 데이트 약간이지만.

877
00:47:31,000 --> 00:47:33,000
우리는 "정수 ID를."라고합니다

878
00:47:33,000 --> 00:47:35,000
우리는 "문자열의 이름을 입력합니다."라고합니다

879
00:47:35,000 --> 00:47:37,000
그럼 우리가 "문자열 하우스"를 말씀 드리죠

880
00:47:37,000 --> 00:47:40,000
그래서 지금 코드의 이러한 몇 줄의 끝으로

881
00:47:40,000 --> 00:47:45,000
난 그냥 존재하는 그 소리를 가르쳤

882
00:47:45,000 --> 00:47:49,000
문자열 이외의 ints 이외의 데이터 유형은, 외에 수레 외에, 배가됩니다.

883
00:47:49,000 --> 00:47:54,000
>> 타임 라인 11이 순간부터, 학생이라는 새로운 데이터 형식, 지금이

884
00:47:54,000 --> 00:47:58,000
지금은 어디서든 내가 원하는 학생 변수를 선언 할 수

885
00:47:58,000 --> 00:48:01,000
그러니 사람들이 여기까지 스크롤 보자.

886
00:48:01,000 --> 00:48:05,000
지금이 제거 할 수 있으며, 여기 데이비드로 내려갈 수

887
00:48:05,000 --> 00:48:10,000
데이빗에 난 사실 그, 데이비드 말할 수

888
00:48:10,000 --> 00:48:13,000
우리는 문자 그대로 자​​신 이후에 변수 이름을 지정할 수 있습니다

889
00:48:13,000 --> 00:48:16,000
유형 학생의 될 것입니다.

890
00:48:16,000 --> 00:48:18,000
이 약간 이상하게 보일 수 있지만,이 모든 다르지 않다

891
00:48:18,000 --> 00:48:22,000
정수 나 문자열 또는 float 타입으로 무언가를 선포에서.

892
00:48:22,000 --> 00:48:24,000
그것은 너무 지금 학생이라고 할 일이

893
00:48:24,000 --> 00:48:28,000
그리고이 구조의 안쪽에 뭔가를 넣어하려는 경우

894
00:48:28,000 --> 00:48:31,000
, 지금은 문법의 새로운 조각을 사용해야하지만 쓰세요

895
00:48:31,000 --> 00:48:39,000
david.id = 123, 자본 D의 david.name = "데이비드"

896
00:48:39,000 --> 00:48:42,000
그리고 david.house = "메이"

897
00:48:42,000 --> 00:48:46,000
지금 여기이 물건을 제거 할 수 있습니다.

898
00:48:46,000 --> 00:48:51,000
우리는 이제 정말 훨씬 좋은 방법으로 우리의 프로그램을 새롭게 디자인했습니다 통지

899
00:48:51,000 --> 00:48:54,000
점에서 지금 우리의 프로그램은 현실 세계를 반영.

900
00:48:54,000 --> 00:48:57,000
>> 사람이나 학생의 실제 생각이 있어요.

901
00:48:57,000 --> 00:49:02,000
여기 우리는 이제 사람 또는 더 구체적으로 학생의 C 버전이 있습니다.

902
00:49:02,000 --> 00:49:05,000
그 사람의 내부 관련성있는 특성입니다

903
00:49:05,000 --> 00:49:10,000
ID, 이름, 집, 그래서 롭은 기본적으로 여기 같은 일이 됐을 때,

904
00:49:10,000 --> 00:49:14,000
, 학생 롭, 그래서 지금 = 456 rob.id

905
00:49:14,000 --> 00:49:17,000
rob.name = "롭."

906
00:49:17,000 --> 00:49:20,000
변수가 남편이라고하는 사실은 의미의 일종입니다.

907
00:49:20,000 --> 00:49:22,000
우리는 X, Y 나 Z 전화했을 수 있습니다.

908
00:49:22,000 --> 00:49:25,000
우리는,이 의미 적으로 일치하도록 롭 이름

909
00:49:25,000 --> 00:49:28,000
하지만 정말 이름은 해당 필드 자체의 내부입니다

910
00:49:28,000 --> 00:49:30,000
그래서 지금이 있습니다.

911
00:49:30,000 --> 00:49:33,000
이건 너무 열심히 데이비드 코딩 한 점에서 최고의 디자인처럼 보이지는 않는다.

912
00:49:33,000 --> 00:49:35,000
난 열심히 로브를 코딩했습니다.

913
00:49:35,000 --> 00:49:39,000
그리고 난 아직 어떤 사본에 의존하고 새로운 변수를하려는 모든 시간을 붙여해야합니다.

914
00:49:39,000 --> 00:49:43,000
또한, 나는 확실히 이러한 각각의 변수 이름을 제공해야

915
00:49:43,000 --> 00:49:46,000
전 차라리이 변수를 설명 할 경우에도

916
00:49:46,000 --> 00:49:48,000
 더 총칭으로 학생.

917
00:49:48,000 --> 00:49:52,000
>> 이제 우리는 우리를 위해 잘 작동 된 아이디어를 병합 할 수 있습니다

918
00:49:52,000 --> 00:49:56,000
대신, 당신이 나 한테라는 변수 학생을 제공하는 건 "라고

919
00:49:56,000 --> 00:50:01,000
그리고 지금이 더 구체화 할 수 있도록 "의 그 크기가 3이 될 해주세요,

920
00:50:01,000 --> 00:50:04,000
, 수동으로 선언 다윗의 제거

921
00:50:04,000 --> 00:50:08,000
그리고 대신 [0] 여기 학생들은 같은 말을 할 수 있습니다.

922
00:50:08,000 --> 00:50:11,000
그럼, [0] 여기 학생들을 말할 수

923
00:50:11,000 --> 00:50:14,000
학생들이 여기 등등 [0], 나는 주변을 둘러 볼 수 있습니다

924
00:50:14,000 --> 00:50:16,000
그리고 남편이 그 부분을 청소하십시오.

925
00:50:16,000 --> 00:50:19,000
그리고 지금, 아마도 루프를 추가하는 방법에 대해 갈 수

926
00:50:19,000 --> 00:50:23,000
실제로 사용자로부터 이러한 값을 얻을 GetString 및 GetInt을 사용합니다.

927
00:50:23,000 --> 00:50:27,000
이 일반적으로 나쁜 관행 때문에 상수를 추가하는 방법에 대해 갈 수

928
00:50:27,000 --> 00:50:29,000
여기에 3 번 하드 코드 일부 임의의 숫자

929
00:50:29,000 --> 00:50:33,000
그리고 당신이 거기에 더 이상 세 이상의 학생을 놓아야합니다 기억.

930
00:50:33,000 --> 00:50:36,000
아마 내 파일의 상단에 정의 # 사용하는 것이 더 효과적입니다

931
00:50:36,000 --> 00:50:40,000
그리고 밖으로, 그래서 실제로, 제가 가서이를 일반화하도록하는 것이 요인.

932
00:50:40,000 --> 00:50:43,000
>> 나 오늘날의 사이입니다 예를 열어 보자

933
00:50:43,000 --> 00:50:46,000
사전에 예, structs1.

934
00:50:46,000 --> 00:50:49,000
이 # 여기서 정의를 사용하는보다 완벽한 프로그램입니다

935
00:50:49,000 --> 00:50:51,000
우리는 기본적으로 3 학생들을 할 겁니다 말합니다.

936
00:50:51,000 --> 00:50:54,000
난 여기 학생들의 수업의 가치를 선언 있어요

937
00:50:54,000 --> 00:50:57,000
학생들의 교실 그래서 지금은 루프를 사용

938
00:50:57,000 --> 00:51:00,000
그냥 코드가 좀 더 우아 할, 클래스를 생성

939
00:51:00,000 --> 00:51:05,000
사용자의 입력에 따라서 3 학생에 전 = 0에서에 반복합니다.

940
00:51:05,000 --> 00:51:07,000
그리고이 버전에서 사용자를 프롬프트

941
00:51:07,000 --> 00:51:10,000
 무슨 학생의 ID, 난 GetInt과를 얻을.

942
00:51:10,000 --> 00:51:13,000
어떤 학생의 이름이고, 그럼 제가 GetString으로 얻을.

943
00:51:13,000 --> 00:51:15,000
학생의 집은 무엇입니까? 나는 GetString과를 얻을.

944
00:51:15,000 --> 00:51:19,000
그리고 여기 하단에 방금 변경하기로 결정

945
00:51:19,000 --> 00:51:22,000
난이를 인쇄있어 실제로 루프를 사용하는 방법,

946
00:51:22,000 --> 00:51:24,000
나는 누구를 인쇄 이유는 무엇입니까?

947
00:51:24,000 --> 00:51:27,000
코멘트에 따르면 나는 메이에있는 사람을 인쇄 할 거예요

948
00:51:27,000 --> 00:51:30,000
그 로브와 토미 때문에 등등 - 실제로 토미 메이의 거예요.

949
00:51:30,000 --> 00:51:34,000
토미와 데이빗이 경우에는 인쇄 할 수 있지만, 어떻게 작동합니까?

950
00:51:34,000 --> 00:51:40,000
우리는 전에이 기능을 볼 수 있지만,이 무엇을에 같은 추측을하지 않았습니다.

951
00:51:40,000 --> 00:51:42,000
문자열을 비교합니다.

952
00:51:42,000 --> 00:51:45,000
>> 그것이 판명 때문에이 문자열을 비교하는 방법 좀 비 확실

953
00:51:45,000 --> 00:51:49,000
그 뜻은 0을 반환하면 문자열이 동일하다.

954
00:51:49,000 --> 00:51:53,000
가 -1을 반환하면 그 하나가, 다른 전에 알파벳순으로되어 의미

955
00:51:53,000 --> 00:51:57,000
가 다른 단어를 의미 +1 돌아온다면 알파벳 순으로되어 있습니다

956
00:51:57,000 --> 00:52:00,000
다른 전에, 당신은 온라인 또는 맨 페이지에서 찾을 수 있습니다

957
00:52:00,000 --> 00:52:04,000
정확히 어떤 방식으로 어떤 것을 보는 것은 있지만,이 모든 지금하고있는 것은이 말하는 것입니다

958
00:52:04,000 --> 00:52:09,000
[I]. 집은 '메이'와 동일한 경우

959
00:52:09,000 --> 00:52:13,000
그런 다음 진행 등 인쇄 등 메이에 있습니다.

960
00:52:13,000 --> 00:52:16,000
하지만 여기 우리가 전에 보지 못했던, 그리고 우리는이에 돌아올거야.

961
00:52:16,000 --> 00:52:21,000
난 절대 내 프로그램 중 하나에서이 작업을 수행 할 필요가 기억하지 않습니다.

962
00:52:21,000 --> 00:52:24,000
무료 분명히 메모리를 참조 메모리를 자유롭게 is

963
00:52:24,000 --> 00:52:31,000
하지만 분명이 프로그램의 하단에이 루프에서 뭘 메모리를 자유롭게 이유는 무엇입니까?

964
00:52:31,000 --> 00:52:34,000
내가 사람의 이름을 해방시켜주고있는거야 것 같습니다

965
00:52:34,000 --> 00:52:37,000
그리고 사람의 집에 있지만, 이유는?

966
00:52:37,000 --> 00:52:41,000
>> 당신이 GetString을 사용하고있는 모든 이들 주 나봐

967
00:52:41,000 --> 00:52:45,000
우리는 가지의 프로그램 하나 하나에 버그를 소개 했어요.

968
00:52:45,000 --> 00:52:51,000
당신 문자열로 반환 할 수 있도록 설계 할당 메모리가 GetString,

969
00:52:51,000 --> 00:52:55,000
같은 데이빗, 또는 롭, 당신은 다음 원하는 건 뭐든지 할 수

970
00:52:55,000 --> 00:52:59,000
우리는 당신을위한 메모리를 예약했기 때문에 프로그램에서 해당 문자열.

971
00:52:59,000 --> 00:53:02,000
문제는 GetString 호출 할 때마다이 시간

972
00:53:02,000 --> 00:53:05,000
우리, GetString의 저자는 운영 체제를 물어왔다

973
00:53:05,000 --> 00:53:07,000
이 문자열에 대한 우리 RAM의 비트를 제공합니다.

974
00:53:07,000 --> 00:53:09,000
이 다음 문자열을 우리에게 RAM의 비트를 제공합니다.

975
00:53:09,000 --> 00:53:11,000
우리에게이 다음 문자열에 대한 좀 더 RAM을 제공합니다.

976
00:53:11,000 --> 00:53:13,000
당신이, 프로그래머가 일을 본 적이 없습니다

977
00:53:13,000 --> 00:53:15,000
우리에게 기억을 다시 제공하고 있습니다

978
00:53:15,000 --> 00:53:17,000
따라서 이러한 몇 주 동안 모든 프로그램이 작성한

979
00:53:17,000 --> 00:53:20,000
사람들이 계속 사용된다 메모리 도약이라는 일을 가지고

980
00:53:20,000 --> 00:53:24,000
점점 더 많은 메모리가 GetString 전화, 그 괜찮아마다.

981
00:53:24,000 --> 00:53:27,000
그렇게 재미없는 사람이기 때문에 우리는 의도적으로 첫 몇 주에서 해당 작업을 수행

982
00:53:27,000 --> 00:53:29,000
문자열이 나오는 곳에 대해 걱정할 필요가 있습니다.

983
00:53:29,000 --> 00:53:34,000
당신이 원하는 모든 단어 때 사용자가 형식을 인치 돌아와 로브

984
00:53:34,000 --> 00:53:38,000
>> 그러나 앞으로 이동 우리는 이제 이것에 대해 더 정교지고 시작해야합니다.

985
00:53:38,000 --> 00:53:42,000
우리는 메모리를 할당 할 때마다 우리는 더 나은 결국 다시 넘겨.

986
00:53:42,000 --> 00:53:45,000
그렇지 않으면 Mac 또는 PC에있는 현실 세계에서 당신은 가끔 경험이있을

987
00:53:45,000 --> 00:53:50,000
컴퓨터가 결국 중단 분쇄되어 증상

988
00:53:50,000 --> 00:53:54,000
나 바보 회전 해변 공은 컴퓨터의을 차지하고있다

989
00:53:54,000 --> 00:53:56,000
전체주의 그리고 당신은 일을 수행 할 수 없습니다.

990
00:53:56,000 --> 00:54:00,000
그는 버그의 번호로 설명하지만, 그 수 버그들 수 있습니다

991
00:54:00,000 --> 00:54:03,000
가지 메모리 누수라고 상기 소프트웨어의 조각을 썼다 사람

992
00:54:03,000 --> 00:54:07,000
당신은 자유 메모리에 기억하지 못 사용하고

993
00:54:07,000 --> 00:54:10,000
그 또는 그녀가에 대한 운영 체제를 물어

994
00:54:10,000 --> 00:54:14,000
그 CS50 일이기 때문에, GetString을 사용하지만, 이와 유사한 기능을 사용하지

995
00:54:14,000 --> 00:54:16,000
메모리의 운영 체제를 묻지.

996
00:54:16,000 --> 00:54:19,000
당신이나 애들이 실수하고있는 경우 실제로 메모리를 반환하지 않을

997
00:54:19,000 --> 00:54:24,000
프로그램이 느려지고 느려지고 느려지 것을 할 수의 증상

998
00:54:24,000 --> 00:54:26,000
당신은 무료로 전화하는 것을 잊지 않는.

999
00:54:26,000 --> 00:54:28,000
>> 언제 왜 무료로 전화를 해 우리는 다시 올거야

1000
00:54:28,000 --> 00:54:32,000
하지만 그냥 좋은 측정 가서이 특정 프로그램을 실행 해 보자.

1001
00:54:32,000 --> 00:54:35,000
이것은 structs1 불렀다 입력합니다.

1002
00:54:35,000 --> 00:54:40,000
데이비드 메이, 저를 가서 structs1을 실행 123 보자

1003
00:54:40,000 --> 00:54:47,000
456, 롭 커크 랜드, 789,

1004
00:54:47,000 --> 00:54:50,000
토미 메이, 우리는 메이의 데이빗를 참조 토미 메이 인치

1005
00:54:50,000 --> 00:54:53,000
이 프로그램이 작동하는 것을 그냥 좀 정신 검사입니다.

1006
00:54:53,000 --> 00:54:56,000
지금, 불행하게도,이 프로그램은한다는 점에서 약간 실망스러운

1007
00:54:56,000 --> 00:55:00,000
제 말은, 제가 9 다른 문자열에서 모든 일을 입력 못했지만, 입력을 누르

1008
00:55:00,000 --> 00:55:04,000
메이에 누가 말했지, 아직 분명 내가 그것을 입력하기 때문에 이미 메이에 누군지 알았습니다.

1009
00:55:04,000 --> 00:55:07,000
이 프로그램은 더 많은 데이터베이스 같은 경우는 적어도 좋을 것이다

1010
00:55:07,000 --> 00:55:10,000
그리고 실제로 제가 입력 한 내용을 기억

1011
00:55:10,000 --> 00:55:12,000
그래서 다시 입력이 학생 기록을해야하지 마십시오.

1012
00:55:12,000 --> 00:55:15,000
어쩌면 registrarial 시스템입니다.

1013
00:55:15,000 --> 00:55:21,000
>> 우리는, 파일 I / O, 파일 입력 및 출력으로 알려진이 기술을 사용하여이 작업을 수행 할 수 있습니다

1014
00:55:21,000 --> 00:55:24,000
이 파일을 읽거나 파일을 작성하려는 시간을 말하는 매우 일반적인 방법

1015
00:55:24,000 --> 00:55:26,000
당신은 함수의 특정 세트로이 작업을 수행 할 수 있습니다.

1016
00:55:26,000 --> 00:55:29,000
내가 가서이 예제 structs2.c을 열어 보자,

1017
00:55:29,000 --> 00:55:33,000
이는 거의 동일하지만, 지금 무엇을보고합시다.

1018
00:55:33,000 --> 00:55:36,000
파일의 상단에 I는 학생들의 클래스를 선언합니다.

1019
00:55:36,000 --> 00:55:38,000
그럼, 사용자의 입력을 클래스를 생성

1020
00:55:38,000 --> 00:55:41,000
그래서 코드의 해당 줄이 정확히 전에 좋아합니다.

1021
00:55:41,000 --> 00:55:45,000
메이에 모두가 임의로 전에 좋아 여기 아래로 스크롤하면 그럼 난 인쇄

1022
00:55:45,000 --> 00:55:47,000
하지만이 흥미로운 새 기능입니다.

1023
00:55:47,000 --> 00:55:51,000
코드의이 줄 새로운 있으며, 그들은 뭔가를 소개

1024
00:55:51,000 --> 00:55:55,000
FILE, 모든 모자, 그리고뿐만 아니라 여기에 * 있습니다.

1025
00:55:55,000 --> 00:55:58,000
저뿐만 아니라 여기에, 여기에 *를이 이동하세요.

1026
00:55:58,000 --> 00:56:00,000
>> 이 기능은 우리가 전에 보지 못했어요, fopen,

1027
00:56:00,000 --> 00:56:03,000
하지만 열려있는 파일을 의미하므로이를 통해가 탈지하자

1028
00:56:03,000 --> 00:56:05,000
이 우리가 앞으로 psets에에 돌아 오면 뭔가있다

1029
00:56:05,000 --> 00:56:10,000
하지만 여기이 줄은 본질적으로, 데이터베이스라는 파일을 엽니 다

1030
00:56:10,000 --> 00:56:13,000
그리고 구체적으로는 거기에 무엇을 할 수있는 방식에 열립니다?

1031
00:56:13,000 --> 00:56:15,000
[안 들리게 - 학생이]

1032
00:56:15,000 --> 00:56:19,000
좋아요, 그럼 "w"는 그냥 운영 체제를 말하는 뜻

1033
00:56:19,000 --> 00:56:21,000
내가에 쓸 수 있도록하는 방식으로이 파일을 엽니 다.

1034
00:56:21,000 --> 00:56:23,000
내가 읽고 싶지 않아. 난 그냥보고 싶지 않아.

1035
00:56:23,000 --> 00:56:26,000
난 그 변경하고 잠재적으로 물건을 추가 할

1036
00:56:26,000 --> 00:56:28,000
그리고 파일은 데이터베이스라고 할 것이다.

1037
00:56:28,000 --> 00:56:30,000
이것은 아무것도 호출 할 수 있습니다.

1038
00:56:30,000 --> 00:56:32,000
이 database.txt 될 수 있습니다. 이. 데시벨이 될 수 있습니다.

1039
00:56:32,000 --> 00:56:37,000
이 foo는 같은 단어 일 수도 있지만 임의의 파일 데이터베이스 이름을 선택했습니다.

1040
00:56:37,000 --> 00:56:42,000
이것은 우리가 시간이 지남에 따라 큰 자세하게에 돌아 오면하는 약간 정신 수표가

1041
00:56:42,000 --> 00:56:47,000
FP는 파일 포인터에 대해 동일한 NULL을하지 않는 경우에는 그게 다 잘되고 있습니다.

1042
00:56:47,000 --> 00:56:51,000
>> 짧게 말하면, fopen 등의 기능은 종종 실패합니다.

1043
00:56:51,000 --> 00:56:53,000
아마 파일이 존재하지 않습니다. 아마 당신은 디스크 공간이 부족합니다.

1044
00:56:53,000 --> 00:56:55,000
아마 당신은, 해당 폴더에 권한이 없습니다

1045
00:56:55,000 --> 00:56:58,000
fopen은 null 뭔가를 반환하므로 경우에 나쁜 일.

1046
00:56:58,000 --> 00:57:02,000
fopen가 null 반환하지 않는 경우 반대로, 모든 잘

1047
00:57:02,000 --> 00:57:04,000
그리고이 파일에 쓰기를 시작할 수 있습니다.

1048
00:57:04,000 --> 00:57:06,000
여기에 새로운 마술입니다.

1049
00:57:06,000 --> 00:57:08,000
이것은 학생들의 각을 통해 반복있어 용 루프입니다

1050
00:57:08,000 --> 00:57:10,000
이 방법은 우리가 전에 한 짓에 너무 유사

1051
00:57:10,000 --> 00:57:15,000
하지만이 기능은 printf printf 파일을 fprintf라는의 사촌입니다

1052
00:57:15,000 --> 00:57:18,000
그것들은 오직 두 가지 방법으로 다릅니다 확인합니다.

1053
00:57:18,000 --> 00:57:20,000
하나는, 그것은 대신 P의 F로 시작하는

1054
00:57:20,000 --> 00:57:23,000
하지만 첫 번째 인수는 분명 무엇인가?

1055
00:57:23,000 --> 00:57:25,000
[학생] 파일. >>은이 파일입니다.

1056
00:57:25,000 --> 00:57:30,000
결국 우리가 파일 포인터가 뭔지 떨어져 애타게됩니다 FP라는 일이,

1057
00:57:30,000 --> 00:57:35,000
하지만 지금 FP는 단순히 제가 오픈 한 파일을 나타냅니다

1058
00:57:35,000 --> 00:57:41,000
그래서 fprintf 여기는 파일이 사용자의 ID를 인쇄 화면으로 말하고 있습니다.

1059
00:57:41,000 --> 00:57:44,000
파일에 사용자의 이름이 아닌 화면을 인쇄

1060
00:57:44,000 --> 00:57:47,000
파일에 대한, 아니, 분명히, 거기에 다음 화면으로, 집

1061
00:57:47,000 --> 00:57:50,000
파일을 닫은 다음 여기 메모리 무료입니다.

1062
00:57:50,000 --> 00:57:53,000
>> 이 버전 2와 버전 1 사이의 유일한 차이점

1063
00:57:53,000 --> 00:57:58,000
fopen의 도입과 *이 파일입니다

1064
00:57:58,000 --> 00:58:01,000
와 fprintf의 개념, 그래서 최종 결과는 무엇 보자.

1065
00:58:01,000 --> 00:58:03,000
내 터미널 창으로 가자.

1066
00:58:03,000 --> 00:58:06,000
입력, 제가 structs2를 실행할 수 있습니다.

1067
00:58:06,000 --> 00:58:09,000
모든 잘 것 같아요. 가 structs2를 다시 실행 보자.

1068
00:58:09,000 --> 00:58:15,000
123 데이비드 메이, 456, 롭 커크 랜드,

1069
00:58:15,000 --> 00:58:19,000
789, 토미 메이 더는, 입력합니다.

1070
00:58:19,000 --> 00:58:23,000
이 같은 행동처럼 보이는,하지만 지금은이게 할 경우

1071
00:58:23,000 --> 00:58:28,000
모든 코드들 여기에 어떤 파일 발견, 데이터베이스,

1072
00:58:28,000 --> 00:58:32,000
그러니 그런 걸 즉, 데이터베이스의 gedit 및 모양을 열 수 있습니다.

1073
00:58:32,000 --> 00:58:34,000
이 파일 형식의 가장 섹시한 없습니다.

1074
00:58:34,000 --> 00:58:38,000
정말, 라인 당 한 줄에 데이터 라인의 한 조각

1075
00:58:38,000 --> 00:58:42,000
하지만 Excel 또는 CSV 파일을 사용 분들은 쉼표, 값을 분리

1076
00:58:42,000 --> 00:58:47,000
나는 확실히 대신에 어쩌면 이런 짓을 할 fprintf 사용 수

1077
00:58:47,000 --> 00:58:50,000
사실은 엑셀 파일의 동등한을 만들 수 있도록

1078
00:58:50,000 --> 00:58:53,000
쉼표 아니라 새로운 라인으로 물건을 구분하여.

1079
00:58:53,000 --> 00:58:56,000
>> 이 경우 내가 대신 쉼표 대신 새로운 라인을 사용했을 경우

1080
00:58:56,000 --> 00:59:01,000
내가 대신이 한 것처럼 한 경우는 말 그대로 엑셀에서이 데이터베이스 파일을 열 수 있습니다.

1081
00:59:01,000 --> 00:59:03,000
즉, 이제 우리는 파일에 쓸 수있는 힘을 가지고 있다는

1082
00:59:03,000 --> 00:59:07,000
우리는 이제 디스크에 주변을 유지 지속 데이터를 시작할 수 있습니다

1083
00:59:07,000 --> 00:59:10,000
우리는 또 한번, 또 한번 주위에 정보를 유지할 수 있도록.

1084
00:59:10,000 --> 00:59:14,000
지금은 좀 더 익숙한 몇 가지 다른 사항을 확인하십시오.

1085
00:59:14,000 --> 00:59:16,000
이 C 파일의 상단에 우리는 typedef가

1086
00:59:16,000 --> 00:59:21,000
우리는 단어를 나타내는 데이터 유형을 생성하고 싶었 때문에

1087
00:59:21,000 --> 00:59:25,000
이러한 유형의 단어라고합니다 수 있도록하고, 내부 구조의

1088
00:59:25,000 --> 00:59:27,000
지금 조금 애호가입니다.

1089
00:59:27,000 --> 00:59:30,000
왜 단어는 분명히 배열로 구성되어 있습니다?

1090
00:59:30,000 --> 00:59:33,000
단지 직관적 단어는 무엇입니까?

1091
00:59:33,000 --> 00:59:35,000
>> 이 문자의 배열입니다.

1092
00:59:35,000 --> 00:59:37,000
이 백업 백업으로 돌아 문자의 순서입니다.

1093
00:59:37,000 --> 00:59:41,000
모두 대문자로 문자는 우리가 임의로 말을 할 일이 최대 길이

1094
00:59:41,000 --> 00:59:44,000
우리가 출격을 위해 사용하고 사전에 단어.

1095
00:59:44,000 --> 00:59:46,000
이유는 하나 있어요?

1096
00:59:46,000 --> 00:59:48,000
널 문자입니다.

1097
00:59:48,000 --> 00:59:51,000
우리가 Bananagrams 예제를 죽일 때 우리가 특별한 값을 필요로 리콜

1098
00:59:51,000 --> 00:59:55,000
를 추적 할 수있는 단어의 끝 순서로

1099
00:59:55,000 --> 00:59:59,000
문제 세트 사양은 말합니다 단어가 실제로 종료 위치에, 그리고로

1100
00:59:59,000 --> 01:00:03,000
여기 우리는 주어진 단어를 사용하여 Boolean 값을 연결하는

1101
01:00:03,000 --> 01:00:05,000
플래그는, 그래서 true 나 false 말을합니다.

1102
01:00:05,000 --> 01:00:09,000
우리가 알고 있기 때문에 당신은 이미이 단어를 발견했습니다

1103
01:00:09,000 --> 01:00:13,000
우리가 기억하는 방법이 필요하지 만​​ 스크램블에 단어 일 것입니다

1104
01:00:13,000 --> 01:00:15,000
하지만 여부에 상관없이 인간은 그것을 발견

1105
01:00:15,000 --> 01:00:20,000
당신이 찾아내는하지 않으면 단어 "는"당신이 단지를 입력 할 수 있도록 입력, 입력, 입력

1106
01:00:20,000 --> 01:00:23,000
3 점, 3 점, 3 점, 3 점을.

1107
01:00:23,000 --> 01:00:26,000
우리는 BOOL을 설정하여 해당 단어를 블랙리스트 할 수 있도록 할

1108
01:00:26,000 --> 01:00:29,000
당신이 이미 그것을 발견 한 경우 이유를 true로하고, 그래서 우리는 야

1109
01:00:29,000 --> 01:00:31,000
이 구조에 캡슐화.

1110
01:00:31,000 --> 01:00:35,000
>> 지금, 여기 스크램블에 사전 불리는이 다른 구조체가 있습니다.

1111
01:00:35,000 --> 01:00:39,000
여기에 결석하는 typedef 단어 때문에이 경우에

1112
01:00:39,000 --> 01:00:43,000
우리는 사전의 아이디어를 캡슐화하는 데 필요한

1113
01:00:43,000 --> 01:00:46,000
그리고 사전은 단어를 많이 포함하고

1114
01:00:46,000 --> 01:00:49,000
로이 배열에 의해 암시하는 방법과 해당 단어 몇 명이지?

1115
01:00:49,000 --> 01:00:51,000
음,이 변수라는 크기의 말씀에 무조건.

1116
01:00:51,000 --> 01:00:53,000
그러나 우리는 하나의 사전이 필요 해요.

1117
01:00:53,000 --> 01:00:55,000
우리는 사전이라는 데이터 형식을 필요하지 않습니다.

1118
01:00:55,000 --> 01:00:58,000
우리는 둘 중 하나를해야하기 때문에 C에서 변

1119
01:00:58,000 --> 01:01:03,000
당신은 typedef 말하지 않는 경우, 그냥 구조체라고하는 다음 중괄호 안에

1120
01:01:03,000 --> 01:01:05,000
당신이 이름을 넣어 다음, 변수를 넣어.

1121
01:01:05,000 --> 01:01:09,000
즉, 하나의 변수라는 사전을 선언합니다

1122
01:01:09,000 --> 01:01:11,000
그게이 것 같습니다.

1123
01:01:11,000 --> 01:01:16,000
대조적으로,이 라인은 단어라는 재사용 가능한 데이터 구조를 만드는

1124
01:01:16,000 --> 01:01:19,000
우리가 만든 것처럼 당신은 여러 사본을 만들 수

1125
01:01:19,000 --> 01:01:22,000
학생들의 여러 사본.

1126
01:01:22,000 --> 01:01:24,000
>> 이 종국에는 우리가 무엇을 할 수 있습니까?

1127
01:01:24,000 --> 01:01:30,000
저 간단한 시간에서의 말을 간단한 예를 들어 보자로 돌아 가자,

1128
01:01:30,000 --> 01:01:34,000
그리고 compare1.c, 보자, 내가 다 열 수 있습니다.

1129
01:01:34,000 --> 01:01:38,000
손에서 여기 문제는에 실제로 다시 껍질을 벗기다 수 있습니다

1130
01:01:38,000 --> 01:01:41,000
문자열의 레이어 이러한 훈련 바퀴를 벗고 시작

1131
01:01:41,000 --> 01:01:44,000
그 문자열이이 모든 시간을 변 때문에

1132
01:01:44,000 --> 01:01:47,000
우리가 주 1 단지 닉네임을 약속 한대로이며,

1133
01:01:47,000 --> 01:01:51,000
동의어 조금 더 이상한 모양 뭔가 CS50 라이브러리에서,

1134
01:01:51,000 --> 01:01:53,000
숯불 *는, 우리는 전에이 별을보고했습니다.

1135
01:01:53,000 --> 01:01:55,000
우리는 파일의 컨텍스트에서 봤어요.

1136
01:01:55,000 --> 01:01:59,000
>> 지금 우리가 시간이 세부 사항을 숨겨 왔던 이유의 지금 보자.

1137
01:01:59,000 --> 01:02:02,000
여기 compare1.c라는 파일입니다

1138
01:02:02,000 --> 01:02:07,000
그리고 분명히, s 및 t, 2 문자열을 사용자에게 묻습니다

1139
01:02:07,000 --> 01:02:11,000
다음은 라인 (26)에서 평등을 그 문자열을 비교하려고

1140
01:02:11,000 --> 01:02:14,000
그들이 말하는 동일한 경우와, "당신은, 같은 일을 입력"

1141
01:02:14,000 --> 01:02:17,000
하고 평등하지 않으면 그것은 "당신은 다른 일을 입력"이라고 말했다.

1142
01:02:17,000 --> 01:02:19,000
내가 가서이 프로그램을 실행할 수 있습니다.

1143
01:02:19,000 --> 01:02:23,000
내 소스가있는 디렉토리로 가자, compare1을합니다. 괜찮 컴파일.

1144
01:02:23,000 --> 01:02:25,000
저 compare1를 실행할 수 있습니다.

1145
01:02:25,000 --> 01:02:27,000
나는 확대 입력해야합니다.

1146
01:02:27,000 --> 01:02:29,000
말 좀 해봐. 안녕하세요.

1147
01:02:29,000 --> 01:02:32,000
다시 말을합니다. 안녕하세요.

1148
01:02:32,000 --> 01:02:34,000
확실히 다른 일을 입력하지 않았습니다.

1149
01:02:34,000 --> 01:02:37,000
>> - 다시 시도해 보자. 안녕.

1150
01:02:37,000 --> 01:02:40,000
물론 차이가 여기 무슨 일이야 그래서?

1151
01:02:40,000 --> 01:02:44,000
음, 정말 라인 (26)에서 어떤 비교 되나요?

1152
01:02:44,000 --> 01:02:46,000
[안 들리게 - 학생이]

1153
01:02:46,000 --> 01:02:49,000
네, 그래서 문자열 데이터 형식은 하얀 거짓말 종류의 것을 밝혀졌다.

1154
01:02:49,000 --> 01:02:53,000
문자열은 문자 *하지만, 숯불 *는 무엇인가?

1155
01:02:53,000 --> 01:02:56,000
숯불 *이 사람들 말처럼, 포인터

1156
01:02:56,000 --> 01:03:00,000
그리고 포인터가 효과적으로 주소입니다

1157
01:03:00,000 --> 01:03:05,000
합 메모리에 위치, 당신은 HELLO 같은 단어를 입력 한 것으로 발생할 경우,

1158
01:03:05,000 --> 01:03:08,000
문자열의 과거 토론에서 기억

1159
01:03:08,000 --> 01:03:16,000
이 단어처럼 HELLO입니다.

1160
01:03:16,000 --> 01:03:19,000
HELLO 같은 단어가 표현 될 수 있음을 기억

1161
01:03:19,000 --> 01:03:22,000
이와 같은 문자의 배열로

1162
01:03:22,000 --> 01:03:25,000
그리고 마지막에 특수 문자와 함께 유효하지 않은 문자라고

1163
01:03:25,000 --> 01:03:27,000
\ 존재라는 증거 있습니다.

1164
01:03:27,000 --> 01:03:29,000
문자열은 실제로 무엇입니까?

1165
01:03:29,000 --> 01:03:32,000
이 메모리의 여러 덩어리가됩니다

1166
01:03:32,000 --> 01:03:36,000
당신은 전체 문자열을 찾아 한번와 사실, 그것의 끝은 잘 알려져 있습니다

1167
01:03:36,000 --> 01:03:38,000
특별 널 문자를 찾고 있습니다.

1168
01:03:38,000 --> 01:03:41,000
그러나 이것은 내 컴퓨터의 메모리에서 메모리의 덩어리 인 경우,

1169
01:03:41,000 --> 01:03:44,000
우선은 임의로이 문자열 단지 운이 좋아서, 그런 말을

1170
01:03:44,000 --> 01:03:47,000
그리고 그것은 내 컴퓨터의 RAM의 처음에 배치 했어요.

1171
01:03:47,000 --> 01:03:54,000
이 바이트 0, 1, 2, 3, 4, 5, 6은 ...

1172
01:03:54,000 --> 01:04:02,000
>> 나는 GetString 같은 말을하고 문자열 S = GetString을 수행 할 때

1173
01:04:02,000 --> 01:04:04,000
정말 어떤 반환되는 거죠?

1174
01:04:04,000 --> 01:04:08,000
지난 몇 주 동안, 무슨 일이 정말들에 저장되고 있어요

1175
01:04:08,000 --> 01:04:13,000
본질적으로이 문자열 아니지만,이 경우 어떤 저장되는거야 것은

1176
01:04:13,000 --> 01:04:18,000
GetString가 실제로 무엇을 때문에 숫자 0

1177
01:04:18,000 --> 01:04:20,000
그것은 물리적으로 문자열을 반환하지 않습니다 있습니다.

1178
01:04:20,000 --> 01:04:22,000
그건 문제도 정말 개념 이해되지 않습니다.

1179
01:04:22,000 --> 01:04:24,000
그 수익은 숫자입니다 무엇을하는지에 관해.

1180
01:04:24,000 --> 01:04:28,000
그 번호는 메모리 HELLO의 주소입니다

1181
01:04:28,000 --> 01:04:32,000
및 문자열 s은 (는) 다음 우리는 다시 껍질을 벗기면이 레이어, 문자열은 실제로 존재하지 않는 경우.

1182
01:04:32,000 --> 01:04:35,000
단지 CS50 라이브러리의 단순화입니다.

1183
01:04:35,000 --> 01:04:38,000
>> 이건 정말 숯불 *라는 일입니다.

1184
01:04:38,000 --> 01:04:41,000
어떤 HELLO 같은 단어이기 때문에 문자는 의미가?

1185
01:04:41,000 --> 01:04:44,000
음, 문자 일련의, 문자 일련의입니다.

1186
01:04:44,000 --> 01:04:47,000
숯불 *는 문자의 주소를 의미합니다

1187
01:04:47,000 --> 01:04:50,000
그래서 뭐가 어떻다는는 문자열을 반환한다는 것은 무슨 뜻입니까?

1188
01:04:50,000 --> 01:04:53,000
문자열을 반환의 좋은, 간단한 방법

1189
01:04:53,000 --> 01:04:57,000
이보다는 제가 5 ~ 6 다른 바이트로 돌아가 방법을 강구 해

1190
01:04:57,000 --> 01:05:01,000
나 바이트의 주소로 돌려?

1191
01:05:01,000 --> 01:05:03,000
첫 번째.

1192
01:05:03,000 --> 01:05:06,000
즉, 나에게 메모리에 문자의 주소를 주자.

1193
01:05:06,000 --> 01:05:10,000
즉, 숯불 *가 무엇을 나타내는 지 메모리에 하나의 문자의 주소입니다.

1194
01:05:10,000 --> 01:05:12,000
변수 s를 호출합니다.

1195
01:05:12,000 --> 01:05:15,000
제가 임의로 밝혔다 특정 주소가 0입니다 s의 스토어

1196
01:05:15,000 --> 01:05:19,000
그냥 일을 간단하게하기 위해,하지만 현실에서 일반적으로 더 큰 숫자입니다.

1197
01:05:19,000 --> 01:05:21,000
>> 잠깐만 요.

1198
01:05:21,000 --> 01:05:23,000
만 저에게 첫 문자의 주소를 제공하는 경우에는 어떻게 주소는 어떻게 알 수 있습니까

1199
01:05:23,000 --> 01:05:25,000
두 번째 문자, 세 번째, 네 번째와 다섯 번째?

1200
01:05:25,000 --> 01:05:27,000
[안 들리게 - 학생이]

1201
01:05:27,000 --> 01:05:31,000
문자열의 끝이 편리 속임수의 방법으로 어디 있는지 만 알

1202
01:05:31,000 --> 01:05:35,000
그래서 당신은 같은 printf 무언가를 사용할 때, 어떻게 printf 그대로, 그 인자로 소요

1203
01:05:35,000 --> 01:05:39,000
우리가이 % s의 자리 표시자를 사용하는 기억, 그리고 당신은에 전달

1204
01:05:39,000 --> 01:05:41,000
문자열을 보관하고 있어요 변수.

1205
01:05:41,000 --> 01:05:47,000
당신이 정말 통과가 그 문자열의 첫 번째 문자의 주소입니다.

1206
01:05:47,000 --> 01:05:50,000
Printf는 그 주소를 수신에 루프 또는 동안 루프에 대한 사용

1207
01:05:50,000 --> 01:05:53,000
예를 들어, 0, 그래서, 내가 지금이 일을하게 놔두지

1208
01:05:53,000 --> 01:06:02,000
printf ( "% s의 \ N,"S);

1209
01:06:02,000 --> 01:06:07,000
내가 전화 할 때 printf ( "% s의 \ N,"S), 내가 정말와 printf 제공 해요

1210
01:06:07,000 --> 01:06:13,000
이 임의의 경우에 H. 있습니다 s의 첫 문자의 주소입니다

1211
01:06:13,000 --> 01:06:16,000
>> 어떻게 printf 화면에 표시 정확히 알 수 있습니까?

1212
01:06:16,000 --> 01:06:19,000
구현 된 사람은 printf 루프 동안 루프 또는를 구현

1213
01:06:19,000 --> 01:06:23,000
이 문자가 특별한 널 문자를 동일 않는 말씀인가요?

1214
01:06:23,000 --> 01:06:25,000
그렇지 않은 경우를 인쇄 할 수 있습니다. 이 개 어때요?

1215
01:06:25,000 --> 01:06:28,000
를 인쇄 할 경우, 양식을 인쇄하고 인쇄를 인쇄 할 수 있습니다.

1216
01:06:28,000 --> 01:06:32,000
아,이 아이는 특별합니다. 인쇄를 중지하고 사용자에게 돌아갑니다.

1217
01:06:32,000 --> 01:06:35,000
그리고는 그대로 후드 아래에 일어나는 것 전부예요

1218
01:06:35,000 --> 01:06:38,000
그는 클래스의 첫 번째 하루에 소화 할 수있는 많이

1219
01:06:38,000 --> 01:06:43,000
하지만 지금은 정말 이해 모든 빌딩 블록입니다

1220
01:06:43,000 --> 01:06:46,000
그는 우리의 컴퓨터의 메모리 내부의 계속 된

1221
01:06:46,000 --> 01:06:49,000
결국 우리는 약간의 도움이 떨어져 애타게합니다

1222
01:06:49,000 --> 01:06:51,000
스탠포드에서 우리 친구들 중 하나에서.

1223
01:06:51,000 --> 01:06:56,000
>> 스탠포드 교수 닉 Parlante이 멋진 비디오 시퀀스를 완료했다

1224
01:06:56,000 --> 01:06:58,000
소개 다른 언어로 모든 종류의에서

1225
01:06:58,000 --> 01:07:00,000
이 작은 Claymation 문자 빙키.

1226
01:07:00,000 --> 01:07:03,000
당신은 몇 초 미리 미리보기에서 듣고 할 겁니다 음성

1227
01:07:03,000 --> 01:07:05,000
스탠포드 교수의입니다, 당신은지고있어

1228
01:07:05,000 --> 01:07:07,000
이러한 권리 만 5 ~ 6 초에,

1229
01:07:07,000 --> 01:07:09,000
하지만 우리가 오늘 체결됩니다 된 메모입니다

1230
01:07:09,000 --> 01:07:11,000
그리고 수요일에 시작됩니다.

1231
01:07:11,000 --> 01:07:15,000
난 당신에게 빙키의 미리보기가있는 포인터 즐거운을 제공합니다.

1232
01:07:15,000 --> 01:07:18,000
[♪ 음악 ♪] [교수 Parlante] 안녕, 빙키.

1233
01:07:18,000 --> 01:07:21,000
정신 차려. 이 포인터 즐거운 시간입니다.

1234
01:07:21,000 --> 01:07:24,000
[빙키] 그게 뭔데? 포인터에 대해 자세히 알아보십시오?

1235
01:07:24,000 --> 01:07:26,000
아, 케이크!

1236
01:07:26,000 --> 01:07:29,000
>> 우리는 수요일에 표시됩니다.

1237
01:07:29,000 --> 01:07:32,000
[CS50.TV]