>> [இசை கேட்கிறது]
>> ZAMYLA சான்: மீட்க தடுப்பாட்டம் பார்ப்போம்.
மீட்டெடு ஒருவேளை எனக்கு பிடித்த pset ஆகிறது, முக்கியமாக நான் நினைக்கிறேன், ஏனெனில்
உண்மையில் குளுமையாக.
அடிப்படையில், நீங்கள் ஒரு நினைவக கொடுக்கப்பட்ட அட்டை கோப்பை இதில்
படங்கள் நீக்கப்பட்டன.
ஆனால் நீங்கள் என்ன செய்ய போகிறீர்கள் செய்ய அவர்களுக்கு அனைத்து மீட்க ஆகிறது.
>> சரி.
எனவே இது உண்மையில் நன்றாக இருக்கிறது, ஆனால் ஒரு நீங்கள் இருப்பதால், சிறிய மிரட்டுதல்
ஒரு வெற்று சி கோப்பு கொடுக்கப்பட்ட நீங்கள் அதை உள்ளே நிரப்ப வேண்டும்
சரி, இந்த உடைக்க அனுமதிக்க சமாளிக்க பகுதிகளாக.
நீங்கள் திறக்க வேண்டும் என்று நான் நினைக்கிறேன் மெமரி கார்டு கோப்பு.
என்று போதுமான எளிய தெரிகிறது.
பின்னர், ஆரம்பத்தில் கண்டுபிடிக்க ஒரு JPG படத்தை.
இந்த நினைவகம் அனைத்து கோப்புகள் அட்டை JPGs இருக்க போகிறோம்.
பின்னர், ஒரு முறை நீங்கள், ஆரம்பத்தில் கண்டுபிடிக்க நீங்கள், ஒரு புதிய JPG திறக்க போகிறோம் என்று
, போன்ற, ஒரு JPG உருவாக்க, மற்றும் 512 எழுத ஒரு புதிய JPG வரை ஒரு நேரத்தில் பைட்
இல்லை, திட்டத்தை நிறுத்துவதற்கான ஒரு முறை நீங்கள் கோப்பு இறுதியில் கண்டறிய.
>> எனவே முதல் படிகள் முதல் திறக்க உள்ளது மெமரி கார்டு கோப்பு.
ஆனால் நீங்கள் ஏற்கனவே தெரியும், அங்கே தான் நடக்கிறது என்று ஒரு கோப்பு நான் / ஓ செயல்பாடு
மிகவும் பயனுள்ளதாக நிரூபிக்க.
சரி.
எனவே JPGs என்ன?
நாங்கள் தொடக்கத்தில் அது வேண்டும், ஏனெனில்.
சரி, JPGs, பிட் வரைபடங்கள் போன்ற, தான் பைட்டுகள் தொடர்ச்சியாகும்.
அதிர்ஷ்டவசமாக, ஒவ்வொரு JPG அல்லது தொடங்குகிறது 0xff, 0xd8, 0xff, 0xe0, ஒரு காட்சியில்
பைட்டுகள், அல்லது மற்றொரு பைட்டுகள் வரிசை.
>> எனவே அந்த நான்கு பைட்டுகள் குறிக்கின்றன ஒரு JPG தொடக்கத்தில்.
அந்த இரண்டு சேர்க்கைகள் தவிர வேறு ஒருவரும் இல்லை நான்கு பைட்டுகள்.
மற்றும் அதிர்ஷ்டவசமாக எங்களுக்கு, மற்றொரு உண்மை என்று நாம் பயன்படுத்தி கொள்ள முடியும் என்று ஒவ்வொரு
JPG பக்க மூலம் பக்க சேமிக்கப்படுகிறது மெமரி கார்டு மீது.
நான் ஒரு கட்டமைப்பு குறிப்பிடப்படுகின்றன காலியிட இந்த மெமரி கார்டு
இங்கே சரிய.
இங்கே, ஒவ்வொரு சதுர, ஒவ்வொரு செவ்வகம், 512 பைட்டுகள் பிரதிபலிக்கிறது, மற்றும் அது தொடங்குகிறது
நாங்கள் இல்லை என்று ஒரு சாம்பல் உண்மையில் ஒரு JPG வேண்டும்.
>> ஆனால் நாம் இறுதியாக வெற்றி ஒரு நட்சத்திரம் ஒரு தொகுதி.
அதாவது முதல் நான்கு பைட்டுகள் வெளியே அந்த 512 அந்த இரண்டு ஒன்று
ஒரு JPG தொடர்ச்சியை தொடங்கி.
ஒரு முறை நாம் பின்னர் அங்கு இருந்து சென்று, ஒரு JPG அடுத்த ஒரு தொடங்குகிறது, முடிகிறது.
நாம் எப்போதும் எந்த இல்லை இடையே சாம்பல் விண்வெளி.
>> ஆனால் எப்படி நாம் உண்மையில் இந்த படிக்கிறோம், மற்றும் நாம் செய்ய முடியும் என்று 512 பைட்டுகள் படிக்க
ஒப்பீடு முதல் இடம்?
சரி, மீண்டும் fread போகலாம் இது கொண்டிருக்கும் என்று struct உள்ள எடுக்கிறது
நீங்கள் படித்து என்று பைட்டுகள்.
எனவே நீங்கள் வைக்க போகிறோம் அங்கு அந்த -
அளவு, எண்ணிக்கை, பின்னர் inpointer நீங்கள் படித்து என்று.
இப்போது, நாம் ஒரு நேரத்தில் 512 படிக்க வேண்டும், மற்றும் நாம் ஒரு இடையக இந்த சேமிக்க வேண்டும்,
நான் அழைக்க போகிறேன்.
>> அடிப்படையில், நாம் நடத்த போகிறோம் அந்த 512 பைட்டுகள் மீது செய்ய
அது விஷயங்கள், சரியான?
நாம் ஒன்று முதல் ஒப்பிட்டு போகிறோம் நான்கு பைட்டுகள் அல்லது நாங்கள் போகிறோம்
சரி, அது படிக்க?
எனவே தரவு சுட்டிக்காட்டி பின்னர் சாப்பிடுவேன் உங்கள் தாங்கல் பணியாற்ற
inpointer, நன்றாக, என்று தான் நடக்கிறது உங்கள் மெமரி கார்டு இருக்க வேண்டும்.
>> எங்கள் மெமரி கார்டு திட்ட மீண்டும்.
நாம் ஒரு நேரத்தில் 512 பைட்டுகள் படிக்க போகிறோம், ஒவ்வொரு 512 பைட் தொகுதி சேமித்து
ஒரு இடையகத்திற்குள், வைத்திருக்கும் அந்த மீது நாங்கள் தெரியும் வரை, அந்த 512 பைட்டுகள் தாங்குவதற்கு
சரியாக என்ன செய்ய.
எனவே தொடக்கத்தில் எதுவும் இல்லை, எனவே நாம், தாங்கல் வாசிக்க அதை ஒப்பிட்டு, மற்றும் வேண்டும்
நாம் அது ஒன்றும் செய்ய தேவையில்லை.
பின்னர், நாம் இறுதியாக ஒரு நட்சத்திரம் வெற்றி நாம் தான், அதாவது தடுக்க
எங்கள் முதல் JPG கிடைத்தது.
எனவே தாங்கல் இப்போது நடத்த என்று JPG இருந்து பைட்டுகள்.
>> அவர்கள் 512 பைட்டுகள், ஏனெனில் அடுத்த முறை இல்லை ஒரு நட்சத்திர தொகுதி, உள்ளன
என்று JPG பகுதியாக.
மேலும் JPGs அங்கு இருந்து தொடர்ந்து இருக்கின்றன நாம் அடுத்த JPG ஹிட் வரை, உள்ள.
பின்னர் தாங்கல் பின்னர் வைத்திருக்கிறது 512 என்று JPG பைட்ஸ்களாக, மற்றும்
அதனால், மற்றும் முன்னும் பின்னுமாக.
சரி.
>> நீங்கள் முதல் நடித்தார் அடிக்கிறீர்கள் எனவே ஒரு முறை தொகுதி, முதல் JPG, எப்படி நீங்கள் செய்கிறீர்கள்
உண்மையில், நன்றாக, அதை திறக்க?
ஒரு புதிய JPG செய்யலாம்.
ஒரு JPG ஐந்து பெயர்கள் போகிறோம் வடிவமைப்பில் இருக்க, எண், எண்,
number.jpg, என்று அவர்கள் பெயர் அவர்கள் காணப்படும் எந்த வரிசையில்,
0 துவங்கும்.
>> எனவே முதல் JPG என்று நீங்கள் கண்டுபிடிக்க 000.jpg வேண்டும்.
எனவே, ஒருவேளை ஒரு நல்ல யோசனை கண்காணிப்பதற்கான நீங்கள் இதுவரை பார்த்த எத்தனை JPGs.
எனவே அந்த கோப்பு பெயர்.
ஆனால் நீங்கள் உண்மையில் அந்த செய்ய?
சரி, நாம் பயன்படுத்த போகிறோம் ஒரு செயல்பாடு sprintf என்று.
Printf போன்ற ஒரு சிறிய பிட், அங்கு நீங்கள், சரங்களை பெட்டிகள் பயன்படுத்த முடியும்
இந்த வழக்கு தவிர, sprintf அச்சிட வேண்டும் தற்போதைய ஒரு கோப்பு அவுட்
அடைவு இல்லை முனையத்தில்.
>> சரி.
இங்கு நாம் தலைப்பு வேண்டும் என்று பார்க்கிறோம், சேமிக்க என்று ஒரு கரி வரிசை
விளைவாக சரம், நாம் கடந்து ஒரு உண்மையான சரம் தலைப்பு
ஒதுக்கிட, நாம் விரும்புகிறேன் printf செய்ய கற்று.
ஆனால் நான் இங்கே இல்லை என்று இந்த குறியீடு 2.jpg, இல்லை 002.jpg கொடுக்கும்.
அதனால் நான் கண்டுபிடிக்க நீங்கள் விட்டு விடுகிறேன் எப்படி செய்ய ஒதுக்கிட மாற்ற
சரியான பெயர்.
>> சரி.
எனவே ஒரு முறை நீங்கள் நீங்கள் பின்னர் sprintf'd அது உள்ளது, ஏனெனில், அந்த கோப்பு திறக்க
fopen உங்கள் அடைவு, பயன்படுத்தி தலைப்பு, மற்றும் நீங்கள் விரும்பினால் பின்னர் என்ன முறை
உள்ளே அந்த கோப்பு திறக்க
எனவே இப்போது நாம் ஒரு புதிய JPG கோப்பு திறந்து விட்டேன் என்று, இப்போது நாம் ஒரு நேரத்தில் 512 பைட்டுகள் எழுத முடியும்
ஒரு புதிய JPG காணப்படுகிறது வரை நேரம்,.
எனவே மற்றொரு பார்க்கலாம் fwrite என்ற தொடரியல்.
>> நான் இந்த ஸ்லைட் ஒரு காட்டி இருக்கிறேன் என்று எனக்கு தெரியும் நிறைய, ஆனால் நான் உறுதி செய்ய வேண்டும்
நீங்கள், மிகவும் குழப்பி கொள்ள வேண்டாம், ஏனெனில் நான் அதை மிக எளிது என்று
முதல் மற்றும் கடைசி வரை கலந்து வாதம், குறிப்பாக.
ஆனால் நீங்கள் எழுதி என்று நினைவில் வெளியே கோப்பு படங்களை உங்கள் தாங்கல்.
>> இப்போது உங்களுக்கு தெரியும் என்று எப்படி எழுத 512 நீங்கள் நான் என்று உங்கள் JPG கோப்பு பைட்கள்
உருவாக்கப்பட்ட, நன்றாக, நாம் தடுக்க வேண்டும் நாம் இறுதியில் அடைந்துவிட்டீர்கள் செயல்முறை முறை
எங்கள் அட்டை, ஏனெனில் இருக்க மாட்டேன் காணப்படும் எந்த மேலும் படங்கள்.
எனவே fread திரும்பி செல்லலாம் மேலும், நான் சத்தியம் செய்கிறேன்.
fread அளவு எவ்வளவு பொருட்களை கொடுக்கிறது, அளவு, வெற்றிகரமாக தயாராக இருந்தனர்.
வெறுமனே, இந்த போகிறது என்ன நீங்கள் சொல்வது சரி, பல கடந்து?
நீங்கள் எண் வாசிக்க முயற்சிக்கும் ஏனெனில் அளவு, அளவு கூறுகள்.
ஆனால் fread என்று படிக்க முடியவில்லை என்றால் உறுப்புகள் எண்ணிக்கை, பின்னர் அதை திரும்ப வேண்டும்
அது வெற்றிகரமாக படிக்க என்ன எண்.
>> இப்போது, கவனிக்க வேண்டிய ஒரு முக்கியமான விஷயம் இருக்கிறது என்று நீங்கள் நான் / ஓ மற்றொரு கோப்பு பயன்படுத்தினால்
fgetc போன்ற செயல்பாடு, இது திரும்ப வேண்டும் அது வெற்றிகரமாக படித்தது எவ்வளவு பொருட்களை.
என்ன இந்த செயல்பாடு பற்றி பயனுள்ளதாக இருக்கிறது என்று நீங்கள் ஒரு உள்ளே செயல்பாடுகளை பயன்படுத்த
இந்த நிலையில், அது போது தன்னை இயக்கவும் வேண்டும் இது அந்த நிலையில், தீர்மானிப்பதில்
உண்மையில் பயனுள்ளதாக இருக்கும்.
எனவே நீங்கள் இந்த நிலைமைகள், என்று, என்றால் fread தாங்கல், sizeof நாய், 2,
சுட்டிக்காட்டி, 1 சமம், சமம் என்று நான் படிக்க விரும்புகிறேன் என்று அர்த்தம்
அந்த நேரத்தில் 2 நாய்கள்.
ஆனால் fread பதிலாக 2 1 திரும்புகிறார் என்றால் எதிர்பார்க்கப்படுகிறது, அந்த 2 உள்ளன என்று அர்த்தம்
நாய்கள் என் கோப்பில் விட்டு, மாறாக 1.
ஆனால் அது 2 கொடுக்கிறது என்றால், நான் இன்னும் வேண்டும் என் தாங்கல் உள்ளே அந்த 2 நாய்கள்.
>> எனவே இப்போது நீங்கள் எப்படி ஒரு உணர்வு கொடுக்கிறது கோப்பின் இறுதியில் சரிபார்க்க, ஆனால்
இப்போது தர்க்கம் வழியாக செல்லலாம்.
எப்படி நாம் உண்மையில் அனைத்து துண்டு செய்ய ஒன்றாக இந்த கூறுகளை?
நாங்கள் எங்கள் முதல் JPG வெற்றி, பின்னர் நாம் JPGs சேமிக்கப்படும் என்று
contiguously, நாம் வரை எழுதி நாங்கள் அட்டை கோப்பு இறுதியில் அடைய.
ஆனால் நாம் எழுத விரும்பவில்லை எதையும் அதுவரை.
அதை நாம் இருக்கிறோம் என்று மட்டும், முக்கியமாகிறது ஒரு புதிய JPG தொடக்கத்தில், ஆனால் என்பதை
நாம் ஏற்கனவே ஒரு JPG அல்லது கண்டுபிடித்துள்ளேன்.
>> இது ஒரு புதிய JPG தொடக்கத்தில் இருந்தால், நாம் தருகிறேன் நமது தற்போதைய JPG கோப்பு என்றால் மூட வேண்டும்
நாங்கள் ஒரு திறந்த, மற்றும் திறந்த வேண்டும் ஒரு எழுத ஒரு புதிய.
புதிய JPG தொடக்கத்தில் இல்லை என்றால், எனினும், நாம் அதே JPG கோப்பு வைக்கிறேன்
திறந்து என்று எழுத.
நாம் எந்த ஒரு எங்கள் தாங்கல் எழுத வேண்டும் நாம் திறக்க JPG கோப்பு, என்று வழங்கப்படும்
நாம் நிச்சயமாக, ஒரு திறந்த வேண்டும்.
நாங்கள் எங்கள் முதல் JPG இல்லை என்றால் இன்னும், நாம் எதையும் எழுத வில்லை.
இந்த செயல்முறை நீங்கள் வரை தொடர்கிறது அட்டை கோப்பு இறுதியில் அடைய.
>> இறுதியாக, நீங்கள் செய்ய வேண்டும் நீங்கள் எந்த fclose என்று உறுதி
நீங்கள் fopened என்று கோப்புகளை.
நீங்கள் வசதியாக இருக்கும் முறை கருத்துக்கள், சில பாருங்கள்
நான் இங்கே சேர்த்தேன் இது சூடோகுறியீடு.
முதல், நீங்கள் அட்டை கோப்பை திறக்க வேண்டும், பின்னர் பின்வரும் செயல்முறை மீண்டும்
நீங்கள் அடைந்துவிட்டீர்கள் வரை அட்டை இறுதியில்.
நீங்கள் 512 பைட்டுகள் படிக்க வேண்டும் ஒரு இடையகத்திற்குள்.
என்று இடையக பயன்படுத்தி, நீங்கள் பார்க்க வேண்டும் என்று நான் நினைக்கிறேன் நீங்கள் ஒரு தொடக்க இருக்கிறோம் என்பதை
புதிய JPG அல்லது இல்லை.
அந்த கேள்விக்கு பதில் உங்கள் கோப்பு மேலாண்மை பாதிக்கும் -
இது திறக்கும் கோப்புகள், இது தான் நீங்கள் மூட வேண்டாம்.
>> பின்னர், நீங்கள் ஏற்கனவே ஒரு JPG கிடைத்தது?
நீங்கள் எப்படி வைத்து அந்த பாடல்?
பின்னர், அந்த பொறுத்து, நீங்கள் நிற்க முடியும் தற்போதைய JPG ஒரு எழுத வேண்டும் என்று நீங்கள்
அதை எழுத திறக்க, அல்லது இல்லை, நீங்கள் இன்னும் ஒரு JPG இல்லை, ஏனெனில்.
இறுதியாக, நீங்கள் இறுதியில் அடைந்துவிட்டீர்கள் கோப்பு, நீங்கள் எந்த மூட வேண்டும் என்று
நீங்கள் திறந்த கோப்புகளை மீதமுள்ள.
நாம் இங்கே நேர்த்தியாகவும் இருக்க வேண்டும்.
>> அந்த நிலையில், நீங்கள் அனைவரும் மீண்டு விட்டேன் என்று நினைவகம் இருந்து விடுபட்ட கோப்புகள்
ஒரு அழகான அற்புதமான சாதனையை இது அட்டை,.
எனவே மீண்டும் உங்களை அமைதிப்படுத்த.
ஆனால், இன்னும் ஒரு உறுப்பு உள்ளது போட்டியில் இது PSet,.
நீங்கள் கண்டுபிடிக்க வேண்டும் என்று படங்களை அனைத்து நீங்கள் மீண்டு விட்டேன் என்று உண்மையில்
CS50 ஊழியர்கள் படங்கள்.
எனவே நீங்கள் வளாகம் அல்லது எங்காவது என்றால் அருகில், நீங்கள் படங்களை எடுக்க முடியும்
ஊழியர்கள், மற்றும் அந்த பகுதியில் ஊழியர்கள் உறுப்பினர்கள் மிகவும் படங்கள்
தங்கள் மீண்டு கோப்புகளை சாப்பிடுவேன் ஒரு அற்புதமான பரிசு கிடைக்கும்.
என்று கொண்டு, பிறகு நீங்கள் முடிச்சுட்டேன் மீட்க pset.
என் பெயர் Zamyla உள்ளது, மற்றும் இந்த CS50 உள்ளது.