1
00:00:00,000 --> 00:00:02,490
[Powered by Google Translate] [CS50 நூலகம்]

2
00:00:02,490 --> 00:00:04,220
[நேட் Hardison] [ஹார்வர்ட் பல்கலைக்கழகம்]

3
00:00:04,220 --> 00:00:07,260
[இந்த CS50 உள்ளது. CS50.TV]

4
00:00:07,260 --> 00:00:11,510
CS50 நூலகம் நாம் பயன்பாட்டிற்கான நிறுவப்பட்டுள்ள ஒரு பயனுள்ளதாக கருவி

5
00:00:11,510 --> 00:00:15,870
நீங்கள் நிரல்களை எழுத எளிதாகும் என்று உள்ளீடு கேட்கும் செய்த.

6
00:00:15,870 --> 00:00:21,670
இந்த வீடியோ, நாம் திரை மீண்டும் இழுக்க வேண்டும் மற்றும் CS50 நூலகத்தில் சரியாக என்ன பாருங்கள்.

7
00:00:21,670 --> 00:00:25,520
>> சி நூலகங்கள் வீடியோ, நாம் உங்களுக்கு # தலைப்புகளை கோப்புகள் ஆகியவை பற்றி பேச

8
00:00:25,520 --> 00:00:27,570
உங்கள் மூல குறியீடு உள்ள நூலகம்,

9
00:00:27,570 --> 00:00:31,150
பின்னர் நீங்கள் இணைக்கும் கட்டத்தில் ஒரு பைனரி நூலகம் கோப்பு இணைப்பு

10
00:00:31,150 --> 00:00:33,140
தொகுப்பு செயல்பாட்டின்.

11
00:00:33,140 --> 00:00:36,440
தலைப்பு கோப்புகள் நூலகத்தின் முகப்பில் குறிப்பிடவும்.

12
00:00:36,440 --> 00:00:41,280
என்று, அவர்கள் விவரம் நீங்கள் பயன்படுத்த நூலகம் கிடைக்கும் என்று அனைத்து ஆதாரங்களும், இது

13
00:00:41,280 --> 00:00:45,250
விழாவில் அறிவிப்புக்கள், மாறிலிகள், மற்றும் தரவு வகைகள் போன்ற.

14
00:00:45,250 --> 00:00:48,890
பைனரி நூலகம் கோப்பு, நூலகம் செயல்படுத்த உள்ளது

15
00:00:48,890 --> 00:00:54,580
இது நூலகத்தின் தலைப்பு கோப்புகள் மற்றும் நூலகத்தின். கேட்ச் மூல குறியீடு கோப்புகளை இருந்து தொகுக்கப்பட்ட.

16
00:00:54,580 --> 00:00:59,820
>> பைனரி நூலகம் கோப்பு இது பைனரி உள்ள, நன்கு, தான் இருந்து பார்க்க மிகவும் சுவாரசியமான அல்ல.

17
00:00:59,820 --> 00:01:03,300
எனவே, இந்த தலைப்பு நூலகம் கோப்புகளை பதிலாக பாருங்கள் நாம்.

18
00:01:03,300 --> 00:01:07,710
இந்த வழக்கில், cs50.h. என்று ஒரே ஒரு தலைப்பு கோப்பு இல்லை

19
00:01:07,710 --> 00:01:11,040
நாம் பயனர் அதை நிறுவிய அடைவு அடங்கும்

20
00:01:11,040 --> 00:01:15,150
மற்ற கணினி நூலகங்கள் 'தலைப்பு கோப்புகள் சேர்த்து.

21
00:01:15,150 --> 00:01:21,530
>> நீங்கள் கவனிக்க வேண்டும் முதல் விஷயங்கள் ஒரு cs50.h # மற்ற நூலகங்கள் இருந்து தலைப்பு கோப்புகள் உள்ளன என்று -

22
00:01:21,530 --> 00:01:25,670
மிதவை, வரம்புகள், நிலையான bool, மற்றும் நிலையான lib.

23
00:01:25,670 --> 00:01:28,800
மீண்டும், சக்கர துறையை மீண்டும் இல்லை கொள்கை தொடர்ந்து,

24
00:01:28,800 --> 00:01:33,490
நாம் மற்ற எங்களுக்கு வழங்கிய கருவிகளை பயன்படுத்தி CS0 நூலகம் கட்டப்பட்டது.

25
00:01:33,490 --> 00:01:38,690
>> நீங்கள் நூலகத்தில் பார்க்கலாம் அடுத்த விஷயத்தை நாம் ஒரு புதிய வகை வரையறை என்பது "சரம்."

26
00:01:38,690 --> 00:01:42,330
இந்த வரி உண்மையில் வெறும் எரிப்பதை * வகை மாற்று உருவாக்குகிறது,

27
00:01:42,330 --> 00:01:46,000
அது மாயமாக பண்புகளை புதிய சரம் வகை ஊக்குவி இல்லை

28
00:01:46,000 --> 00:01:49,650
பொதுவாக, பிற மொழிகளில் சரம் பொருட்களை தொடர்புடைய

29
00:01:49,650 --> 00:01:50,850
போன்ற நீளம் என்று.

30
00:01:50,850 --> 00:01:55,180
நாம் செய்த காரணம் கோரமான விவரங்களை புதிய மென்பொருள் காப்பாற்ற வேண்டும்

31
00:01:55,180 --> 00:01:57,580
சுட்டிகள் அவர்கள் தயாராக வரை.

32
00:01:57,580 --> 00:02:00,130
>> தலைப்பு கோப்பு அடுத்த பகுதியாக செயல்பாடுகளை அறிவிப்பு ஆகும்

33
00:02:00,130 --> 00:02:04,410
CS50 நூலகம் ஆவணங்களை சேர்த்து வழங்கும்.

34
00:02:04,410 --> 00:02:06,940
இங்கே கருத்துக்களில் விவரம் அளவு கவனிக்க.

35
00:02:06,940 --> 00:02:10,560
மக்கள் இந்த செயல்பாடுகளை பயன்படுத்துவது எப்படி என்று இந்த முக்கியமான சூப்பர் உள்ளது.

36
00:02:10,560 --> 00:02:19,150
நாம் இதையொட்டி, அறிவிக்க, பயனர் மற்றும் வருவாய் எழுத்துகள், இரட்டையர், மிதவைகள், ints, நிரல் செயல்படுத்தி

37
00:02:19,150 --> 00:02:24,160
நீண்ட longs, மற்றும் சரங்களை, எங்கள் சொந்த சரம் வகை பயன்படுத்தி.

38
00:02:24,160 --> 00:02:26,260
தகவல் மறைக்கும் கொள்கை தொடர்ந்து,

39
00:02:26,260 --> 00:02:31,640
. நாம் ஒரு தனி கேட்ச் செயல்படுத்த கோப்பில் எங்கள் வரையறை செய்து விட்டீர்கள் - cs50.c -

40
00:02:31,640 --> 00:02:35,110
பயனர் மூல அடைவில்.

41
00:02:35,110 --> 00:02:38,040
அதை பாருங்கள் என்று நாம், அந்த கோப்பு வழங்கியுள்ளோம்

42
00:02:38,040 --> 00:02:41,490
அதை அறிய, மற்றும் நீங்கள் விரும்பினால் வேறு கணினிகளில் அது மீள்தொகுப்பானது,

43
00:02:41,490 --> 00:02:45,510
நாம் அது இந்த வர்க்கத்திற்கு பயன்பாட்டிற்கான வேலை நல்லது என்று நான் நினைக்கிறேன் கூட.

44
00:02:45,510 --> 00:02:47,580
எப்படியும், இப்போது அதை பார்த்து விட்டு.

45
00:02:49,020 --> 00:02:54,620
>> செயல்பாடுகளை GetChar, GetDouble, GetFloat, GetInt, மற்றும் GetLongLong

46
00:02:54,620 --> 00:02:58,160
அனைத்து GetString செயல்பாடு மேல் கட்டப்பட்ட.

47
00:02:58,160 --> 00:03:01,510
அவர்கள் அனைத்து அடிப்படையில் அதே பாணி பின்பற்ற வேண்டும் என்று கூறினார்.

48
00:03:01,510 --> 00:03:04,870
அவர்கள் உள்ளீடு ஒரு வரி பயனர் நிரல் ஒரு வட்டத்திற்கு பயன்படுத்த.

49
00:03:04,870 --> 00:03:08,430
அவர்கள் பயனர் உள்ளீடுகளை ஒரு வெற்று வரியை ஒரு சிறப்பு மதிப்பு கொடுங்கள்.

50
00:03:08,430 --> 00:03:11,750
அவர்கள், சரியான வகையாக பயனர் உள்ளீடு இட முயற்சிக்கும்

51
00:03:11,750 --> 00:03:15,010
இது ஒரு கரி, இரட்டை, ஒரு மிதவை, முதலியன இருக்கும்

52
00:03:15,010 --> 00:03:18,710
உள்ளீடு வெற்றிகரமாக அலச இருந்து பின்னர் அவர்கள் விளைவாக திரும்ப

53
00:03:18,710 --> 00:03:21,330
அல்லது அவர்கள் பயனர் reprompt.

54
00:03:21,330 --> 00:03:24,230
>> அதிக அளவில், மிகவும் தந்திரமான எதுவும் இங்கு இல்லை.

55
00:03:24,230 --> 00:03:28,760
நீங்கள் கடந்த காலத்தில் இதேபோல் கட்டமைக்கப்பட்ட குறியீடு உங்களை எழுதப்பட்ட.

56
00:03:28,760 --> 00:03:34,720
ஒருவேளை மிகவும் ரகசிய காணப்படும் பகுதி பயனர் உள்ளீடு parses என்று sscanf அழைப்பு.

57
00:03:34,720 --> 00:03:38,160
Sscanf உள்ளீடு வடிவம் மாற்றம் குடும்பத்தின் பகுதியாக உள்ளது.

58
00:03:38,160 --> 00:03:42,300
அது நிலையான io.h வாழ்ந்து, அதன் வேலையை ஒரு சி சரம் இட வேண்டும்

59
00:03:42,300 --> 00:03:46,520
மாறி பாகுபடுத்தி முடிவு சேமித்து, ஒரு குறிப்பிட்ட வடிவம் படி

60
00:03:46,520 --> 00:03:48,720
அழைப்பவர் வழங்கப்படும்.

61
00:03:48,720 --> 00:03:53,570
உள்ளீடு வடிவம் மாற்ற செயல்பாடுகள் மிகவும் பயனுள்ள, பரவலாக பயன்படுத்தப்படும் செயல்பாடுகளை இருப்பதால்

62
00:03:53,570 --> 00:03:56,160
முதலில் உள்ளுணர்வு சூப்பர் என்று

63
00:03:56,160 --> 00:03:58,300
நாம் sscanf வேலை எப்படி செல்லலாம்.

64
00:03:58,300 --> 00:04:03,330
>> sscanf முதல் வாதம் ஒரு எரிப்பதை * இல்லை - ஒரு பாத்திரம் ஒரு சுட்டிக்காட்டி.

65
00:04:03,330 --> 00:04:05,150
செயல்பாடு சரியாக வேலை, வேண்டும்

66
00:04:05,150 --> 00:04:08,340
அந்த கதாபாத்திரம், ஒரு சி சரம் முதல் பாத்திரம் வேண்டும்

67
00:04:08,340 --> 00:04:12,270
பூஜ்ய \ 0 தன்மையை முடிவு.

68
00:04:12,270 --> 00:04:15,120
இந்த அலச சரம்

69
00:04:15,120 --> 00:04:18,269
sscanf இரண்டாவது வாதம், ஒரு வடிவம் சரம்

70
00:04:18,269 --> 00:04:20,839
பொதுவாக, ஒரு சரம் மாறா வழங்கப்பட்டது

71
00:04:20,839 --> 00:04:24,040
நீங்கள் printf பயன்படுத்தும் போது இப்படி ஒரு சரம் கண்டிருக்கலாம்.

72
00:04:24,040 --> 00:04:28,650
வடிவமைப்பு சரம் ஒரு சதவீதம் அடையாளம் ஒரு மாற்று வரையறுப்பி குறிக்கிறது.

73
00:04:28,650 --> 00:04:30,850
கேரக்டர் உடனடியாக, ஒரு சதவீதம் அடையாளம் தொடர்ந்து

74
00:04:30,850 --> 00:04:35,430
நாம் மாற்ற sscanf வேண்டும் என்று சி வகை குறிக்கிறது.

75
00:04:35,430 --> 00:04:40,090
GetInt நீங்கள் ஒரு% d மற்றும்% கேட்ச் உள்ளது என்று பார்க்க.

76
00:04:40,090 --> 00:04:48,690
% D - - ஒரு கரி -% கேட்ச் இந்த sscanf ஒரு தசம எண்ணாக முயற்சி என்று பொருள்.

77
00:04:48,690 --> 00:04:51,510
வடிவமைப்பு சரம் ஒவ்வொரு மாற்ற வரையறுப்பி செய்ய,

78
00:04:51,510 --> 00:04:56,620
sscanf அதன் வாதம் பட்டியலில் ஒரு தொடர்புடைய வாதம் பின்னர் எதிர்பார்க்கிறது.

79
00:04:56,620 --> 00:05:00,850
அந்த வாதம் சரியான தட்டச்சு செய்த இடம் சுட்டி வேண்டும்

80
00:05:00,850 --> 00:05:04,000
மாற்றத்தின் விளைவாக சேமிக்க இதில்.

81
00:05:04,000 --> 00:05:08,910
>> இதை வழக்கமான வழியில் sscanf அழைப்பு முன் ஸ்டேக் ஒரு மாறி உருவாக்க வேண்டும்

82
00:05:08,910 --> 00:05:11,440
நீங்கள் சரம் இருந்து இட வேண்டும் என்று ஒவ்வொரு உருப்படிக்கு

83
00:05:11,440 --> 00:05:15,520
சுட்டிகள் அனுப்ப - ampersand - பின்னர் முகவரியை ஆபரேட்டர் பயன்படுத்த

84
00:05:15,520 --> 00:05:19,100
sscanf அழைப்பு அந்த மாறிகள் வேண்டும்.

85
00:05:19,100 --> 00:05:22,720
நீங்கள் GetInt நாம் சரியாக செய்ய வேண்டும் என்று பார்க்கலாம்.

86
00:05:22,720 --> 00:05:28,240
வலது sscanf அழைப்பு முன், நாம், n என்று ஒரு முழு எண்ணாக மற்றும் ஸ்டாக் ஒரு எரிப்பதை அழைப்பு கேட்ச் பிரகடனம்

87
00:05:28,240 --> 00:05:32,340
நாம் sscanf அழைப்பு அவற்றை சுட்டிகளையும் அனுப்ப.

88
00:05:32,340 --> 00:05:35,800
ஸ்டாக் இந்த மாறிகள் போடுவதற்கு ஒதுக்கப்பட்ட இடத்தை பயன்படுத்தி முன்னுரிமை

89
00:05:35,800 --> 00:05:39,350
நீங்கள் malloc அழைப்பு மேன்மையின் தவிர்க்க இருந்து malloc கொண்ட குவியல், மீது,

90
00:05:39,350 --> 00:05:43,060
நீங்கள் நினைவக கசிவு பற்றி கவலைப்பட வேண்டியது இல்லை.

91
00:05:43,060 --> 00:05:47,280
ஒரு சதவீதம் அடையாளம் மூலம் முன்னொட்டாக இல்லை எழுத்துக்களை மாற்ற நிரல் இல்லை.

92
00:05:47,280 --> 00:05:50,380
மாறாக அவர்கள் தான் வடிவமைப்பு விவரக்குறிப்பு சேர்க்க.

93
00:05:50,380 --> 00:05:56,500
>> எடுத்துக்காட்டாக, GetInt உள்ள வடிவம் சரம் பதிலாக% d இருந்தால்,

94
00:05:56,500 --> 00:05:59,800
sscanf, ஒரு முழு எண்ணாக தொடர்ந்து ஒரு கடிதம் தேடுவார்

95
00:05:59,800 --> 00:06:04,360
அது முழு எண்ணாக மாற்ற முயற்சி செய்யும் போது, அது ஒரு வேறு எதுவும் செய்ய முடியாது என்று.

96
00:06:04,360 --> 00:06:07,440
இந்த ஒரே விதிவிலக்கு இடைவெளி உள்ளது.

97
00:06:07,440 --> 00:06:11,030
வடிவமைப்பு சரம் வெள்ளை இடைவெளி எழுத்துகள் இடைவெளி எந்த அளவு பொருந்தும் -

98
00:06:11,030 --> 00:06:12,890
அனைத்து கூட எவரும்.

99
00:06:12,890 --> 00:06:18,100
கருத்து முன்னணி மற்றும் / அல்லது இடைவெளி பின் அநேகமாக குறிப்பிடுகிறார் ஏன், என்று.

100
00:06:18,100 --> 00:06:22,910
எனவே, இது எங்கள் sscanf அழைப்பு போல் இந்த பயனரின் உள்ளீடு சரம் அலச முயற்சிக்கும்

101
00:06:22,910 --> 00:06:25,380
சாத்தியமான முன்னணி இடைவெளி சரிபார்ப்பு மூலம்,

102
00:06:25,380 --> 00:06:29,300
int மாறி n இல் மாற்றப்படுகிறது மற்றும் சேமிக்கப்படும் என்று ஒரு முழு எண்ணாக தொடர்ந்து

103
00:06:29,300 --> 00:06:33,090
இடைவெளி சில அளவு தொடர்ந்து, ஒரு பாத்திரம் தொடர்ந்து

104
00:06:33,090 --> 00:06:35,810
கரி மாறி கேட்ச் சேமிக்கப்படும்.

105
00:06:35,810 --> 00:06:37,790
>> மீண்டும் மதிப்பு என்ன?

106
00:06:37,790 --> 00:06:41,560
Sscanf, தொடக்கத்தில் இருந்து முடிவு வரை உள்ளீடு வரியை அலச

107
00:06:41,560 --> 00:06:44,860
உள்ளீடு ஒரு பாத்திரம் அது இறுதியில் அடையும் போது நிறுத்தாமல் அல்லது போது

108
00:06:44,860 --> 00:06:49,320
ஒரு வடிவம் தன்மை பொருந்தவில்லை அல்லது ஒரு மாற்ற முடியாது போது.

109
00:06:49,320 --> 00:06:52,690
அதை திரும்ப மதிப்பு அதை நிறுத்தி போது தனித்து பயன்படுத்தப்படுகிறது.

110
00:06:52,690 --> 00:06:55,670
அதை உள்ளீடு சரம் இறுதியில் அடைந்தது, ஏனெனில் இது, நிறுத்தி இருந்தால்

111
00:06:55,670 --> 00:07:00,630
எந்த மாற்றங்களை உருவாக்கும் முன் மற்றும் வடிவமைப்பு சரம் பகுதியாக பொருந்தும் தவறியதாக முன்,

112
00:07:00,630 --> 00:07:04,840
பின்னர் சிறப்பு நிலையான EOF திரும்பினார்.

113
00:07:04,840 --> 00:07:08,200
இல்லையெனில், அது, வெற்றிகரமான மாற்றங்கள் எண்ணிக்கை கொடுக்கிறது

114
00:07:08,200 --> 00:07:14,380
நாம் இரண்டு மாற்றங்கள் கேட்டேன் இருந்து இது, 0, 1, அல்லது 2 முடியும்.

115
00:07:14,380 --> 00:07:19,000
நம் வழக்கில், நாம் பயனர் ஒரு முழு எண்ணாக மட்டுமே ஒரு முழு எண்ணாக தட்டச்சு என்பதை உறுதி செய்ய வேண்டும்.

116
00:07:19,000 --> 00:07:23,370
>> எனவே, நாம் sscanf 1 திரும்ப வேண்டும். ஏன் பார்க்க?

117
00:07:23,370 --> 00:07:26,850
Sscanf 0 திரும்பிய பிறகு, எந்த மாற்றங்கள் செய்யப்பட்டன,

118
00:07:26,850 --> 00:07:31,690
அதனால் பயனர் உள்ளீடு ஆரம்பத்தில் ஒரு முழு எண்ணாக தவிர வேறு ஏதாவது தட்டச்சு.

119
00:07:31,690 --> 00:07:37,100
Sscanf 2 கொடுக்கிறது என்றால், பயனர் ஒழுங்காக, உள்ளீடு ஆரம்பத்தில் அதை தட்டச்சு

120
00:07:37,100 --> 00:07:41,390
ஆனால் அவர்கள் பின்னர் அதன் பின்னர் சில இடைவெளி அல்லாத பாத்திரம் தட்டச்சு

121
00:07:41,390 --> 00:07:44,940
% முதல் கேட்ச் மாற்ற வெற்றி.

122
00:07:44,940 --> 00:07:49,570
ஆஹா, அந்த முற்றிலும் ஒரு செயல்பாடு அழைப்பு ஒரு நீண்ட விளக்கம் தான்.

123
00:07:49,570 --> 00:07:53,460
எப்படியும், நீங்கள் sscanf மற்றும் அதன் உடன்பிறப்புகளில் மேலும் தகவல் வேண்டும் என்றால்,

124
00:07:53,460 --> 00:07:57,130
மனிதன் பக்கங்கள், கூகுள், அல்லது இரண்டையும் பாருங்கள்.

125
00:07:57,130 --> 00:07:58,780
வடிவமைப்பு சரம் விருப்பங்களை நிறைய உள்ளன

126
00:07:58,780 --> 00:08:03,830
சி இல் சரங்களை இட முயற்சிக்கும் போது இந்த நீங்கள் உடல் உழைப்பு நிறைய சேமிக்க முடியும்

127
00:08:03,830 --> 00:08:07,180
>> பார்க்க நூலகத்தில் இறுதி செயல்பாடு GetString உள்ளது.

128
00:08:07,180 --> 00:08:10,310
இது, GetString ஒழுங்காக எழுத ஒரு தந்திரமான செயல்பாடு என்று மாறிவிடும்

129
00:08:10,310 --> 00:08:14,290
இது போன்ற ஒரு எளிமையான, பொது பணி போல் கூட.

130
00:08:14,290 --> 00:08:16,170
ஏன் இந்த நிலை?

131
00:08:16,170 --> 00:08:21,380
சரி, அது எப்படி வரி சேமிக்க போகிறோம் பற்றி யோசிப்போம் என்று உள்ளே பயனர் வகைகள்

132
00:08:21,380 --> 00:08:23,880
ஒரு சரம் எழுத்துகள் வரிசை உள்ளது, ஏனெனில்

133
00:08:23,880 --> 00:08:26,430
நாம், ஸ்டாக் ஒரு வரிசையில் அதை சேமிக்க வேண்டும்

134
00:08:26,430 --> 00:08:31,250
ஆனால் நாம் அதை அறிவிக்க போது வரிசை போகிறது எவ்வளவு தெரியுமா வேண்டும்.

135
00:08:31,250 --> 00:08:34,030
இதேபோல், நாம் குவியல் மீது போட வேண்டும் என்றால்,

136
00:08:34,030 --> 00:08:38,090
நாம், malloc நாம் இருப்பு வேண்டும் பைட்டுகள் எண்ணிக்கையை கடந்து செல்ல வேண்டும்

137
00:08:38,090 --> 00:08:39,730
ஆனால் இந்த சாத்தியமற்றது.

138
00:08:39,730 --> 00:08:42,760
நாம் பயனர் தட்டச்சு எத்தனை எழுத்துகள் தெரியாது

139
00:08:42,760 --> 00:08:46,590
பயனர் உண்மையில் அவர்கள் தட்டச்சு முன்.

140
00:08:46,590 --> 00:08:50,720
>> இந்த பிரச்சினைக்கு ஒரு எளிய தீர்வு தான், விண்வெளி ஒரு பெரிய துண்டின் உண்டு என்று, தான்

141
00:08:50,720 --> 00:08:54,540
பயனர் உள்ளீடு 1000 எழுத்துகள் ஒரு தொகுதி,

142
00:08:54,540 --> 00:08:57,980
பயனர் என்று நீண்ட ஒரு சரம் தட்டச்சு இல்லை என்று அனுமானித்து.

143
00:08:57,980 --> 00:09:00,810
இந்த இரண்டு காரணங்களுக்காக ஒரு மோசமான யோசனை.

144
00:09:00,810 --> 00:09:05,280
முதல், பயனர்கள் பொதுவாக நீண்ட சரங்களை தட்டச்சு என்று அனுமானித்து

145
00:09:05,280 --> 00:09:07,610
நீங்கள் நினைவு நிறைய வீணாக்க முடியாது.

146
00:09:07,610 --> 00:09:10,530
இந்த செய்தால் நவீன கணினிகளில், இந்த சிக்கலை இருக்கலாம்

147
00:09:10,530 --> 00:09:13,890
ஒன்று அல்லது இரண்டு தனித்த வேளைகளில்,

148
00:09:13,890 --> 00:09:17,630
ஆனால் நீங்கள் ஒரு வட்டத்திற்கு பயனர் உள்ளீடு எடுத்து பின்னர் பயன்படுத்த சேமித்து என்றால்,

149
00:09:17,630 --> 00:09:20,870
நீங்கள் விரைவில் நினைவகம் ஒரு டன் வரை சக் முடியும்.

150
00:09:20,870 --> 00:09:24,450
கூடுதலாக, நீங்கள் எழுதி இருக்கும் நிரல் ஒரு சிறிய கணினி உள்ளது -

151
00:09:24,450 --> 00:09:28,100
குறைந்த நினைவகம் ஒரு ஸ்மார்ட்போன் அல்லது வேறு ஏதாவது ஒரு சாதனத்தை -

152
00:09:28,100 --> 00:09:32,060
இந்த தீர்வு நிறைய வேகமாக பிரச்சினைகள் ஏற்படும்.

153
00:09:32,060 --> 00:09:36,450
இந்த செய்ய இரண்டாவது, இன்னும் தீவிரமான காரணம் அது பாதிக்கப்படக்கூடிய உங்கள் திட்டத்தை விட்டு தான்

154
00:09:36,450 --> 00:09:39,710
இடையக வழிவு தாக்குதல் என்று என்ன வேண்டும்.

155
00:09:39,710 --> 00:09:45,840
நிகழ்ச்சிகளில், ஒரு தாங்கல், தற்காலிகமாக உள்ளீடு அல்லது வெளியீடு தரவை சேமிக்க பயன்படும் நினைவு

156
00:09:45,840 --> 00:09:48,980
இந்த வழக்கில் எங்கள் 1000-எரிப்பதை தொகுதி ஆகும்.

157
00:09:48,980 --> 00:09:53,370
தரவு தொகுதி முடிவு கடந்த எழுதிய போது ஒரு இடையக வழிவு ஏற்படும்.

158
00:09:53,370 --> 00:09:57,790
>> உதாரணமாக, ஒரு பயனர் உண்மையில் 1000 க்கும் மேற்பட்ட எழுத்துகள் தட்டச்சு செய்தால்.

159
00:09:57,790 --> 00:10:01,570
வரிசைகள் கொண்ட நிரலாக்க போது தற்செயலாக இந்த அனுபவம்.

160
00:10:01,570 --> 00:10:05,620
நீங்கள் 10 ints ஒரு வரிசை இருந்தால், எதையும் எழுத படிக்க முயற்சி உன்னை தடுப்பது

161
00:10:05,620 --> 00:10:07,810
15 எண்ணாக.

162
00:10:07,810 --> 00:10:10,000
எந்த மொழி எச்சரிக்கைகள் அல்லது பிழைகள் உள்ளன.

163
00:10:10,000 --> 00:10:13,250
திட்டம் மட்டும் நேராக மேலே தவறுகளை மற்றும் நினைவக அணுகல்கள்

164
00:10:13,250 --> 00:10:18,150
அதை நினைக்கும் இடத்தில் 15 எண்ணாக இருக்கும், இந்த மற்ற மாறிகள் மேலெழுத முடியாது.

165
00:10:18,150 --> 00:10:22,040
மோசமான வழக்கில், நீங்கள் உங்கள் நிரல் உள் சில மேலெழுத முடியாது

166
00:10:22,040 --> 00:10:26,820
கட்டுப்பாட்டு இயங்கமைப்புகள், உங்கள் திட்டம் காரணமாக உண்மையில் வேறு வழிமுறைகளை இயக்க

167
00:10:26,820 --> 00:10:28,340
நீங்கள் நோக்கம் விட.

168
00:10:28,340 --> 00:10:31,360
>> இப்போது, அது தற்செயலாக இதை செய்ய பொதுவான இல்லை

169
00:10:31,360 --> 00:10:35,150
ஆனால் இந்த கெட்ட பசங்களா திட்டங்களை உடைக்க பயன்படுத்தும் ஒரு மிகவும் பொதுவான உத்தி

170
00:10:35,150 --> 00:10:39,080
மற்றும் பிற மக்கள் கணினிகளில் தீங்கிழைக்கும் குறியீடு உள்ளது.

171
00:10:39,080 --> 00:10:42,910
எனவே, நாம் நமது உள்நாட்டு தீர்வு பயன்படுத்த முடியாது.

172
00:10:42,910 --> 00:10:45,590
நாம் பாதிக்கப்படக்கூடிய இருந்து நமது திட்டங்களை தடுக்கும் ஒரு வழி வேண்டும்

173
00:10:45,590 --> 00:10:47,880
இடையக வழிவு தாக்குதல்.

174
00:10:47,880 --> 00:10:51,430
இதை செய்ய, நாங்கள் படிக்க நம் இடையக வளர முடியும் என்பதை உறுதி செய்ய வேண்டும்

175
00:10:51,430 --> 00:10:53,850
பயனர் இருந்து மேலும் உள்ளீடு.

176
00:10:53,850 --> 00:10:57,440
தீர்வு? நாம் ஒரு குவியல் ஒதுக்கீடு இடையக பயன்படுத்த.

177
00:10:57,440 --> 00:10:59,950
நாம் மறுஅளவிடும் இருந்து, மறுஅளவீடு realloc செயல்பாட்டை பயன்படுத்தி

178
00:10:59,950 --> 00:11:04,580
நாம் இரண்டு எண்கள் கண்காணிக்க - அடுத்த காலியாக ஸ்லாட் என்ற குறியீட்டு பஃப்பரில்

179
00:11:04,580 --> 00:11:08,390
மற்றும் நீளம் அல்லது தாங்கல் திறன்.

180
00:11:08,390 --> 00:11:13,210
நாம் fgetc செயல்பாட்டை பயன்படுத்தி ஒரு நேரத்தில் பயனர் ஒரு இருந்து எழுத்துகள் படித்தேன்.

181
00:11:13,210 --> 00:11:19,360
stdin - - fgetc விழா எடுக்கும் வாதம், நிலையான உள்ளீட்டு சரத்திற்கு ஒரு குறிப்பு உள்ளது

182
00:11:19,360 --> 00:11:23,810
இது பயனர் உள்ளீடு மாற்ற பயன்படுத்தப்படும் என்று ஒரு preconnected உள்ளீடு தடம்

183
00:11:23,810 --> 00:11:26,270
முனையத்தில் இருந்து நிரல்.

184
00:11:26,270 --> 00:11:29,890
>> அப்போது ஒரு புதிய பாத்திரத்தை பயனர் வகைகள், நாம் பார்க்கவும் என்றால் குறியீட்டு

185
00:11:29,890 --> 00:11:35,810
அடுத்த இலவச ஸ்லாட் மற்றும் பிளஸ் 1 தாங்கல் திறன் அதிகமாக இருக்கும்.

186
00:11:35,810 --> 00:11:39,690
+1, அடுத்த இலவச குறியீட்டு 5 இருந்தால் தான் வருகிறது

187
00:11:39,690 --> 00:11:44,150
பிறகு எங்கள் இடையக இன் நீளம் 6 நன்றி 0 பிரித்தல் வேண்டும்.

188
00:11:44,150 --> 00:11:48,350
நாம் இடையக இட ரன் அவுட் இருந்தால், நாம், அது அளவை முயற்சி

189
00:11:48,350 --> 00:11:51,690
நாம் அளவை என்று மடங்கு எண்ணிக்கை குறைக்கப்பட்டது அதனால் அதை இரட்டிப்பாக்க

190
00:11:51,690 --> 00:11:54,760
பயனர் உண்மையில் நீண்ட சரம் தட்டச்சு செய்ய வேண்டும்.

191
00:11:54,760 --> 00:11:57,950
சரம் நீண்ட சென்றிருக்கிறது அல்லது நாம் குவியல் நினைவகம் ரன் அவுட் என்றால்,

192
00:11:57,950 --> 00:12:01,350
நாம் தடுப்பு மற்றும் மீண்டும் பூஜ்ய விடுவித்து.

193
00:12:01,350 --> 00:12:04,170
>> இறுதியாக, நாம் பஃபர் எரிப்பதை சேர்க்க.

194
00:12:04,170 --> 00:12:08,200
பயனர் வெற்றி உள்ளிடவும் அல்லது திருப்பி, ஒரு புதிய வரி சமிக்ஞை முறை

195
00:12:08,200 --> 00:12:12,050
அல்லது சிறப்பு எரிப்பதை - கட்டுப்பாடு ஈ - உள்ளீடு ஒரு முடிவுக்கு அடையாளம் இது,

196
00:12:12,050 --> 00:12:16,240
நாம் பயனர் உண்மையில் எதுவுமே தட்டச்சு என்பதை ஒரு சோதனை செய்ய.

197
00:12:16,240 --> 00:12:18,820
இல்லை என்றால், நாம் பூஜ்ஜிய திருப்பி.

198
00:12:18,820 --> 00:12:22,280
இல்லையென்றால், எங்கள் இடையக நாம் வேண்டும் விட பெரிய ஏனெனில்,

199
00:12:22,280 --> 00:12:24,830
மோசமான நிலையில் நாம் வேண்டும் என கிட்டத்தட்ட இரு மடங்கு பெரியதாக

200
00:12:24,830 --> 00:12:27,830
நாம் அளவை ஒவ்வொரு முறையும் இரட்டை, முதல்

201
00:12:27,830 --> 00:12:31,840
நாம் வேண்டும் என்று இடத்தை மட்டும் அளவு பயன்படுத்தி சரம் ஒரு புதிய நகலை உருவாக்கும்.

202
00:12:31,840 --> 00:12:34,220
நாம், malloc அழைப்பு ஒரு கூடுதல் 1 சேர்க்க

203
00:12:34,220 --> 00:12:37,810
\ 0 - சிறப்பு பூஜ்ய அழிப்பு தன்மை இடைவெளி இருக்கிறது என்று

204
00:12:37,810 --> 00:12:41,990
இதில் நாம் எழுத்துக்கள் ஏனைய நகலெடுக்க முறை நாம் சரத்திற்கு append,

205
00:12:41,990 --> 00:12:45,060
அதற்கு பதிலாக strcpy என்ற strncpy பயன்படுத்தி

206
00:12:45,060 --> 00:12:48,830
அதனால் நாம் நகலெடுக்க வேண்டும் எத்தனை எழுத்துகள் குறிப்பிட முடியும்.

207
00:12:48,830 --> 00:12:51,690
அது ஒரு \ 0 பலி வரை Strcpy நகலெடுக்கிறது.

208
00:12:51,690 --> 00:12:55,740
நாம் நம் இடையக விடுவித்து மற்றும் அழைப்பவர் செய்ய நகலை திருப்பி.

209
00:12:55,740 --> 00:12:59,840
>> யார் ஒரு எளிய-காணப்படும் செயல்பாடு மிகவும் சிக்கலான முடியும் தெரியும்?

210
00:12:59,840 --> 00:13:02,820
இப்போது நீங்கள் CS50 நூலகம் செல்வது என்ன தெரியும்.

211
00:13:02,820 --> 00:13:06,470
>> என் பெயர் நேட் Hardison, மற்றும் இந்த CS50 உள்ளது.

212
00:13:06,470 --> 00:13:08,350
[CS50.TV]