1
00:00:00,000 --> 00:00:01,000
[Powered by Google Translate] [제 6] [더 편안한]

2
00:00:01,000 --> 00:00:04,000
[롭 보덴] [하버드 대학]

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

4
00:00:09,000 --> 00:00:11,000
>> 우리는 질문의 섹션으로 향 할 수 있습니다.

5
00:00:11,000 --> 00:00:17,000
제가 먼저 공간의 URL을 보냈습니다.

6
00:00:17,000 --> 00:00:22,000
질문의 섹션의 시작 말 -

7
00:00:22,000 --> 00:00:26,000
분명히, 난 아주 쉬운 질문 병 들지 않게이 -이 완전히 안

8
00:00:26,000 --> 00:00:28,000
valgrind는 그냥 뭐죠?

9
00:00:28,000 --> 00:00:30,000
valgrind는 무엇입니까?

10
00:00:30,000 --> 00:00:34,000
누구나 valgrind는 무엇을 말할까요?

11
00:00:34,000 --> 00:00:36,000
[학생] 체크 메모리 누수.

12
00:00:36,000 --> 00:00:41,000
네, valgrind는 일반 메모리 검사기입니다.

13
00:00:41,000 --> 00:00:44,000
어떤 메모리 누수가있는 경우는, 결국, 당신을 알려줍니다

14
00:00:44,000 --> 00:00:49,000
이것은 당신이 원하는 경우 우리 때문에 위해 사용중인 대부분 is

15
00:00:49,000 --> 00:00:54,000
문제 세트에 또는 원하는 경우 잘

16
00:00:54,000 --> 00:00:59,000
큰 탑승, 당신은 전혀 메모리 누수가 없습니다 필요

17
00:00:59,000 --> 00:01:01,000
그리고 경우에 당신은 당신이 찾을 수있는 메모리 누수가

18
00:01:01,000 --> 00:01:04,000
당신은 파일을 열 때마다 해당 염두에 두어야

19
00:01:04,000 --> 00:01:07,000
그리고 그 파일을 종료하지 않을 경우, 그 메모리 누수입니다.

20
00:01:07,000 --> 00:01:10,000
>> 많은 사람들이 그들이 자유롭게하지 않는다는 것을 어떤 노드를 찾고 있습니다

21
00:01:10,000 --> 00:01:15,000
때 정말, 그들은 첫 단계에서 사전을 닫지 않았습니다.

22
00:01:15,000 --> 00:01:19,000
또한, 어떤 잘못이있는 경우 읽기를 알거나 기록

23
00:01:19,000 --> 00:01:22,000
당신이 시도하고 값을 설정하면 그 말은

24
00:01:22,000 --> 00:01:26,000
그 힙의 마지막 넘어이고 감금 잘못이에게 무슨 일이되지 않습니다

25
00:01:26,000 --> 00:01:30,000
하지만 valgrind는, 당신이 실제로 작성하지 말아야으로 그것을 잡는다

26
00:01:30,000 --> 00:01:33,000
그래서 당신은 확실히 그 중 하나의가 없어야합니다.

27
00:01:33,000 --> 00:01:38,000
당신이 어떻게 valgrind 사용합니까?

28
00:01:38,000 --> 00:01:42,000
당신이 어떻게 valgrind 사용합니까?

29
00:01:42,000 --> 00:01:45,000
>> 그것은에 대한 일반적인 질문입니다

30
00:01:45,000 --> 00:01:49,000
의 종류를 실행하고 출력 좀 봐.

31
00:01:49,000 --> 00:01:51,000
출력은 시대의 많은 부담을주지 않습니다.

32
00:01:51,000 --> 00:01:54,000
당신이 심각하게 잘못된 일이있을 경우 오류가 재미도 있어요

33
00:01:54,000 --> 00:01:59,000
루프에서 어떤 일이 일어나고, 그것을 결국 "너무 많은 오류를 말할 것입니다.

34
00:01:59,000 --> 00:02:03,000
이제 카운트 중지 할거야. "

35
00:02:03,000 --> 00:02:08,000
그것은 기본적으로 구문 분석해야하는 텍스트 출력입니다.

36
00:02:08,000 --> 00:02:13,000
결국, 당신이 당신이 가지고있는 메모리 누수를 알려줍니다

37
00:02:13,000 --> 00:02:16,000
유용한 얼마나 많은 블록이 될 수있는 이유

38
00:02:16,000 --> 00:02:20,000
가에서 한 블록 unfreed이라면,이 찾을 수 일반적으로 쉽게

39
00:02:20,000 --> 00:02:23,000
1000 블록 unfreed보다.

40
00:02:23,000 --> 00:02:26,000
unfreed 1000 블록은 아마 당신이 자유롭게 없을 겁니다

41
00:02:26,000 --> 00:02:30,000
적절거나 연결된 목록.

42
00:02:30,000 --> 00:02:32,000
그는 valgrind있어.

43
00:02:32,000 --> 00:02:35,000
>> 이제 우리는, 질문의 섹션을 가지고

44
00:02:35,000 --> 00:02:38,000
어떤을 다운로드 할 필요가 없습니다.

45
00:02:38,000 --> 00:02:41,000
당신이 내 이름을 클릭하고 공간에를 당겨 수 있습니다.

46
00:02:41,000 --> 00:02:44,000
지금 당신은 나를 클릭하십시오.

47
00:02:44,000 --> 00:02:46,000
금요일 수정 한 우리가 처음하고있는 스택 될 것입니다.

48
00:02:46,000 --> 00:02:55,000
금요일 수정 2 대기열 수 및 개정 3은 단독으로 연결리스트 될 것입니다.

49
00:02:55,000 --> 00:02:58,000
우리 스택로 시작.

50
00:02:58,000 --> 00:03:02,000
여기 따르면, 스택, 가장 기본적인 중 하나입니다

51
00:03:02,000 --> 00:03:07,000
컴퓨터 과학의 기본 데이터 구조.

52
00:03:07,000 --> 00:03:11,000
매우 원형 예입니다

53
00:03:11,000 --> 00:03:13,000
식당에서 쟁반의 스택.

54
00:03:13,000 --> 00:03:16,000
당신이 스택에 도입 될 때마다 그것은 원래

55
00:03:16,000 --> 00:03:20,000
사람이 말 것이다 "트레이 스택처럼 오."

56
00:03:20,000 --> 00:03:22,000
당신은 쟁반을 쌓아.

57
00:03:22,000 --> 00:03:24,000
그런 때 트레이를 끌어 이동

58
00:03:24,000 --> 00:03:31,000
당겨진다 첫 번째 줄은 스택에 넣어 된 마지막 사람입니다.

59
00:03:31,000 --> 00:03:34,000
그것은 또한 같은 스택은 여기라고

60
00:03:34,000 --> 00:03:37,000
우리는 스택이라는 메모리의 세그먼트가 있습니다.

61
00:03:37,000 --> 00:03:40,000
그리고 왜 스택이라고?

62
00:03:40,000 --> 00:03:42,000
>> 때문에 스택 데이터 구조와 같은,

63
00:03:42,000 --> 00:03:46,000
그것은 스택에 스택 프레임을 밀어더라도,

64
00:03:46,000 --> 00:03:53,000
스택 프레임은 함수의 특정 호출과 같은 곳입니다.

65
00:03:53,000 --> 00:03:57,000
그리고 스택처럼, 당신은 항상 반환해야합니다

66
00:03:57,000 --> 00:04:03,000
함수 호출에서 다시 낮은 스택 프레임에 내려 오기 전에.

67
00:04:03,000 --> 00:04:08,000
당신은 주요 통화 foo는 호출 바, 메인에 직접 바를 수익을 가질 수 없습니다.

68
00:04:08,000 --> 00:04:14,000
그것은 항상 몰아 보여주고 올바른 스택을 따라 있어요.

69
00:04:14,000 --> 00:04:18,000
두 작업은, 내가 말 한거처럼, 푸시와 팝 있습니다.

70
00:04:18,000 --> 00:04:20,000
사람들은 보편적 인 용어입니다.

71
00:04:20,000 --> 00:04:26,000
당신은 스택에 상관없이 어떤 측면에서 푸시와 팝을 알고 있어야합니다.

72
00:04:26,000 --> 00:04:28,000
우리는 큐가 서로 다른 종류의 아르가 표시됩니다.

73
00:04:28,000 --> 00:04:32,000
정말 보편적 인 용어를 필요는 없지만, 푸시 및 팝 스택에 대한 보편적입니다.

74
00:04:32,000 --> 00:04:34,000
푸시는 단지 스택에 집어 넣습니다.

75
00:04:34,000 --> 00:04:37,000
팝 스택을 벗고 있습니다.

76
00:04:37,000 --> 00:04:43,000
그리고 우리는 우리의 typedef 구조체 스택을 가지고 여기를 클릭하십시오

77
00:04:43,000 --> 00:04:46,000
그래서 우리는 숯불 ** 문자열을 갖추고 있습니다.

78
00:04:46,000 --> 00:04:51,000
어떤 **가 무서워하지 마세요.

79
00:04:51,000 --> 00:04:54,000
이 문자열의 배열로 끝나게 것입니다

80
00:04:54,000 --> 00:04:58,000
문자에 대한 포인터 또는 배열 곳

81
00:04:58,000 --> 00:05:00,000
문자에 대한 포인터는 문자열이어야하는 경향이 있습니다.

82
00:05:00,000 --> 00:05:05,000
이 문자열이어야 할 필요는 없습니다,하지만 그들은 문자열이 될거야.

83
00:05:05,000 --> 00:05:08,000
>> 우리는 문자열의 배열을 갖추고 있습니다.

84
00:05:08,000 --> 00:05:14,000
우리는 스택에 현재 얼마나 많은 요소를 나타내는 크기를,이

85
00:05:14,000 --> 00:05:19,000
그리고 우리는 스택에 얼마나 많은 요소가 될 수있는 능력을 갖추고 있습니다.

86
00:05:19,000 --> 00:05:22,000
용량이 1보다 큰 무언가로 시작해야합니다

87
00:05:22,000 --> 00:05:27,000
하지만 크기가 0으로 시작하려고합니다.

88
00:05:27,000 --> 00:05:36,000
자, 당신이 스택 생각할 수 세 가지가 기본적으로 있습니다.

89
00:05:36,000 --> 00:05:39,000
음, 아마 더 있지만, 주로 사용되는 두 가지 방법은

90
00:05:39,000 --> 00:05:43,000
당신은 배열을 사용하여 구현할 수, 또는 당신은 연결리스트를 사용하여 구현할 수 있습니다.

91
00:05:43,000 --> 00:05:48,000
링크 된 목록은 가지에서 스택을 할 사소한입니다.

92
00:05:48,000 --> 00:05:51,000
그것은 연결된 목록을 사용하여 스택을 만드는 것은 매우 쉬운 일이다

93
00:05:51,000 --> 00:05:55,000
그래서 여기, 우리는 배열을 사용하여 스택을 만들 거라고

94
00:05:55,000 --> 00:05:59,000
그리고 배열을 사용하여, 당신이 생각할 수있는 두 가지 방법도 있습니다.

95
00:05:59,000 --> 00:06:01,000
전에, 내가 말했을 때 우리는 스택의 용량을 가지고

96
00:06:01,000 --> 00:06:04,000
그래서 우리는 스택에 요소를 이용하실 수 있습니다.

97
00:06:04,000 --> 00:06:09,000
>> 무슨 일이 수있는 유일한 방법은 가능한 빨리 10 요소를 누르으로 다음 작업이 완료됩니다.

98
00:06:09,000 --> 00:06:13,000
당신은 세계에서 10 가지의 행 위가 알고 있습니다

99
00:06:13,000 --> 00:06:16,000
당신은 당신의 스택에 10 개 이상의 일을하지 않아도 될 것

100
00:06:16,000 --> 00:06:20,000
이 경우 귀하의 스택의 크기에 행 위를 할 수 있습니다.

101
00:06:20,000 --> 00:06:23,000
아니면, 당신의 스택이 경계해야 가질 수

102
00:06:23,000 --> 00:06:27,000
당신이 배열을하고 있다면, 그건 매번는 10 요소를 누르 것을 의미합니다

103
00:06:27,000 --> 00:06:29,000
이 20 요소를 쳤을 때 다음이 20 요소에 성장 할 것, 그리고하고

104
00:06:29,000 --> 00:06:33,000
은 30 요소 40 요소로 배열을 성장 할거야.

105
00:06:33,000 --> 00:06:37,000
당신은 우리가 여기서 할 수있는 일은 무엇 용량을 증가해야 할거야.

106
00:06:37,000 --> 00:06:40,000
우리가 우리 스택의 최대 크기에 도달 매번

107
00:06:40,000 --> 00:06:46,000
우리가 다른 뭔가를 밀어 때, 우리는 용량을 증가해야 할거야.

108
00:06:46,000 --> 00:06:50,000
여기, 우리는 푸쉬 푸쉬 BOOL (숯불 * STR)로 선언했습니다.

109
00:06:50,000 --> 00:06:54,000
숯불 *의 str을 우리가 스택에 밀어되는 문자열입니다

110
00:06:54,000 --> 00:06:58,000
그리고 BOOL은 우리가 성공 또는 실패 여부를 말합니다.

111
00:06:58,000 --> 00:07:00,000
>> 우리가 어떻게 실패 할 수 있습니까?

112
00:07:00,000 --> 00:07:04,000
당신이 생각할 수있는 유일한 상황은 무엇입니까

113
00:07:04,000 --> 00:07:07,000
우리는 FALSE를 반환해야합니다 어디에?

114
00:07:07,000 --> 00:07:09,000
그래.

115
00:07:09,000 --> 00:07:12,000
[학생]는 가득하고 우리가 접하고 구현을 사용하는 경우.

116
00:07:12,000 --> 00:07:17,000
그래, 우리가 어떻게 정의 - 그는 그럴 답변

117
00:07:17,000 --> 00:07:23,000
그것은 전체, 우리는 경계 구현을 사용하는 경우.

118
00:07:23,000 --> 00:07:26,000
그럼 우리가 확실히 false를 반환합니다.

119
00:07:26,000 --> 00:07:31,000
즉시 우리가 배열에 10 가지를 누르으로, 우리는 11 맞지 않을 수 있으며, 우리가 false를 반환하므로.

120
00:07:31,000 --> 00:07:32,000
이 경계 경우 어떻게해야합니까? 그래.

121
00:07:32,000 --> 00:07:38,000
당신은 어떤 이유로 배열을 확장 할 수 있습니다.

122
00:07:38,000 --> 00:07:43,000
그래, 메모리, 제한된 자원이다

123
00:07:43,000 --> 00:07:51,000
결국, 우리는 다시 이상 스택에 밀어 물건을 계속한다면,

124
00:07:51,000 --> 00:07:54,000
우리는 맞게 큰 배열을 시도하고 할당 할거야

125
00:07:54,000 --> 00:07:59,000
우리가 사용하고있는 큰 용량 및 malloc 또는 무슨 일이든 False를 반환 예정이다.

126
00:07:59,000 --> 00:08:02,000
음, malloc는 null 반환합니다.

127
00:08:02,000 --> 00:08:05,000
>> 기억, 당신은 malloc를 호출 매번, 당신은 확인 만해야하는 경우 그

128
00:08:05,000 --> 00:08:12,000
null을 반환 또는 다른 그 정확성을 공제합니다.

129
00:08:12,000 --> 00:08:17,000
우리는 경계가 스택을 갖고 싶어 때문에,

130
00:08:17,000 --> 00:08:21,000
우리가하려고하는 경우 우리가 거​​짓 반환 할 수있는 유일한 경우는

131
00:08:21,000 --> 00:08:26,000
용량 및 malloc을 늘리거나 false를 반환 뭐든간에.

132
00:08:26,000 --> 00:08:30,000
그런 다음 팝업은 인수도도지지 않습니다

133
00:08:30,000 --> 00:08:37,000
그리고 스택의 최상위 (top)에있는 문자열을 반환합니다.

134
00:08:37,000 --> 00:08:41,000
어쨌든이 가장 최근에 스택에 밀어되었다가, 재 무엇 팝업입니다

135
00:08:41,000 --> 00:08:44,000
그리고 또한 스택에서 제거합니다.

136
00:08:44,000 --> 00:08:50,000
그리고 스택에 아무​​것도없는 경우가 null이 반환 확인합니다.

137
00:08:50,000 --> 00:08:53,000
이 스택이 비어 있는지 항상 가능합니다.

138
00:08:53,000 --> 00:08:55,000
자바에서, 당신이 그, 또는 다른 언어로 사용하는 경우,

139
00:08:55,000 --> 00:09:01,000
빈 스택에서 튀어하는 것은 예외이나 뭐 발생할 수 있습니다.

140
00:09:01,000 --> 00:09:09,000
>> 그러나 C에서 null은 우리가 이러한 문제를 처리하는 방법에 많은 사건 종류의 것입니다.

141
00:09:09,000 --> 00:09:13,000
null을 반환하면 우리는 스택이 비어 있다는 의미 할거야 방법입니다.

142
00:09:13,000 --> 00:09:16,000
우리는 귀하의 스택의 기능을 테스트 할 코드를 제공

143
00:09:16,000 --> 00:09:19,000
푸시와 팝을 구현합니다.

144
00:09:19,000 --> 00:09:23,000
이 코드의 많은 수 없습니다.

145
00:09:23,000 --> 00:09:40,000
그러 - 사실은, 우리가하기 전에, 힌트, 힌트 -

146
00:09:40,000 --> 00:09:44,000
당신이 그것을 본적이 없다면, malloc이 유일한 함수가 아닙니다

147
00:09:44,000 --> 00:09:47,000
그 말은 당신의 힙에 메모리를 할당합니다.

148
00:09:47,000 --> 00:09:51,000
alloc 함수의 가족이 있습니다.

149
00:09:51,000 --> 00:09:53,000
첫 번째는 당신이 익숙 malloc입니다.

150
00:09:53,000 --> 00:09:56,000
그런 다음 malloc과 같은 일을 calloc은이

151
00:09:56,000 --> 00:09:59,000
하지만 당신 모든것을 제로합니다.

152
00:09:59,000 --> 00:10:04,000
혹시 무언가를 mallocing 후 null로 모든 설정하려고 한 경우

153
00:10:04,000 --> 00:10:06,000
당신은 대신 쓰기의 처음에 calloc을 사용했는데

154
00:10:06,000 --> 00:10:09,000
메모리의 전체 블록을 0으로 루프.

155
00:10:09,000 --> 00:10:15,000
>> Realloc는 malloc처럼하고 특별한 경우를 많이 있습니다

156
00:10:15,000 --> 00:10:19,000
하지만 기본적으로 realloc은 무엇을입니다

157
00:10:19,000 --> 00:10:24,000
이미 할당 된 포인터를 걸립니다.

158
00:10:24,000 --> 00:10:27,000
Realloc 당신이 여기에 관심을 지불 할 원하는 함수입니다.

159
00:10:27,000 --> 00:10:31,000
이미 malloc에​​서 반환 된 포인터를 걸립니다.

160
00:10:31,000 --> 00:10:35,000
자, 당신이 malloc에​​서 10 바이트 포인터를 요청 말한다.

161
00:10:35,000 --> 00:10:38,000
그런 다음 나중에, 당신이 20 바이트를 원 실현

162
00:10:38,000 --> 00:10:42,000
그래서 당신은, 20 바이트 가진 포인터에 realloc를 호출

163
00:10:42,000 --> 00:10:47,000
그리고 realloc는 자동으로 모든 걸 복사합니다.

164
00:10:47,000 --> 00:10:51,000
당신은 내가 10 바이트의 블록을 가지고있는 것처럼, 다시 malloc을했다. 경우

165
00:10:51,000 --> 00:10:53,000
지금은 20 바이트의 블록을 필요

166
00:10:53,000 --> 00:10:58,000
그래서 malloc 20 바이트를하는 경우, 그럼 수동으로 먼저에서 10 바이트를 넘는 복사해야

167
00:10:58,000 --> 00:11:01,000
먼저 두 번째로 후 무료로 제공됩니다.

168
00:11:01,000 --> 00:11:04,000
Realloc는 그 부분을 처리합니다.

169
00:11:04,000 --> 00:11:11,000
>> 서명이 무효의 * 될 것입니다 공지 사항

170
00:11:11,000 --> 00:11:15,000
이는 단지 메모리 블록에 대한 포인터를 제공하고 있습니다

171
00:11:15,000 --> 00:11:17,000
그리고 무효 * PTR.

172
00:11:17,000 --> 00:11:22,000
당신은 일반 포인터로 공극 * 생각할 수 있습니다.

173
00:11:22,000 --> 00:11:27,000
일반적으로, 당신은 무효 *로 처리 안

174
00:11:27,000 --> 00:11:30,000
하지만 malloc은 무효 *를 반환되어 다음 단처럼 사용할 있어요

175
00:11:30,000 --> 00:11:34,000
이 사실 숯불 *가 될 것입니다.

176
00:11:34,000 --> 00:11:37,000
malloc에​​ 의해 반환 된 이전 공극 *

177
00:11:37,000 --> 00:11:41,000
지금은 크기 그리고 realloc에​​ 전달 될 예정,되고

178
00:11:41,000 --> 00:11:49,000
당신은 할당 할 바이트의 새로운 수 있으므로 새로운 능력입니다.

179
00:11:49,000 --> 00:11:57,000
내가 몇 분만 시간을 줘, 우리의 공간에서 할 수 있습니다.

180
00:11:57,000 --> 00:12:02,000
금요일 수정 1 시작합니다.

181
00:12:16,000 --> 00:12:21,000
나는, 푸시를 구현하기에 충분한 시간 후에 희망을 중단됩니다

182
00:12:21,000 --> 00:12:24,000
그럼 내가 당신에게 팝업을 다른 휴식을 제공합니다.

183
00:12:24,000 --> 00:12:27,000
그러나 정말 전혀 그렇게 많은 코드가 없습니다.

184
00:12:27,000 --> 00:12:35,000
대부분의 코드는 용량을 확장, 아마도 확장 것들입니다.

185
00:12:35,000 --> 00:12:39,000
좋아요, 완전히 수행 할 수는 없으며 압력,

186
00:12:39,000 --> 00:12:47,000
하지만, 오래은 옳은 길을 가고있는 것처럼 기분으로 좋네요.

187
00:12:47,000 --> 00:12:53,000
>> 사람은 날 끌어 올릴 수있는 편안 코드를 가지고 있습니까?

188
00:12:53,000 --> 00:12:59,000
네, 그럴 게요,하지만 누구에게도 내가 살펴볼 수있는 코드가 무엇입니까?

189
00:12:59,000 --> 00:13:05,000
좋아, 그게 뭐든지간에, 그것을 저장 시작할 수 있습니다?

190
00:13:05,000 --> 00:13:09,000
항상 그 단계를 잊어 버려.

191
00:13:09,000 --> 00:13:15,000
그래, 푸시를보고,

192
00:13:15,000 --> 00:13:18,000
당신은 코드를 설명 하시겠습니까?

193
00:13:18,000 --> 00:13:24,000
[학생] 우선, 제가 크기를 증가했다.

194
00:13:24,000 --> 00:13:28,000
그러니까 아마 그 - 어쨌든이 될 것 같은데, 난의 크기를 증가

195
00:13:28,000 --> 00:13:31,000
이 용량 미만이라면 나는 참조하십시오.

196
00:13:31,000 --> 00:13:36,000
그리고 용량보다면, 난 우리가 이미 가지고있는 배열에 추가합니다.

197
00:13:36,000 --> 00:13:42,000
사실이 아니라면, 내가, 2로 용량을 곱

198
00:13:42,000 --> 00:13:50,000
그리고 지금은 더 큰 용량 크기 뭔가를 문자열 배열을 할당.

199
00:13:50,000 --> 00:13:55,000
거기서 실패하면 그리고 난은 사용자에게 있으며, FALSE를 반환

200
00:13:55,000 --> 00:14:04,000
괜찮아요되면, 나는 새로운 장소에 문자열을 넣어.

201
00:14:04,000 --> 00:14:07,000
>> [롭 B.]는 우리가 좋은 비트 연산자를 사용한 또한을 발견

202
00:14:07,000 --> 00:14:09,000
2로 곱합니다.

203
00:14:09,000 --> 00:14:11,000
단, 왼쪽 시프트는 항상 둘을 곱한 할 예정이다.

204
00:14:11,000 --> 00:14:15,000
당신이 그걸 기억으로 오른쪽 이동은 오랫동안 2로 나누어 져 있습니다

205
00:14:15,000 --> 00:14:18,000
2로 나누어 정수에서와 같이 2로 나눕니다.

206
00:14:18,000 --> 00:14:20,000
그것은 여기 저기 1 잘릴 수 있습니다.

207
00:14:20,000 --> 00:14:26,000
그러나 1 왼쪽 시프트는 항상 2을 곱한 할 것입니다

208
00:14:26,000 --> 00:14:32,000
당신이 오버 플로우 정수의 범위를하지 않는 한, 다음이되지 않습니다.

209
00:14:32,000 --> 00:14:34,000
사이드 댓글 달기를 수행 할 수 있습니다.

210
00:14:34,000 --> 00:14:39,000
내가 뭘 -이 어떠한 방법을 코딩가 호전되지는 할

211
00:14:39,000 --> 00:14:48,000
하지만 이런 짓을 것을 좋아합니다.

212
00:14:48,000 --> 00:14:51,000
그것은 실제로 약간 이상 할 것이다.

213
00:15:04,000 --> 00:15:08,000
어쩌면이이 문제를 보여 완벽한 아닙니다

214
00:15:08,000 --> 00:15:14,000
하지만의 -이 블록으로 세그먼트에 좋아

215
00:15:14,000 --> 00:15:17,000
이런 경우 괜찮다면, 그럼 내가 뭔가를 할거야

216
00:15:17,000 --> 00:15:19,000
다음 기능을 수행합니다.

217
00:15:19,000 --> 00:15:22,000
나는 그 함수를 아래로 내 눈을 모든 방법을 스크롤 할 필요가 없습니다

218
00:15:22,000 --> 00:15:25,000
다른 한 이후에 발생하는 볼 수 있습니다.

219
00:15:25,000 --> 00:15:27,000
이러한 상황이 발생할 경우 경우가있어, 그 다음엔 그냥 반환합니다.

220
00:15:27,000 --> 00:15:30,000
또한이 이외의 모든 좋은 장점이 있습니다

221
00:15:30,000 --> 00:15:33,000
지금 한 번 왼쪽으로 이동합니다.

222
00:15:33,000 --> 00:15:40,000
난 더 이상, 간 경우 지금까지 터무니 긴 라인 근처 필요가 없습니다

223
00:15:40,000 --> 00:15:45,000
다음, 그 4 바이트 도움이 수 있으며, 또한 더 많은 왼쪽 뭔가가

224
00:15:45,000 --> 00:15:48,000
덜 - 그래, 내가 기억해야하는 경우 기분이 압도

225
00:15:48,000 --> 00:15:53,000
나는 루프의 다른 내부의 안쪽에 잠시 루프에서 현재입니다.

226
00:15:53,000 --> 00:15:58,000
아무 데나 당신은 내가 가지 같은, 당장 수익을 수행 할 수 있습니다.

227
00:15:58,000 --> 00:16:05,000
그것은 완전히 선택 사항이며 어떠한 방식으로 예상.

228
00:16:05,000 --> 00:16:12,000
>> [학생]가이 크기이어야합니다 - 페일 조건에?

229
00:16:12,000 --> 00:16:19,000
여기에 실패 조건은 우리가 지금 네, realloc에​​ 실패합니다.

230
00:16:19,000 --> 00:16:22,000
추측 컨데, 실패 조건에서 어떻게 발견

231
00:16:22,000 --> 00:16:26,000
우리 무료 콘텐츠 나중에하지 않는 한, 우리는 항상 실패 할 것

232
00:16:26,000 --> 00:16:29,000
우리가 뭔가를 밀어하려고 몇 번을 찍었는지는 상관 없습니다.

233
00:16:29,000 --> 00:16:32,000
우린 계속 밀고 나아가 야하는 경우, 우리는 증가 크기를 유지

234
00:16:32,000 --> 00:16:36,000
우리는 스택에 아무​​것도 넣어되지 않더라도.

235
00:16:36,000 --> 00:16:39,000
보통은 될 때까지의 크기를 증가하지 않습니다

236
00:16:39,000 --> 00:16:43,000
우리는 성공적으로 스택에 넣어 한 후.

237
00:16:43,000 --> 00:16:50,000
우리는 하나 여기, 여기, 말을 할 것입니다.

238
00:16:50,000 --> 00:16:56,000
대신 ≤ 용량을 s.size의 뜻을 그리고, 그것은 용량보다 덜

239
00:16:56,000 --> 00:17:01,000
모든 곳을 우리가 이동하기 때문에.

240
00:17:01,000 --> 00:17:07,000
>> 그리고 기억, 우리는 가능한 허위 유일한 장소를 반환 수

241
00:17:07,000 --> 00:17:14,000
realloc이 null 반환 곳, 여기에

242
00:17:14,000 --> 00:17:19,000
당신은 표준 오류를 기억 발생할 경우,

243
00:17:19,000 --> 00:17:22,000
당신은 표준 오류를 인쇄하려는 아마이 사건을 고려해 볼 수 있습니다

244
00:17:22,000 --> 00:17:26,000
대신 표준 출력에 직접 인쇄가 너무 fprintf STDERR.

245
00:17:26,000 --> 00:17:31,000
다시 말하지만, 그건 기대하지 않지만 그것을 오류가 있다면

246
00:17:31,000 --> 00:17:41,000
printf 입력 한 다음 당신은 대신 표준에서의 표준 오류에 인쇄 할 수도 있습니다.

247
00:17:41,000 --> 00:17:44,000
>> 누구든지주의 다른 게 있나요? 예.

248
00:17:44,000 --> 00:17:47,000
[학생] 당신은 [안 들리게]에 가서 할 수 있나요?

249
00:17:47,000 --> 00:17:55,000
[롭 B. 네, 실제 그것의 binariness 또는 뭐지?

250
00:17:55,000 --> 00:17:57,000
[학생] 그래서 당신은 두하여 곱?

251
00:17:57,000 --> 00:17:59,000
[롭 B.] 네, 기본적으로.

252
00:17:59,000 --> 00:18:11,000
진 땅에서, 우리는 항상 숫자 우리의 세트가 있습니다.

253
00:18:11,000 --> 00:18:22,000
오른쪽에있는 여기를 기본적으로 삽입을 1이 왼쪽을 이동.

254
00:18:22,000 --> 00:18:25,000
돌아하려면 이진의 모든 것들이 기억

255
00:18:25,000 --> 00:18:28,000
2의 힘이기 때문에이 0 2를 나타냅니다

256
00:18:28,000 --> 00:18:30,000
1이 2이 2 2.

257
00:18:30,000 --> 00:18:33,000
이제 오른쪽에 0을 삽입하여, 우리는 모든 이상 이동.

258
00:18:33,000 --> 00:18:38,000
어떤 0-2으로 사용하면 2, 지금 2 1-2이다.

259
00:18:38,000 --> 00:18:41,000
우리가 삽입 한 오른쪽

260
00:18:41,000 --> 00:18:44,000
반드시 0 될 것입니다 것은

261
00:18:44,000 --> 00:18:46,000
하는 말이 있습니다.

262
00:18:46,000 --> 00:18:49,000
지금까지 2로 번호를 곱하면 이상한 결국 않을거야

263
00:18:49,000 --> 00:18:54,000
그래서 0 장소에 2, 0이어야합니다

264
00:18:54,000 --> 00:18:59,000
당신이 바꿔 발생 경우이 내가 절반 전에 대한 경고가 무엇

265
00:18:59,000 --> 00:19:01,000
정수의 비트 수없는,

266
00:19:01,000 --> 00:19:04,000
다음이 1에서 살게 될 것입니다.

267
00:19:04,000 --> 00:19:10,000
당신이 정말로 큰 용량을 처리 할 일이 있으면 그 유일한 걱정입니다.

268
00:19:10,000 --> 00:19:15,000
그러나 그 시점에서, 다음, 다 수십억의 배열을 상대

269
00:19:15,000 --> 00:19:25,000
어쨌든 메모리에 맞지 않을 수있는.

270
00:19:25,000 --> 00:19:31,000
>> 이제 우리는 더욱 쉽게 팝,로 이동할 수 있습니다.

271
00:19:31,000 --> 00:19:36,000
당신은 전체 무리를 나타에 있다면 당신은 그것을 좋아 할 수

272
00:19:36,000 --> 00:19:38,000
지금 다시 이분의 일 용량에있다.

273
00:19:38,000 --> 00:19:42,000
당신은 당신이 가진 메모리의 양을 축소하기 위해 realloc 수

274
00:19:42,000 --> 00:19:47,000
하지만 그런 걱정은 할 필요가 없습니다, 그래서 유일한 realloc 케이스가 될 것입니다

275
00:19:47,000 --> 00:19:50,000
메모리를 축소 적이 메모리를 증가

276
00:19:50,000 --> 00:19:59,000
이는 팝업 슈퍼 쉽게 만들어 줄 수 있습니다.

277
00:19:59,000 --> 00:20:02,000
스택처럼 될거야 지금 큐,

278
00:20:02,000 --> 00:20:06,000
하지만 당신이 일을 수행하는 순서가 반대로되어 있습니다.

279
00:20:06,000 --> 00:20:10,000
큐의 원형 예제는 줄입니다

280
00:20:10,000 --> 00:20:12,000
그래서 난 당신이 영어라면했는데 이렇게 말했을 것이다

281
00:20:12,000 --> 00:20:17,000
대기열의 원형 예는 큐입니다.

282
00:20:17,000 --> 00:20:22,000
그래서 라인과 같은, 당신은 라인의 첫 번째 사람이라면,

283
00:20:22,000 --> 00:20:24,000
당신은 선을 첫 번째 사람이되고 기대합니다.

284
00:20:24,000 --> 00:20:31,000
이 라인의 마지막 사람 인 경우 서비스를 마지막으로 본 사람이 될거야.

285
00:20:31,000 --> 00:20:35,000
스택은 LIFO 패턴이었다 반면 우리는 그 FIFO 패턴을 전화하십시오.

286
00:20:35,000 --> 00:20:40,000
그 단어는 매우 보편적이다.

287
00:20:40,000 --> 00:20:46,000
>> 스택과 같은과 배열과는 달리, 큐는 일반적으로 중간에 요소에 대한 액세스를 허용하지 않습니다.

288
00:20:46,000 --> 00:20:50,000
여기서, 스택, 우리는 푸시와 팝을 갖추고 있습니다.

289
00:20:50,000 --> 00:20:54,000
여기, 우리는 그들에게 인큐와 dequeue를 불러 했죠.

290
00:20:54,000 --> 00:20:58,000
나는 또한 그들에게 변화와 unshift라고 들어 보신 적이있을 것입니다.

291
00:20:58,000 --> 00:21:02,000
나는 사람들이 푸시와 팝 큐로도 적용 할 말을 들었습니다.

292
00:21:02,000 --> 00:21:05,000
내 말은, 제거, 삽입 들었습니다

293
00:21:05,000 --> 00:21:11,000
그래서 밀어 당신이 스택에 대해 얘기하는 경우, 당신은 밀 진열하게하고 있습니다, 아빠.

294
00:21:11,000 --> 00:21:16,000
이 큐에 대해 얘기하고 있다면, 당신은 사용하고자하는 단어를 선택 할 수

295
00:21:16,000 --> 00:21:23,000
삽입 및 제거하고 호출해야하는지에 대해서는 합의가 없습니다.

296
00:21:23,000 --> 00:21:27,000
하지만 여기, 우리는 인큐와 dequeue 있습니다.

297
00:21:27,000 --> 00:21:37,000
이제 구조체는 스택 구조체 거의 동일 보입니다.

298
00:21:37,000 --> 00:21:40,000
그러나 우리는 머리를 추적해야합니다.

299
00:21:40,000 --> 00:21:44,000
나는 여기라고 생각하지만, 우리가 왜 머리를해야하나요?

300
00:21:53,000 --> 00:21:57,000
프로토 타입은 푸시와 팝을 기본적으로 동일합니다.

301
00:21:57,000 --> 00:21:59,000
당신은 푸시와 팝으로 생각할 수 있습니다.

302
00:21:59,000 --> 00:22:08,000
유일한 차이점은 팝업 것은 재 - 대신 마지막으로, 처음을 반환 해.

303
00:22:08,000 --> 00:22:12,000
2, 1, 3, 4, 또는 무언가.

304
00:22:12,000 --> 00:22:14,000
여기가 시작이야.

305
00:22:14,000 --> 00:22:17,000
우리 대기열이 완전히 꽉 차 있기 때문에 거기에 4 개 요소가 있습니다.

306
00:22:17,000 --> 00:22:21,000
우리 큐의 끝이 현재 2

307
00:22:21,000 --> 00:22:24,000
지금 우리는 다른 뭔가를 삽입로 이동합니다.

308
00:22:24,000 --> 00:22:29,000
>> 우리는 스택 버전에 우리가 무슨 짓을했는지 다른 뭔가를 삽입 할 때

309
00:22:29,000 --> 00:22:36,000
우리는 메모리의 블록을 확장하고 있습니다.

310
00:22:36,000 --> 00:22:40,000
이것에 대한 문제는 무엇입니까?

311
00:22:40,000 --> 00:22:45,000
[학생] 당신은 2 이동합니다.

312
00:22:45,000 --> 00:22:51,000
나는 큐의 마지막에 대해 이전에 말씀하신 거,

313
00:22:51,000 --> 00:22:57,000
이 1에서 우리가 시작할 때 이해가되지 않는

314
00:22:57,000 --> 00:23:01,000
그런 다음에 우리가 다음엔 dequeue 3, dequeue 4,, dequeue 1 원

315
00:23:01,000 --> 00:23:05,000
다음 dequeue 2, 다음이 하나를 dequeue.

316
00:23:05,000 --> 00:23:08,000
우리는 지금 realloc을 사용할 수 없습니다

317
00:23:08,000 --> 00:23:11,000
아님 최소한, 당신은 다른 방법으로 realloc을 사용해야합니다.

318
00:23:11,000 --> 00:23:15,000
하지만 당신은 아마 realloc을 사용해서는 안됩니다.

319
00:23:15,000 --> 00:23:18,000
당신은 수동으로 메모리를 복사 할 것입니다.

320
00:23:18,000 --> 00:23:21,000
>> 메모리를 복사 할 두 가지 기능이 있습니다.

321
00:23:21,000 --> 00:23:25,000
memcopy와 memmove이 있어요.

322
00:23:25,000 --> 00:23:29,000
나는 현재 사용하려는거야 어떤 볼 사람이 페이지를 읽고 있어요.

323
00:23:29,000 --> 00:23:35,000
좋아요, memcopy, 그 차이는

324
00:23:35,000 --> 00:23:38,000
memcopy와 memmove, 하나는 제대로 사건을 처리하는

325
00:23:38,000 --> 00:23:41,000
당신은이 지역을 겹쳐 발생 영역으로 복사하는 곳

326
00:23:41,000 --> 00:23:46,000
당신은에서 복사하고 있습니다.

327
00:23:46,000 --> 00:23:50,000
Memcopy가 처리하지 않습니다. Memmove는 않습니다.

328
00:23:50,000 --> 00:23:59,000
당신은 - 문제 생각할 수

329
00:23:59,000 --> 00:24:09,000
우선은,이​​ 사람을 복사 할 말

330
00:24:09,000 --> 00:24:13,000
이 남자는 이러한 넷.

331
00:24:13,000 --> 00:24:16,000
결국, 배열은 어떻게 생겼해야합니다

332
00:24:16,000 --> 00:24:26,000
복사는 2, 1, 2, 1, 3, 4, 끝에 일 후.

333
00:24:26,000 --> 00:24:29,000
그러나 우리가 실제로 복사되는 순서에 따라 달라집니다

334
00:24:29,000 --> 00:24:32,000
우리 지역은 우리가에 복사하고있는 사실을 고려하지 않은 경우 이후

335
00:24:32,000 --> 00:24:35,000
중복 우리가에서 복사하고있는 하나

336
00:24:35,000 --> 00:24:46,000
그리고 우리는 여기 시작처럼 할 우리가 가고 싶은 곳으로 2 복사 할 수 있습니다

337
00:24:46,000 --> 00:24:52,000
그리고 앞으로 우리 포인터를 이동합니다.

338
00:24:52,000 --> 00:24:56,000
>> 이제 우리는 여기와 여기에있을거야, 이제 우리는 복사 할

339
00:24:56,000 --> 00:25:04,000
이이 녀석 이상의 남자와 앞으로 우리 포인터를 이동합니다.

340
00:25:04,000 --> 00:25:07,000
우리가 치울거야하면, 1, 2, 1, 2, 1 2

341
00:25:07,000 --> 00:25:10,000
대신 적절한 2, 1, 2, 1, 3, 4 때문에

342
00:25:10,000 --> 00:25:15,000
2, 1은 원래 3, 4을 변형.

343
00:25:15,000 --> 00:25:19,000
Memmove은 정확하게 처리합니다.

344
00:25:19,000 --> 00:25:23,000
이 경우, 기본적으로 항상 memmove를 사용하여

345
00:25:23,000 --> 00:25:26,000
그것은 올바르게 처리 때문입니다.

346
00:25:26,000 --> 00:25:29,000
그것은 일반적으로 더 악화을 수행하지 않습니다.

347
00:25:29,000 --> 00:25:32,000
이 아이디어는 대신 처음부터 시작하고 이런 식으로 복사입니다

348
00:25:32,000 --> 00:25:35,000
우리가 여기처럼, 그것은 끝에서 시작에 복사

349
00:25:35,000 --> 00:25:38,000
그 경우, 당신은 문제가 없다.

350
00:25:38,000 --> 00:25:40,000
더 성능이 손실되지 않습니다.

351
00:25:40,000 --> 00:25:47,000
항상 memmove를 사용합니다. memcopy 걱정하지 마십시오.

352
00:25:47,000 --> 00:25:51,000
당신이 별도로 memmove 할거야 그리고 그것이

353
00:25:51,000 --> 00:26:01,000
대기열의 포장 종합 부분입니다.

354
00:26:01,000 --> 00:26:04,000
걱정이 완전히 수행하지 경우 없습니다.

355
00:26:04,000 --> 00:26:10,000
이 스택, 푸시, 팝보다 더 어렵습니다.

356
00:26:10,000 --> 00:26:15,000
>> 누구든지 우리가 함께 일 수있는 코드가 있습니까?

357
00:26:15,000 --> 00:26:21,000
도 완전히 불완전한 경우?

358
00:26:21,000 --> 00:26:23,000
[학생] 그래,하지만 완전히 불완전입니다.

359
00:26:23,000 --> 00:26:27,000
우리가 - 수의 버전을 저장으로 완전히 불완전한은 오래로 괜찮을까요?

360
00:26:27,000 --> 00:26:32,000
나는 매번 잊어 버려요.

361
00:26:32,000 --> 00:26:39,000
우리가 물건을 크기를 조정해야 할 때 좋아요, 무엇을 무시하면 발생합니다.

362
00:26:39,000 --> 00:26:42,000
완전히 크기를 무시합니다.

363
00:26:42,000 --> 00:26:49,000
이 코드를 설명합니다.

364
00:26:49,000 --> 00:26:54,000
크기가 모든 처음 사본보다 작다면 내가 먼저 모든 알아보고 있어요

365
00:26:54,000 --> 00:27:01,000
그리고 그 후, 나는 삽입 - 난 머리 + 크기를 가져

366
00:27:01,000 --> 00:27:05,000
그리고, 그것은 배열의 용량을 주위에 래핑해야합니다

367
00:27:05,000 --> 00:27:08,000
그리고 난 그 위치에서 새로운 문자열을 삽입합니다.

368
00:27:08,000 --> 00:27:12,000
그럼 내가 크기를 증가시키고 TRUE를 반환.

369
00:27:12,000 --> 00:27:22,000
>> [롭 B.]이 분명히 당신이 모드를 사용하려는 것 이러한 경우 중 하나입니다.

370
00:27:22,000 --> 00:27:25,000
당신이 근처에 배치 생각한다면, 주변에 감기가있는 경우 모든 종류의

371
00:27:25,000 --> 00:27:29,000
바로 생각 MOD해야합니다.

372
00:27:29,000 --> 00:27:36,000
빠른 최적화로 / 코드 한 줄이 짧은하기

373
00:27:36,000 --> 00:27:42,000
당신은 선이 바로 이것에 따라 것을 알

374
00:27:42,000 --> 00:27:53,000
단지 크기 + +하므로 병합이이 줄에, 크기 + +.

375
00:27:53,000 --> 00:27:58,000
여기 이제, 우리는 가방을 가지고

376
00:27:58,000 --> 00:28:01,000
어디에서 우리는 충분한 메모리가 없습니다

377
00:28:01,000 --> 00:28:05,000
그래서 우리는 2 일까지 용량을 증가하고 있습니다.

378
00:28:05,000 --> 00:28:09,000
, 난 당신이 여기 같은 문제가 될 것 같은데,하지만 지금 무시할 수

379
00:28:09,000 --> 00:28:13,000
귀하의 용량을 증가하는 데 실패 곳 경우,

380
00:28:13,000 --> 00:28:18,000
그런 다음 다시 두하여 용량을 감소하려는거야.

381
00:28:18,000 --> 00:28:24,000
또 다른 짧은 메모 니가 할 수있는 일 뿐이에요 + =,

382
00:28:24,000 --> 00:28:30,000
여러분은 << = 작업을 수행 할 수 있습니다.

383
00:28:30,000 --> 00:28:43,000
동일하기 전에 거의 무엇이든 갈 수, + =, | =, & =, << =.

384
00:28:43,000 --> 00:28:52,000
숯불 * 새로운 메모리의 새로운 블록입니다.

385
00:28:52,000 --> 00:28:55,000
아, 여기여.

386
00:28:55,000 --> 00:29:02,000
>> 사람들은 메모리의 새로운 블록의 종류에 대해 어떻게 생각하십니까?

387
00:29:02,000 --> 00:29:06,000
[학생]은 숯불 **해야합니다.

388
00:29:06,000 --> 00:29:12,000
여기까지 우리 구조체로 생각,

389
00:29:12,000 --> 00:29:14,000
문자열은 우리가 재분배는 것이 야.

390
00:29:14,000 --> 00:29:21,000
우리는 큐에 요소에 대한 완전히 새로운 동적 스토리지를하고 있습니다.

391
00:29:21,000 --> 00:29:25,000
우리는 문자열로 지정 될 것 것은 우리가 지금 mallocing있는거야

392
00:29:25,000 --> 00:29:30,000
그래서 새로운 숯불 **가 될 것입니다.

393
00:29:30,000 --> 00:29:34,000
그것은 문자열의 배열거야.

394
00:29:34,000 --> 00:29:38,000
그럼 우리가 False를 반환 할거야하는 아래의 경우는 무엇인가?

395
00:29:38,000 --> 00:29:41,000
[학생] 우리는 숯불 * 일을해야 하는가?

396
00:29:41,000 --> 00:29:44,000
[롭 B.] 네, 좋은 전화.

397
00:29:44,000 --> 00:29:46,000
[학생] 무슨 일이야?

398
00:29:46,000 --> 00:29:49,000
[롭 B.] 우리는이 더 없기 때문에 숯불 *의 크기를하고 싶었 이상 -

399
00:29:49,000 --> 00:29:53,000
sizeof (문자)가 1 일하기 때문에 실제로는 매우 큰 문제가 될 것입니다.

400
00:29:53,000 --> 00:29:55,000
Sizeof 문자 *는 4가 될 것입니다

401
00:29:55,000 --> 00:29:58,000
그래서 당신은 ints 상대가 시대의 많은,

402
00:29:58,000 --> 00:30:01,000
여러분이 가지고 도망가지기 때문 INT *의 INT와 크기의 크기

403
00:30:01,000 --> 00:30:04,000
32 비트 시스템에서 같은 일이 될거야.

404
00:30:04,000 --> 00:30:09,000
하지만 여기, sizeof (숯불)와 sizeof는 (숯불 *) 지금 같은 일이 될거야.

405
00:30:09,000 --> 00:30:15,000
>> 우리가 False를 반환 상황은 무엇입니까?

406
00:30:15,000 --> 00:30:17,000
[학생] 새가 null입니다.

407
00:30:17,000 --> 00:30:23,000
새로운 null이면 네,, 우리는 False를 반환

408
00:30:23,000 --> 00:30:34,000
그리고 내가 내려 간다 여기

409
00:30:34,000 --> 00:30:37,000
[학생] [안 들리게]

410
00:30:37,000 --> 00:30:39,000
[롭 B. 그래,이 유효합니다.

411
00:30:39,000 --> 00:30:46,000
당신도 2 배 용량이나 용량 변화 한 후 만 여기이든 뭐든간에 내려 설정을 할 수 있습니다.

412
00:30:46,000 --> 00:30:52,000
우리가 그렇게 우리는 할 수 있습니다.

413
00:30:52,000 --> 00:30:56,000
용량 >> = 1.

414
00:30:56,000 --> 00:31:08,000
그리고 당신은 1의 자리를 잃어 버릴까 걱정해야 할 수 없어

415
00:31:08,000 --> 00:31:12,000
당신은 1 이동 떠난 것 때문에, 그래서 1의 장소는 반드시 0

416
00:31:12,000 --> 00:31:16,000
그래서 지금 1 변화, 계속 잘 될거야.

417
00:31:16,000 --> 00:31:19,000
[학생]는 당신이 반환하기 전에 해당 작업을 수행 할 필요가 있습니까?

418
00:31:19,000 --> 00:31:29,000
[롭 B. 네,이 전혀 의미가 없습니다.

419
00:31:29,000 --> 00:31:36,000
>> 우리가 끝으로 진정한 재 끝낼거야 지금 가정합니다.

420
00:31:36,000 --> 00:31:39,000
우리가이 memmoves을 다하겠습니다 방법

421
00:31:39,000 --> 00:31:45,000
우리는 우리가 그들을 어떻게주의해야한다.

422
00:31:45,000 --> 00:31:50,000
사람이 우리가 그들을 어떻게에 대한 제안 사항이 있습니까?

423
00:32:17,000 --> 00:32:21,000
다음은 시작입니다.

424
00:32:21,000 --> 00:32:28,000
필연적으로, 우리는 다시 처음부터 시작하려면

425
00:32:28,000 --> 00:32:35,000
거기서부터와 복사 일, 1, 3, 4, 2.

426
00:32:35,000 --> 00:32:41,000
당신이 어떻게해야합니까?

427
00:32:41,000 --> 00:32:52,000
첫째, 다시 memmove에 대한 man 페이지를보고 있습니다.

428
00:32:52,000 --> 00:32:57,000
Memmove, 인수의 순서는 항상 중요합니다.

429
00:32:57,000 --> 00:33:01,000
우리는 소스 두 번째 크기 셋째, 먼저 목적지 싶습니다.

430
00:33:01,000 --> 00:33:06,000
원본 및 대상을 취소 기능이 많이 있습니다.

431
00:33:06,000 --> 00:33:11,000
대상, 소스는 다소 일치하는 경향이있다.

432
00:33:17,000 --> 00:33:21,000
이동, 왜 반환입니까?

433
00:33:21,000 --> 00:33:27,000
당신이 할 수있는 어떤 이유로 목적지에 대한 포인터를 반환합니다.

434
00:33:27,000 --> 00:33:32,000
난 읽을 수 사진,하지만 우리는 우리의 목적지로 이동하고 싶습니다.

435
00:33:32,000 --> 00:33:35,000
>> 우리의 목적지를 어떻게 할거야?

436
00:33:35,000 --> 00:33:37,000
[학생] 새.

437
00:33:37,000 --> 00:33:39,000
[롭 B.] 그래, 우린 어디로에서 복사거야?

438
00:33:39,000 --> 00:33:43,000
우리가 복사하는 첫 번째 일은이 1, 3, 4입니다.

439
00:33:43,000 --> 00:33:50,000
, 4 3 -이 1 무엇입니까.

440
00:33:50,000 --> 00:33:55,000
이 1의 주소는 무엇입니까?

441
00:33:55,000 --> 00:33:58,000
그 1의 주소는 무엇입니까?

442
00:33:58,000 --> 00:34:01,000
[학생] [안 들리게]

443
00:34:01,000 --> 00:34:03,000
[롭 B.] 헤드 + 첫 번째 요소의 주소를 입력합니다.

444
00:34:03,000 --> 00:34:05,000
우리가 어떻게 배열의 첫 번째 요소를 어떻게해야합니까?

445
00:34:05,000 --> 00:34:10,000
[학생] 큐.

446
00:34:10,000 --> 00:34:15,000
[롭 B. 네, q.strings.

447
00:34:15,000 --> 00:34:20,000
단, 여기, 우리의 머리는 1입니다.

448
00:34:20,000 --> 00:34:24,000
제길. 난 그냥 생각 마법 -

449
00:34:24,000 --> 00:34:29,000
여기, 우리의 머리는 1입니다. 나도 내 색을 변경하는거야.

450
00:34:29,000 --> 00:34:36,000
여기 문자열입니다.

451
00:34:36,000 --> 00:34:41,000
우리가 여기에했던 것처럼이, 우리는 둘 다 쓸 수 있습니다

452
00:34:41,000 --> 00:34:43,000
로 헤드 + q.strings.

453
00:34:43,000 --> 00:34:51,000
많은 사람들이 또한 그것을 작성 및 q.strings [머리].

454
00:34:51,000 --> 00:34:55,000
이건 정말 덜 효율적이지 않습니다.

455
00:34:55,000 --> 00:34:58,000
당신이 그것을 dereferencing 후의 주소를지고대로, 생각 수 있습니다

456
00:34:58,000 --> 00:35:04,000
하지만 컴파일러는 q.strings가 + 머리, 어쨌든 우리가 전에했던 일에 번역 예정이다.

457
00:35:04,000 --> 00:35:06,000
당신이 생각하고 싶지 어느 방법입니다.

458
00:35:06,000 --> 00:35:11,000
>> 그리고 얼마나 많은 바이트 우리가 복사 하시겠습니까?

459
00:35:11,000 --> 00:35:15,000
[학생] 용량 - 머리.

460
00:35:15,000 --> 00:35:18,000
용량 - 머리.

461
00:35:18,000 --> 00:35:21,000
그리고 당신은 항상 예를​​ 작성할 수

462
00:35:21,000 --> 00:35:23,000
그 말이 맞다면 알아낼 수 있습니다.

463
00:35:23,000 --> 00:35:26,000
[학생]이 다음 2로 나누어해야합니다.

464
00:35:26,000 --> 00:35:30,000
그래, 난 우리가 크기를 사용할 수 있습니다 같아요.

465
00:35:30,000 --> 00:35:35,000
우리는 여전히 크기가되는 -

466
00:35:35,000 --> 00:35:39,000
크기를 사용하여, 우리는 4 같은 크기만큼의 공간을 확보한다.

467
00:35:39,000 --> 00:35:42,000
우리 크기는 4입니다. 우리의 머리는 1입니다.

468
00:35:42,000 --> 00:35:46,000
우리는이 3 요소를 복사하고 싶습니다.

469
00:35:46,000 --> 00:35:54,000
그것은 정신이 크기를 확인이야 - 머리는 제대로 3.

470
00:35:54,000 --> 00:35:58,000
우리가 전에 말 한거처럼,, 여기로 올

471
00:35:58,000 --> 00:36:00,000
우리가 능력을 사용하는 경우, 우리는 2로 나누어해야 할

472
00:36:00,000 --> 00:36:04,000
우리는 이미 용량을 성장했기 때문에 대신에, 우리는 크기를 사용하려고하고 있습니다.

473
00:36:11,000 --> 00:36:13,000
그 사본 부분.

474
00:36:13,000 --> 00:36:18,000
이제, 우리는 다른 부분, 시작의 왼쪽 된 부분을 복사해야합니다.

475
00:36:18,000 --> 00:36:28,000
>> 그게 무슨 위치로 memmove하는거야?

476
00:36:28,000 --> 00:36:32,000
[학생]는 플러스 크기 - 머리.

477
00:36:32,000 --> 00:36:38,000
네, 그래서 우리는 이미 크기로 복사 한 - 헤드 바이트를,

478
00:36:38,000 --> 00:36:43,000
그래서 우리는 나머지 바이트를 복사 할 것은 새로운

479
00:36:43,000 --> 00:36:48,000
그리고 크기는 마이너스 - 음, 바이트 수는 이미 인치 복사

480
00:36:48,000 --> 00:36:52,000
그리고 우리가 어디에에서 복사거야?

481
00:36:52,000 --> 00:36:54,000
[학생] Q.strings [0].

482
00:36:54,000 --> 00:36:56,000
[롭 B. 네, q.strings.

483
00:36:56,000 --> 00:37:02,000
우리는 하나를 수행 & q.strings [0]. 수

484
00:37:02,000 --> 00:37:05,000
이렇게하면이보다 훨씬 적은 것이 일반적입니다.

485
00:37:05,000 --> 00:37:14,000
그냥 0 거에요 경우에는 q.strings을 볼 경향이 있습니다.

486
00:37:14,000 --> 00:37:16,000
우리가에서 복사하는 곳이야.

487
00:37:16,000 --> 00:37:18,000
우리는 복사 얼마나 많은 바이트를 떠난합니까? >> [학생] 10.

488
00:37:18,000 --> 00:37:20,000
맞아.

489
00:37:20,000 --> 00:37:25,000
[학생] 우리가 5를 곱해야합니까 - 10 배 바이트 나 뭐의 크기?

490
00:37:25,000 --> 00:37:30,000
그래,이 곳 정확하게 우리가 복사하는 것입니다?

491
00:37:30,000 --> 00:37:32,000
[학생] [안 들리게]

492
00:37:32,000 --> 00:37:34,000
우리가 복사하는 것은의 유형은 무엇입니까?

493
00:37:34,000 --> 00:37:36,000
[학생] [안 들리게]

494
00:37:36,000 --> 00:37:41,000
그들이 어디서 오는 네, 숯불 *의 우리가 복사하는 있도록, 우리는 몰라요.

495
00:37:41,000 --> 00:37:47,000
뭐, 가리키는 곳, 문자열처럼, 우리는 대기열에 그것을 밀어 결국

496
00:37:47,000 --> 00:37:49,000
또는 대기열에 enqueuing.

497
00:37:49,000 --> 00:37:51,000
그 어디 출신, 우리는 아무 생각이 없습니다.

498
00:37:51,000 --> 00:37:56,000
우리는 숯불 *의 자신을 추적해야합니다.

499
00:37:56,000 --> 00:38:00,000
머리 바이트 - 우리가 크기를 복사 싶지 않아요.

500
00:38:00,000 --> 00:38:03,000
머리 숯 * S, - 우리가 크기를 복사 할

501
00:38:03,000 --> 00:38:11,000
그래서 우리는 sizeof (숯불에 *)하여이 문제를 곱거야.

502
00:38:11,000 --> 00:38:17,000
동일 앉아서 머리 * sizeof (숯불 *).

503
00:38:17,000 --> 00:38:24,000
>> [학생] 무엇에 대한 [안 들리게]?

504
00:38:24,000 --> 00:38:26,000
여기 맞죠?

505
00:38:26,000 --> 00:38:28,000
[학생] 아니, 그건 아래의 크기 - 머리.

506
00:38:28,000 --> 00:38:30,000
[롭 B.] 여기 요?

507
00:38:30,000 --> 00:38:32,000
포인터 산술.

508
00:38:32,000 --> 00:38:35,000
포인터 산술 돌아가는 일에 어떻게 건

509
00:38:35,000 --> 00:38:40,000
가 자동으로 우리 상대가있는 유형의 크기에 따라 만연하고 있습니다.

510
00:38:40,000 --> 00:38:46,000
그냥, 여기에 같은 새로운 + (크기 - 머리)

511
00:38:46,000 --> 00:38:56,000
& 새 [- 머리 크기]를 정확히 동일합니다

512
00:38:56,000 --> 00:39:00,000
우리가 그렇게가 올바르게 작동 것으로 예상 될 때까지

513
00:39:00,000 --> 00:39:04,000
우리는 정수 배열을 상대하는 경우 때문에, 우리는이 정수 색인을하지

514
00:39:04,000 --> 00:39:07,000
로 또는 5의 크기지만, 넌 4 요소를 원할 경우, 우리는 색인

515
00:39:07,000 --> 00:39:10,000
INT 배열 [4].

516
00:39:10,000 --> 00:39:14,000
당신이 ... - [4] INT의 * 크기입니다.

517
00:39:14,000 --> 00:39:21,000
그래서이 경우에게 자동으로 처리하고,

518
00:39:21,000 --> 00:39:29,000
그대로 동​​일합니다, 그래서 브래킷 구문

519
00:39:29,000 --> 00:39:34,000
단지 최대한 빨리 컴파일로 변환 할 것이다.

520
00:39:34,000 --> 00:39:38,000
그게 당신이주의 할 필요가 뭔가

521
00:39:38,000 --> 00:39:42,000
당신은 크기를 추가하는 - 머리

522
00:39:42,000 --> 00:39:45,000
당신은 1 바이트가 아닌 추가됩니다.

523
00:39:45,000 --> 00:39:53,000
한 바이트 또는 무엇이든 다 될 수있는 한 문자 *를 추가하고 있습니다.

524
00:39:53,000 --> 00:39:56,000
>> 다른 질문?

525
00:39:56,000 --> 00:40:04,000
좋아요, dequeue 쉽게 될 것입니다.

526
00:40:04,000 --> 00:40:11,000
내가 구현하는 분을 제공합니다.

527
00:40:11,000 --> 00:40:18,000
아, 이런 일이 같은 상황 이네요 곳

528
00:40:18,000 --> 00:40:21,000
무엇 인큐 경우, 우리는 null을 enqueuing하는 경우,

529
00:40:21,000 --> 00:40:24,000
어쩌면 우리가 그것을 처리 할, 우리가하지 않습니다.

530
00:40:24,000 --> 00:40:27,000
우리는 여기서 다시는 이런 짓을하지만, 우리 스택 경우와 동일하지 않습니다.

531
00:40:27,000 --> 00:40:34,000
우리가 널 (null)을 인큐 경우, 우리는 그것을 무시 할 수 있습니다.

532
00:40:34,000 --> 00:40:40,000
누구나 내가 끌어 수있는 몇 가지 코드가 있습니까?

533
00:40:40,000 --> 00:40:45,000
[학생] 난 그냥 dequeue 있습니다.

534
00:40:45,000 --> 00:40:56,000
버전 2는 - 괜찮습니다.

535
00:40:56,000 --> 00:40:59,000
당신은 설명하고 싶어?

536
00:40:59,000 --> 00:41:01,000
[학생] 먼저 큐에 뭔가가 있는지 확인

537
00:41:01,000 --> 00:41:07,000
그리고 크기는 1 하강.

538
00:41:07,000 --> 00:41:11,000
당신은 작업을 수행 할 필요가 그리고 당신은 머리를 돌려

539
00:41:11,000 --> 00:41:13,000
그리고 한 백업 머리를 이동합니다.

540
00:41:13,000 --> 00:41:19,000
좋아, 그럼 우리가 고려해야 할 코너 경우가 있습니다. 그래.

541
00:41:19,000 --> 00:41:24,000
[학생] 머리가 마지막 요소에있는 경우

542
00:41:24,000 --> 00:41:26,000
다음은 헤드가 배열의 외부 가리 싶지 않아요.

543
00:41:26,000 --> 00:41:29,000
>> 그래, 가능한 한 빨리 머리로, 우리의 배열의 끝을 도달

544
00:41:29,000 --> 00:41:35,000
우리가 dequeue 때, 우리의 머리는 다시 0으로 modded해야합니다.

545
00:41:35,000 --> 00:41:40,000
불행하게도, 우리는 한 단계에서 해당 작업을 수행 할 수 없습니다.

546
00:41:40,000 --> 00:41:44,000
나는 아마도이 해결 할 방법을 생각

547
00:41:44,000 --> 00:41:52,000
이 우리가 돌​​려 무엇 숯불 *가 될거야

548
00:41:52,000 --> 00:41:55,000
당신의 변수 이름은되고 싶어 뭐든간에.

549
00:41:55,000 --> 00:42:02,000
그런 다음 우리는 우리의 능력으로 머리를 MOD하려면

550
00:42:02,000 --> 00:42:10,000
그리고 RET 반환합니다.

551
00:42:10,000 --> 00:42:14,000
여기에 많은 사람들이 그들이 무엇을 - 할 수 있습니다

552
00:42:14,000 --> 00:42:19,000
이 - 올의 경우 것은 사람들이 볼 수있는 경우 머리

553
00:42:19,000 --> 00:42:29,000
용량보다 큰, 머리를 해 - 용량을.

554
00:42:29,000 --> 00:42:36,000
그리고는 모드가 무엇인지 주변에 일.

555
00:42:36,000 --> 00:42:41,000
머리 모드 = 용량은 훨씬 청소기입니다

556
00:42:41,000 --> 00:42:51,000
용량 -. 주변 용량의 머리보다 머리 큰 경우보다 포장의

557
00:42:51,000 --> 00:42:56,000
>> 질문이 있으십니까?

558
00:42:56,000 --> 00:43:02,000
자, 우리가 남아있는 마지막 일은 우리의 링크 목록입니다.

559
00:43:02,000 --> 00:43:07,000
당신이 한 경우는 연결리스트 문제의 일부에 사용 될 수 있습니다

560
00:43:07,000 --> 00:43:11,000
당신은 해시 테이블을 한 경우 귀하의 해시 테이블에 목록을 연결.

561
00:43:11,000 --> 00:43:15,000
난 강력하게 해시 테이블을하는 것이 좋습니다.

562
00:43:15,000 --> 00:43:17,000
당신은 이미, trie을했을 거에요

563
00:43:17,000 --> 00:43:23,000
하지만 시도는 더 어렵습니다.

564
00:43:23,000 --> 00:43:27,000
이론적으로, 그들은 점근 더 잘해.

565
00:43:27,000 --> 00:43:30,000
하지만, 진정, 전광판을보고

566
00:43:30,000 --> 00:43:35,000
더 나은하지 않을 시도, 그들은 더 많은 메모리를 차지합니다.

567
00:43:35,000 --> 00:43:43,000
모든 것들이에 더 일을 악화되고 종료하려고합니다.

568
00:43:43,000 --> 00:43:49,000
그것은 데이비드 Malan의 솔루션이 항상있는 거구나

569
00:43:49,000 --> 00:43:56,000
그는 항상 게시물 자신의 trie 솔루션을하며, 그 현재 위치를 보자.

570
00:43:56,000 --> 00:44:00,000
그는 데이비드 J, 아래 무엇입니까?

571
00:44:00,000 --> 00:44:06,000
그는 제 18 야, 그건 정말 나쁘지 않아요 때문에

572
00:44:06,000 --> 00:44:09,000
그리고 가장 중 하나를 할 거에요하면 생각할 수 시도

573
00:44:09,000 --> 00:44:17,000
또는 가장 중 하나가 trie의 시도합니다.

574
00:44:17,000 --> 00:44:23,000
그건 그의 원래의 솔루션도하지 않아?

575
00:44:23,000 --> 00:44:29,000
trie 솔루션은 RAM 사용의 범위에서 더 많은 경향이 같아.

576
00:44:29,000 --> 00:44:33,000
>> 상단으로 이동 RAM 사용이 하나의 자리에 있습니다.

577
00:44:33,000 --> 00:44:36,000
하단으로 내려 가서, 그 다음에 당신이 시도 표시되기 시작

578
00:44:36,000 --> 00:44:41,000
당신은 절대적으로 대규모 RAM 사용량을 어디

579
00:44:41,000 --> 00:44:45,000
와 시도가 더 어렵습니다.

580
00:44:45,000 --> 00:44:53,000
하지 완전히하지만 교육 경험의 가치 하나를 택한다면.

581
00:44:53,000 --> 00:44:56,000
마지막으로, 우리의 연결된 목록입니다

582
00:44:56,000 --> 00:45:04,000
이러한 세 가지, 스택, 큐, 그리고 링크 된 목록,

583
00:45:04,000 --> 00:45:09,000
지금까지 컴퓨터 과학에서 수행하는 미래의 일이

584
00:45:09,000 --> 00:45:12,000
당신이 것들로 익숙를 가정 한 것입니다.

585
00:45:12,000 --> 00:45:19,000
그들은 모든 걸 그냥 기본입니다.

586
00:45:19,000 --> 00:45:25,000
>> 목록을 연결하고, 여기에 우리는 단독으로 연결된 목록은 우리가 구현 될 것입니다하고 있습니다.

587
00:45:25,000 --> 00:45:34,000
단독으로 무엇을 연결 않기 때문에 이중 연결에 반대하는 말인가요? 예.

588
00:45:34,000 --> 00:45:37,000
[학생] 단지 다음 포인터가 아니라 포인터를 가리키는

589
00:45:37,000 --> 00:45:39,000
그와 후 하나를 이전 한처럼.

590
00:45:39,000 --> 00:45:44,000
그래, 사진 형식으로, 난 그냥 무슨 짓을 한거야?

591
00:45:44,000 --> 00:45:48,000
나는 두 가지가 있습니다. 나는 그림과 사진이 있습니다.

592
00:45:48,000 --> 00:45:51,000
그림 형식으로, 우리의 단독 링크 목록,

593
00:45:51,000 --> 00:45:57,000
필연적으로, 우리는 우리의 목록의 머리에 포인터 어떤 종류의이

594
00:45:57,000 --> 00:46:02,000
다음 목록에서, 우리는 그냥 포인터를 가지고

595
00:46:02,000 --> 00:46:05,000
그리고 어쩌면이 점은 null입니다.

596
00:46:05,000 --> 00:46:08,000
이 단독으로 연결된 목록의 전형적인 그림거야.

597
00:46:08,000 --> 00:46:14,000
이중 연결리스트, 당신은 뒤로 이동할 수 있습니다.

598
00:46:14,000 --> 00:46:19,000
당신에게 목록의 노드를 제공한다면, 반드시 갈 수

599
00:46:19,000 --> 00:46:23,000
다른 노드 목록에서이 이중 연결리스트 인 경우.

600
00:46:23,000 --> 00:46:27,000
하지만 당신에게 목록에서 세 번째 노드를하고 단독으로 연결리스트 있다면,

601
00:46:27,000 --> 00:46:30,000
지금까지 첫 번째와 두 번째 노드에있을 겁니다. 방법 없습니다

602
00:46:30,000 --> 00:46:34,000
그리고 장점과 detriments, 그리고 확실한 사람도

603
00:46:34,000 --> 00:46:42,000
더 많은 크기를 차지, 당신은 이런 일이 지금 가리키고있는 곳을 추적해야합니다.

604
00:46:42,000 --> 00:46:49,000
그러나 우리는 약 단독으로 연결되어 신경.

605
00:46:49,000 --> 00:46:53,000
>> 우리가 구현해야 할 것 몇 가지.

606
00:46:53,000 --> 00:47:00,000
귀하의 typedef 구조체 노드, INT I : 구조체 노드 * 다음, 노드.

607
00:47:00,000 --> 00:47:09,000
그 typedef는 마음에 타오른해야합니다.

608
00:47:09,000 --> 00:47:14,000
퀴즈 1, 연결리스트 노드의 typedef를 제공 좋아한다

609
00:47:14,000 --> 00:47:18,000
당신은 즉시 내려 끄적 할 수 있어야한다

610
00:47:18,000 --> 00:47:22,000
생각도.

611
00:47:22,000 --> 00:47:27,000
난 몇 질문을 추측, 왜 우리가 여기 구조체해야하나요?

612
00:47:27,000 --> 00:47:32,000
왜 우리가 노드 * 말을 못 들어?

613
00:47:32,000 --> 00:47:35,000
[학생] [안 들리게]

614
00:47:35,000 --> 00:47:38,000
그래.

615
00:47:38,000 --> 00:47:44,000
일로 노드를 정의 유일한

616
00:47:44,000 --> 00:47:47,000
자체 typedef입니다.

617
00:47:47,000 --> 00:47:55,000
하지만,이 시점의, 우리가이 구조체 노드 정의를 통해 분석의 종류가되면,

618
00:47:55,000 --> 00:48:01,000
우리는 typedef가 완료되지 않았습니다 때문에 때문에 아직 우리의 typedef을 완료하지 않은

619
00:48:01,000 --> 00:48:05,000
노드가 존재하지 않습니다.

620
00:48:05,000 --> 00:48:12,000
그러나 구조체 노드는 않습니다,이 노드 여기에,

621
00:48:12,000 --> 00:48:14,000
이 또한 무엇이라고 할 수있다.

622
00:48:14,000 --> 00:48:16,000
이것은 N 호출 할 수 있습니다.

623
00:48:16,000 --> 00:48:19,000
이 연결리스트 노드라고 할 수있다.

624
00:48:19,000 --> 00:48:21,000
그것은 아무 것도 호출 할 수 있습니다.

625
00:48:21,000 --> 00:48:26,000
그러나이 구조체 노드는이 구조체 노드와 같은 일을 호출해야합니다.

626
00:48:26,000 --> 00:48:29,000
이 또한 여기에 있습니다 전화 뭐,

627
00:48:29,000 --> 00:48:32,000
그리고 그렇게 또한 질문의 두 번째 지점을 답

628
00:48:32,000 --> 00:48:37,000
- 그래서 당신은 structs와 structs의 typedefs를 볼 시간이 많이되는데,이입니다

629
00:48:37,000 --> 00:48:42,000
방금 typedef 구조체를 볼 수 있습니다 어디에, 익명 structs를 볼 수 있습니다

630
00:48:42,000 --> 00:48:47,000
구조체, 사전, 또는 어떤의 구현입니다.

631
00:48:47,000 --> 00:48:51,000
>> 왜 여기 우리는 노드라고해야하나요?

632
00:48:51,000 --> 00:48:54,000
왜 익명 구조체가 될 수없는 이유는 무엇입니까?

633
00:48:54,000 --> 00:48:56,000
거의 같은 대답입니다.

634
00:48:56,000 --> 00:48:58,000
[학생] 당신은 구조체 내에 참조해야합니다.

635
00:48:58,000 --> 00:49:04,000
네, 구조체 내에서 구조체 자체를 참조해야합니다.

636
00:49:04,000 --> 00:49:10,000
이 구조체 이름을 지정하지 않으면이 익명 구조체 있다면, 당신은 그것을 참조 할 수 없습니다.

637
00:49:10,000 --> 00:49:17,000
그리고 마지막하지만 적어도 -이 모든이어야 다소 간단하지,

638
00:49:17,000 --> 00:49:20,000
이을 작성하는 경우 그리고 당신이 생각하는 도움이 될 것입니다

639
00:49:20,000 --> 00:49:24,000
일 이러한 종류의 말이하지 않으면 당신은 뭔가 잘못하고 있다는.

640
00:49:24,000 --> 00:49:28,000
마지막으로, 왜이 구조체 노드 * 있어야합니까?

641
00:49:28,000 --> 00:49:34,000
왜 바로 옆에 노드를 구조체 할 수없는 이유는 무엇입니까?

642
00:49:34,000 --> 00:49:37,000
다음 구조체를 [학생]는 포인터.

643
00:49:37,000 --> 00:49:39,000
우리가 원하는 필연적입니다.

644
00:49:39,000 --> 00:49:42,000
왜 다음 구조체 노드 수 없다?

645
00:49:42,000 --> 00:49:50,000
왜 * 다음 구조체 노드 수있는 거지? 그래.

646
00:49:50,000 --> 00:49:53,000
[학생] 그것은 무한 루프 같아요.

647
00:49:53,000 --> 00:49:55,000
그래.

648
00:49:55,000 --> 00:49:57,000
[학생]은 모든 하나가 될 것입니다.

649
00:49:57,000 --> 00:50:02,000
네, 우리가의 크기 나 일을 할 방법을 생각합니다.

650
00:50:02,000 --> 00:50:08,000
구조체의 크기는 기본적으로이 + 또는 - 여기 저기 몇 가지 패턴.

651
00:50:08,000 --> 00:50:15,000
그것은 기본적으로 구조체에있는 물건의 크기의 합거야.

652
00:50:15,000 --> 00:50:18,000
이게 바로 아무 것도 변경하지 않고, 크기는 쉽게 될 것입니다.

653
00:50:18,000 --> 00:50:24,000
구조체 노드의 크기는 다음의 전 + 크기의 크기가 될 것입니다.

654
00:50:24,000 --> 00:50:27,000
난의 크기는 4가 될 것입니다. 다음의 크기는 4가 될 것입니다.

655
00:50:27,000 --> 00:50:30,000
구조체 노드의 크기는 8 될 것입니다.

656
00:50:30,000 --> 00:50:34,000
우리가 *되어 있지 않은 경우, sizeof 생각

657
00:50:34,000 --> 00:50:37,000
그리고 sizeof는 (i) 4가 될 것입니다.

658
00:50:37,000 --> 00:50:43,000
구조체 노드의 크기 다음 다음 구조체 노드의 + 크기 난의 크기가 될거야

659
00:50:43,000 --> 00:50:46,000
다음 구조체 노드의 I + 크기 + 크기입니다.

660
00:50:46,000 --> 00:50:55,000
이 노드의 무한 재귀 것입니다.

661
00:50:55,000 --> 00:51:00,000
이 일들이 있어야하는 방법입니다 이유입니다.

662
00:51:00,000 --> 00:51:03,000
>> 다시 말하지만, 확실히, 그를 기억

663
00:51:03,000 --> 00:51:06,000
적어도 당신이 할 수 할 수있는 충분한 이해

664
00:51:06,000 --> 00:51:12,000
그 모양은 무엇을 통해 이유입니다.

665
00:51:12,000 --> 00:51:14,000
우리가 구현하려는 것 것들.

666
00:51:14,000 --> 00:51:18,000
만약 길이 목록 -

667
00:51:18,000 --> 00:51:21,000
당신은 속임수와 주변을 유지할 수

668
00:51:21,000 --> 00:51:24,000
글로벌 길이 나 뭐하지만, 그렇게는하지 않을거야.

669
00:51:24,000 --> 00:51:28,000
우리는 목록의 길이를 계산거야.

670
00:51:28,000 --> 00:51:34,000
우리는 포함 된 한 그는 기본적으로 검색처럼 있으므로

671
00:51:34,000 --> 00:51:41,000
그래서 우리는이 정수 링크 된 목록에 있는지 확인하기 위해 정수의 연결리스트가 있습니다.

672
00:51:41,000 --> 00:51:44,000
앞에이 목록의 시작 부분에 삽입 예정이다.

673
00:51:44,000 --> 00:51:46,000
추가는 끝 부분에 삽입하는 것이다.

674
00:51:46,000 --> 00:51:53,000
Insert_sorted는 목록에서 정렬 위치에 삽입 예정이다.

675
00:51:53,000 --> 00:52:01,000
의 Insert_sorted 종류는 앞에 사용하거나 나쁜 방법으로 추가 적이 있다고 가정합니다.

676
00:52:01,000 --> 00:52:09,000
>> 당신이 구현 때 insert_sorted - Insert_sorted

677
00:52:09,000 --> 00:52:13,000
우선은 우리의 연결리스트가 있다고 가정 해 봅시다.

678
00:52:13,000 --> 00:52:18,000
이 기능은 현재 5, 4, 2, 모습입니다.

679
00:52:18,000 --> 00:52:24,000
내가 너무 오래 목록 자체가 이미 정렬되기 때문에, 3을 삽입 할

680
00:52:24,000 --> 00:52:27,000
그것은 3가 있어야 할 곳 쉽게 찾을 수 있습니다.

681
00:52:27,000 --> 00:52:29,000
I 2부터 시작합니다.

682
00:52:29,000 --> 00:52:32,000
그래, 3은 2보다 큰, 그래서 제가 계속하고 싶습니다.

683
00:52:32,000 --> 00:52:35,000
아, 4 너무 커서, 그래서 3 2과 4 사이에 갈 걸 알아

684
00:52:35,000 --> 00:52:39,000
그리고 포인터와 모든 걸 해결해야합니다.

685
00:52:39,000 --> 00:52:43,000
하지만 우리는 엄격히 insert_sorted 사용하지 않은 경우

686
00:52:43,000 --> 00:52:50,000
좋아 그러니, 내가 6 앞에 말

687
00:52:50,000 --> 00:52:55,000
그리고 내 연결 목록이 될 것이다.

688
00:52:55,000 --> 00:53:01,000
이제 insert_sorted를 들어, 당신이 방금 가정 수 있도록, 말이 안

689
00:53:01,000 --> 00:53:04,000
작업이 존재하더라도 목록이 정렬되어

690
00:53:04,000 --> 00:53:09,000
이는이 정렬되지 않을 수 있으며, 바로 그 거에요.

691
00:53:09,000 --> 00:53:20,000
그가 구현해야 할거야 주 것들 도움이 삽입 소를 찾아보십시오.

692
00:53:20,000 --> 00:53:24,000
>> 지금 들어, 길이를 할 분을 가지고이 포함되어

693
00:53:24,000 --> 00:53:30,000
저들은 비교적 빨리해야합니다.

694
00:53:41,000 --> 00:53:48,000
종료 시간을 얼마 남지 않으므로 누구든지 길이에 대한 건이나 포함되어 있습니다?

695
00:53:48,000 --> 00:53:50,000
그들은 거의 동일거야.

696
00:53:50,000 --> 00:53:57,000
[학생] 길이.

697
00:53:57,000 --> 00:54:01,000
, 어디 한번 수정하자.

698
00:54:01,000 --> 00:54:04,000
좋아요.

699
00:54:12,000 --> 00:54:15,000
당신은 설명하고 싶어?

700
00:54:15,000 --> 00:54:21,000
[학생] 난 그냥 포인터 노드를 생성하고 글로벌 변수 먼저,에 초기화,

701
00:54:21,000 --> 00:54:27,000
그리고 나는 감금 잘못을하고 그 경우 경우 0을 반환하지 않도록이 null이 있는지 확인하십시오.

702
00:54:27,000 --> 00:54:34,000
그렇지 않으면,을 통해 루프, 정수 내에서의 트랙을 유지

703
00:54:34,000 --> 00:54:38,000
나는 목록의 다음 요소에 액세스 한 횟수

704
00:54:38,000 --> 00:54:43,000
와 같은 증가 작업 또한 그 실제 요소에 액세스

705
00:54:43,000 --> 00:54:47,000
그럼 내가 계속,이 null이 있는지 확인 볼 수 있도록

706
00:54:47,000 --> 00:54:56,000
가 널 (null)입니다되면, 그것은 중단하고 내가 액세스 한 요소의 개수를 반환합니다.

707
00:54:56,000 --> 00:55:01,000
>> [롭 B.] 누구에 어떤 의견을 가지고 있습니까?

708
00:55:01,000 --> 00:55:06,000
이 훌륭한 정확성의 바램 보입니다.

709
00:55:06,000 --> 00:55:10,000
[학생] 당신이 노드 == null이 필요하다고 생각하지 않습니다.

710
00:55:10,000 --> 00:55:13,000
그래, 노드 경우 == null을 반환 0.

711
00:55:13,000 --> 00:55:18,000
그러나 노드 == null이는 다음이 - 오, 정확성에 문제가있는 경우.

712
00:55:18,000 --> 00:55:23,000
그것은 당신이 내가 돌려 이었지만, 그건 지금 범위에 없습니다.

713
00:55:23,000 --> 00:55:30,000
당신은 INT 난 단지 필요 그래서 = 0.

714
00:55:30,000 --> 00:55:34,000
노드가 null이라면, 그 아직도, 0이 될 것입니다

715
00:55:34,000 --> 00:55:39,000
우리는 0을 반환 할거야,이 사건이 동일하므로.

716
00:55:39,000 --> 00:55:48,000
또 다른 일반적인 문제는 선언을 유지하는 것입니다

717
00:55:48,000 --> 00:55:51,000
루프의 노드 내부의.

718
00:55:51,000 --> 00:55:54,000
당신이 말하는 오 수 없음.

719
00:55:54,000 --> 00:55:56,000
이 오늘로 유지하자.

720
00:55:56,000 --> 00:55:59,000
아마, int는 전 = 0 여기에 넣어 것입니다

721
00:55:59,000 --> 00:56:05,000
그런 다음 노드 * 노드 = 여기에서 첫번째.

722
00:56:05,000 --> 00:56:11,000
그리고 지금 제거 - 점점 방법 때문일 수 있습니다.

723
00:56:11,000 --> 00:56:14,000
이 내가 작성한 얼마나 때문일 수 있습니다.

724
00:56:14,000 --> 00:56:21,000
이처럼에서도 보이는 수 있습니다.

725
00:56:21,000 --> 00:56:25,000
여기에 루프 구조에 대한이

726
00:56:25,000 --> 00:56:30,000
INT I = 0 등 거의 같은 자연이어야합니다

727
00:56:30,000 --> 00:56:33,000
내가 배열의 길이보다 작 전 + +.

728
00:56:33,000 --> 00:56:38,000
그게 당신이 배열을 통해 반복하는 방법은 경우,이는 연결리스트를 통해 반복하는 방법입니다.

729
00:56:38,000 --> 00:56:45,000
>> 이 점에서 두 번째 특징이어야합니다.

730
00:56:45,000 --> 00:56:50,000
염두에두고이 거의 같은 될 것입니다.

731
00:56:50,000 --> 00:56:57,000
당신은 링크 된 목록을 통해 반복하려는거야.

732
00:56:57,000 --> 00:57:02,000
만약 노드 I는 값이라고 아무 생각이 없습니다.

733
00:57:02,000 --> 00:57:04,000
노드 i를.

734
00:57:04,000 --> 00:57:15,000
해당 노드의 값은 = 내가 TRUE를 반환하고, 그게 다예요합니다.

735
00:57:15,000 --> 00:57:18,000
공지 사항 우리가 어느 false를 반환 수있는 유일한 방법

736
00:57:18,000 --> 00:57:23,000
우리는 전체 연결 목록을 통해 반복하고 TRUE를 반환하지 않을 경우이며,

737
00:57:23,000 --> 00:57:29,000
그래서 그 사건이 무엇을하는지에 관해.

738
00:57:29,000 --> 00:57:36,000
같은 측면 노트 우리가 아마 추가하거나 덧붙이하게하지 않습니다.

739
00:57:36,000 --> 00:57:39,000
>> 빠른 마지막으로 확인합니다.

740
00:57:39,000 --> 00:57:52,000
당신이 정적 키워드를 표시하는 경우, 그래서가 정적 정수 카운트가 = 0한다고 가정 해 보겠습니다

741
00:57:52,000 --> 00:57:56,000
그리고 우리가 수를 + +, 당신은 기본적으로 전역 변수로 생각할 수,

742
00:57:56,000 --> 00:58:00,000
난 그냥 우리가 길이를 구현하는 것 방법이 아니라고하더라도.

743
00:58:00,000 --> 00:58:06,000
여기이 일을하고 + +를 계산거야.

744
00:58:06,000 --> 00:58:11,000
우리가 우리의 수를 증가 아르의 연결 목록에 노드를 입력 할 수있는 방법입니다.

745
00:58:11,000 --> 00:58:15,000
이 점은 정적 키워드의 의미입니다.

746
00:58:15,000 --> 00:58:20,000
난 그냥 int는 카운트가 있다면 = 평범한 전역 변수가 될 것입니다 0.

747
00:58:20,000 --> 00:58:25,000
어떤 정적 int는 카운트 수단 것은이 파일에 대한 전역 변수이다.

748
00:58:25,000 --> 00:58:28,000
그것은 다른 파일에 대한 불가능합니다

749
00:58:28,000 --> 00:58:34,000
당신이 시작하면 pset (5)의 생각 좋아해요.

750
00:58:34,000 --> 00:58:39,000
, 당신은 두 speller.c을 가지고, 당신은 dictionary.c이

751
00:58:39,000 --> 00:58:42,000
그리고 당신은 speller.c에 다음 아무 것도 글로벌 물건을 선언하는 경우

752
00:58:42,000 --> 00:58:45,000
dictionary.c 반대로에 액세스 할 수 있습니다.

753
00:58:45,000 --> 00:58:48,000
전역 변수는 모든. C 파일로 액세스 할 수 있습니다

754
00:58:48,000 --> 00:58:54,000
하지만 정적 변수는 파일 자체 내에서 액세스 할 수 있습니다

755
00:58:54,000 --> 00:59:01,000
안으로 dictionary.c의 맞춤법 검사기 또는 내부의,

756
00:59:01,000 --> 00:59:06,000
이 내 배열의 크기를 내 변수를 선언 방식을 거라고

757
00:59:06,000 --> 00:59:10,000
또는 사전에있는 단어의 전화 번호의 크기.

758
00:59:10,000 --> 00:59:15,000
나는 사람에 접근했다는 전역 변수를 선언하지 않으므로하면,

759
00:59:15,000 --> 00:59:18,000
사실 난 단지 내 자신의 목적을 위해 신경.

760
00:59:18,000 --> 00:59:21,000
>> 이것에 대해 좋은 점은 또한 전체 이름 충돌 콘텐츠입니다.

761
00:59:21,000 --> 00:59:27,000
다른 파일 개수라는​​ 전역 변수를 사용하려고 할 경우, 상황이 매우, 매우 잘못,

762
00:59:27,000 --> 00:59:33,000
따라서이 잘 가지를 안전하게 유지하며, 당신은에 액세스 할 수 있습니다

763
00:59:33,000 --> 00:59:38,000
그리고 다른 아무도 수 있으며, 다른 사람이 수라는 전역 변수를 선언한다면,

764
00:59:38,000 --> 00:59:43,000
그때가 카운트라는 정적 변수에 영향을주지 않습니다.

765
00:59:43,000 --> 00:59:47,000
그 정적이거야. 이 파일을 전역 변수입니다.

766
00:59:47,000 --> 00:59:52,000
>> 뭔가에 질문이 있으십니까?

767
00:59:52,000 --> 00:59:59,000
모든 세트. 안녕.

768
00:59:59,000 --> 01:00:03,000
[CS50.TV]