1
00:00:00,000 --> 00:00:02,700
[Powered by Google Translate] [연습 - 문제 세트 4]

2
00:00:02,700 --> 00:00:05,000
[Zamyla 찬 - 하버드 대학교 (Harvard University)]

3
00:00:05,000 --> 00:00:07,340
[이 CS50입니다. - CS50.TV]

4
00:00:08,210 --> 00:00:11,670
괜찮아요. 안녕하세요 여러분, 연습 4 환영합니다.

5
00:00:11,670 --> 00:00:14,270
>> 오늘은 pset 과학 수사입니다.

6
00:00:14,270 --> 00:00:18,080
과학 수사대가 비트 맵 파일을 다루는 것을 포함 정말 재미 pset입니다

7
00:00:18,080 --> 00:00:21,550
범죄를 저지른 사람 발견합니다.

8
00:00:21,550 --> 00:00:24,200
그럼 우리가 어떤 비트 맵 파일의 크기를 조정 할거야

9
00:00:24,200 --> 00:00:27,780
그리고 우리는 또한, 복구라는 정말 재미있는 부분을 처리 할거야

10
00:00:27,780 --> 00:00:31,160
있는 우리는 기본적으로 메모리 카드를 건네하고

11
00:00:31,160 --> 00:00:34,350
있는 사람이 실수로 자신의 파일을 모두 삭제하였습니다,

12
00:00:34,350 --> 00:00:38,860
그리고 우리는 이러한 파일을 복구하도록 요청하고 있습니다.

13
00:00:38,860 --> 00:00:42,910
>> 우리가 pset에 도착하기 전에 먼저, 정말 모든 사람들을 축하하고 싶습니다.

14
00:00:42,910 --> 00:00:45,230
우리는이 과정의 중간 지점에있을거야.

15
00:00:45,230 --> 00:00:50,070
퀴즈 0 우리 뒤에 있으며, 우리는 중간, 그러니 본질적으로, pset4에있다.

16
00:00:50,070 --> 00:00:55,490
귀하의 psets, pset0 및 pset1로 보면 우리는 먼 길을왔다

17
00:00:55,490 --> 00:00:57,300
그래서 그것에 대해 자신을 축하

18
00:00:57,300 --> 00:01:00,760
그리고 우리는 정말 재미에 심취 해있을 겁니다.

19
00:01:00,760 --> 00:01:07,070
>> 그래서 pset에 대한 도구 상자, 다시 대신 얌는 sudo-Y 업데이트를 실행,

20
00:01:07,070 --> 00:01:13,890
당신은 위의 기기의 버전 17.3과에 있으면 우리는 update50을 실행할 수있게되었습니다.

21
00:01:13,890 --> 00:01:17,380
그럼 update50를 실행해야합니다 -이 몇 덜 자, 더 쉽게이야 -

22
00:01:17,380 --> 00:01:20,640
귀하가 어플라이언스의 최신 버전에 있어요 있는지 확인합니다.

23
00:01:20,640 --> 00:01:25,410
우리가 CS50 확인을 사용하기 시작하면 특히 그 update50는 중요해.

24
00:01:25,410 --> 00:01:28,700
당신이 그렇게 있는지 확인하십시오.

25
00:01:28,700 --> 00:01:30,760
>> 이 pset에 대한 섹션의 모든 들어,

26
00:01:30,760 --> 00:01:34,350
우리가 파일 입력 및 출력을 상대해야 할거야, 파일 I / O.

27
00:01:34,350 --> 00:01:38,140
우리는 배열을 처리 프로그램의 많은 반복해야 할거야

28
00:01:38,140 --> 00:01:40,350
파일 및 그와 같은 일을 가리키는

29
00:01:40,350 --> 00:01:43,050
그래서 우리는 우리가 친숙하고 편안한 있는지 확인하려면

30
00:01:43,050 --> 00:01:47,990
어떻게 파일로 입력 및 출력에 대응.

31
00:01:47,990 --> 00:01:52,080
>> 이 pset에 대한 유통 코드에 copy.c라는 파일입니다

32
00:01:52,080 --> 00:01:55,280
그 우리에게 정말 도움이 될 것입니다 우리가 찾을 수있을 것입니다

33
00:01:55,280 --> 00:02:00,340
우리가 끝장 때문에 실제로 copy.c 파일을 복사

34
00:02:00,340 --> 00:02:05,350
불과 약간 문제 집합의 처음 2 부품을 달성 할 수 있도록을 변경.

35
00:02:05,350 --> 00:02:09,030
>> 내가 전에 언급 한대로 그리고 그때, 우리는 비트 맵뿐만 아니라 JPEG 파일을 다루는됩니다.

36
00:02:09,030 --> 00:02:13,170
그래서 정말, 그 파일이 구성되는 방법의 구조를 이해

37
00:02:13,170 --> 00:02:16,170
우리가 정말 structs에 0s와 1 초를 번역 할 수있는 방법

38
00:02:16,170 --> 00:02:19,040
우리가 실제로 이해하고 해석하고 편집 할 수있는 건,

39
00:02:19,040 --> 00:02:21,000
그건 정말 중요한 것입니다

40
00:02:21,000 --> 00:02:25,970
그래서 JPEG 및 비트 맵 파일로 가서 그의 구조를 이해.

41
00:02:25,970 --> 00:02:30,780
>> Pset4, 항상 그렇지만, 질문 섹션을 시작합니다.

42
00:02:30,780 --> 00:02:36,600
이러한 파일 I / O 처리하고 그에 익숙해 얻을 것이다.

43
00:02:36,600 --> 00:02:42,520
그런 다음 1 부 당신이 비트 맵 파일을 제공하고있는, 추리 소설입니다

44
00:02:42,520 --> 00:02:45,630
그게 전부 위에 빨간 점처럼 가지 보입니다.

45
00:02:45,630 --> 00:02:52,180
그리고 기본적으로 우리가 어떻게 할 거냐이 파일을 가지고 단지 약간 편집 is

46
00:02:52,180 --> 00:02:54,010
우리가 읽을 수있는 버전으로.

47
00:02:54,010 --> 00:02:56,000
기본적으로, 우리는 우리가 동일한 파일을주지 완료

48
00:02:56,000 --> 00:03:02,630
를 제외하고 우리는 그 붉은 점으로 숨겨져 숨겨진 메시지를 볼 수 있습니다.

49
00:03:02,630 --> 00:03:07,310
그런 다음 크기 조정이 파일을 주어진있는 프로그램입니다

50
00:03:07,310 --> 00:03:11,490
다음은 출력 한 파일의 이름을 부여하고,뿐만 아니라 번호를 부여

51
00:03:11,490 --> 00:03:16,850
실제로 정수 값으로 해당 비트 맵의​​ 크기를 조정합니다.

52
00:03:16,850 --> 00:03:19,240
그런 다음 마지막으로, 우리는 회복의 pset 있습니다.

53
00:03:19,240 --> 00:03:24,160
우리는 메모리 카드를 제공하고 모든 사진을 복구 할되어 있습니다

54
00:03:24,160 --> 00:03:25,920
실수로 삭제 된 즉,

55
00:03:25,920 --> 00:03:31,420
우리가 배울 수로하지만, 실제로 삭제 파일에서 제거되지 않습니다;

56
00:03:31,420 --> 00:03:38,470
그들은 파일에 갔던 곳의 우리는 그냥 종류 잃었지만 우리는 그렇게 복구거야.

57
00:03:38,470 --> 00:03:44,950
>> 좋아요. 따라서 사용하겠다고 함수의 전체 목록은 I / O는 특별히이이 파일에 들어갔습니다.

58
00:03:44,950 --> 00:03:49,840
당신은 이미 약간의 fopen의 기본, fread, fwrite를하고, 본

59
00:03:49,840 --> 00:03:54,350
그러나 우리는 일부 파일을 추가로 보는거야 I / 등 fputc와 같은 O 기능,

60
00:03:54,350 --> 00:03:56,930
하는 당신은 한 번에 하나의 문자를 쓰기

61
00:03:56,930 --> 00:04:02,000
당신이 친절 앞으로 및 뒤로 파일 위치 지시자를 이동의, fseek로

62
00:04:02,000 --> 00:04:05,770
그리고 몇몇 다른. 그러나 우리는 pset 동안 조금 나중에 들어갈 수 있습니다.

63
00:04:08,050 --> 00:04:13,100
>> 그래서 일단, 그냥 파일로 받아 I / O 우리는 pset로 이동하기 전에,

64
00:04:13,100 --> 00:04:19,860
파일을 열 예를 들어, 당신이해야 할 일은 실제로 파일에 대한 포인터를 설정합니다.

65
00:04:19,860 --> 00:04:22,710
그래서 우리는 파일 * 포인터가 있습니다.

66
00:04:22,710 --> 00:04:27,140
그건 내 infile 될거야 있기 때문에이 경우, 내가 포인터에 전화 했어.

67
00:04:27,140 --> 00:04:33,340
그래서 난 함수 fopen 다음 파일의 이름을 사용하는거야

68
00:04:33,340 --> 00:04:36,360
그리고 나는 갈거야하는 모드는 파일을 처리 할 수​​ 있습니다.

69
00:04:36,360 --> 00:04:42,080
따라서 읽기이 경우 "R", 작문에 대해 "w", 그리고 첨부의 "이"가 있습니다.

70
00:04:42,080 --> 00:04:44,270
예를 들어, 때 infile 상대하고

71
00:04:44,270 --> 00:04:47,310
그리고 당신이 원하는 모든이가 저장된 비트와 바이트를 읽어

72
00:04:47,310 --> 00:04:50,420
그런 다음 당신은 아마 당신의 모드로 "R"을 사용하려는거야.

73
00:04:50,420 --> 00:04:54,520
당신이 실제로 기록 할 때, 가지 새 파일을 만들어

74
00:04:54,520 --> 00:04:57,220
그리고 우리가 할 수있는 일은은 우리가 새로운 파일을 열 것 때문이다

75
00:04:57,220 --> 00:05:02,410
와 쓰기에 대해 "w"모드를 사용합니다.

76
00:05:02,410 --> 00:05:07,540
>> 그럼 당신은 실제로 파일로 읽을 때, 구조는 다음과 같습니다.

77
00:05:07,540 --> 00:05:14,930
먼저 당신이 읽고있는 바이트를 포함 할 구조체에 포인터가 포함되어 있습니다.

78
00:05:14,930 --> 00:05:19,830
그럼 그 말은 당신이 읽고있는 바이트의 끝 위치거야.

79
00:05:19,830 --> 00:05:23,360
그런 다음 크기를 표시하는 것 같은 기본적으로 얼마나 많은 바이트

80
00:05:23,360 --> 00:05:30,100
프로그램이 파일에 읽기 있으며, 크기는 기본적으로 하나의 요소는,

81
00:05:30,100 --> 00:05:32,620
그리고 당신이 읽고 싶은 얼마나 많은 요소를 지정하는거야.

82
00:05:32,620 --> 00:05:34,980
그리고 마지막으로, 당신은 어디에서 읽고 어디에 있는지 알고 있어야 하거든

83
00:05:34,980 --> 00:05:37,580
그래서 귀하의 포인터거야.

84
00:05:37,580 --> 00:05:41,780
fread는 fwrite 매우 유사합니다 때문에이를 색상 코딩

85
00:05:41,780 --> 00:05:47,050
당신이 올바른 순서를 사용하고 있는지 확인하려면 제외

86
00:05:47,050 --> 00:05:51,960
당신이 실제로 작성하거나 오른쪽 파일에서 읽고 있는지 확인하십시오.

87
00:05:54,910 --> 00:05:58,610
>> 그럼 우선, 우리는 요소의 크기뿐만 아니라 요소의 수를 가지고 있다면,

88
00:05:58,610 --> 00:06:00,600
그러면 우리는 여기에 약간의 주위에 재생할 수 있습니다.

89
00:06:00,600 --> 00:06:06,810
나는 개 구조체가 있고 그래서 내가 한 번에 두 개를 참조하세요 말해봐.

90
00:06:06,810 --> 00:06:12,450
내가 할 수있는 것은 한 요소의 크기 떠는 것 뿐이은 한 개의 크기가 될거야

91
00:06:12,450 --> 00:06:14,770
그리고 실제로 두 가지를 읽을거야.

92
00:06:14,770 --> 00:06:18,290
또는 내가 할 수있는 건 단 하나의 요소를 읽을거야 떠는 것 뿐이

93
00:06:18,290 --> 00:06:21,340
한 요소는 두 개의 크기가 될 것입니다.

94
00:06:21,340 --> 00:06:24,320
그래서 그런 유사한 방법은 당신이 크기와 수 주변에 놀이의 종류 수

95
00:06:24,320 --> 00:06:28,250
당신에게 더 직관적인지에 따라 다릅니다.

96
00:06:28,250 --> 00:06:30,810
>> 괜찮아요. 이제 우리는 서면 파일을 얻을.

97
00:06:30,810 --> 00:06:36,880
자네가 읽고있는 당신은 파일을 기록 할 때, 첫번째 인자는 실제로 있습니다.

98
00:06:36,880 --> 00:06:42,050
그래서, 당신은 파일에 쓸 계획하는 기본적으로 데이터의

99
00:06:42,050 --> 00:06:44,490
마지막에 아웃 포인터가있는 것입니다.

100
00:06:44,490 --> 00:06:47,670
그래서 당신은 pset를 처리 할 때, 당신이 혼란스러워하지 않도록합니다.

101
00:06:47,670 --> 00:06:50,480
어쩌면 측에 의해 정의 측면이 있습니다.

102
00:06:50,480 --> 00:06:58,090
당신은 예를 들어, 사람을 입력하여 설명서에 정의를 당겨하고 fwrite 수 있습니다

103
00:06:58,090 --> 00:06:59,950
터미널에서, 또는이 슬라이드로 참조 할 수 있습니다

104
00:06:59,950 --> 00:07:03,570
하고 오른쪽 하나를 사용하고 있는지 확인하십시오.

105
00:07:03,570 --> 00:07:08,700
그러니 다시 fwrite를 들어, 파일이 때로 작성하려는

106
00:07:08,700 --> 00:07:14,290
그 마지막 인자 될거야하고 ​​해당 파일에 대한 포인터가 생길거야.

107
00:07:14,290 --> 00:07:18,670
그래서 그건 우리가 한 번에 아마도 몇 바이트를 작성하는 처리 방법

108
00:07:18,670 --> 00:07:21,820
하지만 당신이 지금 하나의 단일 문자로 작성하려면 말한다.

109
00:07:21,820 --> 00:07:25,940
우리가이 예제에서 나중에 볼 수 있듯이, 비트 맵에서 우리는 것을 사용해야합니다.

110
00:07:25,940 --> 00:07:32,180
우리가 fputc 사용할 수있을 때 정말, 본질적으로 단지 chr은 한 번에 한 문자를 넣어

111
00:07:32,180 --> 00:07:37,050
이 파일 포인터에, 그게 우리의 아웃 포인터.

112
00:07:38,700 --> 00:07:41,560
그래서 우리는 찾거나 파일에 쓸 때마다

113
00:07:41,560 --> 00:07:44,690
파일이 우리가있는 곳을 추적하는 데있다.

114
00:07:44,690 --> 00:07:47,810
그럼 커서 파일 위치 지시자의 일종입니다.

115
00:07:47,810 --> 00:07:54,330
그리고, 우리는 쓸 때마다 또는 파일로 다시 읽기

116
00:07:54,330 --> 00:07:56,760
그곳이 어딘지 파일이 실제로 기억

117
00:07:56,760 --> 00:07:59,270
그리고 이제 커서가있는 곳에서 계속됩니다.

118
00:07:59,270 --> 00:08:03,970
당신이 원하는 때 뭔가를 특정 금액 읽고, 말, 도움이 될 수 있습니다

119
00:08:03,970 --> 00:08:06,160
후, 다음 금액을 읽을

120
00:08:06,160 --> 00:08:10,700
하지만 때때로 우리는 특정 기준 값에서 시작 다시하거나 실제로 이동 할 수 있습니다.

121
00:08:10,700 --> 00:08:16,870
그래서 fseek 함수는, 만약 잘못된 것은 우리가 특정 파일에 커서를 이동할 수 있습니다

122
00:08:16,870 --> 00:08:19,680
바이트의 특정 번호입니다.

123
00:08:19,680 --> 00:08:24,260
그리고 우리가해야 할 일은 참조 값은 위치를 지정할 수 있습니다.

124
00:08:24,260 --> 00:08:31,520
그럼 하나는, 커서는 현재 위치에서 앞이나 뒤로 이동

125
00:08:31,520 --> 00:08:35,750
또는 우리는 단지 파일의 시작 부분에서 이동해야 지정할 수 있습니다

126
00:08:35,750 --> 00:08:37,090
또는 파일의 끝에서.

127
00:08:37,090 --> 00:08:41,230
그리고 당신은 금액에 제외 나 긍정적 인 값을 전달할 수 있습니다

128
00:08:41,230 --> 00:08:44,960
그리고 그 가지 중 앞 또는 뒤로 커서를 이동합니다.

129
00:08:46,170 --> 00:08:51,920
>> 우리가 다른 psets으로 시작하기 전에, 파일에 대한 질문이 I / O?

130
00:08:53,860 --> 00:08:59,990
좋아요. 우리가 더 많은 예제에 들어가으로 질문 날 막을 주시기 바랍니다.

131
00:08:59,990 --> 00:09:06,930
>> 따라서 추리 소설에, 당신이 슬라이드에있는이 붉은 비슷한 비트 맵 파일을 넘겨있어,

132
00:09:06,930 --> 00:09:14,510
그리고은 다음과 같습니다 - 붉은 점의 무리 - 그리고 당신은 정말 서면 건지 모르겠어요.

133
00:09:14,510 --> 00:09:23,310
당신은 곁눈질하면 중간 안에 약간 푸른 색을 볼 수 있습니다.

134
00:09:23,310 --> 00:09:26,270
텍스트가 저장되어있는 위치 기본적으로, 그입니다.

135
00:09:26,270 --> 00:09:30,270
이 일 살인 사건이었고, 우리는 그런 짓을했는지 밝혀 낼해야합니다.

136
00:09:30,270 --> 00:09:36,760
그렇게하기 위해, 우리는 읽을 수있는 형식으로 이미지를 변환의 정도 필요합니다.

137
00:09:36,760 --> 00:09:42,740
당신들이이가 발생하는 경우, 때때로 약간의 키트가 될

138
00:09:42,740 --> 00:09:48,510
어디서 붉은 필름에 돋보기를해야한다. 누구? 그래.

139
00:09:48,510 --> 00:09:52,770
따라서이 같은 손으로 뭔가있을거야, 당신은 돋보기가 것

140
00:09:52,770 --> 00:09:58,130
위에 빨간색 필름으로, 당신은 이미지 위에 넣어 것입니다

141
00:09:58,130 --> 00:10:03,410
당신은 메시지가 그 안에 숨겨져 볼 수있을 것입니다.

142
00:10:03,410 --> 00:10:07,080
우리는 붉은 필름과 돋보기가 없기 때문에 대신에 우리는 예전의 우리가 직접 만들 수의가는거야

143
00:10:07,080 --> 00:10:09,060
이 pset 인치

144
00:10:09,060 --> 00:10:15,760
그리고 사용자는 다음 입력 추리 소설, 단서에 갈 수 있습니다. BMP는,

145
00:10:15,760 --> 00:10:18,800
빨간 점으로 메시지입니다 infile이고, 그래서

146
00:10:18,800 --> 00:10:23,550
그리고 그들은 verdict.bmp 우리 outfile 될 것입니다 말씀하시는 거예요.

147
00:10:23,550 --> 00:10:27,900
그래서 단서 하나와 유사한 새로운 비트 맵 이미지를 만들거야

148
00:10:27,900 --> 00:10:32,600
읽을 수있는 형식으로 제외하고있는 우리는 숨겨진 메시지를 볼 수 있습니다.

149
00:10:32,600 --> 00:10:37,550
>> 우리는 어떤 종류의 비트 맵을 편집 및 조작을 상대해야 할거야 때문에

150
00:10:37,550 --> 00:10:42,400
우리는 이러한 비트 맵 파일의 구조로의 다이빙 종류에가는거야.

151
00:10:42,400 --> 00:10:48,130
우리는 강의에서이 약간 넘는 갔지만, 좀 더 그들에 대해 조사합시다.

152
00:10:48,130 --> 00:10:51,740
비트 맵은 본질적으로 바이트 단지 배치 아르

153
00:10:51,740 --> 00:10:55,790
우리가 지정한 곳하는 바이트 무엇 의미합니다.

154
00:10:55,790 --> 00:11:00,540
자, 이제 비트 맵 이미지의지도처럼 가지입니다

155
00:11:00,540 --> 00:11:08,550
그 어떤 헤더 파일로 시작한다는, 거기에 몇 가지 정보와 함께 시작합니다.

156
00:11:08,550 --> 00:11:16,540
당신은에 대한 바이트 번호 14의 크기는 비트 맵 이미지의 표시되는 것을 볼

157
00:11:16,540 --> 00:11:18,520
그리고에 계속됩니다.

158
00:11:18,520 --> 00:11:23,810
하지만 우리가 여기서 관심은 바이트 수가 54 주위에 시작합니다.

159
00:11:23,810 --> 00:11:26,060
우리는이 RGB의 트리플 있습니다.

160
00:11:26,060 --> 00:11:30,760
하려는 일을하면 실제 픽셀의 색상 값을 포함합니다.

161
00:11:30,760 --> 00:11:35,950
헤더에 그 위의 모든 몇 가지 정보입니다

162
00:11:35,950 --> 00:11:41,240
이미지, 이미지의 폭과 높이의 크기에 해당.

163
00:11:41,240 --> 00:11:44,930
우리가 나중에 패딩으로 들어갈 때, 우리는 볼 이유가 이미지의 크기

164
00:11:44,930 --> 00:11:48,670
폭 또는 높이가 다를 수 있습니다.

165
00:11:48,670 --> 00:11:54,240
그럼 다음을 나타냅니다 방법 -이 비트 맵 이미지를 바이트 시퀀스 있습니다 -

166
00:11:54,240 --> 00:11:59,370
괜찮아,라고되어 우리가 할 수있는 건, 기억 할거야 그 인덱스 14,

167
00:11:59,370 --> 00:12:03,380
우리가이 쉽게하기 위해 어떻게 할 거냐 대신 크기가 예를 들어, 어디에 만,

168
00:12:03,380 --> 00:12:06,020
구조체에 캡슐화되어 있습니다.

169
00:12:06,020 --> 00:12:08,880
그래서 우리는 우리 둘이서 연애 structs, BITMAPFILEHEADER이

170
00:12:08,880 --> 00:12:10,440
와 BITMAPINFOHEADER,

171
00:12:10,440 --> 00:12:14,840
그래서 우리가 그 파일에 읽기 때마다 기본적으로는 순서대로가는거야

172
00:12:14,840 --> 00:12:22,360
그리고 순서에 또한 biWidth와 biSize 등의 변수에의 기입 할거야.

173
00:12:25,270 --> 00:12:31,230
그리고 마지막으로, 모든 픽셀은 세 바이트로 표현됩니다.

174
00:12:31,230 --> 00:12:35,500
첫 번째는 픽셀의 파란색의 양이고, 두 번째는 녹색의 양입니다

175
00:12:35,500 --> 00:12:41,120
마지막으로, 0은 본​​질적으로 더 블루 또는 전혀 녹색입니다 붉은 색의 금액이나 레드

176
00:12:41,120 --> 00:12:43,720
그리고 FF는 최대 값입니다.

177
00:12:43,720 --> 00:12:46,800
다음은 16 진수 값입니다.

178
00:12:46,800 --> 00:12:53,870
우리가 FF0000이있는 경우 그럼, 해당 파란색의 최대 금액에 해당하는

179
00:12:53,870 --> 00:12:58,890
그리고 녹색과 레드 때문에 해당이 우리에게 파란 픽셀을 제공하지 않을 없습니다.

180
00:12:58,890 --> 00:13:04,190
우리는 보드에서 FF의 모든 경우, 그러면 우리가 흰색 픽셀을 가지고 있다는 것을 의미합니다.

181
00:13:04,190 --> 00:13:11,370
우리가 RGB 말을 할 때 일반적으로에 반대 종류의 것입니다. 사실은 BGR을거야.

182
00:13:12,750 --> 00:13:18,990
>> 우리가 실제로 비트 맵 이미지의 예를 조사다면 - 내가 여기를 하세.

183
00:13:31,560 --> 00:13:33,830
조금 작 네요.

184
00:13:39,890 --> 00:13:47,840
나는 확대, 우리는 그것이 pixelated있어 볼 수 있습니다. 그것은 색의 블록 것 같습니다.

185
00:13:47,840 --> 00:13:50,110
그런 다음 흰색 블록과 빨간 블록을 갖추고 있습니다.

186
00:13:50,110 --> 00:13:53,700
당신이 Microsoft 그림판에서 재생하는 경우, 예를 들어, 당신은 그런 일을 만들 수

187
00:13:53,700 --> 00:13:58,960
에 의해 기본적으로는 특정 순서로 특정 사각형을 그림.

188
00:13:58,960 --> 00:14:08,060
그래서 비트 맵의​​에 대한 어떤이 번역은 다음과 같습니다 수 있습니다.

189
00:14:08,060 --> 00:14:15,710
여기 우리는 6 F의 것을 먼저 흰색 픽셀을 가지고 있고, 그런 다음에 우리가 붉은 색 픽셀이

190
00:14:15,710 --> 00:14:19,910
0000FF으로 표시.

191
00:14:19,910 --> 00:14:27,940
그리고 우리가 가지고 바이트의 시퀀스는 비트 맵 이미지가 꼴 방법을 나타냅니다.

192
00:14:27,940 --> 00:14:32,230
그래서 여기 한 것은 바로 모든 바이트를 작성하고 빨간색으로 한 다음 색

193
00:14:32,230 --> 00:14:37,550
어떤 종류의 볼 수 있도록의 종류 웃는 얼굴을 나타냅니다 방법을 곁눈질 조금, 경우.

194
00:14:40,180 --> 00:14:46,390
>> 비트 맵 이미지 작업을 나야하는 방법은 그리드로 기본적를 구상.

195
00:14:46,390 --> 00:14:54,940
그리고 기본적으로 그리드의 모든 행은 4 바이트의 배수 여야합니다.

196
00:15:00,520 --> 00:15:07,060
우리가 비트 맵 이미지를 보면, 당신은 모든 값에 작성하고 있습니다.

197
00:15:07,060 --> 00:15:17,370
예를 들어, 당신은 여기, 여기, 여기, 파란색 녹색 빨간색이있을 수

198
00:15:17,370 --> 00:15:24,950
하지만 이미지가 4 바이트의 배수으로 채워되어 있는지 확인해야합니다.

199
00:15:24,950 --> 00:15:32,200
나는 세 블록 폭이 될 수있는 이미지를하려는 경우 그럼, 난 빈 값을 넣어해야

200
00:15:32,200 --> 00:15:35,640
마지막에 네 분이 여러 수 있도록하고 있습니다.

201
00:15:35,640 --> 00:15:39,530
그래서 나는 우리가 패딩 전화하는거야 뭔가를 추가합니다.

202
00:15:39,530 --> 00:15:43,750
난 그냥 거기에 X로 표시 할거야.

203
00:15:44,920 --> 00:15:54,160
지금은 우리가 예를 들어, 7 픽셀 긴 이미지를 원하는 말한다.

204
00:15:54,160 --> 00:15:59,550
우리는 1, 2, 3, 4, 5, 6, 7을 가지고

205
00:16:04,750 --> 00:16:07,000
그 모두 색으로 가득 차 있습니다.

206
00:16:07,000 --> 00:16:10,620
비트 맵 이미지가 작동하는 방식은 우리가 여덟째을해야한다는 것입니다.

207
00:16:10,620 --> 00:16:12,460
지금 우리는 1, 2, 3, 4, 5, 6, 7을 갖추고 있습니다.

208
00:16:12,460 --> 00:16:19,360
우리는 올바르게 읽을 수있는 비트 맵 이미지 8 공간이 필요합니다.

209
00:16:19,360 --> 00:16:25,600
그럼 우리가해야 할 일 패딩 조금에 추가됩니다

210
00:16:25,600 --> 00:16:29,430
폭의 유니폼되었는지 확인하려면

211
00:16:29,430 --> 00:16:34,260
그리고 너비의 모든 4의 배수임을.

212
00:16:42,110 --> 00:16:47,310
그래서 나는 이전에 X 또는 구불 구불 한 선으로 패딩, 표시

213
00:16:47,310 --> 00:16:53,880
하지만 실제 비트 맵 이미지에 패딩은 16 진수 0으로 표시됩니다.

214
00:16:53,880 --> 00:16:57,340
그래서 하나의 문자, 0이 될 것입니다.

215
00:16:58,980 --> 00:17:06,329
어떤 쓸모가있을 것이 xxd 명령입니다.

216
00:17:06,329 --> 00:17:11,220
만약 성공하지 건 내가 웃는으로 이전 한 것과 유사 실제로 당신을 보여줍니다 같다

217
00:17:11,220 --> 00:17:15,630
사실은 각 색상의 픽셀을위한 일하는지 알아 인쇄 할 때

218
00:17:15,630 --> 00:17:21,800
다음 명령을 xxd 실행할​​ 때 다음, 그것을 색

219
00:17:21,800 --> 00:17:28,670
다음은 실제로 색상이 해당 픽셀에 대한 어떤 인쇄합니다.

220
00:17:28,670 --> 00:17:33,810
당신이해야 할 일은-S 54처럼, 나는 표시 이쪽에

221
00:17:33,810 --> 00:17:36,530
나는 54번째 바이트에서 시작 할거야 있다고

222
00:17:36,530 --> 00:17:40,820
우리가 비트 맵의​​지도로 돌아 보면 그 이전 있기 때문에 기억

223
00:17:40,820 --> 00:17:42,690
그렇게 헤더 정보와 물건은 자네입니다.

224
00:17:42,690 --> 00:17:46,280
하지만 우리가 정말 신경하면 색상을 나타내는 실제 픽셀입니다.

225
00:17:46,280 --> 00:17:52,700
그래서,-S 54 그 플래그에 추가하여, 우리는 색상 값을 볼 수있게되었습니다.

226
00:17:52,700 --> 00:17:56,020
그리고 그 같은 복잡한 국기와 일에 대해 걱정하지 마십시오.

227
00:17:56,020 --> 00:18:05,020
문제 세트 사양에서는 픽셀을 표시 할 수 xxd 사용하는 방법에 대한 지시 사항을해야합니다.

228
00:18:07,070 --> 00:18:15,590
당신이 여기서 보는면, 그것은 종류의 녹색 상자,이 작은 일 것 같습니다.

229
00:18:15,590 --> 00:18:23,610
나는 기본적으로 더 파랑, 녹색의 많은, 그리고 더 붉은 말을하지로 00FF00을 색으로했습니다.

230
00:18:23,610 --> 00:18:26,370
그래서 녹색에 해당합니다.

231
00:18:26,370 --> 00:18:31,920
당신이 여기서 보는 바와 같이, 우리는 녹색 사각형을 참조하십시오.

232
00:18:31,920 --> 00:18:36,660
이 녹색 사각형은 우리가 뭘해야하는지 그럼, 단 3 픽셀 폭

233
00:18:36,660 --> 00:18:44,350
이미지는 4 폭의 배수인지 확인하는 것은 추가 패딩에 추가됩니다.

234
00:18:44,350 --> 00:18:49,460
그리고 해당 당신이 여기이 0s를 볼 방법은 다음과 같습니다.

235
00:18:49,460 --> 00:18:54,510
이와 같은 사실은 실제로 당신의 크기 조정 pset의 결과입니다

236
00:18:54,510 --> 00:19:01,350
기본적으로 작은 비트 맵을 복용 한 후 4하여 확대.

237
00:19:01,350 --> 00:19:09,380
그리고 우리가 볼 것은, 실제로이 이미지는 12 픽셀 (폭)입니다하지만, 12는 4의 배수이다

238
00:19:09,380 --> 00:19:12,940
우리가 어떤을 추가 할 필요가 없기 때문에 그래서 우리는 실제로 끝에서 어떤 0s 표시되지 않습니다

239
00:19:12,940 --> 00:19:19,070
은 완전히 패드를 물렸다이 없기 때문입니다. 그것은 더 이상 공간이 없습니다.

240
00:19:20,720 --> 00:19:23,470
>> 좋아요. 패딩에 대한 질문?

241
00:19:25,150 --> 00:19:27,460
좋아요. 좋아.

242
00:19:27,460 --> 00:19:32,520
>> 내가 전에 언급 한 바와 같이, 비트 맵은 바이트의 순서입니다.

243
00:19:32,520 --> 00:19:39,170
그리고 우리가해야하는 것은 아닌 바이트의 정확히 어떤 수를 추적 할 필요입니다

244
00:19:39,170 --> 00:19:47,050
특정 요소에 해당하는, 우리는 실제로를 대표하는 구조체를 만들었습니다.

245
00:19:47,050 --> 00:19:50,930
그래서 우리가하는 것은 RGBTRIPLE 구조체입니다.

246
00:19:50,930 --> 00:19:54,590
당신이 RGB 트리플의 인스턴스를 가지고 때마다,

247
00:19:54,590 --> 00:20:00,970
이 유형의 구조체를 정의하기 때문에, 다음은 rgbtBlue 변수에 액세스 할 수 있습니다

248
00:20:00,970 --> 00:20:09,520
표시됩니다 마찬가지로 녹색 및 빨간색 변수, 얼마나 파랑, 녹색, 빨간색,

249
00:20:09,520 --> 00:20:11,580
각각이 있습니다.

250
00:20:11,580 --> 00:20:16,800
>> 우리는 0, FF의 녹색 세트, 파란색 변수 세트를 가지고면

251
00:20:16,800 --> 00:20:22,060
어느 당신이 가진 수있는 최대 값으로, 다음 빨간색 변수는 0으로 설정

252
00:20:22,060 --> 00:20:27,870
그리고 무슨 색이 특정 RGB 트리플는 대표까요? >> [학생] 그린.

253
00:20:27,870 --> 00:20:29,150
그린. 그렇지.

254
00:20:29,150 --> 00:20:34,480
알면 도움이 될거야 당신이 RGB 트리플의 인스턴스가있을 때마다

255
00:20:34,480 --> 00:20:41,340
, 푸른 녹색, 빨간색 - - 개별적으로 당신은 실제로 색상의 양을 액세스 할 수 있습니다.

256
00:20:43,350 --> 00:20:54,900
>> 이제 우리는 그 구조에 대해 이야기하는, 그럼 BMP 파일을 살펴 보자.

257
00:20:54,900 --> 00:20:57,870
이 당신을 위해 만든 structs입니다.

258
00:20:57,870 --> 00:21:01,820
여기 BITMAPFILEHEADER 구조체의 수 있습니다.

259
00:21:01,820 --> 00:21:07,610
관심의 크기입니다.

260
00:21:07,610 --> 00:21:12,660
나중에, 우리는 우리에게 흥미 몇 가지 더있는 정보 헤더를,이

261
00:21:12,660 --> 00:21:15,480
즉 크기, 폭 및 높이입니다.

262
00:21:15,480 --> 00:21:19,170
우리가 나중에 들어가 겠지만,이 파일을 읽었을 때,

263
00:21:19,170 --> 00:21:25,500
가 자동으로 우리가 동일 할 순서를 설정 한 때문으로 읽습니다.

264
00:21:25,500 --> 00:21:31,990
따라서 biSize은 이미지의 실제 크기에 해당하는 권리 바이트를 포함합니다.

265
00:21:34,700 --> 00:21:40,500
우리가 얘기 한 것처럼 그리고 여기 마지막으로, 우리는 RGBTRIPLE typedef 구조체가 있습니다.

266
00:21:40,500 --> 00:21:46,840
우리는과 관련 rgbtBlue, 녹색, 빨간색을 갖추고 있습니다.

267
00:21:48,210 --> 00:21:49,340
>> 좋아요. 좋아요.

268
00:21:49,340 --> 00:21:56,360
이제 비트 맵을 좀 이해, 우리는 파일 헤더를 가지고 이해

269
00:21:56,360 --> 00:22:00,790
그리고 그것으로하고 그 후 관련 정보 헤더는, 우리는 흥미로운 물건이

270
00:22:00,790 --> 00:22:05,110
색상, 이러한 색상은 RGBTRIPLE structs에 의해 나타내어진다

271
00:22:05,110 --> 00:22:12,710
저들은 차례로, 녹색, 파란색, 그리고 빨간색으로 연결된 세 값을 가진다.

272
00:22:12,710 --> 00:22:17,270
>> 이제, 우리는 약을 조금 복구 생각의 종류 수 있습니다.

273
00:22:17,270 --> 00:22:20,130
미안 해요. 추리 소설에 대해 생각해보십시오.

274
00:22:20,130 --> 00:22:25,750
우리 단서 파일이 때 다음 우리가 원하는 것은 그것 픽셀의 픽셀에서 읽어

275
00:22:25,750 --> 00:22:33,860
우리가 읽을 수있는 형식으로 출력 할 수 있도록하고 어떻게 든 그 픽셀을 변경할 수 있습니다.

276
00:22:33,860 --> 00:22:41,020
그리고 그것을 출력하기 위해 verdict.bmp 파일에 픽셀이 픽셀을 쓸거야.

277
00:22:41,020 --> 00:22:45,120
그해야 할 많은 종류의 있습니다. 우리는 그렇게 알고 있습니다.

278
00:22:45,120 --> 00:22:49,860
그래서 우리가 한 것은 우리가 실제로 당신을 제공합니다 copy.c.

279
00:22:49,860 --> 00:22:57,610
어떤 copy.c이 수행하는 것은 단지 주어진 비트 맵 파일의 정확한 복사본을 만들어 다음을 출력합니다.

280
00:22:57,610 --> 00:23:01,900
그래서이 이미 당신을 위해 파일을 열 픽셀에서 픽셀로 읽

281
00:23:01,900 --> 00:23:04,510
다음 출력 파일에에 씁니다.

282
00:23:04,510 --> 00:23:07,080
>> 씨가를 살펴 보자.

283
00:23:13,390 --> 00:23:18,290
이것은 적절한 사용을 보장합니다

284
00:23:18,290 --> 00:23:22,640
여기에 파일 이름을 받고.

285
00:23:22,640 --> 00:23:29,940
이게 않는 것은 우리가 여기 infile에서의 통과했는지로 입력 파일을 설정 is

286
00:23:29,940 --> 00:23:34,750
이는 우리의 두번째 명령 줄 인수입니다.

287
00:23:34,750 --> 00:23:37,640
우리가 파일을 열 수 있는지 확인하기 위해 확인합니다.

288
00:23:38,960 --> 00:23:44,860
우리가 여기에서 새 outfile을 만들 수 있도록 확인합니다.

289
00:23:45,630 --> 00:23:53,270
그런 다음이 여기에 무엇을, 그냥 기본적으로 처음부터 비트 맵 파일에 읽기 시작합니다.

290
00:23:53,270 --> 00:23:56,700
시작은 우리가 알다시피, BITMAPFILEHEADER를 포함

291
00:23:56,700 --> 00:24:03,200
그래서 비트있는 시퀀스 직접 BITMAPFILEHEADER을 작성합니다.

292
00:24:03,200 --> 00:24:07,940
그래서 우리가 여기있는 것은 그 BITMAPFILEHEADER BF 말을합니다 -

293
00:24:07,940 --> 00:24:13,150
그건 형 BITMAPFILEHEADER의 새로운 변수 있어요 -

294
00:24:13,150 --> 00:24:22,560
우리가 포인터에서에서 읽어 BF 안에 넣어 것, 즉 우리 infile입니다.

295
00:24:22,560 --> 00:24:23,970
우리는 얼마나 읽습니까?

296
00:24:23,970 --> 00:24:32,160
우리는 전체 BITMAPFILEHEADER를 포함 할 필요가 얼마나 많은 바이트 읽어보십시오.

297
00:24:32,160 --> 00:24:34,660
마찬가지로, 그 정보를 헤더에 대해 우리가 할 일을 한거야.

298
00:24:34,660 --> 00:24:39,010
그래서 우리는, infile에서 우리의 파일을 함께 지속적으로

299
00:24:39,010 --> 00:24:44,360
우리는 이러한 비트와 바이트를 읽을, 우리는에 직접 연결해하고

300
00:24:44,360 --> 00:24:47,880
우리가 만드는하고있는 변수의 이러한 경우에.

301
00:24:49,370 --> 00:24:53,800
여기 우리가 비트 맵은 비트 맵인지 확인하고 있어요.

302
00:24:57,670 --> 00:25:01,030
>> 이제 우리는 오른쪽 outfile 있나요?

303
00:25:01,030 --> 00:25:04,420
우리가 그것을 만들 때 서 있도록, 그것은 기본적으로 비어 있습니다.

304
00:25:04,420 --> 00:25:07,710
그래서 우리는 기본적으로 처음부터 새로운 비트 맵을 만들 수 있습니다.

305
00:25:07,710 --> 00:25:12,280
우리가 할 일은 우리가 파일 헤더에 복사되었는지 확인해야 해

306
00:25:12,280 --> 00:25:16,850
불과 infile 같은 정보 헤더가 있습니다.

307
00:25:16,850 --> 00:25:22,850
와 BF가 변수입니다 기억 - 우리가 할 일은 우리가 쓸 수 있습니다

308
00:25:22,850 --> 00:25:29,300
유형 BITMAPFILEHEADER의, 우리가 할 것은 우리가 그 콘텐츠를 사용할 수 있습니다 있도록

309
00:25:29,300 --> 00:25:34,980
outfile로 작성할 수 있습니다.

310
00:25:36,550 --> 00:25:38,510
여기, 우리가 패딩 얘기를 기억

311
00:25:38,510 --> 00:25:47,820
우리가 가지고 픽셀의 양이 4의 배수인지 확인하는 것이 중요합니다 방법.

312
00:25:47,820 --> 00:25:52,790
이렇게하면 얼마나 패딩 계산 매우 유용 할 공식이에요

313
00:25:52,790 --> 00:25:57,670
파일의 폭 주어진.

314
00:25:57,670 --> 00:26:04,120
나는 너희들이 copy.c에 우리가 패딩을 계산하기위한 공식을 기억하고 싶습니다.

315
00:26:04,120 --> 00:26:07,970
알았어? 그래서 모두가 기억이. 좋아요.

316
00:26:07,970 --> 00:26:14,050
그럼 copy.c은 무엇을 다음은 scanlines의 전부를 반복합니다.

317
00:26:14,050 --> 00:26:23,730
그것은 첫째 행지나 다음되는지 모든 트리플을 저장

318
00:26:23,730 --> 00:26:26,920
다음 outfile에 기록합니다.

319
00:26:26,920 --> 00:26:33,120
그래서 여기에 우리는 한 번에 하나의 RGB 트리플을 읽고

320
00:26:33,120 --> 00:26:39,860
다음 outfile에 같은 트리플를 넣어.

321
00:26:41,120 --> 00:26:48,340
까다로운 부분은 패딩이 RGB 트리플하지 않습니다 것입니다

322
00:26:48,340 --> 00:26:55,200
그래서 우리는 RGB의 트리플의 패딩 금액을 읽을 수 없습니다.

323
00:26:55,200 --> 00:27:01,460
우리가해야 할 일은 실제로, 우리의 파일 위치 지시자를 이동의 커서를 이동하기

324
00:27:01,460 --> 00:27:06,840
우리가 다음 행에 있어요 있도록 모든 패딩 건너 뛰는 종류의 있습니다.

325
00:27:06,840 --> 00:27:12,990
그리고이 무엇을 복사하면 패딩을 추가 할 수 방법을 보여줍니다 것입니다.

326
00:27:12,990 --> 00:27:14,990
그래서 우리는, 우리가 필요로 얼마나 많은 패딩 계산 한

327
00:27:14,990 --> 00:27:18,220
그래서 우리는 0s의 패딩 번호가 필요합니다 것을 의미합니다.

328
00:27:18,220 --> 00:27:24,510
이게 않는 것은 우리 outfile에 0s의 패딩 번호를 놓고 루프를위한 것입니다.

329
00:27:24,510 --> 00:27:31,170
그리고 마지막으로, 당신은 두 파일을 닫습니다. 당신은 infile뿐만 아니라 outfile을 닫습니다.

330
00:27:31,170 --> 00:27:34,870
>> 그래서 그런 방법은 copy.c 작품

331
00:27:34,870 --> 00:27:37,430
그리고 그게 매우 유용 할 것 같네요.

332
00:27:39,720 --> 00:27:43,750
대신 실제로 직접 복사하고 붙여 넣기의

333
00:27:43,750 --> 00:27:46,800
또는, 그걸보고 당신이 원하는대로에서 입력

334
00:27:46,800 --> 00:27:49,440
당신은, 터미널에서이 명령을 실행 할 수도 있습니다

335
00:27:49,440 --> 00:27:54,520
새 파일이 생성됩니다 CP copy.c whodunit.c, whodunit.c,

336
00:27:54,520 --> 00:27:58,330
그 사본이 그렇듯 동일한 콘텐츠가 포함되어 있습니다.

337
00:27:58,330 --> 00:28:03,880
그럼 우리가 할 수있는 일을 프레임 워크로하는에 구축하고 편집 할 수있는 사용하고 있습니다

338
00:28:03,880 --> 00:28:06,900
우리의 추리 소설 파일.

339
00:28:08,500 --> 00:28:14,670
>> 이 분들은 우리 투 - 업무는 추리 소설을 위해 무엇을해야하지만, 어떤 copy.c합니까

340
00:28:14,670 --> 00:28:16,730
사실 우리에게 대부분을 담당하고 있습니다.

341
00:28:16,730 --> 00:28:21,900
그래서 우리가 다음 할 필요가 모든 필요에 따라 픽셀을 바꾸는 거죠

342
00:28:21,900 --> 00:28:25,920
실제로 파일을 읽을 수 있도록하고 있습니다.

343
00:28:25,920 --> 00:28:32,960
유형 RGBTRIPLE 주어진 변수 때문에, 트리플 주어진 픽셀에 대한 그 기억,

344
00:28:32,960 --> 00:28:35,990
당신은 파란색, 녹색, 붉은 색 값을 액세스 할 수 있습니다.

345
00:28:35,990 --> 00:28:38,670
그건 유용 거에요 당신이 그들을 액세스 할 수있는 경우 때문에,

346
00:28:38,670 --> 00:28:41,770
그 말은 당신이 또한 그들을 확인할 수 있다는 것을 의미

347
00:28:41,770 --> 00:28:45,430
그리고 그 말은 당신도 변경할 수 있다는 것을 의미합니다.

348
00:28:45,430 --> 00:28:49,430
>> 그래서 우리는 우리의 붉은 색 돋보기 예로 돌아 갔을 때,

349
00:28:49,430 --> 00:28:53,390
기본적으로 그건 우리에게 필터의 일종의 역할을했다.

350
00:28:53,390 --> 00:28:58,160
그래서 우리가 원하는 것은 우리가 들어오고있어 트리플 모든 필터링 싶은

351
00:28:58,160 --> 00:29:01,240
이 작업을 수행하는 방법에는 여러 가지가 있습니다.

352
00:29:01,240 --> 00:29:07,100
기본적으로, 당신은 당신이 원하는 필터의 어떤 유형의 수 있습니다.

353
00:29:07,100 --> 00:29:09,890
아마 당신은 모두 빨간 픽셀을 변경하려면

354
00:29:09,890 --> 00:29:13,570
어쩌면 당신은 다른 색상에 다른 색상 픽셀을 변경하고 싶습니다.

355
00:29:13,570 --> 00:29:15,400
그게 당신에게 달려 있습니다.

356
00:29:15,400 --> 00:29:19,580
당신은 픽셀이 무슨 색 확인할 수 있습니다 기억

357
00:29:19,580 --> 00:29:23,000
당신이 힘든로 그리고 당신은 또한을 변경할 수 있습니다.

358
00:29:24,410 --> 00:29:26,420
>> 좋아요. 그래서 그런 추리 소설입니다.

359
00:29:26,420 --> 00:29:32,760
일단 추리 소설을 실행, 당신은 범죄의 범인이 누구인지 알 수 있습니다.

360
00:29:32,760 --> 00:29:35,540
>> 이제 우리는 크기 조정 갈거야.

361
00:29:35,540 --> 00:29:37,990
우리는 여전히 비트 맵 처리 할거야.

362
00:29:37,990 --> 00:29:40,750
우리가 할 수있는 일은 우리가 입력 비트 맵을 할거야

363
00:29:40,750 --> 00:29:45,890
그리고 우리는 번호를 전달하고 outfile 비트 맵을받을거야

364
00:29:45,890 --> 00:29:51,380
그는 기본적으로 N으로 확장 우리 infile 어디.

365
00:29:54,670 --> 00:30:01,450
내 파일이 하나의 픽셀 큽니다 말해.

366
00:30:01,450 --> 00:30:09,100
제 n은 3 세, 스케일링했다하면, 그럼 난, 시간의 픽셀 N 번호를 반복 것

367
00:30:09,100 --> 00:30:14,410
그래서 3 번하고도뿐만 아니라 3 번 내려 확장.

368
00:30:14,410 --> 00:30:17,840
그래서 당신은 내가 아니라 수평 수직으로 잘 축소있어 참조하십시오.

369
00:30:17,840 --> 00:30:19,680
>> 그리고 여기에는 예입니다.

370
00:30:19,680 --> 00:30:27,590
당신은 N = 2를 사용하는 경우 첫 번째 파란색 픽셀은 두 번이 반복 것을 볼

371
00:30:27,590 --> 00:30:30,930
가로로 두 배 수직뿐만 아니라.

372
00:30:30,930 --> 00:30:38,040
그리고 그 말은 계속하고, 그렇게 두하여 원본 이미지의 직접적인 스케일링을 갖추고 있습니다.

373
00:30:40,920 --> 00:30:47,600
>> 우리가이에 대한 세부 의사를 만약에 그렇다면, 우리는 파일을 엽니 다하고 싶습니다.

374
00:30:47,600 --> 00:30:49,880
그리고, 우리가 돌​​아 가면 걸 알면서

375
00:30:49,880 --> 00:30:54,540
우리는 outfile의 너비가 infile에 대한 폭 다를 것입니다 것을 볼 수 있습니다.

376
00:30:54,540 --> 00:30:56,130
그게 무슨 뜻 이죠?

377
00:30:56,130 --> 00:31:01,230
그건 우리의 헤더 정보가 변경되는 것을 의미합니다.

378
00:31:01,230 --> 00:31:03,790
그리고 우리가하고 싶은 것하면 헤더 정보를 업데이트입니다

379
00:31:03,790 --> 00:31:11,820
당신이 copy.c 프레임 워크에서 작동하는 경우 우리가 파일에 읽을 때 걸 알면서,

380
00:31:11,820 --> 00:31:17,570
우리는 이미 크기가 뭔지 나타냅니다 그 등 변수가 있습니다.

381
00:31:17,570 --> 00:31:24,060
그럼 일단 당신이해야 할 수도 있습니다하는 것은 그 특정 변수를 변경할 수 있으며, 처리해야합니다.

382
00:31:24,060 --> 00:31:29,380
당신이 구조체가있을 경우 해당 내의 변수에 액세스하는 방법, 기억하십시오.

383
00:31:29,380 --> 00:31:32,080
당신이 바로 도트 연산자를 사용할 수 있습니까?

384
00:31:32,080 --> 00:31:36,420
그를 사용하여 그래서, 당신은 헤더 정보를 변경해야합니다 알고.

385
00:31:36,480 --> 00:31:41,030
그래서 여기 그냥 파일에 변경 될 예정되는 실제 요소의 목록입니다.

386
00:31:41,030 --> 00:31:45,180
파일 크기는 이미지뿐만 아니라 폭과 높이를 변경 할 예정이다.

387
00:31:45,180 --> 00:31:50,080
그럼, 비트 맵의​​지도로 돌아 간다

388
00:31:50,080 --> 00:31:57,730
이 파일 헤더 또는 정보를 포함하는 정보 헤더의 여부를 살펴

389
00:31:57,730 --> 00:32:00,920
그리고 필요에 따라 변경합니다.

390
00:32:05,010 --> 00:32:12,470
다시 말하지만, CP copy.c resize.c 말.

391
00:32:12,470 --> 00:32:19,270
그래서 resize.c 지금 사본 안에 포함 전부를 포함 것을 의미합니다

392
00:32:19,270 --> 00:32:24,490
사본은 우리에게 픽셀 각 scanline 픽셀에 읽을 수있는 방법을 제공하기 때문에.

393
00:32:24,490 --> 00:32:29,860
지금 제외하고, 대신에 우리가 추리 소설에했던 것처럼 값을 변경,

394
00:32:29,860 --> 00:32:37,980
우리가 원하는 것은 우리가 여러 픽셀로 작성 싶은

395
00:32:37,980 --> 00:32:43,580
오래 우리의 n은 1보다 큰이기 때문입니다.

396
00:32:43,580 --> 00:32:47,110
>> 그런 다음 우리가 원하는 것은 우리가 N으로 수평을 치고 싶은

397
00:32:47,110 --> 00:32:50,490
뿐만 아니라 N에 수직을 움직.

398
00:32:50,490 --> 00:32:52,710
우리가 어떻게이 작업을 수행 할 수?

399
00:32:52,710 --> 00:32:56,890
귀하의 n은 2 말과이 주어진 infile 있습니다.

400
00:32:56,890 --> 00:32:58,730
커서는 첫 번째에서 시작 것입니다

401
00:32:58,730 --> 00:33:03,530
n은 2면 당신이하길 원하는 것은, 당신은 사람들의 2 인쇄 할.

402
00:33:03,530 --> 00:33:05,490
그럼 당신은 사람들의 2 인쇄 할 수 있습니다.

403
00:33:05,490 --> 00:33:10,830
그런 다음 커서, 빨간 하나 인 다음 픽셀로 이동 것입니다

404
00:33:10,830 --> 00:33:18,400
그리고이 전에 한 일에 그것을를 추가, 그 붉은 색의 2를 인쇄 할거야.

405
00:33:18,400 --> 00:33:26,280
그런 다음 커서는 다음 픽셀로 이동 있으며 그 중 2 유도합니다.

406
00:33:26,280 --> 00:33:37,180
여기서이가 무엇을 copy.c 프레임 워크로 돌아 보면

407
00:33:37,180 --> 00:33:42,830
이 RGB 트리플, 트리플라는 새로운 변수의 새 인스턴스를 생성합니다.

408
00:33:42,830 --> 00:33:50,500
그리고 그건으로 읽고 여기 때, 그것은 infile 한 RGBTRIPLE에서 읽

409
00:33:50,500 --> 00:33:53,470
그 트리플 변수의 내부를 저장합니다.

410
00:33:53,470 --> 00:33:57,590
그래서 당신은 실제로 특정 픽셀을 나타내는 변수가 있습니다.

411
00:33:57,590 --> 00:34:05,290
그럼 당신은 당신이 할 수도 있습니다 무엇을 쓸 때 루프에 fwrite 문을 싸는 is

412
00:34:05,290 --> 00:34:11,080
그 필요에 따라 몇 번으로 outfile에 기록합니다.

413
00:34:17,449 --> 00:34:20,100
그 정도면 간단합니다.

414
00:34:20,200 --> 00:34:27,590
그냥 기본적으로 쓰기 작업 N 수평 확장 할 횟수를 반복합니다.

415
00:34:27,590 --> 00:34:32,969
>> 하지만 우리는 우리의 패딩이 변경되는 것을 기억해야합니다.

416
00:34:47,350 --> 00:34:53,020
이전, 우리는 길이 3 걸 가지고 말한다.

417
00:34:53,020 --> 00:35:00,130
그럼 우리가 얼마나 많은 패딩에 추가까요? 하나 더 4의 여러 확인합니다.

418
00:35:00,130 --> 00:35:10,480
그러나 우리는 N = 2에 의해 특정 이미지를 축소하고 있다고 가정 해 보겠습니다.

419
00:35:10,480 --> 00:35:16,300
그래서 얼마나 많은 블루 픽셀 우리는 마지막 겠어? 우리는 6을 얻을 수 있습니다.

420
00:35:16,300 --> 00:35:21,470
1, 2, 3, 4, 5, 6. 괜찮아요.

421
00:35:21,470 --> 00:35:26,580
6은 4의 배수가 아닙니다. 4 가장 가까운 여러 무엇입니까? 그 8 할거야​​.

422
00:35:26,580 --> 00:35:33,200
그래서 우리는 실제로이 패딩의 2 문자를 할 겁니다.

423
00:35:33,200 --> 00:35:38,720
>> 우리가 패딩을 계산하는 공식이있는 경우 누구나 기억 하는가

424
00:35:38,720 --> 00:35:41,350
, 어디으로?

425
00:35:41,350 --> 00:35:45,160
[안 들리게 학생 응답] >> 네, copy.c. 맞아.

426
00:35:45,160 --> 00:35:49,800
당신은 얼마나 패딩 계산 copy.c의 수식이 있습니다

427
00:35:49,800 --> 00:35:53,810
비트 맵 이미지의 특정 폭을 제공.

428
00:35:53,810 --> 00:36:02,950
당신은 패딩의 일정 금액에 추가해야 할 때 그래서 무슨 일이 유용 할 수

429
00:36:02,950 --> 00:36:06,160
실제로 당신이 추가 할 필요가 얼마나 많은 패딩 파악합니다.

430
00:36:10,820 --> 00:36:15,850
그러나 참고하지만, 당신이 적당한 크기를 사용하고 있는지 확인하려는 것입니다.

431
00:36:15,850 --> 00:36:21,410
당신은 기본적으로 두 비트 맵 이미지를 처리​​ 할 것 때문에 조심.

432
00:36:21,410 --> 00:36:23,410
당신이 바로 하나를 사용하고 있는지 확인하고 싶습니다.

433
00:36:23,410 --> 00:36:26,820
당신은 outfile에 대한 여백을 계산할 때, 당신은 outfile의 폭을 사용하려면

434
00:36:26,820 --> 00:36:29,860
아니라 이전의 너비.

435
00:36:29,860 --> 00:36:37,240
>> 좋아요. 는 그런 수평으로 전체 비트 맵 이미지를 스트레칭을 담당한다.

436
00:36:37,240 --> 00:36:41,290
우리가 할 일은 원하는 실제로 수직으로 잘 펴고있다.

437
00:36:41,290 --> 00:36:48,760
이것은 우리가 행을 복사 완료되면 때문에 조금 까다 될 것입니다

438
00:36:48,760 --> 00:36:51,580
그 행을 쓰기, 우리 커서는 마지막에 될 것입니다.

439
00:36:51,580 --> 00:36:56,210
다시 읽고 자한다면 다음 그냥 다음 줄에 읽을거야.

440
00:36:56,210 --> 00:37:03,660
그래서 우리가 원하는 것은 다시 그 행을 복사하는 몇 가지 방법을 찾을 kind입니다

441
00:37:03,660 --> 00:37:12,500
또는 행을 복용 한 후 다시를 바꿀 뿐이예요.

442
00:37:14,380 --> 00:37:17,940
내가 친절 중 - 언급으로이 작업을 수행하는 여러 가지 방법이 있습니다.

443
00:37:17,940 --> 00:37:23,040
당신이 어떻게하고 특정 scanline을 읽고로서 당신이 할 수있는 것은

444
00:37:23,040 --> 00:37:28,560
필요한대로 변경 한 다음 저장소의 종류 배열에서 해당 픽셀의 모든.

445
00:37:28,560 --> 00:37:36,350
나중에 당신에게 당신이 다시 배열을 인쇄해야합니다 알고,

446
00:37:36,350 --> 00:37:39,830
그래서 당신은 그렇게 해당 배열을 사용할 수 있습니다.

447
00:37:39,830 --> 00:37:44,500
할 수있는 또 다른 방법은, 당신이 하나의 행을 복사 수있는 전부입니다

448
00:37:44,500 --> 00:37:47,950
당신은 다시 복사 할 필요가 있다고 이해, 그래서 사실은, 커서를 이동

449
00:37:47,950 --> 00:37:50,950
그리고 그 방법 fseek를 사용 거에요.

450
00:37:50,950 --> 00:37:56,410
다시 커서 모든 방법을 이동 한 다음 다시 복사 과정을 반복 수 있습니다.

451
00:37:56,410 --> 00:38:03,960
>> 우리 스케일링 번호가 N 인 경우 그럼, 몇 번이나 돌아 가야 할 것입니다

452
00:38:03,960 --> 00:38:10,500
그리고 라인을 재 작성? >> [학생] N - 1. >> 네, 좋아요. N - 1.

453
00:38:10,500 --> 00:38:14,390
우리는 한 번 이미 그렇게 한 다음에 우리가 돌​​아갈 과정을 반복 할 것

454
00:38:14,390 --> 00:38:17,460
N - 시간의 1 금액입니다.

455
00:38:22,730 --> 00:38:25,860
좋아요. 그래서 당신은 크기 조정 기능을 갖추고 있습니다.

456
00:38:25,860 --> 00:38:34,360
>> 이제 우리는 정말 재미 부분 복구 나만의 즐겨 찾기 pset에받을 수 있습니다.

457
00:38:34,360 --> 00:38:39,580
대신 비트 맵으로,이 시간 우리는 JPEG 파일로 다루고 있습니다.

458
00:38:39,580 --> 00:38:43,370
우리는 실제로 JPEG 파일의 파일을 제공하지하면,

459
00:38:43,370 --> 00:38:46,600
우리는 기본적으로 원시 메모리 카드 형식을 제공하고 있습니다.

460
00:38:46,600 --> 00:38:51,790
그리고 이건 시작에 정보와 쓰레기 값의 비트가 포함되어 있습니다

461
00:38:51,790 --> 00:38:57,240
다음은 시작하며 JPEG 파일의 무리가 있습니다.

462
00:38:57,240 --> 00:39:03,430
우리가 사진을 삭제 한 곳 그러나, 우리는 카드를 건네하고,

463
00:39:03,430 --> 00:39:08,300
사진이 카드 내에 위치 본질적으로, 우리는 잊어 버렸습니다.

464
00:39:08,300 --> 00:39:12,770
그래서 복구 우리의 작업은이 카드 형식을 통해 이동하는 것입니다

465
00:39:12,770 --> 00:39:16,500
다시 그 사진을 찾으십시오.

466
00:39:16,500 --> 00:39:23,990
>> 다행히도, JPEG 파일 및 카드 파일의 구조는 조금 도움이됩니다.

467
00:39:23,990 --> 00:39:28,850
이렇게 특정 형식으로하지 않는다면 그것은 확실히 약간 난이도가되었습니다 수 있습니다.

468
00:39:28,850 --> 00:39:40,160
모든 JPEG 파일은 실제로 위에서 열거 한 두 가지 시퀀스로 시작.

469
00:39:40,160 --> 00:39:42,970
기본적으로, 새 JPEG 파일을있을 때마다

470
00:39:42,970 --> 00:39:52,720
이 순서 ffd8 ffe0 또는 다른 하나 ffd8 ffe1 중 하나와 함께 시작합니다.

471
00:39:52,720 --> 00:39:59,530
알아야 할 또 다른 유용한 점은 JPEG 파일이 contiguously 저장됩니다 것입니다.

472
00:39:59,530 --> 00:40:03,380
어느 JPEG 파일을 종료 할 때마다, 다른 하나가 시작됩니다.

473
00:40:03,380 --> 00:40:07,070
그래서 값에 중간 모든 종류의가 없습니다.

474
00:40:07,070 --> 00:40:15,510
이미 JPEG를 읽어 봤는데 경우 일단, JPEG의 시작을 누르

475
00:40:15,510 --> 00:40:21,800
당신이 이전과 다음의 시작의 끝을 턴 알아요.

476
00:40:21,800 --> 00:40:25,890
>> 이 시각화의 종류에, 내가 설계도했다.

477
00:40:25,890 --> 00:40:36,910
JPEG 파일에 대한 또 다른 한가지는, 우리가 한 번에 512 바이트의 시퀀스에서 내용을 읽을 수 있다는 것입니다

478
00:40:36,910 --> 00:40:39,380
마찬가지로 카드의 시작과.

479
00:40:39,380 --> 00:40:43,370
우리는 형편 때문에 모든 단일 바이트를 확인 할 필요가 없습니다.

480
00:40:43,370 --> 00:40:48,200
대신에, 우리가 할 수있는 것은 실제로 한 번에 512 바이트에서 읽을 수 있습니다

481
00:40:48,200 --> 00:40:54,700
다음, 대신 그 작은 조각에서 그 사이에 검사의,

482
00:40:54,700 --> 00:40:58,640
우리는 512 바이트의 시작을 확인할 수 있습니다.

483
00:40:58,640 --> 00:41:02,570
기본적으로,이 그림에, 어떻게 당신이 보는 것은 카드의 시작 부분에

484
00:41:02,570 --> 00:41:08,700
당신은 실제 JPEG 파일 자체에 아주 관련이없는 값을 가진다.

485
00:41:08,700 --> 00:41:15,830
하지만 내가 가진 것은 JPEG에 대한 두 시작 시퀀스 중 하나를 표시하는 별이다.

486
00:41:15,830 --> 00:41:19,910
그럼 당신은 별을 볼 때마다, 당신은 JPEG 파일을 가지고 있다는 것을 알고.

487
00:41:19,910 --> 00:41:25,030
그리고 모든 JPEG 파일은 512 바이트의 일부 여러 될 것입니다

488
00:41:25,030 --> 00:41:27,880
하지만 같은 여러 필요는 없습니다.

489
00:41:27,880 --> 00:41:32,050
당신이 다른 별을 친다면 당신은 다른 JPEG를 누르 걸 알고하는 방법입니다

490
00:41:32,050 --> 00:41:39,090
바이트의 또 다른 시작 순서.

491
00:41:39,090 --> 00:41:43,330
그런 다음 당신이 여기있는 당신이 스타를 누르까지, 계속 빨간색 JPEG 파일이 있습니다

492
00:41:43,330 --> 00:41:45,150
어떤은 새로운 색상으로 표시됩니다.

493
00:41:45,150 --> 00:41:48,510
계속 한 다음 다른 스타를 누르, 당신은 다른 JPEG를 누르

494
00:41:48,510 --> 00:41:50,590
당신이 끝날 때까지 모든 방법을 계속합니다.

495
00:41:50,590 --> 00:41:53,180
당신이 여기 마지막 사진에있는 분홍색 사람이야.

496
00:41:53,180 --> 00:41:58,220
이 파일 문자의 끝을 누르 때까지 끝으로 이동합니다.

497
00:41:58,220 --> 00:42:00,820
이건 정말 유용 할 것입니다.

498
00:42:00,820 --> 00:42:03,170
>> 여기에 몇 가지 주요 테이크 아웃 :

499
00:42:03,170 --> 00:42:06,670
카드 파일은 JPEG로 시작하지 않습니다

500
00:42:06,670 --> 00:42:13,350
JPEG이 시작되면 그러나, JPEG 파일의 모든 측면에 의해 서로 편을 저장됩니다.

501
00:42:17,520 --> 00:42:20,420
>> 복구에 대한 일부 의사.

502
00:42:20,420 --> 00:42:22,570
첫째, 우리는 우리 카드 파일을 열거야

503
00:42:22,570 --> 00:42:27,500
그게 우리 파일 I / O 함수를 사용하여 할거야.

504
00:42:27,500 --> 00:42:32,430
우리는 파일의 끝에 도달 할 때까지 다음과 같은 과정을 반복거야.

505
00:42:32,430 --> 00:42:36,450
우리는 한 번에 512 바이트를 읽을거야.

506
00:42:36,450 --> 00:42:39,180
그리고 내가 여기서 말은, 우리가 버퍼에 저장하는 것입니다

507
00:42:39,180 --> 00:42:46,230
우리가 그들과 어떻게 정확히 알 때까지 기본적으로 이러한 512 바이트를 가져.

508
00:42:46,230 --> 00:42:50,300
그런 다음 우리가 원하는 것은 우리가 스타 여부를 누르 여부를 확인해야합니다.

509
00:42:50,300 --> 00:42:57,960
우리가 시작 시퀀스 중 하나를 누르 경우 우리가 스타를 누르 한 경우

510
00:42:57,960 --> 00:42:59,980
그리고 우리는 새로운 JPEG 파일을 턴 알아요.

511
00:42:59,980 --> 00:43:08,860
그게 우리가 원하는 것 우리는 우리 pset4 디렉토리에 새 파일을 만들 거예요

512
00:43:08,860 --> 00:43:14,480
그 파일을 계속합니다.

513
00:43:14,480 --> 00:43:18,220
뿐만 아니라, 우리는 이미 전에 JPEG 한 경우

514
00:43:18,220 --> 00:43:25,620
그러면 우리는, 그 파일을 종료하고 pset4 폴더에 보내려

515
00:43:25,620 --> 00:43:29,780
우리가 파일을 저장해야합니다 장소는 우리가 JPEG 파일을 종료 한 지정하지 않은 경우 때문에,

516
00:43:29,780 --> 00:43:37,290
그런 다음에 우리가 기본적으로 보류 금액을해야합니다. JPEG 파일의 끝하지 않습니다.

517
00:43:37,290 --> 00:43:40,840
그래서 우리는, 그렇게 우리가 JPEG 파일에 읽기 및 쓰기 할 때 있는지 확인하려면

518
00:43:40,840 --> 00:43:46,590
우리는 구체적으로 다음 하나를 열려면 해당을 닫습니다 싶습니다.

519
00:43:46,590 --> 00:43:48,430
우리는 몇 가지를 확인하는 것이 좋습니다.

520
00:43:48,430 --> 00:43:52,880
우리는 우리가 버퍼로 새 JPEG의 시작에와 있는지 확인하려면

521
00:43:52,880 --> 00:43:56,780
또한 우리는 이미 전에 JPEG를 발견 한 경우

522
00:43:56,780 --> 00:44:03,930
그 때문에 약간 당신의 프로세스가 변경됩니다.

523
00:44:03,930 --> 00:44:07,880
당신은 모든 방법으로 이동 한 후에 그래서 당신이 파일의 끝을 누르

524
00:44:07,880 --> 00:44:11,570
그런 다음 당신이해야 할 것하면 현재 열려있는 모든 파일을 닫아야 할 것입니다.

525
00:44:11,570 --> 00:44:14,100
그건 아마, 당신이 가지고있는 마지막 JPEG 파일이어야합니다

526
00:44:14,100 --> 00:44:18,930
뿐만 아니라 카드 파일과 당신이 상대 한.

527
00:44:21,940 --> 00:44:28,670
>> 우리가 해결해야 할 마지막 장애물은 실제로 JPEG 파일을 만드는 방법입니다

528
00:44:28,670 --> 00:44:31,950
실제로 폴더에 밀어하는 방법.

529
00:44:33,650 --> 00:44:39,850
pset, 당신이 발견 한 모든 JPEG는 다음과 같은 형식이어야합니다

530
00:44:39,850 --> 00:44:43,990
어디서 수 있습니다. JPG.

531
00:44:43,990 --> 00:44:50,750
수는, 그건 0하더라도 우리는 000.jpg 전화하십시오.

532
00:44:50,750 --> 00:44:55,730
당신은 당신의 프로그램에 JPEG를 찾을 때마다

533
00:44:55,730 --> 00:44:58,040
당신은이 발견하고 순서에 이름을 지정하려는거야.

534
00:44:58,040 --> 00:44:59,700
이것은 무엇을 의미할까요?

535
00:44:59,700 --> 00:45:03,530
우리는 우리가 발견 한 몇를 추적 가지 필요

536
00:45:03,530 --> 00:45:08,680
각 JPEG의 수는 있어야하는.

537
00:45:08,680 --> 00:45:13,800
여기 우리는 sprintf 함수를 이용거야.

538
00:45:13,800 --> 00:45:17,480
, printf와 마찬가지로 어느 터미널에 지문이 단지 종류의 값 중에

539
00:45:17,480 --> 00:45:23,910
sprintf 폴더로 파일을 출력합니다.

540
00:45:23,910 --> 00:45:30,870
그리고이 거기 문자열 다음에 뭐 제가 sprintf, 제목이 있다면 어떻게, 그리고 것입니다

541
00:45:30,870 --> 00:45:36,660
이 2.jpg를 인쇄합니다.

542
00:45:36,660 --> 00:45:41,020
, 내가 제대로 내 파일을 종료 한 가정

543
00:45:41,020 --> 00:45:47,210
그건 내가 알아 쓰는했던 한 파일을 포함합니다.

544
00:45:47,210 --> 00:45:50,320
그러나 한 가지입니다 제가 여기 가지고있는 코드

545
00:45:50,320 --> 00:45:53,360
꽤 pset에 필요한 것을 만족하지 않습니다.

546
00:45:53,360 --> 00:46:02,410
pset 두 번째 JPEG 파일 대신 2 002 이름되어야합니다.

547
00:46:02,410 --> 00:46:09,160
그래서 이름을 인쇄 할 때 그럼 당신은 약간 자리 표시 자를 변경 할 수 있습니다.

548
00:46:09,160 --> 00:46:18,140
>> 사람이 우리가 뭔가를 인쇄 할 때 불필요한 공백을 허용하는 방법 기억 하는가?

549
00:46:18,140 --> 00:46:22,530
그래. >> [학생] 당신은 백분율 기호와 2 사이에 3 넣어. >> 네, 좋아요.

550
00:46:22,530 --> 00:46:25,610
우리가 3 공간을 원하기 때문에이 경우 3을 올려 놓을 게요.

551
00:46:25,610 --> 00:46:32,590
%의 차원은 아마 당신에게 002.jpg 대신 2를 제공하게됩니다.

552
00:46:32,590 --> 00:46:40,120
sprintf 함수에 첫 번째 인수는, 실제로 문자 배열입니다

553
00:46:40,120 --> 00:46:42,520
있는 우리는 이전에 문자열로 알고 있었다.

554
00:46:42,520 --> 00:46:50,700
이러한 의지, 임시 저장처럼 종류, 그냥 결과 문자열을 저장합니다.

555
00:46:50,700 --> 00:46:54,950
당신은 정말이 처리되지 않습니다하지만, 당신이 그걸를 포함해야합니다.

556
00:46:54,950 --> 00:47:00,710
>> 모든 파일 이름 세 글자를 차지 번호를 가지고 알고,

557
00:47:00,710 --> 00:47:06,770
다음. JPG,이 배열은 얼마나 오래해야하나요?

558
00:47:09,070 --> 00:47:14,310
번호를 던져. 이름으로 제목에 몇 글자?

559
00:47:18,090 --> 00:47:26,320
따라서 세 해시 태그, 기간, JPG가 있습니다. >> [학생] 7. >> 7. 전혀 아닙니다.

560
00:47:26,320 --> 00:47:32,000
우리는뿐만 아니라 null이 종결을 할 수 있도록 원하기 때문에 우리는 8 할거야​​.

561
00:47:45,340 --> 00:47:49,730
>> 마지막으로, 단지, 당신은 복구를 위해 일을 할 거라고 과정을 그리는

562
00:47:49,730 --> 00:47:55,420
당신은 몇 가지 시작 정보가 있습니다.

563
00:47:55,420 --> 00:48:02,460
당신은 JPEG 파일의 시작을 찾을 때까지 계속

564
00:48:02,460 --> 00:48:07,900
그 두 시작 시퀀스 중 하나가 될 수 있습니다.

565
00:48:07,900 --> 00:48:12,510
당신은 책을 읽고 계속. 여기에 모든 슬래시는 512 바이트를 나타냅니다.

566
00:48:12,510 --> 00:48:22,630
당신은 다른 시작 순서가 발생할 때까지 읽기 계속 읽기 계속.

567
00:48:22,630 --> 00:48:29,790
일단, 현재 JPEG을 종료하는이 -이 경우, 그것은 빨간색 하나,

568
00:48:29,790 --> 00:48:31,030
그럼 당신은을 종료하고 싶습니다.

569
00:48:31,030 --> 00:48:35,540
당신은 당신의 pset4 폴더에 그 sprintf 이름으로 원하는

570
00:48:35,540 --> 00:48:41,580
다음은 새로운 JPEG를 연 다음 독서을 계속하고 싶어

571
00:48:41,580 --> 00:48:46,370
당신은 다음에 발생할 때까지.

572
00:48:46,370 --> 00:48:49,040
읽기 계속 읽기 계속

573
00:48:49,040 --> 00:48:56,290
그리고 마지막으로, 결국, 당신은 파일의 끝에 도달 할거야

574
00:48:56,290 --> 00:49:00,360
그리고 당신은 당신이 작업하는 동안 가장 마지막에 JPEG를 닫 할 것

575
00:49:00,360 --> 00:49:08,380
sprintf 당신의 pset4 폴더에 다음이라도 한 사진을 모두 볼 것.

576
00:49:08,380 --> 00:49:12,050
그 사진은 실제로 CS50 직원의 사진입니다

577
00:49:12,050 --> 00:49:16,430
pset의 보너스 재미있는 부분이 만들었다는 등이 있습니다

578
00:49:16,430 --> 00:49:26,310
당신이 사진에서 TFS를 찾기 위해 섹션에 경쟁하는 것입니다

579
00:49:26,310 --> 00:49:34,610
그들과 사진을 찍어은 pset를 한 것을 증명하는

580
00:49:34,610 --> 00:49:37,030
그리고 그래서 당신은 직원이 사진에 확인할 수 있습니다.

581
00:49:37,030 --> 00:49:41,510
그럼 당신은 직원과 사진을 찍고있어. 때때로 당신이 그들을 심판해야합니다.

582
00:49:41,510 --> 00:49:44,680
아마도 그들 중 일부는 당신에게서 도망 할 것입니다.

583
00:49:44,680 --> 00:49:47,320
당신은 그들과 함께 사진을 찍고있어.

584
00:49:47,320 --> 00:49:51,190
이 진행 중입니다. pset이 때문입니다 때 인해 아닙니다.

585
00:49:51,190 --> 00:49:53,340
마감 사양에 발표 될 예정입니다.

586
00:49:53,340 --> 00:49:58,060
그런 다음 함께 섹션, 이때 둘 중 빠른 날짜 부분이 가장 사진을 찍을 수

587
00:49:58,060 --> 00:50:04,430
가장 임직원과 상당히 멋진 상을 받게됩니다.

588
00:50:04,430 --> 00:50:08,890
얻을 수 인센티브의 일종 이죠 귀하의 pset4는 가능한 빨리 완료

589
00:50:08,890 --> 00:50:10,820
다음 사업 이야기를 시작하자 수 있기 때문에

590
00:50:10,820 --> 00:50:14,570
모든 다른 CS50 직원 사냥.

591
00:50:14,570 --> 00:50:17,500
필수 아니 잖아,하지만 일단 당신이 사진을 얻을

592
00:50:17,500 --> 00:50:20,310
다음은 pset4이 완료됩니다.

593
00:50:20,310 --> 00:50:23,970
>> 그리고 난 너무 주셔서 감사 연습 4 먹었어요.

594
00:50:23,970 --> 00:50:29,330
과학 수사대와 행운을 빕니다. [박수]

595
00:50:29,330 --> 00:50:31,000
[CS50.TV]