1
00:00:00,000 --> 00:00:11,200

2
00:00:11,200 --> 00:00:12,580
>> DAVID 마란 : 좋아, 다시 오신 것을 환영합니다.

3
00:00:12,580 --> 00:00:13,290
이 CS50입니다.

4
00:00:13,290 --> 00:00:15,130
이것은 일주일 내내의 시작입니다.

5
00:00:15,130 --> 00:00:18,890
따라서 그것은 오랜만, 그래서 우리는 거라고 생각이야
여기서 우리의 회오리 바람 투어를

6
00:00:18,890 --> 00:00:20,760
그만 둔 곳에 우리는 이제 겁니다.

7
00:00:20,760 --> 00:00:23,310
>> 이 물건은 여기에있을 수 있도록
처음에 약간의 불안을 일으키는 원인이되었다.

8
00:00:23,310 --> 00:00:27,680
그러나 잘 만하면, 당신을 시작하고
이 여기에 나타냅니다 무엇에 적응 -

9
00:00:27,680 --> 00:00:32,670
인 포인터를 나타내는 별
더 쉽게 설명하자면에서 그냥 뭐?

10
00:00:32,670 --> 00:00:33,400
그래서 주소입니다.

11
00:00:33,400 --> 00:00:35,490
>> 그래서의 주소입니다
메모리에 뭔가.

12
00:00:35,490 --> 00:00:38,260
그리고 우리는 다시 껍질 레이어로 시작
몇 주 전, 상황이 좋아

13
00:00:38,260 --> 00:00:41,800
하는 GetString 및 기타 기능
모든 시간은 반환되었습니다

14
00:00:41,800 --> 00:00:46,010
같은 메모리 것들의 주소,
의 첫 번째 문자의 주소

15
00:00:46,010 --> 00:00:46,990
어떤 순서.

16
00:00:46,990 --> 00:00:50,360
>> 그래서 우리는 또한 Valgrind의를 소개 한
이 문제에 사용할 시작합니다

17
00:00:50,360 --> 00:00:53,380
특히 다음에 대한 설정
문제뿐만 아니라 설정합니다.

18
00:00:53,380 --> 00:00:54,980
그리고 Valgrind는 우리를 위해 무엇을합니까?

19
00:00:54,980 --> 00:00:57,520

20
00:00:57,520 --> 00:01:01,020
그것은 메모리 누수를 확인하고,
또한 메모리의 남용을 확인합니다.

21
00:01:01,020 --> 00:01:05,890
>> 그것은 약간의 확률로, 검출 할 수있는 경우
코드 메모리를 만지는 것입니다

22
00:01:05,890 --> 00:01:07,100
그게 간단하지 않아야합니다.

23
00:01:07,100 --> 00:01:10,410
그래서 누출을 반드시 있지만, 그렇지 않은 경우
일부의 경계를 넘어

24
00:01:10,410 --> 00:01:14,730
배열, 당신은 실제로 Valgrind를 실행
그 행동을 유도하면서

25
00:01:14,730 --> 00:01:17,870
Valgrind는은 프로그램에서 실행되는
그것의 내부에서 실행, 당신은 얻을 것이다

26
00:01:17,870 --> 00:01:21,460
다음과 같은 메시지 - "유효하지 않은 쓰기
의 몇 리콜 크기 4 "

27
00:01:21,460 --> 00:01:25,880
주 전 내가 실수했다 것을 의미
너무 멀리 한 INT에 좋아

28
00:01:25,880 --> 00:01:27,250
배열의 경계를 넘어.

29
00:01:27,250 --> 00:01:30,790
그리고 크기 4 여기에 크기를 의미합니다
특정 INT의.

30
00:01:30,790 --> 00:01:35,260
>> 그래서 사실에 확신을 가지고 그
Valgrind의의 출력, 그것의 형식,

31
00:01:35,260 --> 00:01:36,170
다만 극악이다.

32
00:01:36,170 --> 00:01:40,180
그것은 혼란을 볼 수 정말 어렵다
재미있는 정보.

33
00:01:40,180 --> 00:01:42,910
그래서 우리가했던 것은 단지 발췌입니다
이상의 몇 가지 중 일부

34
00:01:42,910 --> 00:01:43,850
흥미로운 라인.

35
00:01:43,850 --> 00:01:46,760
그러나 실현 Valgrind의의의 80 %
출력의 비트가 될 것입니다

36
00:01:46,760 --> 00:01:47,650
산만.

37
00:01:47,650 --> 00:01:52,820
>> 다만 이와 같은 패턴을 보면 -
오른쪽 무효, 무효, 40 바이트를 읽고

38
00:01:52,820 --> 00:01:56,690
및 블록의 일부 숫자가 분명히 있습니다
같은 키워드 잃었다.

39
00:01:56,690 --> 00:02:01,920
그리고 당신이 희망을 볼 수 있습니다 몇 가지입니다
이 기능 어​​떤 추적의 종류

40
00:02:01,920 --> 00:02:03,340
실수 인치 실제로

41
00:02:03,340 --> 00:02:07,195
여기이 경우, 어떤 라인
내 코드는 분명히 오류인가?

42
00:02:07,195 --> 00:02:09,729

43
00:02:09,729 --> 00:02:14,130
>> 했다 memory.c에라는 파일에 26
우리가 연주 한 예

44
00:02:14,130 --> 00:02:14,890
시간.

45
00:02:14,890 --> 00:02:16,460
그래서 malloc에​​있는 아마 아니에요.

46
00:02:16,460 --> 00:02:18,630
대신 내 코드에서 아마이었다.

47
00:02:18,630 --> 00:02:20,910
그래서 우리는 이것을 다시 볼 수 있습니다
다시 오래 전에.

48
00:02:20,910 --> 00:02:24,080
>> scanf와 그래서이 등장했습니다
지금까지 형태의 커플입니다.

49
00:02:24,080 --> 00:02:26,410
우리는 간단히 sscanf를 보았다.

50
00:02:26,410 --> 00:02:28,330
무언가의 숫자였다
당신은 당신에에 다이빙

51
00:02:28,330 --> 00:02:29,535
퀴즈에 대한 준비.

52
00:02:29,535 --> 00:02:33,130
scanf와 실제로 무엇 CS50
라이브러리는 아래 사용하고 있어요

53
00:02:33,130 --> 00:02:36,560
순서에 꽤 많은 시간 동안 후드
사용자의 입력을 얻을 수 있습니다.

54
00:02:36,560 --> 00:02:40,420
>> 예를 들어, 나는 CS50를 통해 이동하는 경우
제품 여기 내가 열어 보자

55
00:02:40,420 --> 00:02:45,315
scanf와 - 0.c라고 예를 들어 오늘
그리고 그것은 매우 간단합니다.

56
00:02:45,315 --> 00:02:46,590
그것은 단지 몇 줄의 코드입니다.

57
00:02:46,590 --> 00:02:50,880
그러나 그것은 보여줍니다 정말 어떻게 getInt를
이 모든 시간을 일하고있다.

58
00:02:50,880 --> 00:02:54,710
>> 16 라인 여기에이 프로그램에
내가 int를 선언 할 것을 알 수 있습니다.

59
00:02:54,710 --> 00:02:57,270
그래서 아무 포인터 없으며, 마법의 아무것도
이 단지 INT.

60
00:02:57,270 --> 00:03:00,330
다음 라인 (17)에, 나는 메시지를 표시
번호 사용자가주세요.

61
00:03:00,330 --> 00:03:02,930
그런 후반 18, 여기 scanf와를 사용합니다.

62
00:03:02,930 --> 00:03:06,910
그리고 내가 지정, 같은 종류의 printf,
제가 견적을 기대 해요

63
00:03:06,910 --> 00:03:08,110
퍼센트에게 나는 맺다.

64
00:03:08,110 --> 00:03:10,920
>> 퍼센트 나는 그래서, 물론,
int를 나타냅니다.

65
00:03:10,920 --> 00:03:14,580
그러나주의하는 무슨 번째
scanf와에 인수입니다.

66
00:03:14,580 --> 00:03:17,350
어떻게 두 번째를 설명하는 것
쉼표 다음 인수?

67
00:03:17,350 --> 00:03:19,450
그것은 무엇인가?

68
00:03:19,450 --> 00:03:20,670
>> 그것은 X의 주소입니다.

69
00:03:20,670 --> 00:03:25,490
그래서이 때문에 제공하여 유용합니다
X의 주소와 scanf와, 무엇을하지

70
00:03:25,490 --> 00:03:29,560
즉, 어떻게 그 기능을 강화할?

71
00:03:29,560 --> 00:03:33,010
다만 거기에 갈뿐만 아니라, 어떻게?

72
00:03:33,010 --> 00:03:34,060
>> 그것에 변경합니다.

73
00:03:34,060 --> 00:03:38,080
당신이 거기에 갈 수 있기 때문에, 그것은 일종의의
메모리의 위치를​​지도처럼.

74
00:03:38,080 --> 00:03:41,900
그리고 너무 오래 당신이 제공하기 때문에 scanf와 나
이러한지도, 그와 함께 모든 기능을

75
00:03:41,900 --> 00:03:45,840
함수가 갈 수 있습니다뿐만 아니라,
값을보고 있지만, 그것은 또한 수

76
00:03:45,840 --> 00:03:49,670
경우에 유용 그 값을 변경
scanf와 삶의 목적은 다음과 같습니다

77
00:03:49,670 --> 00:03:53,060
특히, 사용자의 입력을 스캔
키보드에서.

78
00:03:53,060 --> 00:03:57,830
그리고 F는 마찬가지로 포맷 의미
printf를, F는 포맷을 나타냅니다

79
00:03:57,830 --> 00:03:58,930
당신이 인쇄 할 문자열입니다.

80
00:03:58,930 --> 00:04:04,430
>> 그래서 짧은,이 라인 18은 단순히 말한다,
사용자의 INT를 읽으려고 시도

81
00:04:04,430 --> 00:04:10,420
키보드에서 x의 내부에 저장
여기서 x는에서 살고 무슨 일이 생기면 주소입니다.

82
00:04:10,420 --> 00:04:14,860
그리고 마지막으로, 선 19 단지 말한다,
이 경우 INT 주셔서 감사합니다.

83
00:04:14,860 --> 00:04:15,940
>> 그래서 내가 가서이 문제를 확인 할 수 있습니다.

84
00:04:15,940 --> 00:04:18,570
따라서 scanf와 0을합니다.

85
00:04:18,570 --> 00:04:20,130
내가 가서 확대하자

86
00:04:20,130 --> 00:04:22,960
내가 함께 가서이 실행됩니다
점 scanf와 0을 슬래시.

87
00:04:22,960 --> 00:04:24,020
수, 제발?

88
00:04:24,020 --> 00:04:24,720
50.

89
00:04:24,720 --> 00:04:25,730
50 감사합니다.

90
00:04:25,730 --> 00:04:27,270
그래서 아주 간단합니다.

91
00:04:27,270 --> 00:04:28,160
>> 지금은 일을하지 않습니까?

92
00:04:28,160 --> 00:04:29,940
그것은 전체 무리를 안하고있어
오류 검사.

93
00:04:29,940 --> 00:04:33,000
예를 들어, 내가 협조하지 않을 경우,
나는 숫자를 입력하지 않지만

94
00:04:33,000 --> 00:04:37,860
대신 나는 "안녕하세요"같이 쓰기
그 이상한이긴하네요.

95
00:04:37,860 --> 00:04:41,130
일 CS50의 그리고 하나
라이브러리는 일부 우리 해왔

96
00:04:41,130 --> 00:04:43,440
시간은 reprompting입니다
및 reprompting.

97
00:04:43,440 --> 00:04:49,320
>> 다시 시도 문구 리콜은 cs50.c에 있었다
그리고 그 그 getInt를있는 이유

98
00:04:49,320 --> 00:04:51,670
CS50 라이브러리는 실제로 전체입니다
긴 줄의 무리, 우리가이기 때문에

99
00:04:51,670 --> 00:04:53,190
이 바보 같은 것들에 대한 검사.

100
00:04:53,190 --> 00:04:55,730
사용자는 포기하지 않았다
우리 사실, INT?

101
00:04:55,730 --> 00:04:57,910
그 또는 그녀가 우리에게 뭔가를 줬나
알파벳 문자 셨나요?

102
00:04:57,910 --> 00:05:01,410
그렇다면, 우리가 감지 할
그와 그들 고함.

103
00:05:01,410 --> 00:05:03,915
>> 하지만 일이 더 흥미있어
이 다음 예제합니다.

104
00:05:03,915 --> 00:05:09,840
내가 scanf와-1.C에 가면, 무엇 하나입니다
근본적으로 변경됩니다 것

105
00:05:09,840 --> 00:05:11,135
이 다음 예제?

106
00:05:11,135 --> 00:05:13,690

107
00:05:13,690 --> 00:05:16,010
나는 물론, 문자 *를 사용하고 있습니다
int 대신.

108
00:05:16,010 --> 00:05:19,210
>> 때문에 char *로 그래서는 재미있다
기억, 그냥 정말

109
00:05:19,210 --> 00:05:20,190
문자열 같은 것.

110
00:05:20,190 --> 00:05:23,840
그래서 아마 같은이 슈퍼 느낌
하는 GetString의 간단한 구현.

111
00:05:23,840 --> 00:05:26,010
하지만 레이어를 다시 벗겨습니다
CS50 라이브러리, 난 그렇게

112
00:05:26,010 --> 00:05:27,550
지금이 문자 *를 호출.

113
00:05:27,550 --> 00:05:30,070
그럼 보자, 어디, 어디에서든지 경우
우리가 잘못.

114
00:05:30,070 --> 00:05:30,840
>> 라인 17 -

115
00:05:30,840 --> 00:05:33,950
나는 다시 나에게 뭔가를 준다, 말
이 경우 문자열입니다.

116
00:05:33,950 --> 00:05:37,940
그리고 그 다음 줄에, 나는 scanf와 전화
다시, 그것을 형식 코드를 제공,

117
00:05:37,940 --> 00:05:39,310
이번에 퍼센트의.

118
00:05:39,310 --> 00:05:41,900
다음이 시간, 난
그것을 버퍼를 제공.

119
00:05:41,900 --> 00:05:43,550
>> 지금은 사용하지 않는거야, 알
앰퍼샌드.

120
00:05:43,550 --> 00:05:47,120
왜 여기가 아마 OK입니까?

121
00:05:47,120 --> 00:05:49,760
이미 버퍼에 무엇 때문에?

122
00:05:49,760 --> 00:05:50,770
그것은 이미 포인터이다.

123
00:05:50,770 --> 00:05:51,650
그것은 이미 주소입니다.

124
00:05:51,650 --> 00:05:54,510
>> 그리고하자이 단어 나하자 "혼란"의
단지를 위해, 예를 들면, 그것의 전화

125
00:05:54,510 --> 00:05:55,050
단순.

126
00:05:55,050 --> 00:05:58,250
하지만 그것은 버퍼라고 한에 있기 때문에
일반, 프로그래밍, 당신은이 있다면

127
00:05:58,250 --> 00:06:02,130
메모리 청크, 문자열 정말
다만, 당신은 버퍼를 호출 할 수 있습니다.

128
00:06:02,130 --> 00:06:04,460
그것은 정보를 저장하는 장소입니다.

129
00:06:04,460 --> 00:06:07,400
>> 때 유튜브 같은 것들과 유사
그들은 말하자면, 버퍼링하고 그

130
00:06:07,400 --> 00:06:10,270
그냥에서 비트를 다운로드 뜻
인터넷에 저장

131
00:06:10,270 --> 00:06:14,160
지역 배열, 그래서 메모리의 지방 덩어리
당신은하지 않고 나중에 볼 수있는

132
00:06:14,160 --> 00:06:16,830
그것은 건너 뛰는에 매달려
당신이 재생하는 동안.

133
00:06:16,830 --> 00:06:20,930
>> 그래서 문제는,하지만 여기있다
내가 scanf와를 말하고 있기 때문에 기대

134
00:06:20,930 --> 00:06:22,320
사용자로부터 문자열입니다.

135
00:06:22,320 --> 00:06:24,410
여기의 주소입니다
메모리 덩어리.

136
00:06:24,410 --> 00:06:26,180
거기에 문자열을 넣습니다.

137
00:06:26,180 --> 00:06:31,230
왜 바운드주고있다
하지만 우리는 문제?

138
00:06:31,230 --> 00:06:33,490
>> 그게 뭐야?

139
00:06:33,490 --> 00:06:35,510
내가 액세스 할 수 있습니까
메모리의 일부?

140
00:06:35,510 --> 00:06:36,250
당신도 알다시피, 나도 몰라.

141
00:06:36,250 --> 00:06:39,210
버퍼를 초기화 되었기 때문에
무엇을?

142
00:06:39,210 --> 00:06:39,820
정말.

143
00:06:39,820 --> 00:06:43,090
그리고 그것은 우리가 호출 봤는데 무슨
쓰레기 값하는

144
00:06:43,090 --> 00:06:44,040
공식적인 단어가 없습니다.

145
00:06:44,040 --> 00:06:49,200
그것은 단지 우리가 어떤 비트 아무 생각이 없음을 의미
그 4 바이트의 내부에

146
00:06:49,200 --> 00:06:51,240
나는 버퍼로 할당했다.

147
00:06:51,240 --> 00:06:52,450
>> 내가 malloc을 호출하지 않았습니다.

148
00:06:52,450 --> 00:06:53,940
나는 확실히하는 GetString 호출되지 것.

149
00:06:53,940 --> 00:06:56,380
그래서 사람들은 실제로 알고
버퍼 안에?

150
00:06:56,380 --> 00:07:00,550
아직 scanf와 말하는 것은 맹목적으로, 거기에 갈
그리고 사용자가 입력 한 어떤 넣어.

151
00:07:00,550 --> 00:07:04,460
>> 그래서 일으킬 것입니다
우리의 코드에서 우리는 그것을 실행하는 경우?

152
00:07:04,460 --> 00:07:05,700
아마이 segfault가.

153
00:07:05,700 --> 00:07:07,970
어쩌면, 그러나 아마이 segfault가.

154
00:07:07,970 --> 00:07:10,620
그리고 내가 말할 아마 때문에 때로는
당신은 때때로 수행

155
00:07:10,620 --> 00:07:11,380
당신은 segfault을 얻을하지 않습니다.

156
00:07:11,380 --> 00:07:14,280
가끔은 그냥 운이 있지만,
그럼에도 불구있을거야

157
00:07:14,280 --> 00:07:15,340
우리의 프로그램의 버그가 수정되었습니다.

158
00:07:15,340 --> 00:07:17,060
>> 그래서 내가 가서이 문제를 컴파일 할 수 있습니다.

159
00:07:17,060 --> 00:07:18,280
나는 오래된 학교 방법 할거야.

160
00:07:18,280 --> 00:07:23,825
그래서 연타 돌진 0, scanf와-1,
scanf와-1.c를 입력합니다.

161
00:07:23,825 --> 00:07:24,720
죄송합니다, 너무 오래된 학교.

162
00:07:24,720 --> 00:07:26,550
보자.

163
00:07:26,550 --> 00:07:28,440
내가 어디에 있습니까?

164
00:07:28,440 --> 00:07:29,700
아, 숯불 * 버퍼입니다.

165
00:07:29,700 --> 00:07:33,595

166
00:07:33,595 --> 00:07:35,130
아, 감사합니다 -

167
00:07:35,130 --> 00:07:36,930
OK 저장 -

168
00:07:36,930 --> 00:07:37,690
아주 오래된 학교.

169
00:07:37,690 --> 00:07:38,900
좋아, 그것은 오랜만이야.

170
00:07:38,900 --> 00:07:41,720
>> 그래서 난 그냥 파일 후를 저장 한
그 임시 만들기

171
00:07:41,720 --> 00:07:42,700
순간 전 변경합니다.

172
00:07:42,700 --> 00:07:46,090
그리고 지금 나는 그것을 컴파일
수동으로 연타와 함께.

173
00:07:46,090 --> 00:07:49,500
그리고 지금 나는 앞서 갈거야
및 입력 scanf와-1을 실행합니다.

174
00:07:49,500 --> 00:07:50,290
문자열 주시기 바랍니다.

175
00:07:50,290 --> 00:07:51,600
난에 입력합니다 "안녕하세요."

176
00:07:51,600 --> 00:07:54,070
>> 그리고 지금, 여기에 printf는 솔직히 어디에
조금 성가신 수 있습니다.

177
00:07:54,070 --> 00:07:56,020
실제로 안 갈거야
이 경우 세그 폴트.

178
00:07:56,020 --> 00:07:59,860
printf를 조금 특별하기 때문에
그것은 일반적으로 사용하므로 슈퍼이야

179
00:07:59,860 --> 00:08:03,570
기본적으로 printf를하고있다
우리는 호의와 실현,

180
00:08:03,570 --> 00:08:04,830
즉, 유효한 포인터 아니다.

181
00:08:04,830 --> 00:08:09,080
자신이 방금 인쇄에 내가 그것을 보자
괄호 널의 아웃도

182
00:08:09,080 --> 00:08:13,340
그것이 반드시 아니에요하지만 무엇
우리는 자신이 예상.

183
00:08:13,340 --> 00:08:16,940
>> 그래서 우리는 정말 쉽게 유도 할 수
이 명확이 함께 segfault가 있지만,

184
00:08:16,940 --> 00:08:18,600
내가 원하는 동작을하지 않습니다.

185
00:08:18,600 --> 00:08:19,800
그래서 간단한 해결책은 무엇인가?

186
00:08:19,800 --> 00:08:25,650
음, scanf와-2, 내가 제안하자 그
대신 실제로 단지를 할당

187
00:08:25,650 --> 00:08:30,100
문자 *는, 내가 좀 똑똑 대한하자
이것은 나를 버퍼를 할당하자

188
00:08:30,100 --> 00:08:32,940
16 문자의 시퀀스로.

189
00:08:32,940 --> 00:08:34,200
>> 그래서 몇 가지 방법으로이 작업을 수행 할 수 있습니다.

190
00:08:34,200 --> 00:08:35,610
나는 절대적으로 malloc을을 사용할 수 있습니다.

191
00:08:35,610 --> 00:08:38,980
하지만 일주일에 두로 돌아갈 수있을 때
나는 단지의 전체 무리를 필요로

192
00:08:38,980 --> 00:08:39,620
자.

193
00:08:39,620 --> 00:08:40,860
그건 그냥 배열입니다.

194
00:08:40,860 --> 00:08:44,870
그럼 내가 대신 버퍼를 다시 정의하자
16 문자의 배열입니다.

195
00:08:44,870 --> 00:08:47,340
>> 그리고 지금은 언제에 버퍼를 전달합니다 -

196
00:08:47,340 --> 00:08:49,940
이것은 우리가하지 않았다 뭔가
주 두 이야기 -

197
00:08:49,940 --> 00:08:53,730
하지만 당신은 배열로 처리 할 수​​ 있습니다
그것은 주소가 비록.

198
00:08:53,730 --> 00:08:56,390
우리가 보았 듯이 기술적으로, 그들은있어
조금 다른.

199
00:08:56,390 --> 00:09:01,290
당신이 그것을 전달하는 경우에 scanf와는 상관 없습니다
배열의 이름 때문에 어떤

200
00:09:01,290 --> 00:09:05,030
우리가 본질적 위해 연타 할 것
로 그 배열의 이름을 치료

201
00:09:05,030 --> 00:09:08,280
16 바이트의 청크의 주소를 입력합니다.

202
00:09:08,280 --> 00:09:09,550
>> 그래서 더 낫다.

203
00:09:09,550 --> 00:09:12,110
이 지금은 희망 할 수 있다는 것을 의미
다음을 수행하십시오.

204
00:09:12,110 --> 00:09:16,800
저 순간을 축소하자
OK 컴파일 scanf와-2을 다하겠습니다.

205
00:09:16,800 --> 00:09:19,390
지금 나 슬래시 scanf와-2를 가지고하자.

206
00:09:19,390 --> 00:09:22,430
문자열 주시기 바랍니다. "안녕하세요." 그리고
이 시간을 작동하는 것 같았다.

207
00:09:22,430 --> 00:09:26,020
>> 하지만 누군가 시나리오를 제안 할 수있다
하는 그것은 여전히​​ 작동하지 않을 수 있습니다?

208
00:09:26,020 --> 00:09:28,550
그래?

209
00:09:28,550 --> 00:09:30,640
16 자 이상인가.

210
00:09:30,640 --> 00:09:32,020
실제로, 우리는 할 수 있습니다
좀 더 정확한.

211
00:09:32,020 --> 00:09:36,540
더 이상 다음 15 자인가,
정말 우리가 염두에 두어야 할 필요가 있기 때문에

212
00:09:36,540 --> 00:09:39,920
우리는 백 슬래쉬 제로를 필요로하는
암시 적 문자열의 끝에서,

213
00:09:39,920 --> 00:09:42,950
이는 따로 scanf와 일반적으로 것입니다
우리의주의를 기울입니다.

214
00:09:42,950 --> 00:09:46,210
>> 그래서 내가 뭔가를 할 수 있도록 -

215
00:09:46,210 --> 00:09:48,040
때때로 우리는 단지 수
그런 식 둡니다.

216
00:09:48,040 --> 00:09:50,630
좋아, 그럼 우리는 이제 유도 한
우리의 세그먼트 오류.

217
00:09:50,630 --> 00:09:51,000
왜?

218
00:09:51,000 --> 00:09:54,940
저는 15 이상에 입력했기 때문에
자, 그래서 우리가 실제로했습니다

219
00:09:54,940 --> 00:09:58,280
감동하는 메모리 I 실제로
필요는 없습니다.

220
00:09:58,280 --> 00:10:00,180
>> 그래서 정말 여기에 솔루션입니다?

221
00:10:00,180 --> 00:10:02,210
음, 우리는 긴 문자열이 필요하면?

222
00:10:02,210 --> 00:10:03,960
음, 우리는 어쩌면 32 바이트합니다.

223
00:10:03,960 --> 00:10:05,160
그럼, 그 충분히 아니라면?

224
00:10:05,160 --> 00:10:06,040
방법에 대한 64 바이트?

225
00:10:06,040 --> 00:10:07,080
무슨 긴 충분하지 않습니다 경우에?

226
00:10:07,080 --> 00:10:09,640
어떻게 약 12​​8 또는 200 바이트?

227
00:10:09,640 --> 00:10:12,660
무엇이 정말 여기에 솔루션입니다
일반적인 경우, 우리는 알고하지 않은 경우

228
00:10:12,660 --> 00:10:14,460
사용자가 입력하는 무슨 진출?

229
00:10:14,460 --> 00:10:20,000

230
00:10:20,000 --> 00:10:23,050
>> 그것은 엉덩이에 큰 고통을이긴하네요
솔직히 말해서, 이것은 이유

231
00:10:23,050 --> 00:10:29,050
CS50 라이브러리의 수십 라인이
총체적으로 구현 코드

232
00:10:29,050 --> 00:10:32,390
우리가하지 않는 방식으로 문자열을 getString에
사전에 알고 있어야 어떤

233
00:10:32,390 --> 00:10:33,430
사용자가 입력하는 것입니다.

234
00:10:33,430 --> 00:10:37,370
특히 경우에 당신은 회고
cs50.c 2 주 전에에서, 당신은 볼 것이다

235
00:10:37,370 --> 00:10:40,480
그하는 GetString 실제로 수행
이 방법으로 scanf와 사용하지 마십시오.

236
00:10:40,480 --> 00:10:43,720
오히려, 그것은 하나의 문자를 읽고
시간.

237
00:10:43,720 --> 00:10:46,010
>> 때문에 대한 하나의 좋은 점
하나의 문자를 읽는 것은 우리가 할 수있는 것입니다

238
00:10:46,010 --> 00:10:48,490
항상 자신을 보장
적어도 하나의 문자가있다.

239
00:10:48,490 --> 00:10:51,740
난 그냥 받아 다음 문자를 선언 할 수 있습니다
다만 이러한 진정으로 아기 단계

240
00:10:51,740 --> 00:10:54,380
에서의 한 문자를 읽어
키보드에서 시간입니다.

241
00:10:54,380 --> 00:10:58,240
그리고, 당신은 무엇을하는 GetString을 볼 수 있습니다
수행은, 그것의 밖으로 실행하는 모든 시간

242
00:10:58,240 --> 00:11:02,280
메모리의 16 바이트라고, 그것은 사용
malloc에​​, 또는 사촌 이들에

243
00:11:02,280 --> 00:11:06,810
오래된, 복사, 더 많은 메모리를 할당
그 새, 그리고 포복으로 메모리

244
00:11:06,810 --> 00:11:09,900
따라서, 한 번에 하나의 문자를 받고
그리고 그 부족할 때

245
00:11:09,900 --> 00:11:13,370
메모리 청크, 잡고 그것을 멀리 던졌습니다
메모리의 큰 덩어리는 옛 복사

246
00:11:13,370 --> 00:11:14,750
새로운, 그리고 반복에.

247
00:11:14,750 --> 00:11:18,480
그리고 그것은 실제로는 정말 고통
처럼 간단한 무언가를 구현

248
00:11:18,480 --> 00:11:19,710
사용자로부터 입력을 받고.

249
00:11:19,710 --> 00:11:21,090
>> 그래서 당신은 scanf와 사용할 수 있습니다.

250
00:11:21,090 --> 00:11:22,430
당신은 다른 유사한 기능을 사용할 수 있습니다.

251
00:11:22,430 --> 00:11:25,420
그리고 교과서의 많은 온라인
예 않지만, 모든이야

252
00:11:25,420 --> 00:11:27,210
이 같은 문제에 취약합니다.

253
00:11:27,210 --> 00:11:29,550
그리고 궁극적으로는 segfault가 점점
어떤 성가신입니다.

254
00:11:29,550 --> 00:11:30,680
그것은 사용자에 대한 좋지 않다.

255
00:11:30,680 --> 00:11:33,560
>> 그러나 최악의 경우, 어떤 작업을 수행
그것은 근본적으로 당신을 넣어

256
00:11:33,560 --> 00:11:37,160
위험에 코드?

257
00:11:37,160 --> 00:11:39,250
공격의 일종, 잠재적으로.

258
00:11:39,250 --> 00:11:41,680
우리는 그러한 공격에 대해 이야기 -
스택 오버플로.

259
00:11:41,680 --> 00:11:44,660
그러나 일반적으로, 당신이 허용하는 경우
오버 플로우 버퍼처럼 우리는했다

260
00:11:44,660 --> 00:11:48,070
그냥 쓰는 전 몇 주,
더 스택에 "안녕하세요"대신,

261
00:11:48,070 --> 00:11:52,330
실제로, 잠재적 인수 할 수
컴퓨터, 또는 적어도 데이터를 얻을이

262
00:11:52,330 --> 00:11:53,510
당신에 속하지 않습니다.

263
00:11:53,510 --> 00:11:55,970
>> 우리가 왜 그렇게 짧은이 있습니다
이러한 훈련 바퀴.

264
00:11:55,970 --> 00:11:59,090
하지만 지금, 우리는 그들을 데리고 시작
우리의 프로그램은 더 이상 필요하지 않기 때문에,

265
00:11:59,090 --> 00:12:00,610
사용자로부터 반드시 입력.

266
00:12:00,610 --> 00:12:03,960
그러나 문제의 경우에, 여섯 세트
귀하의 의견은 거대한에서 올 것이다

267
00:12:03,960 --> 00:12:07,520
150와 사전 파일 일부
이상한 천 단어.

268
00:12:07,520 --> 00:12:10,330
>> 그래서 당신은 걱정하지 않아도됩니다
사용자의 임의의 입력.

269
00:12:10,330 --> 00:12:13,720
우리는 당신에게 몇 가지 가정을 줄 것이다
해당 파일에 대한.

270
00:12:13,720 --> 00:12:20,340
포인터 나 scanf와에 대한 문의
또는 일반적으로 사용자 입력?

271
00:12:20,340 --> 00:12:24,450
>> 좋아, 그래서 1에서 다음 간단히 살펴
2 주전에서 항목을 후행.

272
00:12:24,450 --> 00:12:28,590
그리고 그 구조체의이 개념이었다.

273
00:12:28,590 --> 00:12:34,180
하지 않음 -이 개념
무슨 일이 있었던, 구조체?

274
00:12:34,180 --> 00:12:35,430
구조체는 우리를 위해 무엇을 했는가?

275
00:12:35,430 --> 00:12:39,280

276
00:12:39,280 --> 00:12:39,860
>> 정의 -

277
00:12:39,860 --> 00:12:41,710
죄송합니다?

278
00:12:41,710 --> 00:12:42,820
변수 유형을 정의합니다.

279
00:12:42,820 --> 00:12:44,410
그래서 정렬.

280
00:12:44,410 --> 00:12:46,180
우리는 실제로 두 개의 주제를 조합하고 있습니다.

281
00:12:46,180 --> 00:12:49,510
형식 정의에 그래서, 우리가 할 수있는 기억
처럼 우리 자신의 유형을 선언

282
00:12:49,510 --> 00:12:51,500
문자 *를위한 문자열처럼 동의어.

283
00:12:51,500 --> 00:12:56,200
그러나 형식 정의와 구조체를 사용하여, 우리는 할 수있다
진정으로 우리 자신의 데이터 구조를 만들 수 있습니다.

284
00:12:56,200 --> 00:12:59,600
>> 예를 들어, 내가 다시 가면 gedit를로
여기에 단지 잠시 동안, 나는 가서

285
00:12:59,600 --> 00:13:08,230
뭔가 같이 할, 내가 저장할 수
이 같이 structs.c, 보자

286
00:13:08,230 --> 00:13:10,840
일시적으로, 난 그냥 갈거야
가서 포함하는

287
00:13:10,840 --> 00:13:14,360
standardio.h, 주요 int 무효.

288
00:13:14,360 --> 00:13:18,960
그리고 여기, 내가 원하는 가정
저장하는 프로그램을 작성

289
00:13:18,960 --> 00:13:21,840
복수의 여러 학생들
주택, 예를 들면.

290
00:13:21,840 --> 00:13:24,430
그래서 registrarial처럼
어떤 종류의 데이터베이스입니다.

291
00:13:24,430 --> 00:13:29,550
>> 내가 이름을 한 학생을 필요로하는 경우에, I
, char *로 이름처럼 뭔가를 할 수 있습니다

292
00:13:29,550 --> 00:13:31,570
내가 뭔가를 할 수 있습니다 -

293
00:13:31,570 --> 00:13:34,410
실제로,의는 CS50 라이브러리를 사용할 수 있도록
잠시이를 만들기 위해

294
00:13:34,410 --> 00:13:38,380
좀 더 간단, 그래서 우리는 빌릴 수 있습니다
줄의 코드들을 수십.

295
00:13:38,380 --> 00:13:39,340
그리고하자 그냥 간단하게있어.

296
00:13:39,340 --> 00:13:42,610
우리는 그것이 문자열하겠습니다
지금하는 GetString.

297
00:13:42,610 --> 00:13:47,420
>> 그래서 내가 이름을 저장 했으므로 이제 주장
일부 학생, 그리고 집

298
00:13:47,420 --> 00:13:50,240
단순히 변수를 사용하여 일부 학생
우리는 한 주일에 일인치처럼

299
00:13:50,240 --> 00:13:52,370
하지만 지금은 지원한다고 가정
여러 학생.

300
00:13:52,370 --> 00:13:58,460
좋아, 그래서 내 직감 할 수 있습니다
문자열 NAME2가하는 GetString, 문자열을 가져옵니다

301
00:13:58,460 --> 00:14:01,370
하우스 2가하는 GetString 가져옵니다.

302
00:14:01,370 --> 00:14:05,850
그리고 세 번째 학생
NAME3하는 GetString을하자.

303
00:14:05,850 --> 00:14:09,170
>> 좋아, 그래서 이것은 잘하면 눈에 띄는입니다
바보의 종류 같이,

304
00:14:09,170 --> 00:14:11,580
이 과정은 정말 결코 없기 때문에
끝날지, 그리고 그냥가는거야

305
00:14:11,580 --> 00:14:13,130
내 코드가 더 보이게
그리고 더 악화.

306
00:14:13,130 --> 00:14:14,810
그러나 우리는 일주일에 두 너무이 해결했다.

307
00:14:14,810 --> 00:14:19,450
우리의 비교적 깨끗한 해결책은 무엇인가
우리의 여러 변수가있을 때

308
00:14:19,450 --> 00:14:23,580
동일한 데이터 모두와 관련된 유형 만
우리는이 극악한 혼란을 원하지 않았다

309
00:14:23,580 --> 00:14:26,870
비슷한 이름의 변수?

310
00:14:26,870 --> 00:14:30,060
우리는 대신에 무엇을 했는가?

311
00:14:30,060 --> 00:14:31,260
>> 그래서 제가 몇 군데를 들었다 생각합니다.

312
00:14:31,260 --> 00:14:32,590
우리는 배열을했다.

313
00:14:32,590 --> 00:14:37,110
당신의 여러 인스턴스를하려는 경우
뭔가, 왜 우리는이 모든 청소하지 마십시오

314
00:14:37,110 --> 00:14:39,540
위로 다만 저에게 말
배열 이름이라고?

315
00:14:39,540 --> 00:14:41,640
>> 그리고 지금은 하드 코드 3하자.

316
00:14:41,640 --> 00:14:44,450
그리고 그 때 저에게 또 다른 배열을 제공합니다
집 전화, 그리고 저를 보자

317
00:14:44,450 --> 00:14:45,800
지금은 하드 코딩 3.

318
00:14:45,800 --> 00:14:49,220
그리고 대규모을 청소했습니다
내가 방금 만든 엉망.

319
00:14:49,220 --> 00:14:52,400
지금, 나는 여전히 하드 3 코딩 왔지만도
3 동적에서 올 수

320
00:14:52,400 --> 00:14:54,350
사용자 또는 ARGV, 나처럼.

321
00:14:54,350 --> 00:14:55,720
그래서 이미 클리너입니다.

322
00:14:55,720 --> 00:15:00,100
>> 하지만 이것에 대해 성가신 것은이다
지금은 비록 이름은 어떻게 든입니다

323
00:15:00,100 --> 00:15:02,280
기본적으로 연결
학생의 집 -

324
00:15:02,280 --> 00:15:04,720
그것은 내가 정말 학생의
나타내려면 -

325
00:15:04,720 --> 00:15:08,080
지금은 평행 한 두 개의 배열을 가지고
그들은 걸 의미에서

326
00:15:08,080 --> 00:15:13,930
같은 크기, 이름 브래킷 0
주택 브래킷 0 ~ 아마지도,

327
00:15:13,930 --> 00:15:16,600
와 이름 브래킷 1지도
집에 브라켓 1.

328
00:15:16,600 --> 00:15:19,280
다른 말로하면, 그 학생의 삶
그 집, 그리고 다른 학생의

329
00:15:19,280 --> 00:15:20,530
다른 집에서 살고있다.

330
00:15:20,530 --> 00:15:23,720
그러나 확실하게이 될 수
더욱 깔끔하게 수행.

331
00:15:23,720 --> 00:15:24,990
>> 음, 수, 사실과.

332
00:15:24,990 --> 00:15:28,730
그리고 내가 가서 열게
structs.h까지, 당신은거야

333
00:15:28,730 --> 00:15:31,130
여기이 아이디어를 참조하십시오.

334
00:15:31,130 --> 00:15:34,905
당신과 내가 typedef를 사용한 것을 알 수
전 선언하는 순간에 언급 우리

335
00:15:34,905 --> 00:15:35,570
자신의 데이터 형식입니다.

336
00:15:35,570 --> 00:15:39,660
그러나 나는 또한 다른 키워드를 사용하고 있습니다
구조체라고하는 저에게 새로운을 제공합니다

337
00:15:39,660 --> 00:15:40,790
데이터 구조.

338
00:15:40,790 --> 00:15:43,980
>> 그리고 주장이 데이터 구조는 것입니다
내부의 두 가지를 가지고

339
00:15:43,980 --> 00:15:47,060
그것은 - name이라는 문자열 및
집이라는 문자열입니다.

340
00:15:47,060 --> 00:15:49,820
그리고 난거야 이름을주는
이 데이터 구조는 것입니다

341
00:15:49,820 --> 00:15:51,005
학생이라고 할 수 있습니다.

342
00:15:51,005 --> 00:15:54,030
나는 그것을 내가 원하는 무엇이든을 호출 할 수 있습니다
하지만이 의미 확인

343
00:15:54,030 --> 00:15:55,810
내 마음에서 나에게 의미.

344
00:15:55,810 --> 00:15:59,160
>> 그래서 지금은 더 나은 버전을 열 경우
프로그램의 내가 쓰기 시작

345
00:15:59,160 --> 00:16:00,390
거기 저 상단으로 이동하자.

346
00:16:00,390 --> 00:16:03,190
그리고 코드를 좀 더 줄이있다
여기에,하지만 나를 집중할 수 있도록

347
00:16:03,190 --> 00:16:04,160
하나 순간.

348
00:16:04,160 --> 00:16:07,790
I는 상수라는 학생을 선언 한
하드 지금은 3 코딩.

349
00:16:07,790 --> 00:16:11,110
하지만 지금은 알 청소하는 방법
내 코드를 얻을 시작합니다.

350
00:16:11,110 --> 00:16:15,030
>> 라인 (22)에서는, 선언
학생의 배열입니다.

351
00:16:15,030 --> 00:16:18,760
학생이 분명히 있음을 알 수
이제 데이터 형식입니다.

352
00:16:18,760 --> 00:16:23,360
이 파일의 상단에 알 수 있기 때문에
그 헤더 파일을 포함했습니다

353
00:16:23,360 --> 00:16:24,820
내가 잠시 전에 뽑아합니다.

354
00:16:24,820 --> 00:16:28,820
그리고 헤더 파일은 매우 간단했다
학생이 정의.

355
00:16:28,820 --> 00:16:32,470
>> 그래서 지금, 난 내 자신의 사용자 지정 데이터를 만들었습니다
입력하는 C 년의 저자

356
00:16:32,470 --> 00:16:33,890
전 미리 생각하지 않았다.

357
00:16:33,890 --> 00:16:34,570
하지만 문제는.

358
00:16:34,570 --> 00:16:35,870
나는 그것을 자신을 만들 수 있습니다.

359
00:16:35,870 --> 00:16:39,050
그래서이 학생이라는 배열
그 구성원 각각의

360
00:16:39,050 --> 00:16:41,100
학생 구조입니다.

361
00:16:41,100 --> 00:16:44,270
그리고 나는 그 세 가지를 원하는
배열합니다.

362
00:16:44,270 --> 00:16:46,030
>> 그리고 지금, 나머지는 무엇을합니까
이 프로그램합니까?

363
00:16:46,030 --> 00:16:47,550
조금 임의의 무언가를 필요로했다.

364
00:16:47,550 --> 00:16:51,450
그래서 온라인 24 이후의,
I 0에서 3까지 반복.

365
00:16:51,450 --> 00:16:54,000
그런 다음에 대한 사용자 요청
학생의 이름을 입력합니다.

366
00:16:54,000 --> 00:16:56,110
그리고 나서 이전과 getString에 사용합니다.

367
00:16:56,110 --> 00:16:59,410
그럼 난, 학생의 집 부탁드립니다
나는 전과 같이하는 GetString을 사용합니다.

368
00:16:59,410 --> 00:17:01,780
>> 그러나주의 - 약간 새로운
구문의 조각 -

369
00:17:01,780 --> 00:17:07,010
나는 i 번째 학생에게 여전히 인덱스 수
하지만 특정 데이터를 어​​떻게받을 수 있나요

370
00:17:07,010 --> 00:17:08,354
구조체의 필드 안에?

371
00:17:08,354 --> 00:17:11,770
음, 확실히 무엇
새 구문의 조각?

372
00:17:11,770 --> 00:17:13,339
그것은 단지 도트 연산자입니다.

373
00:17:13,339 --> 00:17:14,510
>> 우리는 정말이 전에 본 적이 없다.

374
00:17:14,510 --> 00:17:17,819
당신이 한 경우는 pset에 다섯에 본
비트 맵 파일에 이미 뛰어 들었다.

375
00:17:17,819 --> 00:17:22,372
그러나 점은 이것의 내부 의미
구조체 또는 여러 필드는 점을 제공

376
00:17:22,372 --> 00:17:24,510
이름 또는 저에게 도트 집을 제공합니다.

377
00:17:24,510 --> 00:17:28,690
구조체 내부에 갈 것을 의미합니다
그 특정 필드를 얻는다.

378
00:17:28,690 --> 00:17:30,200
>> 이 프로그램의 나머지 부분은 무엇입니까?

379
00:17:30,200 --> 00:17:31,190
그것은 모든 섹시한 아니다.

380
00:17:31,190 --> 00:17:34,640
내가 다시 0에서 3까지 반복 통지,
나는 단순히 영어를 생성

381
00:17:34,640 --> 00:17:40,500
너무나 같은 문구는 및에
에서 점 이름을 전달 같은 집,

382
00:17:40,500 --> 00:17:43,320
i 번째 학생 자신의
집뿐만 아니라.

383
00:17:43,320 --> 00:17:47,560
>> 그리고 마지막으로, 지금 우리가 얻을 시작합니다
우리가있어 지금하는이에 대한 항문,

384
00:17:47,560 --> 00:17:49,580
어떤 malloc을하고 익숙한
다른 기능은왔다

385
00:17:49,580 --> 00:17:50,570
이 모든 시간을 일.

386
00:17:50,570 --> 00:17:54,220
이유는 두 이름을 해제해야합니까
및 집, 비록 I

387
00:17:54,220 --> 00:17:56,960
malloc을 호출하지 않았다?

388
00:17:56,960 --> 00:17:58,020
>> 하는 GetString을했다.

389
00:17:58,020 --> 00:18:00,930
그리고 그의 더러운 작은 비밀이었다
몇 주 만하는 GetString가

390
00:18:00,930 --> 00:18:03,530
모두에 메모리가 누수되고
지금까지 모든 학기를 놓습니다.

391
00:18:03,530 --> 00:18:05,990
그리고 valgrand 마침내 것
우리에게이 공개.

392
00:18:05,990 --> 00:18:10,730
>> 내가 알고 있기 때문에 그러나 그것은 큰 문제가 아니다
나는 단순히 이름을 해제 할 수

393
00:18:10,730 --> 00:18:15,750
와 집, 비록 기술적으로
초, 최고 안전, 내가해야

394
00:18:15,750 --> 00:18:17,890
일부 오류를하는 것은 여기에서 확인.

395
00:18:17,890 --> 00:18:19,040
본능은 당신에게 무엇을 말하고 있습니까?

396
00:18:19,040 --> 00:18:22,480
나는 무엇을 확인해야한다
나는 무엇 해제하기 전에

397
00:18:22,480 --> 00:18:25,470
문자열, 일명하는 문자 *?

398
00:18:25,470 --> 00:18:33,460
>> 정말 확인해야 학생들 경우
브래킷 나는 점 이름은하지 않습니다

399
00:18:33,460 --> 00:18:34,840
같은 널 (null).

400
00:18:34,840 --> 00:18:40,400
그런 다음 앞서 무료 이동 OK있을거야
이 포인터와 동일하거나 다른

401
00:18:40,400 --> 00:18:41,160
하나뿐만 아니라.

402
00:18:41,160 --> 00:18:46,860
학생 브래킷 나는 점 집이없는 경우
널 (null)에 해당이 지금 보호합니다

403
00:18:46,860 --> 00:18:52,520
각 케이스에있는
하는 GetString은 null과 같이 반환합니다.

404
00:18:52,520 --> 00:18:57,310
그리고 우리는 printf의 것, 순간 전보고
다만 말씀으로 우리를 여기까지 보호

405
00:18:57,310 --> 00:18:58,990
null이되는 이상한 보는 것입니다.

406
00:18:58,990 --> 00:19:02,340
하지만 적어도 그것은 segfault가 없습니다
우리가 본 바와 같이.

407
00:19:02,340 --> 00:19:05,990
>> 물론, 내가 여기에 다른 일을 할 수 있습니다.
구조체-0 바보 같은 프로그램의 종류

408
00:19:05,990 --> 00:19:09,700
그런 다음 모든 데이터를 입력하기 때문에
프로그램이 종료되면 그것을 잃었다.

409
00:19:09,700 --> 00:19:10,940
그러나 내가 가서이 작업을 수행 할 수 있습니다.

410
00:19:10,940 --> 00:19:12,830
나 터미널을 만들자
조금 큰 창.

411
00:19:12,830 --> 00:19:17,000
나를 구조체-1를하게하는
이것의 새로운 버전입니다.

412
00:19:17,000 --> 00:19:18,520
>> 나는 조금 확대됩니다.

413
00:19:18,520 --> 00:19:21,620
그리고 지금 저 점을 실행할 수
구조체-1을 슬래시.

414
00:19:21,620 --> 00:19:22,590
학생의 이름 -

415
00:19:22,590 --> 00:19:31,500
데이비드 메이는, 롭 커클랜드을하자
로렌 Leverett을하자.

416
00:19:31,500 --> 00:19:33,650
흥미로운 것은 지금 고시 -

417
00:19:33,650 --> 00:19:35,540
나는 단지이 때문에 알고
내가 프로그램을 작성 -

418
00:19:35,540 --> 00:19:38,930
파일 내 현재 지금 거기
디렉토리 students.csv을했다.

419
00:19:38,930 --> 00:19:40,420
여러분 중 일부는 볼 수도
현실 세계에서 이러한.

420
00:19:40,420 --> 00:19:42,980
>> CSV 파일은 무엇입니까?

421
00:19:42,980 --> 00:19:44,170
값을 쉼표로 구분.

422
00:19:44,170 --> 00:19:46,670
그것은 가난한 사람의 같은 종류의의
Excel 파일의 버전입니다.

423
00:19:46,670 --> 00:19:50,580
그것은 행과 열 테이블의이
당신은 Excel과 같은 프로그램에서 열 수 있습니다

424
00:19:50,580 --> 00:19:51,800
맥 또는 숫자.

425
00:19:51,800 --> 00:19:55,180
>> 그리고 저는 gedit를 여기에이 파일을 열 경우,
공지 사항 -와 숫자가 없습니다.

426
00:19:55,180 --> 00:19:57,360
그건 그냥 말 Gedit에있어
나 행 번호.

427
00:19:57,360 --> 00:19:59,740
이것의 첫 번째 줄에 알
파일은 다윗과 메이입니다.

428
00:19:59,740 --> 00:20:01,450
다음 줄 롭 쉼표 커크이다.

429
00:20:01,450 --> 00:20:04,170
그리고 세 번째 줄 로렌
쉼표 Leverett.

430
00:20:04,170 --> 00:20:05,480
>> 그래서 내가 무엇을 만들었습니다?

431
00:20:05,480 --> 00:20:09,580
이제 C 프로그램을 작성했습니다 그
효율적으로 스프레드 시트를 생성 할 수 있습니다

432
00:20:09,580 --> 00:20:11,840
에서 열 수
Excel과 같은 프로그램입니다.

433
00:20:11,840 --> 00:20:15,520
모든이 뛰어난 데이터 세트 만
당신은 훨씬 더 큰 덩어리가있는 경우

434
00:20:15,520 --> 00:20:18,440
당신이 실제로 할 데이터
조작 및 그래프를 만들기

435
00:20:18,440 --> 00:20:21,260
좋아,이 아마 하나입니다
데이터를 생성하는 방법입니다.

436
00:20:21,260 --> 00:20:25,370
또한, CSV를 일반적인 실제로 최고입니다
그냥 간단하게 데이터를 저장하기위한 -

437
00:20:25,370 --> 00:20:28,940
야후 금융, 예를 들어, 당신이 얻을 경우
그들의 소위를 통해 주가

438
00:20:28,940 --> 00:20:33,180
API, 당신을 할 수있는 무료 서비스
현재까지 - 투 - 날짜 주식을 얻기

439
00:20:33,180 --> 00:20:35,650
기업 지수, 그들은
다시에있는 데이터를 제공합니다

440
00:20:35,650 --> 00:20:37,800
슈퍼 간단한 CSV 형식입니다.

441
00:20:37,800 --> 00:20:39,380
>> 그래서 우리는 어떻게 한거야?

442
00:20:39,380 --> 00:20:42,530
음,이 프로그램의 대부분을 통지
거의 동일합니다.

443
00:20:42,530 --> 00:20:46,870
하지만 여기까지 주목하기보다는 인쇄
선 35 명 중,

444
00:20:46,870 --> 00:20:51,040
이후, 난을 저장 해요 주장
디스크 학생, 그래서 파일을 저장.

445
00:20:51,040 --> 00:20:53,630
>> 그래서 FILE *를 선언하고있어 주목 -

446
00:20:53,630 --> 00:20:57,260
지금,이 C의 기형의 종류
어떤 이유로 들어, FILE은 모두 대문자입니다

447
00:20:57,260 --> 00:21:00,690
이는 대부분의 다른 데이터 형식처럼되지 않습니다
C에서하지만이는 내장

448
00:21:00,690 --> 00:21:02,320
데이터 형식, 파일 *.

449
00:21:02,320 --> 00:21:05,900
그리고, 파일에 대한 포인터를 선언하고있어
당신이 생각할 수있는 방법이다.

450
00:21:05,900 --> 00:21:08,070
>> 하면 fopen은 파일 열기를 의미한다.

451
00:21:08,070 --> 00:21:09,470
당신은 어떤 파일을여시겠습니까?

452
00:21:09,470 --> 00:21:12,620
내가 파일을 열려면 나는 것
임의 students.csv를 호출합니다.

453
00:21:12,620 --> 00:21:14,480
내가 원하는 그 무엇이든 호출 할 수 있습니다.

454
00:21:14,480 --> 00:21:15,200
>> 그리고 생각을.

455
00:21:15,200 --> 00:21:18,960
두 번째 인수는 무엇입니까
하면 fopen은 아마 의미하는?

456
00:21:18,960 --> 00:21:21,480
오른쪽, 쓰기에 대한 W, 수
r은 읽기해야합니다.

457
00:21:21,480 --> 00:21:24,120
경우에는 APPEND를 위해 거기이다
행과하지를 추가 할

458
00:21:24,120 --> 00:21:25,200
전체를 덮어 씁니다.

459
00:21:25,200 --> 00:21:28,005
>> 하지만 난 그냥이 파일을 만들려면
일단, 내가 인용 맺다 w를 사용합니다.

460
00:21:28,005 --> 00:21:31,880
내가 읽은에서 만 알고
문서 나 매뉴얼 페이지를 참조하십시오.

461
00:21:31,880 --> 00:21:35,100
파일이 null가 아닌 경우 - 즉,
아무것도 잘못된없는 경우 -

462
00:21:35,100 --> 00:21:37,820
내가 반복하자
0에서 3 학생.

463
00:21:37,820 --> 00:21:40,410
>> 그리고 지금 무언가가 알
도 다소

464
00:21:40,410 --> 00:21:42,110
여기에 대한 선 41.

465
00:21:42,110 --> 00:21:42,960
그것은 printf는 아니다.

466
00:21:42,960 --> 00:21:46,530
그것은 printf의 파일을 fprintf를이다.

467
00:21:46,530 --> 00:21:47,790
그래서 파일에 쓸거야.

468
00:21:47,790 --> 00:21:48,860
어떤 파일?

469
00:21:48,860 --> 00:21:53,630
그 포인터가 지정하는 하나의
첫 번째 인수로.

470
00:21:53,630 --> 00:21:55,940
>> 그렇다면 우리는 형식 문자열을 지정합니다.

471
00:21:55,940 --> 00:21:59,660
그 다음 우리는 우리가하고 싶은 문자열 지정
첫 번째 퍼센트 초 동안 연결하고,

472
00:21:59,660 --> 00:22:04,320
다음 다른 변수 또는
두 번째 퍼센트의.

473
00:22:04,320 --> 00:22:06,760
그럼 우리가 FCLOSE하여 파일을 닫습니다.

474
00:22:06,760 --> 00:22:09,380
그래도 이전처럼 메모리를보다
나는 다시 가서 추가해야합니다

475
00:22:09,380 --> 00:22:10,540
널위한 몇 가지 확인합니다.

476
00:22:10,540 --> 00:22:12,090
>> 그리고 그것입니다.

477
00:22:12,090 --> 00:22:16,960
하면 fopen은 fprintf를, FCLOSE 날을 제공
텍스트 파일을 생성 할 수있는 능력.

478
00:22:16,960 --> 00:22:19,640
지금, 당신은 문제 세트 다섯 볼 수 있습니다
이미지를 포함하는, 당신은 사용할 수 있습니다

479
00:22:19,640 --> 00:22:20,990
바이너리 파일 대신에.

480
00:22:20,990 --> 00:22:24,200
그러나 근본적으로, 아이디어는 동일합니다
비록 당신이거야 기능

481
00:22:24,200 --> 00:22:28,710
조금 다릅니다 참조하십시오.

482
00:22:28,710 --> 00:22:32,580
>> 회오리 바람 투어 그래서,하지만 당신은 얻을 것이다
파일을 너무나 잘 알고 I/O--

483
00:22:32,580 --> 00:22:34,960
입력 및 출력 - PSET 다섯과 함께.

484
00:22:34,960 --> 00:22:38,607
그리고에 대한 질문
여기에 초기 기본?

485
00:22:38,607 --> 00:22:39,857
그래?

486
00:22:39,857 --> 00:22:41,880

487
00:22:41,880 --> 00:22:43,710
>> 당신이 null 값을 해제하려고하면?

488
00:22:43,710 --> 00:22:48,880
무료를 얻었다 않는 한, 생각
좀 더 사용자 친화적 할 수 있습니다

489
00:22:48,880 --> 00:22:49,890
잠재적 인 세그 폴트.

490
00:22:49,890 --> 00:22:54,160
내가하지 않기 때문에이 null로 전달하면 나쁜
무료 믿고, 당신을 확인하는 귀찮게

491
00:22:54,160 --> 00:22:57,330
잠재적으로 낭비 될 수 있기 때문에
그것 자체를 수행하는 시간의

492
00:22:57,330 --> 00:22:59,022
세계의 모든 사람.

493
00:22:59,022 --> 00:23:00,590
좋은 질문,하지만.

494
00:23:00,590 --> 00:23:04,300
>> 자, 이런 종류의 가져 너무
우리 흥미로운 주제에.

495
00:23:04,300 --> 00:23:07,010
문제 세트의 테마
다섯 법의학이다.

496
00:23:07,010 --> 00:23:08,420
적어도 그건 일부의
문제 세트.

497
00:23:08,420 --> 00:23:12,030
법의학은 일반적으로 말한다
수도 있고 정보의 복구

498
00:23:12,030 --> 00:23:14,110
삭제되지 않았을 수 있습니다
일부러.

499
00:23:14,110 --> 00:23:18,680
그래서 난 당신에게 빠른 줄 줄 알았는데
어떤 맛이 정말 벌어지고

500
00:23:18,680 --> 00:23:21,230
아래의이 시간
컴퓨터 후드.

501
00:23:21,230 --> 00:23:23,960
>> 예를 들어, 내부이 경우의
노트북이나 데스크톱 컴퓨터

502
00:23:23,960 --> 00:23:28,040
하드 드라이브, 그것도 기계의
실제로 회전 장치 ​​-

503
00:23:28,040 --> 00:23:31,650
플래터라는 원형 것들이있다
꽤 어떻게 생겼는지 I

504
00:23:31,650 --> 00:23:34,540
다만 불구하고, 여기에 화면에 있었다
이 점점 더 오래된 학교입니다.

505
00:23:34,540 --> 00:23:37,370
이 3 반 인치입니다
하드 드라이브.

506
00:23:37,370 --> 00:23:40,070
세와 반 인치의 의미
당신이 그것을 설치하는 것은의와

507
00:23:40,070 --> 00:23:40,890
컴퓨터합니다.

508
00:23:40,890 --> 00:23:44,890
>> 이제 노트북에서 여러분의 많은 사람
, 솔리드 스테이트 드라이브 또는 SSD를이

509
00:23:44,890 --> 00:23:46,260
이것은 움직이는 부품이없는이 없습니다.

510
00:23:46,260 --> 00:23:49,170
그들은 RAM과 같은 더 적은 같아
이 기계 장치.

511
00:23:49,170 --> 00:23:51,450
하지만 아이디어는 여전히 동일합니다
확실히 그들은 관계로

512
00:23:51,450 --> 00:23:52,790
문제는 다섯 가지를 설정합니다.

513
00:23:52,790 --> 00:23:57,400
>> 그리고 당신은 하드 드라이브에 대해 지금 생각하면
어떤 원, 인 대표

514
00:23:57,400 --> 00:23:58,930
여기 이런 식으로 그릴 수 있습니다.

515
00:23:58,930 --> 00:24:02,290
당신은 당신의 컴퓨터에있는 파일을 만들 때
그것은 SSD, 또는의 여부

516
00:24:02,290 --> 00:24:06,610
이 경우, 이전 학교의 하드 드라이브,
이 파일은 여러 비트를 포함한다.

517
00:24:06,610 --> 00:24:10,510
의 그것은이 0과 1 가정 해 봅시다,
0과 1의 전체 무리.

518
00:24:10,510 --> 00:24:11,660
그래서 내 전체 하드 드라이브입니다.

519
00:24:11,660 --> 00:24:13,225
이 분명히 꽤 큰 파일입니다.

520
00:24:13,225 --> 00:24:18,080
그리고 그에서 0과 1을 사용하고 있습니다
물리적 인 플래터 부분입니다.

521
00:24:18,080 --> 00:24:19,750
>> 글쎄, 물리적 부분은 무엇입니까?

522
00:24:19,750 --> 00:24:25,310
잘, 그것은 하드 드라이브에 그렇게 밝혀
이러한 유형의 적어도 거기

523
00:24:25,310 --> 00:24:27,340
이 작은 작은 자기 입자.

524
00:24:27,340 --> 00:24:32,630
그리고 그들은 본질적으로 북쪽을 가지고
그들에게 남극, 그래서 만약 당신이

525
00:24:32,630 --> 00:24:35,710
이러한 자성 입자 중 하나를 설정
이 방법은, 당신은 있다고 말할 수

526
00:24:35,710 --> 00:24:36,720
1을 나타내는.

527
00:24:36,720 --> 00:24:39,340
그리고 그것은 거꾸로 아래로 남쪽의 경우
북쪽으로, 당신은 그것이 있다고 말할 수

528
00:24:39,340 --> 00:24:40,390
0을 나타내는.

529
00:24:40,390 --> 00:24:43,660
>> 그래서 실제 물리적 인 세계에서, 그게
당신이 뭔가를 나타낼 수있는 방법

530
00:24:43,660 --> 00:24:45,670
이진 0의 상태 1.

531
00:24:45,670 --> 00:24:46,720
그래서 모든 파일이 있습니다.

532
00:24:46,720 --> 00:24:49,300
자기의 전체 무리가있다
자신이 방법 또는이다 입자

533
00:24:49,300 --> 00:24:51,920
이 방법으로 생성, 패턴
의 0과 1.

534
00:24:51,920 --> 00:24:56,760
>> 그러나, 당신은 파일을 저장할 때 밝혀
일부 정보는 별도로 저장됩니다.

535
00:24:56,760 --> 00:25:00,000
그래서 이것은, 작은 테이블
디렉토리는, 말하자면.

536
00:25:00,000 --> 00:25:05,810
그리고이 열 이름을 호출하고 있습니다
이 칼럼의 위치를​​ 호출합니다.

537
00:25:05,810 --> 00:25:08,850
>> 그리고 가정 말할거야
이 이력서입니다.

538
00:25:08,850 --> 00:25:14,050
내 resume.doc은에 저장됩니다
위치 123 가정 해 봅시다.

539
00:25:14,050 --> 00:25:15,390
난 항상 그 번호에 대한 이동합니다.

540
00:25:15,390 --> 00:25:18,810
하지만 단지 좋아하는 말을 충분
RAM에, 당신은 하드 드라이브를 걸릴 수 있습니다

541
00:25:18,810 --> 00:25:22,350
즉, 기가 바이트 또는 200기가바이트의
또는 테라 바이트, 당신은 할 수 있습니다

542
00:25:22,350 --> 00:25:23,750
수의 모든 바이트.

543
00:25:23,750 --> 00:25:26,480
당신은 8 비트의 덩어리를 셀 수 있습니다.

544
00:25:26,480 --> 00:25:29,030
>> 그래서 우리는이 말을합니다
위치 123.

545
00:25:29,030 --> 00:25:32,070
그래서 내 운영이 디렉토리 안에
시스템이 기억하는 내

546
00:25:32,070 --> 00:25:34,250
이력서는 위치 123입니다.

547
00:25:34,250 --> 00:25:36,850
그러나 때 흥미로운
당신은 파일을 삭제합니다.

548
00:25:36,850 --> 00:25:37,820
>> 예를 들어 이렇게 -

549
00:25:37,820 --> 00:25:40,790
그리고 다행히도, 세계의 대부분이
이에 잡힌 - 어떻게 때 발생

550
00:25:40,790 --> 00:25:45,040
당신은 맥 OS의 파일을 휴지통으로 드래그
또는 Windows 휴지통?

551
00:25:45,040 --> 00:25:48,290

552
00:25:48,290 --> 00:25:50,510
그 일을하는 목적은 무엇입니까?

553
00:25:50,510 --> 00:25:53,860
그것은 파일을 없애 분명의
하지만 드래그의 행동을 수행하고

554
00:25:53,860 --> 00:25:57,550
휴지통 또는에 떨어지고하여
휴지통 컴퓨터에 있습니까?

555
00:25:57,550 --> 00:25:59,230
>> 정말 아무것도 없습니다.

556
00:25:59,230 --> 00:26:00,320
그냥 폴더처럼.

557
00:26:00,320 --> 00:26:01,800
그것은 확실하게, 특수 폴더입니다.

558
00:26:01,800 --> 00:26:04,460
하지만 실제로 파일을 삭제합니까?

559
00:26:04,460 --> 00:26:06,780
>> 아니, 글쎄, 당신 때문에 아마도 중 일부
같이했습니다 젠장, 오, 당신은하지 않았다

560
00:26:06,780 --> 00:26:07,420
이 작업을 수행하는 의미합니다.

561
00:26:07,420 --> 00:26:09,130
그래서 당신은 두 번 클릭
휴지통.

562
00:26:09,130 --> 00:26:11,630
당신은 주변에 찌르고어요 그리고 당신은 복구했습니다
그냥 드래그하여 파일을

563
00:26:11,630 --> 00:26:12,110
거기서.

564
00:26:12,110 --> 00:26:14,420
그래서 분명히, 그것은 반드시 아니에요
을 삭제.

565
00:26:14,420 --> 00:26:15,990
>> OK, 당신은 똑똑 이상입니다.

566
00:26:15,990 --> 00:26:18,860
당신은 알고 그냥으로 끌어
휴지통 또는 휴지통을 의미하지 않는다

567
00:26:18,860 --> 00:26:19,930
당신이 휴지통을 비우는 중입니다.

568
00:26:19,930 --> 00:26:24,110
그래서 당신은 최대 메뉴로 이동, 당신은 말한다
휴지통을 비우거나 휴지통 비우기.

569
00:26:24,110 --> 00:26:25,360
그럼 뭐가됩니까?

570
00:26:25,360 --> 00:26:29,070

571
00:26:29,070 --> 00:26:32,530
>> 그래, 그래서 더 그렇게 삭제됩니다.

572
00:26:32,530 --> 00:26:37,660
그러나 모든 사건이있다.

573
00:26:37,660 --> 00:26:45,350
컴퓨터가 위치를 잊어 버린
resume.doc했다.

574
00:26:45,350 --> 00:26:47,400
>> 하지만 분명히 변경되지 않았습니다
그림에서?

575
00:26:47,400 --> 00:26:51,390

576
00:26:51,390 --> 00:26:55,570
비트는, 내가 주장하는 0과 1은
일부 물리적 측면의 사이트

577
00:26:55,570 --> 00:26:56,280
하드웨어.

578
00:26:56,280 --> 00:26:57,110
그들은 아직도 거기에있어.

579
00:26:57,110 --> 00:26:58,930
그냥 컴퓨터가의
잊혀진 그들이이다.

580
00:26:58,930 --> 00:27:03,160
>> 따라서 그것은 본질적으로 해방있어 파일의
그들은 재사용 할 수있는 비트 수 있도록.

581
00:27:03,160 --> 00:27:06,940
하지만 당신은 더 많은 파일을 생성 할 때까지
더 많은 파일을, 더 많은 파일이됩니다

582
00:27:06,940 --> 00:27:12,150
확률 적으로 그 0과 1,
이러한 자성 입자는 다시 얻을,

583
00:27:12,150 --> 00:27:16,220
에 맞거나 오른쪽 위로,
다른 파일, 0과 1.

584
00:27:16,220 --> 00:27:17,980
>> 그래서 당신은 시간이 창을했습니다.

585
00:27:17,980 --> 00:27:19,860
그리고 그것은 예측이 아니야
길이, 정말.

586
00:27:19,860 --> 00:27:22,240
그것은 하드의 크기에 따라 달라집니다
드라이브에 얼마나 많은 파일이 있고

587
00:27:22,240 --> 00:27:23,490
얼마나 빨리 당신이 새로운 것들을합니다.

588
00:27:23,490 --> 00:27:27,050
그러나 시간이 창 중에있다
해당 파일은 완벽 아직입니다

589
00:27:27,050 --> 00:27:27,770
복구.

590
00:27:27,770 --> 00:27:31,050
>> 당신은 맥아피 같은 프로그램을 사용하므로 경우
또는 노턴 복구를 시도합니다

591
00:27:31,050 --> 00:27:35,680
데이터, 그들이하고있는 모든 위해 노력하고
소위 디렉토리를 복구

592
00:27:35,680 --> 00:27:37,340
파일이 어디에 있는지 알아 내기.

593
00:27:37,340 --> 00:27:40,605
그리고 때때로 노턴과는 말할 것이다
파일은 93 % 복구 할 수 있습니다.

594
00:27:40,605 --> 00:27:42,020
글쎄, 그게 무슨 뜻 이죠?

595
00:27:42,020 --> 00:27:45,690
그냥 의미가 다른 파일
우연히 말을 사용하여 종료

596
00:27:45,690 --> 00:27:48,920
원본 파일의 밖으로의 비트.

597
00:27:48,920 --> 00:27:51,950
>> 그래서 실제로 어떻게 관련되어
데이터를 복구하는?

598
00:27:51,950 --> 00:27:55,720
글쎄, 당신은 뭔가가없는 경우
노턴은 컴퓨터에 미리 설치

599
00:27:55,720 --> 00:27:59,510
가끔 할 수있는 최선 볼 수 있습니다
전체 하드 드라이브를 찾고에

600
00:27:59,510 --> 00:28:00,510
비트 패턴입니다.

601
00:28:00,510 --> 00:28:05,350
그리고 문제 세트의 테마 중 하나
다섯 당신이 검색하는 것입니다

602
00:28:05,350 --> 00:28:09,570
하드 드라이브의 상당 법정
에서 컴팩트 플래시 카드의 이미지

603
00:28:09,570 --> 00:28:13,660
0S를 검색 디지털 카메라,
높은과 그 일반적으로과 1,

604
00:28:13,660 --> 00:28:16,720
확률을 나타냅니다
JPEG 이미지의 시작.

605
00:28:16,720 --> 00:28:21,120
>> 그리고 너희들하여 해당 이미지를 복구 할 수 있습니다
나는이 패턴을 보는 경우에, 가정

606
00:28:21,120 --> 00:28:24,380
법의학 이미지 비트와
표시 높은 확률,

607
00:28:24,380 --> 00:28:25,650
JPEG의 시작.

608
00:28:25,650 --> 00:28:29,520
그리고 나는 다시 동일한 패턴을 보면,
그 아마의 시작을 표​​시

609
00:28:29,520 --> 00:28:32,440
다른 JPEG, 다른
JPEG, 다른 JPEG.

610
00:28:32,440 --> 00:28:34,970
이 일반적으로 어떻게
데이터 복구가 작동합니다.

611
00:28:34,970 --> 00:28:37,870
무엇 JPEG 파일에 대한 좋은 것은 비록입니다
파일 형식 자체가 다소 있습니다

612
00:28:37,870 --> 00:28:44,400
이러한 모든 복잡한, 시작
파일은 실제로 상당히 식별 할 수

613
00:28:44,400 --> 00:28:47,370
, 당신이 볼 수 있듯이 간단한
당신이 이미없는 한 경우.

614
00:28:47,370 --> 00:28:50,270
>> 그럼 그 아래에 좀 더 자세히 살펴 보자
됐어요 정확히 무엇으로 후드

615
00:28:50,270 --> 00:28:53,360
일어나고, 이러한 0과 1 무엇을
당신의 조금 더주고,이다

616
00:28:53,360 --> 00:28:55,330
이 특정 문제에 대한 상황.

617
00:28:55,330 --> 00:28:55,510
>> [동영상 재생]

618
00:28:55,510 --> 00:28:58,700
>> 당신의 PC는 대부분의 상점 - 어디로
영구 데이터.

619
00:28:58,700 --> 00:29:03,390
이렇게하려면 데이터가 RAM에서 여행
말할 소프트웨어 신호와 함께

620
00:29:03,390 --> 00:29:06,110
어떻게 데이터를 저장하는 하드 드라이브.

621
00:29:06,110 --> 00:29:09,410
하드 드라이브 회로 번역
전압으로 그 신호를

622
00:29:09,410 --> 00:29:10,870
변동.

623
00:29:10,870 --> 00:29:14,970
이들은 차례로, 하드 드라이브의 제어
움직이는 부분, 몇 가지 중 일부

624
00:29:14,970 --> 00:29:17,910
에 남아있는 움직이는 부품
현대 컴퓨터.

625
00:29:17,910 --> 00:29:22,130
>> 신호의 일부는 모터를 제어
이는 금속 코팅 플래터를 회전합니다.

626
00:29:22,130 --> 00:29:25,470
데이터가 실제로 저장
이 플래터에.

627
00:29:25,470 --> 00:29:28,610
다른 신호는 읽기 / 쓰기를 이동
읽거나 머리

628
00:29:28,610 --> 00:29:30,710
플래터에 데이터를 기록합니다.

629
00:29:30,710 --> 00:29:35,450
이 기계 때문에 정확한 인간이
머리도 사이를 통과 할 수 없습니다

630
00:29:35,450 --> 00:29:37,280
머리와 회전 플래터.

631
00:29:37,280 --> 00:29:40,316
그러나, 모든 훌륭한 속도로 작동합니다.

632
00:29:40,316 --> 00:29:40,660
>> [END 동영상 재생]

633
00:29:40,660 --> 00:29:42,190
>> DAVID 마란 : 약간 확대
깊은 지금 무엇에

634
00:29:42,190 --> 00:29:44,360
실제로 이러한 플래터합니다.

635
00:29:44,360 --> 00:29:44,720
>> [동영상 재생]

636
00:29:44,720 --> 00:29:47,660
>> 의 볼게 우리 단지에
슬로우 모션으로 보았다.

637
00:29:47,660 --> 00:29:51,710
전기의 짧은 펄스 경우
화나게 경우, 읽기 / 쓰기 헤드로 전송

638
00:29:51,710 --> 00:29:54,650
에 대한 작은 전자에
두 번째의 분수.

639
00:29:54,650 --> 00:29:58,970
자석은 어떤 필드를 생성
변화 작은, 작은의 극성

640
00:29:58,970 --> 00:30:02,850
금속 입자의 부분에있는
코트 각 플래터 표면을.

641
00:30:02,850 --> 00:30:05,940
>> 이 작은의 패턴 시리즈,
디스크에 청구 밀집 지역

642
00:30:05,940 --> 00:30:08,470
의 단일 비트를 나타냅니다
이진수 데이터

643
00:30:08,470 --> 00:30:10,530
컴퓨터에서 사용하는 시스템.

644
00:30:10,530 --> 00:30:13,775
지금 전류가 전송되는 경우 하나의 방법
읽기를 통해 / 지역을 쓰기 헤드

645
00:30:13,775 --> 00:30:15,970
한 방향으로 편광이다.

646
00:30:15,970 --> 00:30:17,950
전류에 전송되는 경우
반대 방향,

647
00:30:17,950 --> 00:30:19,930
분극 반전됩니다.

648
00:30:19,930 --> 00:30:22,370
>> 당신은 하드 디스크에서 데이터를 얻을 수 있습니까?

649
00:30:22,370 --> 00:30:24,090
그냥 과정을 역으로 수행합니다.

650
00:30:24,090 --> 00:30:26,550
따라서 디스크에있는 입자의
그에서 현재를 얻을

651
00:30:26,550 --> 00:30:27,960
머리가 움직이는 읽기 / 쓰기.

652
00:30:27,960 --> 00:30:30,700
이들의 수백만을 함께 넣어
자기 부문, 그리고

653
00:30:30,700 --> 00:30:32,160
당신은 파일을 가지고있다.

654
00:30:32,160 --> 00:30:36,060
>> 이제 단일 파일의 조각 월
모든 드라이브에 걸쳐 분산 될 수

655
00:30:36,060 --> 00:30:39,970
난장판 같은 종류의 플래터,
책상 위에 서류.

656
00:30:39,970 --> 00:30:43,500
그래서 특별한 추가 파일을 추적
모든 곳의.

657
00:30:43,500 --> 00:30:45,985
당신은 당신이 가지고하지 않으
뭐 그런?

658
00:30:45,985 --> 00:30:46,470
>> [END 동영상 재생]

659
00:30:46,470 --> 00:30:47,820
>> DAVID 마란 : OK, 아마.

660
00:30:47,820 --> 00:30:52,070
그렇다면 많은 사람
이들과 함께 자랐?

661
00:30:52,070 --> 00:30:53,970
OK, 그래서 적은과 더 적은이다
손 매년.

662
00:30:53,970 --> 00:30:56,550
하지만 난 당신이 적어도 잘 알고 기뻐
그들과 함께,이 때문에 우리 자신의

663
00:30:56,550 --> 00:31:00,520
책 데모는, 슬프게도, 아주 죽어있다
친숙 여기에 죽음을 천천히.

664
00:31:00,520 --> 00:31:04,010
>> 그러나 이것은 적어도 뒤에, 내가있다
고등학교, 백업에 사용되는 사용합니다.

665
00:31:04,010 --> 00:31:08,110
그리고 그것은 훌륭했다, 당신 때문에
에 1.4 메가 바이트를 저장할 수

666
00:31:08,110 --> 00:31:08,930
이 특정 디스크입니다.

667
00:31:08,930 --> 00:31:12,260
그리고 이것은 고밀도 버전이었다
등이 HD로 표시

668
00:31:12,260 --> 00:31:14,240
오늘의 HD 동영상을하기 전에 의미합니다.

669
00:31:14,240 --> 00:31:16,400
>> 표준 밀도는 8백킬로바이트했다.

670
00:31:16,400 --> 00:31:18,640
그리고 그 전에이 있었다
400 킬로바이트 디스크.

671
00:31:18,640 --> 00:31:23,120
그리고 그 전에, 5, 1 / 4이 있었다
정말로 플로피 하였다 인치 디스크,

672
00:31:23,120 --> 00:31:25,680
그리고 약간 넓고 키
여기에 이​​런 것들보다.

673
00:31:25,680 --> 00:31:29,150
그러나 당신은 실제로 소위를 볼 수 있습니다
이러한 디스크의 플로피 측면.

674
00:31:29,150 --> 00:31:32,630
>> 기능적으로, 그들은 실제로있어
에서의 하드 드라이브에 매우 유사

675
00:31:32,630 --> 00:31:33,570
최소한이 유형입니다.

676
00:31:33,570 --> 00:31:37,270
새 컴퓨터에 다시 SSD를
약간 다르게 작동합니다.

677
00:31:37,270 --> 00:31:41,530
하지만 당신은 그 작은 금속 탭을 이동하면,
실제로, 약간의 쿠키를 볼 수 있습니다

678
00:31:41,530 --> 00:31:42,560
또는 플래터.

679
00:31:42,560 --> 00:31:43,830
>> 그것은이 같은 금속이 아니다.

680
00:31:43,830 --> 00:31:46,000
이 하나의 사실은 약간 저렴
재질 플라스틱.

681
00:31:46,000 --> 00:31:46,750
그리고 당신은 호기심를 종류 할 수 있습니다.

682
00:31:46,750 --> 00:31:50,310
그리고 당신은 속에서의 싸움은 정말 좀 닦아했다
비트 또는 자기 입자의 수

683
00:31:50,310 --> 00:31:51,220
이 디스크에서.

684
00:31:51,220 --> 00:31:52,710
>> 그래서 다행히도, 거기에 아무것도 없습니다.

685
00:31:52,710 --> 00:31:55,790
그 것은 방법의 경우 - 및 커버
당신의 눈과 당신의 이웃 사람 -

686
00:31:55,790 --> 00:31:58,865
, 그냥이 당겨 당신은 할 수 있습니다
그런 전체 칼집 떨어져.

687
00:31:58,865 --> 00:32:01,900
하지만 약간 봄이, 그래서 수
당신의 눈을 가진 그 인식.

688
00:32:01,900 --> 00:32:03,620
그래서 지금 당신은 정말 플로피 디스크가 있습니다.

689
00:32:03,620 --> 00:32:07,090
>> 무엇을 이것에 대해 놀라운이야
이 상태로 그 정도에

690
00:32:07,090 --> 00:32:10,830
더 큰 소규모 표현
하드 드라이브가 이러한 일들은 최고입니다

691
00:32:10,830 --> 00:32:11,590
초간단.

692
00:32:11,590 --> 00:32:15,170
당신은 지금, 그것의 바닥을 공략하면 그
그 금속 것은 오프와 껍질

693
00:32:15,170 --> 00:32:20,990
그들이 열이 모두 두 조각입니다
생각과 소위 플로피 디스크

694
00:32:20,990 --> 00:32:22,930
내부에 금속 조각.

695
00:32:22,930 --> 00:32:25,990
>> 그리고 반은 간다
내 디스크의 내용.

696
00:32:25,990 --> 00:32:27,540
그들의 또 다른 절반 간다.

697
00:32:27,540 --> 00:32:31,375
하지만 그 내부에서 회전하는 것을 전부
작년에 컴퓨터.

698
00:32:31,375 --> 00:32:35,220

699
00:32:35,220 --> 00:32:38,310
>> 그리고 또, 관점에 이것을 넣어
얼마나 큰 당신의 대부분의

700
00:32:38,310 --> 00:32:39,560
하드는 요즘 드라이브?

701
00:32:39,560 --> 00:32:41,960

702
00:32:41,960 --> 00:32:46,230
5백기가바이트, 테라 바이트, 아마의
데스크톱 컴퓨터, 2 테라 바이트, 3

703
00:32:46,230 --> 00:32:47,630
테라 바이트, 4 테라 바이트, 오른쪽?

704
00:32:47,630 --> 00:32:52,480
이 일메가바이트이​​며, 제공 또는 수행
심지어 일반적인 MP3에 맞게 할 수없는

705
00:32:52,480 --> 00:32:55,310
더 이상 이러한 일 또는 일부
유사한 음악 파일을 정렬합니다.

706
00:32:55,310 --> 00:32:59,500
>> 그래서 조금 당신을위한 선물 오늘, 그리고
또한 무엇을 상황화하는 데 도움이

707
00:32:59,500 --> 00:33:03,570
우리는 당연하게 복용 할 수 있습니다
지금 문제 5 가지를 설정합니다.

708
00:33:03,570 --> 00:33:04,820
그래서 사람들은 계속 당신입니다.

709
00:33:04,820 --> 00:33:07,340

710
00:33:07,340 --> 00:33:13,370
이렇게 될 곳으로 저를 전환하자
다음 PSET을 지출뿐만 아니라.

711
00:33:13,370 --> 00:33:18,470
그래서 우리는 지금이 페이지에 대해 설정 한 - 오,
빨리 공지 몇 가지.

712
00:33:18,470 --> 00:33:21,730
>> 이번 주 금요일, 당신이 좋아하면 것인지 CS50 가입
점심, 일반적인 장소로 이동

713
00:33:21,730 --> 00:33:23,610
cs50.net/rsvp.

714
00:33:23,610 --> 00:33:25,100
그리고 최종 프로젝트 -

715
00:33:25,100 --> 00:33:28,520
그래서 강의 당, 우리는 게시 한
이미 최종 프로젝트 사양입니다.

716
00:33:28,520 --> 00:33:31,410
의미하지 않는 것을 깨닫게
그것은 특히 곧 때문이다.

717
00:33:31,410 --> 00:33:33,990
그것은 단지 얻으려면, 정말, 게시이야
너희들은 그것에 대해 생각.

718
00:33:33,990 --> 00:33:37,620
참으로, 매우 중요한
당신의 비율은 태클됩니다

719
00:33:37,620 --> 00:33:40,780
재질에 최종 프로젝트가 우리
심지어 클래스에 입수하지 않은 것은,

720
00:33:40,780 --> 00:33:42,730
하지만 빠르면 다음 주 같은 것입니다.

721
00:33:42,730 --> 00:33:45,530
>> 통지는하지만, 스펙을 요구하는
몇 가지 다른 구성 요소

722
00:33:45,530 --> 00:33:46,190
최종 프로젝트.

723
00:33:46,190 --> 00:33:49,590
첫 번째는, 몇 주이며,
사전 제안에 꽤 캐주얼 이메일

724
00:33:49,590 --> 00:33:52,760
당신의 그 말할 TF하거나 당신이있어
함께 프로젝트에 대한 생각

725
00:33:52,760 --> 00:33:53,650
더 노력하지 않습니다.

726
00:33:53,650 --> 00:33:56,710
제안은 특정 될 것이다
약속은, 말, 여기이 무엇인지

727
00:33:56,710 --> 00:33:57,770
난 내 프로젝트에 대한 수행하고 싶습니다.

728
00:33:57,770 --> 00:33:58,250
당신은 어떻게 생각합니까?

729
00:33:58,250 --> 00:33:58,650
너무 큰?

730
00:33:58,650 --> 00:33:59,145
너무 작은?

731
00:33:59,145 --> 00:34:00,330
그것은 관리인가?

732
00:34:00,330 --> 00:34:02,230
그리고 당신은 자세한 내용은 사양을 참조하십시오.

733
00:34:02,230 --> 00:34:05,060
>> 몇 주 그 이후 상태입니다
유사하다 보고서

734
00:34:05,060 --> 00:34:08,260
얼마나 말을하기 위해 TF 캐주얼 이메일
당신은 당신의 마지막에 뒤쳐져

735
00:34:08,260 --> 00:34:12,360
다음 프로젝트의 구현
CS50 Hackathon 할 사람

736
00:34:12,360 --> 00:34:17,520
초대에서 이벤트가 될
7시까지 어느 날 저녁에 오후 08:00

737
00:34:17,520 --> 00:34:19,150
다음날 아침 오전.

738
00:34:19,150 --> 00:34:22,560
나는 주에 언급 한 수 있으므로 피자,
제로 줘야은 오후 9시 제공 될

739
00:34:22,560 --> 00:34:24,120
1:00 중국 음식 오전.

740
00:34:24,120 --> 00:34:27,929
그리고 당신은시에 아직도 깨어 있다면 오전,
우리는 아침 식사를 위해 IHOP에 여러분을 데려 갈 게요.

741
00:34:27,929 --> 00:34:31,310
>> 그래서 Hackathon는 더 중 하나입니다
클래스의 기억에 남는 경험.

742
00:34:31,310 --> 00:34:35,290
다음 구현으로 인해이며,
그 절정 CS50 박람회.

743
00:34:35,290 --> 00:34:38,070
이들 모두에 대한 자세한 정보
주 올 수 있습니다.

744
00:34:38,070 --> 00:34:40,739
>> 그러나의 뭔가로 돌아 가자
오래된 학교 -

745
00:34:40,739 --> 00:34:41,920
다시 배열입니다.

746
00:34:41,920 --> 00:34:45,040
그것을 해결하기 때문에 그렇게 배열이 좋았다
우리는 같은 문제는 그냥보고

747
00:34:45,040 --> 00:34:49,290
학생 구조 전 순간
컨트롤의 작은 밖으로 얻는 경우 우리

748
00:34:49,290 --> 00:34:52,405
학생 한 학생 두 가지를 갖고 싶어
학생 세, 학생 점 점 점,

749
00:34:52,405 --> 00:34:54,400
학생들의 임의의 숫자입니다.

750
00:34:54,400 --> 00:34:58,850
>> 배열 그래서 몇 주 전,에 습격
및 해결 우리의 문제의하지의

751
00:34:58,850 --> 00:35:03,340
사전에 알고 얼마나 많은 것들
어떤 종류의 우리는 할 수 있습니다.

752
00:35:03,340 --> 00:35:07,390
그리고 우리는 구조체가 우리를 도울 수 있다고 보았다
더 이상 우리의 코드를 구성하고 유지

753
00:35:07,390 --> 00:35:11,660
같은 개념적으로 유사한 변수,
이름과 집, 함께하는 우리

754
00:35:11,660 --> 00:35:15,570
안쪽으로 하나의 엔티티로 취급 할 수
어느 작은 조각이있다.

755
00:35:15,570 --> 00:35:17,810
>> 그러나 배열은 몇 가지 단점이 있습니다.

756
00:35:17,810 --> 00:35:19,780
단점은 무엇입니까
우리가 발생했습니다

757
00:35:19,780 --> 00:35:22,320
배열을 지금까지?

758
00:35:22,320 --> 00:35:23,450
그게 뭐야?

759
00:35:23,450 --> 00:35:28,130
고정 된 크기 - 그래서 심지어 수도 있지만
메모리를 할당 할 수

760
00:35:28,130 --> 00:35:32,310
배열은, 일단 당신이 알고 얼마나 많은 학생들이
당신은 얼마나 많은 문자가

761
00:35:32,310 --> 00:35:35,460
사용자로부터, 일단 당신이 할당 한
배열, 당신은 종류의 페인트 한

762
00:35:35,460 --> 00:35:36,740
코너에 자신.

763
00:35:36,740 --> 00:35:40,600
>> 당신은 새로운 요소를 삽입 할 수 없기 때문에
배열의 중간에.

764
00:35:40,600 --> 00:35:43,660
당신은 더 많은 요소를 삽입 할 수 없습니다
배열의 끝에.

765
00:35:43,660 --> 00:35:47,750
정말, 당신은을 만들기에 의존해야
우리가 설명한대로 새로운 배열,

766
00:35:47,750 --> 00:35:49,320
새에 이전을 복사 할 수 있습니다.

767
00:35:49,320 --> 00:35:52,610
그리고 또, 그 두통입니다
당신과 거래를하는 GetString.

768
00:35:52,610 --> 00:35:56,170
>> 그러나 다시, 당신은 삽입 할 수 없습니다
배열의 중간에 뭔가

769
00:35:56,170 --> 00:35:58,200
속도가 완전히 채워지지 않은 경우.

770
00:35:58,200 --> 00:36:03,010
예를 들어,이 배열의 경우, 여기에 크기
여섯 만, 거기에 다섯 가지가 있습니다

771
00:36:03,010 --> 00:36:06,080
잘, 당신은 그냥 압정 수
끝에 뭔가.

772
00:36:06,080 --> 00:36:08,200
하지만 당신은 뭔가를 삽입 무엇을하려는 경우
의 중간에

773
00:36:08,200 --> 00:36:11,280
배열은, 그것은있을 수 있습니다에도 불구하고
그 여섯 가지의 다섯 가지 중?

774
00:36:11,280 --> 00:36:14,250
>> 음, 우리는 우리 모두가있을 때 무엇을 했는가
인간의 자원 봉사자 무대에

775
00:36:14,250 --> 00:36:15,110
주 과거?

776
00:36:15,110 --> 00:36:18,710
우리가 여기에 사람을 넣어하려는 경우, 하나
이 이동하는 방법이 사람

777
00:36:18,710 --> 00:36:22,540
방법, 또는 이동하는 방법이 사람
방법, 그리고 비싼되었다.

778
00:36:22,540 --> 00:36:26,950
내부 사람들의 이동
배열은 최대 추가하고 비용 끝났다

779
00:36:26,950 --> 00:36:31,240
우리 시간, 따라서 많은 우리의 N 제곱
를 들어, 삽입 정렬과 같은 실행 시간을

780
00:36:31,240 --> 00:36:32,550
예, 최악의 경우합니다.

781
00:36:32,550 --> 00:36:36,520
그래서 배열은 중대하다, 그러나 당신은에있다
당신이 그들을 원하는 얼마나 큰 사전에 알고있다.

782
00:36:36,520 --> 00:36:38,030
>> 그래서 OK, 여기에 솔루션입니다.

783
00:36:38,030 --> 00:36:43,860
나는 미리 알 수없는 경우 얼마나 많은
학생들은 내가 가질 수 있으며 한 번 알아

784
00:36:43,860 --> 00:36:47,870
내가 결정하지만, 나는 그와 함께 갇혔어요
왜 난 항상 많은 학생들을하지 않습니다

785
00:36:47,870 --> 00:36:51,740
두 배 많은 공간을 할당
내가 생각하는대로 내가 필요하십니까?

786
00:36:51,740 --> 00:36:54,450
이것이 좋은 해결책이 아니다?

787
00:36:54,450 --> 00:36:58,240
>> 현실적으로, 우리가 걸 생각하지 않습니다
50 개 이상의 슬롯이 필요할 것

788
00:36:58,240 --> 00:37:02,190
중간 크기의 클래스에 대한 배열,
그럼 그냥 반올림 할 수 있습니다.

789
00:37:02,190 --> 00:37:07,040
난 그냥 내 배열에 100 슬롯을 만들거야
그래서 우리는 확실히 얻을 수

790
00:37:07,040 --> 00:37:10,330
내가 기대하는 학생의 수
일부 중간 크기의 클래스에합니다.

791
00:37:10,330 --> 00:37:14,320
왜 그냥 반올림 및 할당하지
배열에 대해 메모리, 일반적으로,

792
00:37:14,320 --> 00:37:16,290
당신도 당신이해야 할 수도 있습니다 생각보다?

793
00:37:16,290 --> 00:37:20,190
이 간단한 이륙 시각의 연기는 무엇입니까
그 생각을?

794
00:37:20,190 --> 00:37:21,440
>> 당신은 메모리를 낭비하고 있습니다.

795
00:37:21,440 --> 00:37:25,350
그런 다음 쓰기 문자 그대로 모든 프로그램
아마 두 배의 메모리로 사용

796
00:37:25,350 --> 00:37:26,680
당신이 실제로 필요합니다.

797
00:37:26,680 --> 00:37:28,990
그냥 기분하지 않습니다
특히 우아한 솔루션입니다.

798
00:37:28,990 --> 00:37:31,990
또한, 그것은 단지를 감소
문제의 확률.

799
00:37:31,990 --> 00:37:35,300
당신은 인기있는 과정이 일어날 경우
한 학기 및 101이

800
00:37:35,300 --> 00:37:39,610
학생들은 프로그램이 여전히
근본적으로 동일한 문제에 직면.

801
00:37:39,610 --> 00:37:44,280
>> 그래서 고맙게도에 대한 해결책이있다
양식이 광고는 우리의 모든 문제를

802
00:37:44,280 --> 00:37:46,790
있는 데이터 구조
것보다 더 복잡

803
00:37:46,790 --> 00:37:47,970
우리는 지금까지 본 적이.

804
00:37:47,970 --> 00:37:50,530
이것은 내가 주장 연결된 목록입니다.

805
00:37:50,530 --> 00:37:51,920
이 번호의 목록입니다 -

806
00:37:51,920 --> 00:37:54,970
9, 17, 22, 26, 34 -

807
00:37:54,970 --> 00:38:00,120
방법으로 서로 연결되었는지
무엇을 나는 화살표로 그려 놨거든요.

808
00:38:00,120 --> 00:38:03,580
>> 즉, 만약 내가 표현하고 싶었다
배열은, 내가 할 수있는

809
00:38:03,580 --> 00:38:04,910
이런 식으로 뭔가.

810
00:38:04,910 --> 00:38:07,310
그리고 오버 헤드에 이것을 놓을 게요
잠시합니다.

811
00:38:07,310 --> 00:38:09,970
내가 할 수있는 -

812
00:38:09,970 --> 00:38:12,520
안녕하세요, 좋아.

813
00:38:12,520 --> 00:38:14,470
대기.

814
00:38:14,470 --> 00:38:17,360
여기에 새 컴퓨터, 맑은 -

815
00:38:17,360 --> 00:38:18,090
좋아.

816
00:38:18,090 --> 00:38:21,730
>> 그래서 배열이 숫자가있는 경우 -

817
00:38:21,730 --> 00:38:28,880
9, 17, 22, 26, 24 -

818
00:38:28,880 --> 00:38:30,530
확장 할 필요는 없습니다.

819
00:38:30,530 --> 00:38:33,730
좋아, 그래서 여기에 내 배열 -

820
00:38:33,730 --> 00:38:34,980
세상에.

821
00:38:34,980 --> 00:38:38,700

822
00:38:38,700 --> 00:38:40,395
좋아, 그래서 여기에 내 배열입니다.

823
00:38:40,395 --> 00:38:44,110

824
00:38:44,110 --> 00:38:45,050
맙소사.

825
00:38:45,050 --> 00:38:48,820
>> [웃음]

826
00:38:48,820 --> 00:38:49,440
>> DAVID 마란 : 척.

827
00:38:49,440 --> 00:38:52,330
그것은 돌아갈 너무 많은 노력의
그래서 거기에 그 수정 -

828
00:38:52,330 --> 00:38:54,290
26.

829
00:38:54,290 --> 00:38:57,650
그래서 우리는이 배열의이
9, 17, 22, 26, 34.

830
00:38:57,650 --> 00:39:00,260
당신의 사람들은 볼 수에 대한
당황 실수는 그냥 만들어,

831
00:39:00,260 --> 00:39:00,830
거기입니다.

832
00:39:00,830 --> 00:39:04,490
>> 그래서 나는이 것을 주장
매우 효율적인 솔루션입니다.

833
00:39:04,490 --> 00:39:07,310
나는 많은 정수로 할당 한
내가 필요 - 하나, 둘, 셋,

834
00:39:07,310 --> 00:39:09,100
넷, 다섯, 혹은 여섯 -

835
00:39:09,100 --> 00:39:11,660
그리고 그때 숫자에게 저장 한
이 배열의 내부.

836
00:39:11,660 --> 00:39:15,220
그러나 가정은 다음 내가 삽입 할
숫자 8과 같은 가치인가?

837
00:39:15,220 --> 00:39:16,100
글쎄, 어디로 가야합니까?

838
00:39:16,100 --> 00:39:18,530
내가 삽입한다고 가정
20 같은 숫자입니다.

839
00:39:18,530 --> 00:39:19,790
글쎄, 어디로 가야합니까?

840
00:39:19,790 --> 00:39:23,160
어딘가에 중간에,
혹은 숫자 35은 가야

841
00:39:23,160 --> 00:39:24,010
어딘가에 끝.

842
00:39:24,010 --> 00:39:25,320
그러나 나는 모든 공간 데요.

843
00:39:25,320 --> 00:39:29,120
>> 그리고이 근본적인 도전
솔루션입니다 않는 배열.

844
00:39:29,120 --> 00:39:32,280
나는 getString는, 순간 전 주장
이 문제를 해결합니다.

845
00:39:32,280 --> 00:39:37,380
당신은 여섯 번째 번호를 삽입하려면
이 배열에 하나 이상의 무엇인가

846
00:39:37,380 --> 00:39:40,090
솔루션은, 확실히 다시 떨어질 수
다만 우리가하는 GetString와처럼?

847
00:39:40,090 --> 00:39:44,340

848
00:39:44,340 --> 00:39:46,030
그게 뭐야?

849
00:39:46,030 --> 00:39:48,190
>> 음, 더 큰되어 있는지 확인
말하기는 쉽다.

850
00:39:48,190 --> 00:39:52,810
우리는 반드시 배열을 만들 수 없습니다
더 큰,하지만 우리가 무엇을 할 수 있습니까?

851
00:39:52,810 --> 00:39:56,570
사이즈의 큰의 새로운 배열을 만들
6, 아니면 크기 10, 우리가 원하는 경우

852
00:39:56,570 --> 00:40:00,490
앞서 것들을 얻을 후 복사
오래된 새에 배열하고

853
00:40:00,490 --> 00:40:01,680
이전 배열을 해제.

854
00:40:01,680 --> 00:40:05,770
>> 그러나 실행 시간은 무엇인가
이제 프로세스의?

855
00:40:05,770 --> 00:40:09,870
그것은 N의 큰 O 왜냐하면 복사
당신에게 몇 가지 단위를 비용 것입니다

856
00:40:09,870 --> 00:40:13,480
우리는에이 시간이 너무 너무 이상하지 않을 경우
가는 새로운 배열을 할당하는

857
00:40:13,480 --> 00:40:15,610
두 배의 소비
메모리에 임시.

858
00:40:15,610 --> 00:40:16,660
새에 오래된 복사 -

859
00:40:16,660 --> 00:40:18,800
내 말은, 그냥 두통,의 어느
다시, 우리는 왜 썼다

860
00:40:18,800 --> 00:40:19,920
당신을 위해 getString 나.

861
00:40:19,920 --> 00:40:21,380
>> 우리는 대신에 이렇게 무엇을 할 수 있습니까?

862
00:40:21,380 --> 00:40:25,000
그럼, 만약 우리의 데이터 구조
실제로 격차가?

863
00:40:25,000 --> 00:40:30,790
나는 데 내 목표를 완화한다고 가정
메모리의 연속 된 청크 위치 9

864
00:40:30,790 --> 00:40:34,500
이다 17, 바로 옆에
바로 22 옆, 등등.

865
00:40:34,500 --> 00:40:39,570
>> 9가 여기에있을 수 있다고 가정
RAM, 및 17, RAM에 여기 할 수 있습니다

866
00:40:39,570 --> 00:40:40,990
22은 RAM에 여기 할 수 있습니다.

867
00:40:40,990 --> 00:40:43,610
즉, 내가 그들을 필요로하지 않는다
더이상 다시 다시.

868
00:40:43,610 --> 00:40:47,850
난 그냥 어떻게 든 바늘에 실을 꿰다해야
이러한 각 숫자, 또는 각각을 통해

869
00:40:47,850 --> 00:40:51,010
이 노드와 같은 우리를 호출합니다
내가 그들을 그린 것 같은 사각형에

870
00:40:51,010 --> 00:40:55,670
마지막에 도착하는 방법을 기억
첫 번째에서 같은 노드입니다.

871
00:40:55,670 --> 00:40:59,940
>> 그래서 프로그래밍 구성 무엇입니까
우리는 아주 최근에 본 적이되는 I

872
00:40:59,940 --> 00:41:03,030
해당 스레드를 구현하거나 할 수 있습니다
여기에 그려진 내가 할 수있는

873
00:41:03,030 --> 00:41:05,430
그 화살표를 구현?

874
00:41:05,430 --> 00:41:06,500
그래서 포인터, 오른쪽?

875
00:41:06,500 --> 00:41:09,560
난 그냥 할당하는 경우
INT하지만, 노드 - 그리고 별

876
00:41:09,560 --> 00:41:10,810
노드, 난 그냥 용기를 의미합니다.

877
00:41:10,810 --> 00:41:12,900
시각적으로, 나는 사각형을 의미합니다.

878
00:41:12,900 --> 00:41:16,420
노드는 분명히 필요하므로
두 값을 포함하는 -

879
00:41:16,420 --> 00:41:21,490
INT 자체 한 후, 같은 암시
사각형의 아래쪽,

880
00:41:21,490 --> 00:41:23,010
INT위한 충분한 공간.

881
00:41:23,010 --> 00:41:26,130
>> 그래서 그냥 여기에 앞서 생각
이 노드는이, 얼마나 큰

882
00:41:26,130 --> 00:41:27,170
문제의 컨테이너?

883
00:41:27,170 --> 00:41:29,250
INT에 대한 얼마나 많은 바이트?

884
00:41:29,250 --> 00:41:31,310
아마 4, 그것 인 경우
평소와 같이 동일합니다.

885
00:41:31,310 --> 00:41:33,270
그리고 얼마나 많은 바이트
포인터?

886
00:41:33,270 --> 00:41:33,650
4.

887
00:41:33,650 --> 00:41:37,940
따라서이 컨테이너, 또는이 노드가있다
8 바이트 구조가 될 것이다.

888
00:41:37,940 --> 00:41:41,760
아, 그리고 그 행복한 우연의 일치가
우리는 단지이 개념을 도입

889
00:41:41,760 --> 00:41:44,400
구조체 또는 C 구조.

890
00:41:44,400 --> 00:41:48,890
>> 그래서 내가 단계를 수행 할 것을 주장
이보다 정교한 방향

891
00:41:48,890 --> 00:41:52,560
숫자 목록의 구현
번호 연결리스트, 내가 할 필요가

892
00:41:52,560 --> 00:41:56,920
좀 더 정면의 생각과
다만 INT하지만, 구조체 선언

893
00:41:56,920 --> 00:41:58,620
내가 전화 할게 있는지, 종래
여기 노드입니다.

894
00:41:58,620 --> 00:42:01,630
우리는 우리가 원하는 무엇이든 호출 할 수도 있지만
노드는 많이 주제별 될 것입니다

895
00:42:01,630 --> 00:42:03,560
것들을 우리가 지금보고 시작합니다.

896
00:42:03,560 --> 00:42:06,480
>> 해당 노드의 내부 INT N입니다.

897
00:42:06,480 --> 00:42:09,350
그리고이 구문, 조금
첫눈에 이상한 -

898
00:42:09,350 --> 00:42:12,960
구조체 노드 * 다음.

899
00:42:12,960 --> 00:42:16,900
물론 그림으로, 그 무엇인가?

900
00:42:16,900 --> 00:42:21,000
그 하단의 절반
우리가 보았던 사각형

901
00:42:21,000 --> 00:42:22,730
잠시 전.

902
00:42:22,730 --> 00:42:27,600
>> 그런데 왜 나는 * 구조체 노드를 말하고
처럼 노드 *에 반대?

903
00:42:27,600 --> 00:42:31,370
그 포인터가 가리키는 경우 때문에,
다른 노드에서, 그것은 단지의

904
00:42:31,370 --> 00:42:32,760
노드의 주소입니다.

905
00:42:32,760 --> 00:42:35,630
우리가 무슨을과 일치이야
지금까지 포인터에 대해 논의했다.

906
00:42:35,630 --> 00:42:39,690
내가 주장하는 경우에 왜이 구조는
노드라고, 내가 구조체 말을해야합니까

907
00:42:39,690 --> 00:42:42,660
여기에 내부 노드?

908
00:42:42,660 --> 00:42:43,190
>> 정확히.

909
00:42:43,190 --> 00:42:46,490
그것은 C의 바보 같은 현실의 일종
형식 정의는, 말하자면,하지 않은

910
00:42:46,490 --> 00:42:47,220
아직 일어났다.

911
00:42:47,220 --> 00:42:48,510
C 리터럴 슈퍼.

912
00:42:48,510 --> 00:42:51,050
그것은 당신의 코드 맨을 읽고
아래, 왼쪽에서 오른쪽으로.

913
00:42:51,050 --> 00:42:54,930
그리고 할 때까지에 해당 세미콜론 안타
하단 라인은하지 않습니다 추​​측

914
00:42:54,930 --> 00:42:57,590
데이터 형식으로 존재 하는가?

915
00:42:57,590 --> 00:42:59,060
노드 견적 맺다 노드입니다.

916
00:42:59,060 --> 00:43:03,050
>> 그러나 때문에 더 자세한의
선언 나는 첫 번째 줄에 한 -

917
00:43:03,050 --> 00:43:05,340
typedef는 구조체 노드 -

918
00:43:05,340 --> 00:43:08,790
그 전에 먼저 왔기 때문에
중괄호, 같은 종류의의

919
00:43:08,790 --> 00:43:11,800
사전 교육 연타 즉,
뭘 알고 나에게 구조체를 제공

920
00:43:11,800 --> 00:43:13,570
구조체 노드를했다.

921
00:43:13,570 --> 00:43:16,270
솔직히 호출 것을 좋아하지 않는다
구조체 노드 구조체 노드의 모든

922
00:43:16,270 --> 00:43:17,090
내 코드에 걸쳐.

923
00:43:17,090 --> 00:43:20,660
하지만 단지 바로 안쪽, 한 번 사용합니다
그래서 나는 효과적으로 할 수

924
00:43:20,660 --> 00:43:25,010
순환 참조의 종류를하지 생성
본질적으로 자신에 대한 포인터 만,

925
00:43:25,010 --> 00:43:29,400
서로에 대한 포인터
동일한 유형입니다.

926
00:43:29,400 --> 00:43:32,330
>> 그래서 밝혀 그 데이터 구조에
다음과 같이 몇 가지가있다

927
00:43:32,330 --> 00:43:34,470
수 있습니다 작업
우리의 관심.

928
00:43:34,470 --> 00:43:37,460
우리는 삽입 할 수 있습니다
다음과 같은 목록에.

929
00:43:37,460 --> 00:43:39,850
우리는 삭제 할 수 있습니다
이 같은 목록에서.

930
00:43:39,850 --> 00:43:43,490
우리의 목록을 검색 할 수 있습니다
값 또는 더 일반적으로, 이송.

931
00:43:43,490 --> 00:43:46,410
트래버스는 단지 멋진 방법입니다
왼쪽에있는 시작을 말 모든 이동

932
00:43:46,410 --> 00:43:47,650
오른쪽 방법입니다.

933
00:43:47,650 --> 00:43:52,640
>> 심지어이 조금 더 유의 사항,
복잡한 데이터 구조,하자

934
00:43:52,640 --> 00:43:56,510
날 우리가 어떤을 빌릴 수있는 제안
지난 2 주 아이디어와

935
00:43:56,510 --> 00:43:58,410
라는 함수를 구현
다음과 같이 검색 할 수 있습니다.

936
00:43:58,410 --> 00:44:01,360
그것은 나 true를 돌려주는거야
false를 나타내는 예 또는

937
00:44:01,360 --> 00:44:03,390
아니, n은 목록에 있습니다.

938
00:44:03,390 --> 00:44:05,960
두 번째 인수는 포인터
목록 자체 때문에

939
00:44:05,960 --> 00:44:07,920
노드에 대한 포인터.

940
00:44:07,920 --> 00:44:10,350
>> 그럼 내가 할거야 모두 선언합니다
임시 변수입니다.

941
00:44:10,350 --> 00:44:12,730
우리는 규칙에 의해 PTR 전화 할게
포인터.

942
00:44:12,730 --> 00:44:15,220
그리고 나는에이 같은 할당
목록의 시작.

943
00:44:15,220 --> 00:44:16,680
>> 지금은 while 루프를 확인할 수 있습니다.

944
00:44:16,680 --> 00:44:20,640
너무 오래 포인터가 같지 않음으로
null로, 내가 확인하는거야.

945
00:44:20,640 --> 00:44:24,520
이다 포인터 화살표 N 같
전달 된 N?

946
00:44:24,520 --> 00:44:26,410
새로운 - 그리고 잠깐만
구문 조각.

947
00:44:26,410 --> 00:44:29,324
화살표가 갑자기 무엇입니까?

948
00:44:29,324 --> 00:44:30,574
그래?

949
00:44:30,574 --> 00:44:34,200

950
00:44:34,200 --> 00:44:34,810
>> 정확히.

951
00:44:34,810 --> 00:44:38,860
그래서 반면 몇 분 전에, 우리는 사용
뭔가를 액세스 할 점 표기법

952
00:44:38,860 --> 00:44:43,080
구조체의 내부 변수 경우
당신은 구조체되지 않은

953
00:44:43,080 --> 00:44:47,420
자체가 아니라 구조체에 대한 포인터
다행히도, 구문 조각이

954
00:44:47,420 --> 00:44:48,620
마지막으로 직관적 인 의미가 있습니다.

955
00:44:48,620 --> 00:44:52,360
화살표, 포인터를 따라하는 것을 의미
우리 화살표는 일반적 의미처럼

956
00:44:52,360 --> 00:44:56,570
그림으로, 그리고에서 이동
데이터 필드 내부.

957
00:44:56,570 --> 00:44:59,700
그래서 화살표 점과 같은 것입니다 만,
당신은 포인터가있을 때 당신은 그것을 사용합니다.

958
00:44:59,700 --> 00:45:05,270
>> 그래서 그냥 다음 요점을 되풀이하는 경우 N 필드
구조체의 내부 포인터를 호출

959
00:45:05,270 --> 00:45:07,760
같음이 n 일, true를 돌려줍니다.

960
00:45:07,760 --> 00:45:11,970
그렇지 않으면, 여기 라인 - 포인터
다음 포인터 같습니다.

961
00:45:11,970 --> 00:45:17,540
그래서이 무엇을하고 있는지, 통지 인 경우, I
현재 구조체를 가리키는입니다

962
00:45:17,540 --> 00:45:21,430
9, 9를 포함하는 숫자가 아닙니다
내가 찾고 있어요 - 내가 찾고 있어요 가정

963
00:45:21,430 --> 00:45:22,830
에 대한 N 50과 같다 -

964
00:45:22,830 --> 00:45:25,930
내 임시 포인터를 업데이트 할거야
이 노드를 가리 키지하기

965
00:45:25,930 --> 00:45:31,190
더 이상하지만, 포인터 화살표 옆에있는
여기에 나를 넣어 것입니다.

966
00:45:31,190 --> 00:45:34,270
>> 지금은 회오리 바람입니다 실현
소개.

967
00:45:34,270 --> 00:45:37,380
수요일에, 우리는 실제로이 작업을 수행 할 수 있습니다
일부 인간과와 좀 더 함께

968
00:45:37,380 --> 00:45:38,900
느린 속도로 코드입니다.

969
00:45:38,900 --> 00:45:42,990
그러나 실현, 우리는 지금 우리의 데이터를 만들고있어
구조는 더 복잡 그래야 우리

970
00:45:42,990 --> 00:45:45,780
알고리즘은 효율적으로 얻을 수있는
를위한 필수가 될 것입니다

971
00:45:45,780 --> 00:45:50,500
PSET 여섯, 우리는 다시에로드 할 때, 그
150,000 단어지만, 그렇게 할 필요가

972
00:45:50,500 --> 00:45:55,650
효율적으로, 그리고 이상적를 만들
우리의 사용자가하지에 대한 실행 프로그램

973
00:45:55,650 --> 00:46:00,460
선형하지 제곱 중 N, 그러나에
이상에서 일정 시간.

974
00:46:00,460 --> 00:46:02,300
>> 우리는 수요일에 당신을 볼 수 있습니다.

975
00:46:02,300 --> 00:46:07,240
>> 스피커 : 다음 CS50, 데이비드
그의 기본 케이스를 잊어.

976
00:46:07,240 --> 00:46:12,770
>> DAVID 마란 : 그리고 당신이 보내는 방법
텍스트 메시지 C. 무엇 -

977
00:46:12,770 --> 00:46:14,020
>> [다양한 텍스트 메시지
통보 소리]

978
00:46:14,020 --> 00:46:19,734