[Powered by Google Translate] [CS50 நூலகம்]
[நேட் Hardison] [ஹார்வர்ட் பல்கலைக்கழகம்]
[இந்த CS50 உள்ளது. CS50.TV]
CS50 நூலகம் நாம் பயன்பாட்டிற்கான நிறுவப்பட்டுள்ள ஒரு பயனுள்ளதாக கருவி
நீங்கள் நிரல்களை எழுத எளிதாகும் என்று உள்ளீடு கேட்கும் செய்த.
இந்த வீடியோ, நாம் திரை மீண்டும் இழுக்க வேண்டும் மற்றும் CS50 நூலகத்தில் சரியாக என்ன பாருங்கள்.
>> சி நூலகங்கள் வீடியோ, நாம் உங்களுக்கு # தலைப்புகளை கோப்புகள் ஆகியவை பற்றி பேச
உங்கள் மூல குறியீடு உள்ள நூலகம்,
பின்னர் நீங்கள் இணைக்கும் கட்டத்தில் ஒரு பைனரி நூலகம் கோப்பு இணைப்பு
தொகுப்பு செயல்பாட்டின்.
தலைப்பு கோப்புகள் நூலகத்தின் முகப்பில் குறிப்பிடவும்.
என்று, அவர்கள் விவரம் நீங்கள் பயன்படுத்த நூலகம் கிடைக்கும் என்று அனைத்து ஆதாரங்களும், இது
விழாவில் அறிவிப்புக்கள், மாறிலிகள், மற்றும் தரவு வகைகள் போன்ற.
பைனரி நூலகம் கோப்பு, நூலகம் செயல்படுத்த உள்ளது
இது நூலகத்தின் தலைப்பு கோப்புகள் மற்றும் நூலகத்தின். கேட்ச் மூல குறியீடு கோப்புகளை இருந்து தொகுக்கப்பட்ட.
>> பைனரி நூலகம் கோப்பு இது பைனரி உள்ள, நன்கு, தான் இருந்து பார்க்க மிகவும் சுவாரசியமான அல்ல.
எனவே, இந்த தலைப்பு நூலகம் கோப்புகளை பதிலாக பாருங்கள் நாம்.
இந்த வழக்கில், cs50.h. என்று ஒரே ஒரு தலைப்பு கோப்பு இல்லை
நாம் பயனர் அதை நிறுவிய அடைவு அடங்கும்
மற்ற கணினி நூலகங்கள் 'தலைப்பு கோப்புகள் சேர்த்து.
>> நீங்கள் கவனிக்க வேண்டும் முதல் விஷயங்கள் ஒரு cs50.h # மற்ற நூலகங்கள் இருந்து தலைப்பு கோப்புகள் உள்ளன என்று -
மிதவை, வரம்புகள், நிலையான bool, மற்றும் நிலையான lib.
மீண்டும், சக்கர துறையை மீண்டும் இல்லை கொள்கை தொடர்ந்து,
நாம் மற்ற எங்களுக்கு வழங்கிய கருவிகளை பயன்படுத்தி CS0 நூலகம் கட்டப்பட்டது.
>> நீங்கள் நூலகத்தில் பார்க்கலாம் அடுத்த விஷயத்தை நாம் ஒரு புதிய வகை வரையறை என்பது "சரம்."
இந்த வரி உண்மையில் வெறும் எரிப்பதை * வகை மாற்று உருவாக்குகிறது,
அது மாயமாக பண்புகளை புதிய சரம் வகை ஊக்குவி இல்லை
பொதுவாக, பிற மொழிகளில் சரம் பொருட்களை தொடர்புடைய
போன்ற நீளம் என்று.
நாம் செய்த காரணம் கோரமான விவரங்களை புதிய மென்பொருள் காப்பாற்ற வேண்டும்
சுட்டிகள் அவர்கள் தயாராக வரை.
>> தலைப்பு கோப்பு அடுத்த பகுதியாக செயல்பாடுகளை அறிவிப்பு ஆகும்
CS50 நூலகம் ஆவணங்களை சேர்த்து வழங்கும்.
இங்கே கருத்துக்களில் விவரம் அளவு கவனிக்க.
மக்கள் இந்த செயல்பாடுகளை பயன்படுத்துவது எப்படி என்று இந்த முக்கியமான சூப்பர் உள்ளது.
நாம் இதையொட்டி, அறிவிக்க, பயனர் மற்றும் வருவாய் எழுத்துகள், இரட்டையர், மிதவைகள், ints, நிரல் செயல்படுத்தி
நீண்ட longs, மற்றும் சரங்களை, எங்கள் சொந்த சரம் வகை பயன்படுத்தி.
தகவல் மறைக்கும் கொள்கை தொடர்ந்து,
. நாம் ஒரு தனி கேட்ச் செயல்படுத்த கோப்பில் எங்கள் வரையறை செய்து விட்டீர்கள் - cs50.c -
பயனர் மூல அடைவில்.
அதை பாருங்கள் என்று நாம், அந்த கோப்பு வழங்கியுள்ளோம்
அதை அறிய, மற்றும் நீங்கள் விரும்பினால் வேறு கணினிகளில் அது மீள்தொகுப்பானது,
நாம் அது இந்த வர்க்கத்திற்கு பயன்பாட்டிற்கான வேலை நல்லது என்று நான் நினைக்கிறேன் கூட.
எப்படியும், இப்போது அதை பார்த்து விட்டு.
>> செயல்பாடுகளை GetChar, GetDouble, GetFloat, GetInt, மற்றும் GetLongLong
அனைத்து GetString செயல்பாடு மேல் கட்டப்பட்ட.
அவர்கள் அனைத்து அடிப்படையில் அதே பாணி பின்பற்ற வேண்டும் என்று கூறினார்.
அவர்கள் உள்ளீடு ஒரு வரி பயனர் நிரல் ஒரு வட்டத்திற்கு பயன்படுத்த.
அவர்கள் பயனர் உள்ளீடுகளை ஒரு வெற்று வரியை ஒரு சிறப்பு மதிப்பு கொடுங்கள்.
அவர்கள், சரியான வகையாக பயனர் உள்ளீடு இட முயற்சிக்கும்
இது ஒரு கரி, இரட்டை, ஒரு மிதவை, முதலியன இருக்கும்
உள்ளீடு வெற்றிகரமாக அலச இருந்து பின்னர் அவர்கள் விளைவாக திரும்ப
அல்லது அவர்கள் பயனர் reprompt.
>> அதிக அளவில், மிகவும் தந்திரமான எதுவும் இங்கு இல்லை.
நீங்கள் கடந்த காலத்தில் இதேபோல் கட்டமைக்கப்பட்ட குறியீடு உங்களை எழுதப்பட்ட.
ஒருவேளை மிகவும் ரகசிய காணப்படும் பகுதி பயனர் உள்ளீடு parses என்று sscanf அழைப்பு.
Sscanf உள்ளீடு வடிவம் மாற்றம் குடும்பத்தின் பகுதியாக உள்ளது.
அது நிலையான io.h வாழ்ந்து, அதன் வேலையை ஒரு சி சரம் இட வேண்டும்
மாறி பாகுபடுத்தி முடிவு சேமித்து, ஒரு குறிப்பிட்ட வடிவம் படி
அழைப்பவர் வழங்கப்படும்.
உள்ளீடு வடிவம் மாற்ற செயல்பாடுகள் மிகவும் பயனுள்ள, பரவலாக பயன்படுத்தப்படும் செயல்பாடுகளை இருப்பதால்
முதலில் உள்ளுணர்வு சூப்பர் என்று
நாம் sscanf வேலை எப்படி செல்லலாம்.
>> sscanf முதல் வாதம் ஒரு எரிப்பதை * இல்லை - ஒரு பாத்திரம் ஒரு சுட்டிக்காட்டி.
செயல்பாடு சரியாக வேலை, வேண்டும்
அந்த கதாபாத்திரம், ஒரு சி சரம் முதல் பாத்திரம் வேண்டும்
பூஜ்ய \ 0 தன்மையை முடிவு.
இந்த அலச சரம்
sscanf இரண்டாவது வாதம், ஒரு வடிவம் சரம்
பொதுவாக, ஒரு சரம் மாறா வழங்கப்பட்டது
நீங்கள் printf பயன்படுத்தும் போது இப்படி ஒரு சரம் கண்டிருக்கலாம்.
வடிவமைப்பு சரம் ஒரு சதவீதம் அடையாளம் ஒரு மாற்று வரையறுப்பி குறிக்கிறது.
கேரக்டர் உடனடியாக, ஒரு சதவீதம் அடையாளம் தொடர்ந்து
நாம் மாற்ற sscanf வேண்டும் என்று சி வகை குறிக்கிறது.
GetInt நீங்கள் ஒரு% d மற்றும்% கேட்ச் உள்ளது என்று பார்க்க.
% D - - ஒரு கரி -% கேட்ச் இந்த sscanf ஒரு தசம எண்ணாக முயற்சி என்று பொருள்.
வடிவமைப்பு சரம் ஒவ்வொரு மாற்ற வரையறுப்பி செய்ய,
sscanf அதன் வாதம் பட்டியலில் ஒரு தொடர்புடைய வாதம் பின்னர் எதிர்பார்க்கிறது.
அந்த வாதம் சரியான தட்டச்சு செய்த இடம் சுட்டி வேண்டும்
மாற்றத்தின் விளைவாக சேமிக்க இதில்.
>> இதை வழக்கமான வழியில் sscanf அழைப்பு முன் ஸ்டேக் ஒரு மாறி உருவாக்க வேண்டும்
நீங்கள் சரம் இருந்து இட வேண்டும் என்று ஒவ்வொரு உருப்படிக்கு
சுட்டிகள் அனுப்ப - ampersand - பின்னர் முகவரியை ஆபரேட்டர் பயன்படுத்த
sscanf அழைப்பு அந்த மாறிகள் வேண்டும்.
நீங்கள் GetInt நாம் சரியாக செய்ய வேண்டும் என்று பார்க்கலாம்.
வலது sscanf அழைப்பு முன், நாம், n என்று ஒரு முழு எண்ணாக மற்றும் ஸ்டாக் ஒரு எரிப்பதை அழைப்பு கேட்ச் பிரகடனம்
நாம் sscanf அழைப்பு அவற்றை சுட்டிகளையும் அனுப்ப.
ஸ்டாக் இந்த மாறிகள் போடுவதற்கு ஒதுக்கப்பட்ட இடத்தை பயன்படுத்தி முன்னுரிமை
நீங்கள் malloc அழைப்பு மேன்மையின் தவிர்க்க இருந்து malloc கொண்ட குவியல், மீது,
நீங்கள் நினைவக கசிவு பற்றி கவலைப்பட வேண்டியது இல்லை.
ஒரு சதவீதம் அடையாளம் மூலம் முன்னொட்டாக இல்லை எழுத்துக்களை மாற்ற நிரல் இல்லை.
மாறாக அவர்கள் தான் வடிவமைப்பு விவரக்குறிப்பு சேர்க்க.
>> எடுத்துக்காட்டாக, GetInt உள்ள வடிவம் சரம் பதிலாக% d இருந்தால்,
sscanf, ஒரு முழு எண்ணாக தொடர்ந்து ஒரு கடிதம் தேடுவார்
அது முழு எண்ணாக மாற்ற முயற்சி செய்யும் போது, அது ஒரு வேறு எதுவும் செய்ய முடியாது என்று.
இந்த ஒரே விதிவிலக்கு இடைவெளி உள்ளது.
வடிவமைப்பு சரம் வெள்ளை இடைவெளி எழுத்துகள் இடைவெளி எந்த அளவு பொருந்தும் -
அனைத்து கூட எவரும்.
கருத்து முன்னணி மற்றும் / அல்லது இடைவெளி பின் அநேகமாக குறிப்பிடுகிறார் ஏன், என்று.
எனவே, இது எங்கள் sscanf அழைப்பு போல் இந்த பயனரின் உள்ளீடு சரம் அலச முயற்சிக்கும்
சாத்தியமான முன்னணி இடைவெளி சரிபார்ப்பு மூலம்,
int மாறி n இல் மாற்றப்படுகிறது மற்றும் சேமிக்கப்படும் என்று ஒரு முழு எண்ணாக தொடர்ந்து
இடைவெளி சில அளவு தொடர்ந்து, ஒரு பாத்திரம் தொடர்ந்து
கரி மாறி கேட்ச் சேமிக்கப்படும்.
>> மீண்டும் மதிப்பு என்ன?
Sscanf, தொடக்கத்தில் இருந்து முடிவு வரை உள்ளீடு வரியை அலச
உள்ளீடு ஒரு பாத்திரம் அது இறுதியில் அடையும் போது நிறுத்தாமல் அல்லது போது
ஒரு வடிவம் தன்மை பொருந்தவில்லை அல்லது ஒரு மாற்ற முடியாது போது.
அதை திரும்ப மதிப்பு அதை நிறுத்தி போது தனித்து பயன்படுத்தப்படுகிறது.
அதை உள்ளீடு சரம் இறுதியில் அடைந்தது, ஏனெனில் இது, நிறுத்தி இருந்தால்
எந்த மாற்றங்களை உருவாக்கும் முன் மற்றும் வடிவமைப்பு சரம் பகுதியாக பொருந்தும் தவறியதாக முன்,
பின்னர் சிறப்பு நிலையான EOF திரும்பினார்.
இல்லையெனில், அது, வெற்றிகரமான மாற்றங்கள் எண்ணிக்கை கொடுக்கிறது
நாம் இரண்டு மாற்றங்கள் கேட்டேன் இருந்து இது, 0, 1, அல்லது 2 முடியும்.
நம் வழக்கில், நாம் பயனர் ஒரு முழு எண்ணாக மட்டுமே ஒரு முழு எண்ணாக தட்டச்சு என்பதை உறுதி செய்ய வேண்டும்.
>> எனவே, நாம் sscanf 1 திரும்ப வேண்டும். ஏன் பார்க்க?
Sscanf 0 திரும்பிய பிறகு, எந்த மாற்றங்கள் செய்யப்பட்டன,
அதனால் பயனர் உள்ளீடு ஆரம்பத்தில் ஒரு முழு எண்ணாக தவிர வேறு ஏதாவது தட்டச்சு.
Sscanf 2 கொடுக்கிறது என்றால், பயனர் ஒழுங்காக, உள்ளீடு ஆரம்பத்தில் அதை தட்டச்சு
ஆனால் அவர்கள் பின்னர் அதன் பின்னர் சில இடைவெளி அல்லாத பாத்திரம் தட்டச்சு
% முதல் கேட்ச் மாற்ற வெற்றி.
ஆஹா, அந்த முற்றிலும் ஒரு செயல்பாடு அழைப்பு ஒரு நீண்ட விளக்கம் தான்.
எப்படியும், நீங்கள் sscanf மற்றும் அதன் உடன்பிறப்புகளில் மேலும் தகவல் வேண்டும் என்றால்,
மனிதன் பக்கங்கள், கூகுள், அல்லது இரண்டையும் பாருங்கள்.
வடிவமைப்பு சரம் விருப்பங்களை நிறைய உள்ளன
சி இல் சரங்களை இட முயற்சிக்கும் போது இந்த நீங்கள் உடல் உழைப்பு நிறைய சேமிக்க முடியும்
>> பார்க்க நூலகத்தில் இறுதி செயல்பாடு GetString உள்ளது.
இது, GetString ஒழுங்காக எழுத ஒரு தந்திரமான செயல்பாடு என்று மாறிவிடும்
இது போன்ற ஒரு எளிமையான, பொது பணி போல் கூட.
ஏன் இந்த நிலை?
சரி, அது எப்படி வரி சேமிக்க போகிறோம் பற்றி யோசிப்போம் என்று உள்ளே பயனர் வகைகள்
ஒரு சரம் எழுத்துகள் வரிசை உள்ளது, ஏனெனில்
நாம், ஸ்டாக் ஒரு வரிசையில் அதை சேமிக்க வேண்டும்
ஆனால் நாம் அதை அறிவிக்க போது வரிசை போகிறது எவ்வளவு தெரியுமா வேண்டும்.
இதேபோல், நாம் குவியல் மீது போட வேண்டும் என்றால்,
நாம், malloc நாம் இருப்பு வேண்டும் பைட்டுகள் எண்ணிக்கையை கடந்து செல்ல வேண்டும்
ஆனால் இந்த சாத்தியமற்றது.
நாம் பயனர் தட்டச்சு எத்தனை எழுத்துகள் தெரியாது
பயனர் உண்மையில் அவர்கள் தட்டச்சு முன்.
>> இந்த பிரச்சினைக்கு ஒரு எளிய தீர்வு தான், விண்வெளி ஒரு பெரிய துண்டின் உண்டு என்று, தான்
பயனர் உள்ளீடு 1000 எழுத்துகள் ஒரு தொகுதி,
பயனர் என்று நீண்ட ஒரு சரம் தட்டச்சு இல்லை என்று அனுமானித்து.
இந்த இரண்டு காரணங்களுக்காக ஒரு மோசமான யோசனை.
முதல், பயனர்கள் பொதுவாக நீண்ட சரங்களை தட்டச்சு என்று அனுமானித்து
நீங்கள் நினைவு நிறைய வீணாக்க முடியாது.
இந்த செய்தால் நவீன கணினிகளில், இந்த சிக்கலை இருக்கலாம்
ஒன்று அல்லது இரண்டு தனித்த வேளைகளில்,
ஆனால் நீங்கள் ஒரு வட்டத்திற்கு பயனர் உள்ளீடு எடுத்து பின்னர் பயன்படுத்த சேமித்து என்றால்,
நீங்கள் விரைவில் நினைவகம் ஒரு டன் வரை சக் முடியும்.
கூடுதலாக, நீங்கள் எழுதி இருக்கும் நிரல் ஒரு சிறிய கணினி உள்ளது -
குறைந்த நினைவகம் ஒரு ஸ்மார்ட்போன் அல்லது வேறு ஏதாவது ஒரு சாதனத்தை -
இந்த தீர்வு நிறைய வேகமாக பிரச்சினைகள் ஏற்படும்.
இந்த செய்ய இரண்டாவது, இன்னும் தீவிரமான காரணம் அது பாதிக்கப்படக்கூடிய உங்கள் திட்டத்தை விட்டு தான்
இடையக வழிவு தாக்குதல் என்று என்ன வேண்டும்.
நிகழ்ச்சிகளில், ஒரு தாங்கல், தற்காலிகமாக உள்ளீடு அல்லது வெளியீடு தரவை சேமிக்க பயன்படும் நினைவு
இந்த வழக்கில் எங்கள் 1000-எரிப்பதை தொகுதி ஆகும்.
தரவு தொகுதி முடிவு கடந்த எழுதிய போது ஒரு இடையக வழிவு ஏற்படும்.
>> உதாரணமாக, ஒரு பயனர் உண்மையில் 1000 க்கும் மேற்பட்ட எழுத்துகள் தட்டச்சு செய்தால்.
வரிசைகள் கொண்ட நிரலாக்க போது தற்செயலாக இந்த அனுபவம்.
நீங்கள் 10 ints ஒரு வரிசை இருந்தால், எதையும் எழுத படிக்க முயற்சி உன்னை தடுப்பது
15 எண்ணாக.
எந்த மொழி எச்சரிக்கைகள் அல்லது பிழைகள் உள்ளன.
திட்டம் மட்டும் நேராக மேலே தவறுகளை மற்றும் நினைவக அணுகல்கள்
அதை நினைக்கும் இடத்தில் 15 எண்ணாக இருக்கும், இந்த மற்ற மாறிகள் மேலெழுத முடியாது.
மோசமான வழக்கில், நீங்கள் உங்கள் நிரல் உள் சில மேலெழுத முடியாது
கட்டுப்பாட்டு இயங்கமைப்புகள், உங்கள் திட்டம் காரணமாக உண்மையில் வேறு வழிமுறைகளை இயக்க
நீங்கள் நோக்கம் விட.
>> இப்போது, அது தற்செயலாக இதை செய்ய பொதுவான இல்லை
ஆனால் இந்த கெட்ட பசங்களா திட்டங்களை உடைக்க பயன்படுத்தும் ஒரு மிகவும் பொதுவான உத்தி
மற்றும் பிற மக்கள் கணினிகளில் தீங்கிழைக்கும் குறியீடு உள்ளது.
எனவே, நாம் நமது உள்நாட்டு தீர்வு பயன்படுத்த முடியாது.
நாம் பாதிக்கப்படக்கூடிய இருந்து நமது திட்டங்களை தடுக்கும் ஒரு வழி வேண்டும்
இடையக வழிவு தாக்குதல்.
இதை செய்ய, நாங்கள் படிக்க நம் இடையக வளர முடியும் என்பதை உறுதி செய்ய வேண்டும்
பயனர் இருந்து மேலும் உள்ளீடு.
தீர்வு? நாம் ஒரு குவியல் ஒதுக்கீடு இடையக பயன்படுத்த.
நாம் மறுஅளவிடும் இருந்து, மறுஅளவீடு realloc செயல்பாட்டை பயன்படுத்தி
நாம் இரண்டு எண்கள் கண்காணிக்க - அடுத்த காலியாக ஸ்லாட் என்ற குறியீட்டு பஃப்பரில்
மற்றும் நீளம் அல்லது தாங்கல் திறன்.
நாம் fgetc செயல்பாட்டை பயன்படுத்தி ஒரு நேரத்தில் பயனர் ஒரு இருந்து எழுத்துகள் படித்தேன்.
stdin - - fgetc விழா எடுக்கும் வாதம், நிலையான உள்ளீட்டு சரத்திற்கு ஒரு குறிப்பு உள்ளது
இது பயனர் உள்ளீடு மாற்ற பயன்படுத்தப்படும் என்று ஒரு preconnected உள்ளீடு தடம்
முனையத்தில் இருந்து நிரல்.
>> அப்போது ஒரு புதிய பாத்திரத்தை பயனர் வகைகள், நாம் பார்க்கவும் என்றால் குறியீட்டு
அடுத்த இலவச ஸ்லாட் மற்றும் பிளஸ் 1 தாங்கல் திறன் அதிகமாக இருக்கும்.
+1, அடுத்த இலவச குறியீட்டு 5 இருந்தால் தான் வருகிறது
பிறகு எங்கள் இடையக இன் நீளம் 6 நன்றி 0 பிரித்தல் வேண்டும்.
நாம் இடையக இட ரன் அவுட் இருந்தால், நாம், அது அளவை முயற்சி
நாம் அளவை என்று மடங்கு எண்ணிக்கை குறைக்கப்பட்டது அதனால் அதை இரட்டிப்பாக்க
பயனர் உண்மையில் நீண்ட சரம் தட்டச்சு செய்ய வேண்டும்.
சரம் நீண்ட சென்றிருக்கிறது அல்லது நாம் குவியல் நினைவகம் ரன் அவுட் என்றால்,
நாம் தடுப்பு மற்றும் மீண்டும் பூஜ்ய விடுவித்து.
>> இறுதியாக, நாம் பஃபர் எரிப்பதை சேர்க்க.
பயனர் வெற்றி உள்ளிடவும் அல்லது திருப்பி, ஒரு புதிய வரி சமிக்ஞை முறை
அல்லது சிறப்பு எரிப்பதை - கட்டுப்பாடு ஈ - உள்ளீடு ஒரு முடிவுக்கு அடையாளம் இது,
நாம் பயனர் உண்மையில் எதுவுமே தட்டச்சு என்பதை ஒரு சோதனை செய்ய.
இல்லை என்றால், நாம் பூஜ்ஜிய திருப்பி.
இல்லையென்றால், எங்கள் இடையக நாம் வேண்டும் விட பெரிய ஏனெனில்,
மோசமான நிலையில் நாம் வேண்டும் என கிட்டத்தட்ட இரு மடங்கு பெரியதாக
நாம் அளவை ஒவ்வொரு முறையும் இரட்டை, முதல்
நாம் வேண்டும் என்று இடத்தை மட்டும் அளவு பயன்படுத்தி சரம் ஒரு புதிய நகலை உருவாக்கும்.
நாம், malloc அழைப்பு ஒரு கூடுதல் 1 சேர்க்க
\ 0 - சிறப்பு பூஜ்ய அழிப்பு தன்மை இடைவெளி இருக்கிறது என்று
இதில் நாம் எழுத்துக்கள் ஏனைய நகலெடுக்க முறை நாம் சரத்திற்கு append,
அதற்கு பதிலாக strcpy என்ற strncpy பயன்படுத்தி
அதனால் நாம் நகலெடுக்க வேண்டும் எத்தனை எழுத்துகள் குறிப்பிட முடியும்.
அது ஒரு \ 0 பலி வரை Strcpy நகலெடுக்கிறது.
நாம் நம் இடையக விடுவித்து மற்றும் அழைப்பவர் செய்ய நகலை திருப்பி.
>> யார் ஒரு எளிய-காணப்படும் செயல்பாடு மிகவும் சிக்கலான முடியும் தெரியும்?
இப்போது நீங்கள் CS50 நூலகம் செல்வது என்ன தெரியும்.
>> என் பெயர் நேட் Hardison, மற்றும் இந்த CS50 உள்ளது.
[CS50.TV]