1
00:00:00,000 --> 00:00:02,700
[Powered by Google Translate] [Walkthrough - సమస్య సెట్ 4]

2
00:00:02,700 --> 00:00:05,000
[Zamyla చాన్ - హార్వర్డ్ యూనివర్శిటీ]

3
00:00:05,000 --> 00:00:07,340
[ఈ CS50 ఉంది. - CS50.TV]

4
00:00:08,210 --> 00:00:11,670
అన్ని కుడి. హలో, ప్రతి ఒక్కరూ, మరియు Walkthrough 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
మేము ఈ కోర్సు యొక్క midpoint వద్ద చేయబోతున్నారు.

15
00:00:45,230 --> 00:00:50,070
Quiz 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
మరియు మేము కొన్ని నిజంగా సరదాగా stuff పొందడానికి వెళుతున్న.

19
00:01:00,760 --> 00:01:07,070
>> కాబట్టి ఈ pset కోసం మా పరికరాలపెట్టె, మళ్ళీ, బదులుగా సుడో yum-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
>> నేను ముందే చెప్పాను, కావున అప్పుడు, మేము బిట్ మ్యాప్ చిత్రాలన్నీ అలాగే JPEGs వ్యవహరించే ఉంటాయి.

36
00:02:09,030 --> 00:02:13,170
కాబట్టి నిజంగా, ఆ ఫైళ్ళను నిర్వహిస్తారు ఎలా నిర్మాణం understanding

37
00:02:13,170 --> 00:02:16,170
మేము నిజంగా structs లోకి 0 సె మరియు 1s అనువదించు ఎలా

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 మీరు ఒక Bitmap ఫైల్ ఇచ్చిన చేస్తున్న దీనిలో, హూడన్ఇట్ ఉంది

44
00:02:42,520 --> 00:02:45,630
అన్ని పైగా ఎర్రని చుక్కలు వంటి రకమైన కనిపిస్తోంది.

45
00:02:45,630 --> 00:02:52,180
మరియు తర్వాత ప్రధానంగా మేము చేయబోతున్నామని ఈ ఫైలు తీసుకొని కొద్దిగా ఇది సవరణ

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 సమయంలో bit ఆ లోకి తీసుకెళ్తుంది.

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
మొదటి మీరు మీరు చదువుతున్న ఆ బైట్లు కలిగిన struct కు పాయింటర్ ఉన్నాయి.

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
నేను కుక్క struct కలిగి మరియు అందువల్ల నేను ఒక సమయంలో రెండు కుక్కలు చదవండి అనుకుందాం.

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
>> కాబట్టి హూడన్ఇట్ లో, మీరు స్లయిడ్ ఈ Red ఒక సమానమైన Bitmap ఫైల్ అప్పగించారు చేస్తున్నారు,

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
మీరు ఒక Red సినిమా ఒక భూతద్దం ఉంటుంది. ఎవరైనా? అవును.

139
00:09:48,510 --> 00:09:52,770
కాబట్టి మీరు ఈ చేతి ఏదో ఉంటుంది, మీరు ఒక భూతద్దం ఉంటుంది

140
00:09:52,770 --> 00:09:58,130
దాని పై Red సినిమా, మీరు, చిత్రం పైగా ఉంచుతాడు

141
00:09:58,130 --> 00:10:03,410
మరియు మీరు సందేశాన్ని అందులో దాగి చూడండి చేయగలదు.

142
00:10:03,410 --> 00:10:07,080
మేము Red చిత్రం భూతద్దం లేదు, కాబట్టి మేము బదులుగా రకం మా స్వంత సృష్టించడానికి యొక్క చూడాలని

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
మేము తర్వాత padding వెళ్ళాలని, మేము చూస్తారు ఎందుకు చిత్రం యొక్క పరిమాణం

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
ఒక struct లో టూకీగా చెప్పు ఉంది.

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
ఈ హెక్సాడెసిమల్ విలువలు.

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
మీరు మైక్రోసాఫ్ట్ పెయింట్ లో ప్లే, ఉదాహరణకు, మీరు అలాంటిదే చేస్తాయి

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 యొక్క ఉంటాయి, మొదటి వైట్ పిక్సెళ్ళు కలిగి, మరియు అప్పుడు మేము Red పిక్సెళ్ళు కలిగి

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
కానీ మీరు చిత్రం నాలుగు బైట్లు ఒక బహుళ తో నిండి ఉంటుంది నిర్ధారించుకోండి ఉంటుంది.

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
కాబట్టి అప్పుడు మనం padding కాల్ చేస్తున్నారు, ఇది ఏదో లో పేర్కొన్నారు.

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
బిట్మ్యాప్ చిత్రాల పని విధంగా మేము ఒక 8 అవసరం ఉంది.

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
కాబట్టి అప్పుడు మేము వాటిని padding కేవలం ఒక బిట్ లో చేర్చండి ఉంది

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 లేదా ఒక squiggly లైన్ వంటి పాడింగ్, సూచించిన

213
00:16:47,310 --> 00:16:53,880
కానీ వాస్తవ బిట్మ్యాప్ చిత్రాల లో padding ఒక హెక్సాడెసిమల్ 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
నేను 54TH బైట్ వద్ద మొదలు వెళుతున్న చెప్పారు

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 విస్తృత యొక్క బహుళ నిర్ధారించుకోండి అదనపు padding లో చేర్చండి ఉంది.

234
00:18:44,350 --> 00:18:49,460
కాబట్టి ఆ మీరు ఇక్కడ ఈ 0 సె చూడండి ఎలా.

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
మేము ఏ జోడించండి లేదు ఎందుకంటే మరియు అందువలన మేము నిజంగా చివరలో ఏ 0 సె చూడండి లేదు

239
00:19:12,940 --> 00:19:19,070
ఇది పూర్తిగా మందంగా ఎందుకంటే. ఇది ఏ గది లేదు.

240
00:19:20,720 --> 00:19:23,470
>> సరే. Padding గురించి ప్రశ్నలు?

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
ఒక ప్రత్యేక ఎలిమెంట్ అనుగుణంగా, మేము నిజంగా ఆ సూచిస్తూ ఒక struct సృష్టించారు.

245
00:19:47,050 --> 00:19:50,930
సో వాట్ మనం ఒక RGBTRIPLE struct ఉంది.

246
00:19:50,930 --> 00:19:54,590
మీరు ఒక RGB ట్రిపుల్ ఒక ఉదాహరణకు ఉన్నప్పుడు,

247
00:19:54,590 --> 00:20:00,970
ఈ రకం struct నిర్వచించే ఎందుకంటే, అప్పుడు మీరు, 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 to, 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 struct ఉన్నాయి.

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 struct ఉన్నాయి.

266
00:21:40,500 --> 00:21:46,840
మేము దానికి సంబంధించిన ఒక rgbtBlue, గ్రీన్, మరియు Red ఉన్నాయి.

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 చేస్తుంది కేవలం ఒక Bitmap ఫైల్ యొక్క ఖచ్చితమైన కాపీని చేస్తుంది మరియు అప్పుడు అందిస్తుంది ఉంది.

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 లో జారీ చేసిన వాటిని అని ఇన్పుట్ ఫైల్ అమర్చుతుంది ఉంది

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
ఈ ఇక్కడ ఏమి, అది కేవలం ప్రాథమికంగా ప్రారంభం నుండి Bitmap ఫైల్ కు చదవడం ప్రారంభిస్తాడు.

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
ఇక్కడ, మేము padding గురించి మాట్లాడారు గుర్తు

311
00:25:38,510 --> 00:25:47,820
అది మేము కలిగి పిక్సెళ్ళు మొత్తం 4 యొక్క బహుళ నిర్ధారించుకోండి ముఖ్యం ఎలా.

312
00:25:47,820 --> 00:25:52,790
ఈ మీరు ఎంత padding గణించడానికి ఒక అందమైన ఉపయోగకరమైన సూత్రం

313
00:25:52,790 --> 00:25:57,670
మీ ఫైల్ యొక్క వెడల్పు ఇచ్చిన.

314
00:25:57,670 --> 00:26:04,120
నేను మీరు అబ్బాయిలు copy.c లో మేము padding లెక్కించడానికి ఒక ఫార్ములా కలిగి గుర్తుంచుకోవాలనుకుంటున్న.

315
00:26:04,120 --> 00:26:07,970
సరేనా? కాబట్టి ప్రతి ఒక్కరూ గుర్తుంచుకోవాలి. గ్రేట్.

316
00:26:07,970 --> 00:26:14,050
కాబట్టి అప్పుడు copy.c ఏమి పక్కన scanlines పై iterates ఉంది.

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
గమ్మత్తైన భాగంగా, padding ఒక RGB ట్రిపుల్ కాదు

322
00:26:48,340 --> 00:26:55,200
అందువలన మేము RGB ట్రిపుల్స్ ఆ padding మొత్తం చదువలేదు.

323
00:26:55,200 --> 00:27:01,460
మనం లేదు నిజానికి, మా ఫైలు స్థానం సూచిక తరలించడానికి మా కర్సరును మరల్చటానికి ఉంది

324
00:27:01,460 --> 00:27:06,840
రాబోయే వరుస వద్ద ఉన్నట్లు కాబట్టి అన్ని padding పైగా skip యొక్క రకాన్ని.

325
00:27:06,840 --> 00:27:12,990
మరియు ఈ ఏమి కాపీని మీరు padding జోడించదలచిన ఎలా మీరు చూపిస్తుంది ఉంటుంది.

326
00:27:12,990 --> 00:27:14,990
కాబట్టి మేము, మేము అవసరం ఎంత padding లెక్కించిన చేసిన

327
00:27:14,990 --> 00:27:18,220
కాబట్టి మేము 0 సె యొక్క padding సంఖ్య ఉండాలి.

328
00:27:18,220 --> 00:27:24,510
ఈ చేస్తుంది మా outfile లోకి 0 సె యొక్క padding సంఖ్యను ఆ లూప్ ఒక ఉంది.

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
>> ఈ మా కు-DOS హూడన్ఇట్ కోసం ఏమి ఉంటాయి, కానీ 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
బహుశా మీరు అన్ని Red పిక్సెళ్ళు మార్చడానికి కావలసిన

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 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
>> మేము ఈ కోసం వివరాలు pseudocode కు చేస్తే అప్పుడు, మేము ఫైల్ను తెరవడం మీరు.

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
మీరు ఒక struct ఉంటే ఆ లోపల వేరియబుల్స్ యాక్సెస్ ఎలా, గుర్తుంచుకోండి.

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 పిక్సెల్ కు reading ఒక మార్గాన్ని అందిస్తుంది ఎందుకంటే.

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 1 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 ప్రకటన కప్పు ఉంది

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
>> కానీ మేము మా padding మార్చడానికి అన్నారు అని గుర్తుంచుకోండి.

416
00:34:47,350 --> 00:34:53,020
గతంలో, మేము పొడవు 3 యొక్క విషయాలు ఉన్నాయి చెప్పారు.

417
00:34:53,020 --> 00:35:00,130
అప్పుడు మేము ఎంత padding లో కలుపుతాయి? కేవలం ఒక ఎక్కువ 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
కాబట్టి మేము నిజానికి అక్కడ padding యొక్క 2 అక్షరాలు చూడాలని.

423
00:35:33,200 --> 00:35:38,720
>> మేము padding గణించడానికి ఒక ఫార్ములా ఉంటే ఎవరైనా గుర్తు

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
మీరు ఎంత padding లెక్కించేందుకు copy.c ఒక ఫార్ములా ఉంది

427
00:35:49,800 --> 00:35:53,810
బిట్మ్యాప్ చిత్రం యొక్క ఒక నిర్దిష్ట వెడల్పు ఇచ్చిన.

428
00:35:53,810 --> 00:36:02,950
మీరు padding ఒక నిర్దిష్ట పరిమాణం జోడించడానికి కనుక అప్పుడు జరగబోతోంది ఆ ఉపయోగకరంగా ఉంటుందని

429
00:36:02,950 --> 00:36:06,160
నిజానికి మీరు జోడించడానికి ఎంత padding గుర్తించడానికి.

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 కోసం padding గణన చేసినపుడు, మీరు 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
ఈ మేము వరుసగా కాపీ పూర్తి చేసినప్పుడు ఎందుకంటే కొంత trickier అవతరిస్తుంది

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
కాబట్టి మనం చేయాలనుకుంటున్నారా మళ్లీ ఆ వరుసలు కాపీ కొన్ని మార్గాన్ని రకమైన ఉంది

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
బదులుగా బిట్ మ్యాప్ చిత్రాలన్నీ ఈ సమయంలో మేము JPEGs వ్యవహరించే చేస్తున్నారు.

458
00:38:39,580 --> 00:38:43,370
మేము నిజానికి JPEGs ఒక ఫైల్ ఇచ్చిన లేదు,

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
ఈ ప్రత్యేక ఫార్మాట్లో ఒకవేళ ఇది ఖచ్చితంగా ఒక బిట్ trickier ఉండేవి.

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
తెలిసిన మరో ఉపయోగపడిందా విషయం JPEGs పక్కపక్కన నిల్వ ఉంటుంది.

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 reading అయితే మేము మీరు,, ఒక 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
JPEGs గురించి మరొక విషయం, మేము ఒక సమయంలో 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
మీరు నిజమైన JPEGs తమను తాము నిజంగా సంబంధిత లేని విలువలు కలిగి ఉంటాయి.

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
>> ఇక్కడ కొన్ని ప్రధాన takeaways:

499
00:42:03,170 --> 00:42:06,670
కార్డు ఫైలు, ఒక JPEG ప్రారంభం లేదు

500
00:42:06,670 --> 00:42:13,350
ఒక JPEG మొదలవుతుంది ఒకసారి కానీ, JPEGs అన్ని పక్క మరొక వైపు నిల్వ చేయబడతాయి.

501
00:42:17,520 --> 00:42:20,420
>> పునరుద్ధరించు కోసం కొన్ని pseudocode.

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
అప్పుడు మేము ప్రధానంగా ఒక అనిర్దిష్ట మొత్తం ఉంటుంది. JPEGs అంతం కాదు.

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
% 3D బహుశా మీరు 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
కాబట్టి 3 hashtags, కాలం, jpg ఉంది. >> [విద్యార్థి] 7. >> 7. కాదు.

560
00:47:26,320 --> 00:47:32,000
మేము అదే శూన్య టెర్మినేటర్ అనుమతించాలనుకుంటున్న ఎందుకంటే మేము 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
>> మరియు నేను వచ్చే అన్ని ధన్యవాదాలు, Walkthrough 4 నిలిచాడు చేస్తున్నాను.

594
00:50:23,970 --> 00:50:29,330
ఫోరెన్సిక్స్ తో అదృష్టం. [చప్పట్లు]

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