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
బహుశా చాలా గుప్తమైన కనిపించే భాగం యూజర్ యొక్క ఇన్పుట్ కావలసిన విధంగా విభజిస్తుంది ఆ 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
ఆ పాత్ర, C స్ట్రింగ్ మొదటి అక్షరం ఉండాలి

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
గమనికలు పాస్ - ఆంపర్సండ్ చిహ్నం - మరియు తర్వాత చిరునామా ఆపరేటర్లు ఉపయోగించడానికి

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 అనే ఒక Int మరియు స్టాక్ ఒక చార్ కాల్ సి డిక్లేర్

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
అది Int మార్చేందుకు ప్రయత్నిస్తామని, ఇది ఒక తో ఇంకా ఏమి లేదు.

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 మతం మరియు నిల్వ చేయబడుతుంది ఒక Int తరువాత

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
మా సందర్భంలో, మేము వినియోగదారు ఒక Int మరియు మాత్రమే ఒక Int లో టైప్ చేసి నిర్ధారించుకోవాలి.

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
man పేజీలను, Google, లేదా రెండూ చూడండి.

125
00:07:57,130 --> 00:07:58,780
ఫార్మాట్ స్ట్రింగ్ ఐచ్చికాలను మా ఉన్నాయి

126
00:07:58,780 --> 00:08:03,830
C. లో తీగలను అన్వయించడం ప్రయత్నిస్తున్నప్పుడు మరియు ఈ మీరు శారీరక శ్రమ చాలా సేవ్ చేయవచ్చు

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 Int.

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 వ Int ఉంటుంది, మరియు ఇది మీ ఇతర అంశాలపై తిరిగి రాస్తుంది చేయవచ్చు.

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
లేదా ప్రత్యేక చార్ - నియంత్రణ d - ఇన్పుట్ సిగ్నల్స్ యాన్ ఎండ్ ఇది,

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
ఇది మేము అక్షరాలు మిగిలిన కాపీ ఒకసారి మేము స్ట్రింగ్ కు జోడించు,

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]