1
00:00:00,000 --> 00:00:00,499

2
00:00:00,499 --> 00:00:01,395
[సంగీతాన్ని]

3
00:00:01,395 --> 00:00:05,590

4
00:00:05,590 --> 00:00:07,940
>> డౌ LLOYD: OK కాబట్టి ఒక సలహా
ఇక్కడ ప్రారంభించటానికి ముందు.

5
00:00:07,940 --> 00:00:11,660
మీరు వీడియో వీక్షించారు ఉండకపోతే
కాబట్టి మీరు మొదటి చేయాలనుకుంటున్నారా ఉండవచ్చు గమనికలు.

6
00:00:11,660 --> 00:00:15,860
ఈ వీడియో ఎందుకంటే మరొక
గమనికలు పని యొక్క మార్గం.

7
00:00:15,860 --> 00:00:17,574
>> కనుక ఇది మాట్లాడటానికి జరగబోతోంది
కొన్ని అంశాల గురించి

8
00:00:17,574 --> 00:00:19,490
మేము లో కవర్ ఆ
వీడియో గమనికలు, మరియు మేము ఉన్నాము

9
00:00:19,490 --> 00:00:21,948
ఇప్పుడు వాటిని ఉపేక్షించ అన్నారు,
వారు ఇప్పటికే అని ఊహిస్తూ

10
00:00:21,948 --> 00:00:23,090
విధమైన అర్థం.

11
00:00:23,090 --> 00:00:25,440
కాబట్టి కేవలం మీ సరసమైన హెచ్చరిక వార్తలు
మీరు ఈ వీడియో చూస్తూ ఉన్నట్లయితే

12
00:00:25,440 --> 00:00:27,814
మరియు మీరు చూడని
గమనికలు వీడియో, అది బలం విధమైన

13
00:00:27,814 --> 00:00:29,610
మీ తలపై ఒక చిన్న బిట్ ఫ్లై.

14
00:00:29,610 --> 00:00:32,080
కాబట్టి అది మంచి కావచ్చు
ఆ క్రమంలో అది చూడటానికి.

15
00:00:32,080 --> 00:00:34,710
>> కాబట్టి మేము ఇప్పటికే ఒక చూసిన
మార్గం, పాయింటర్లు పని

16
00:00:34,710 --> 00:00:37,810
ఇది మేము ఒక డిక్లేర్ ఉంది
వేరియబుల్, మరియు అప్పుడు మేము

17
00:00:37,810 --> 00:00:42,160
ఒక పాయింటర్ మరొక వేరియబుల్ డిక్లేర్
వేరియబుల్, అది చూపాడు.

18
00:00:42,160 --> 00:00:44,870
కాబట్టి మేము సృష్టించిన ఒక
ఒక పేరుతో వేరియబుల్, మేము చేసిన

19
00:00:44,870 --> 00:00:48,480
ఒక పేరు తో రెండవ వేరియబుల్ రూపొందించినవారు
మరియు మేము రెండవ వేరియబుల్ అభిప్రాయపడుతున్నారు

20
00:00:48,480 --> 00:00:50,220
మొదట.

21
00:00:50,220 --> 00:00:52,370
ఈ విధమైన ఉంది ఒక
సమస్య అయితే, అది ఎందుకంటే

22
00:00:52,370 --> 00:00:54,650
సరిగ్గా తెలుసు మాకు అవసరం
ఎంత మెమరీ మేము ఉన్నాము

23
00:00:54,650 --> 00:00:57,600
క్షణం అవసరం అన్నారు
మా కార్యక్రమం సంగ్రహించబడింది.

24
00:00:57,600 --> 00:00:58,220
>> ఎందుకు అని?

25
00:00:58,220 --> 00:01:03,338
మేము పేరు చెయ్యలేరు అవసరం ఎందుకంటే లేదా
సాధ్యం వేరియబుల్స్ యొక్క అన్ని గుర్తించడానికి

26
00:01:03,338 --> 00:01:04,129
మేము ఎదుర్కొనే కొన్ని.

27
00:01:04,129 --> 00:01:07,910
మేము ఉండవచ్చు అని ఒక శ్రేణి కలిగి ఉండవచ్చు
సమాచారం చాలా పట్టుకునే సామర్ధ్యాన్ని,

28
00:01:07,910 --> 00:01:10,110
కానీ ఇప్పటికీ కాదు
తగినంత ఖచ్చితంగా కచ్చితమైన.

29
00:01:10,110 --> 00:01:12,640
మనం తెలియదు ఉంటే,
మనం ఏ ఆలోచన ఉంటే

30
00:01:12,640 --> 00:01:14,370
ఎంత మేము కంపైల్ సమయంలో చేయాలి?

31
00:01:14,370 --> 00:01:17,020
లేదా ఏ మా కార్యక్రమం రెడీ ఉంటే
ఒక నిజంగా దీర్ఘ సమయం కోసం అమలు,

32
00:01:17,020 --> 00:01:19,810
వివిధ యూజర్ అంగీకరించడం
డేటా, మరియు మేము కాదు నిజంగా

33
00:01:19,810 --> 00:01:23,170
మేము ఉన్నామా అంచనా
1,000 యూనిట్లు అవసరం వెళ్తున్నారు?

34
00:01:23,170 --> 00:01:26,060
>> ఇది మేము చెయ్యవచ్చు ఇష్టం లేదు
కమాండ్ లైన్ వద్ద చెప్పటానికి

35
00:01:26,060 --> 00:01:28,040
ఎన్ని అంశాలు ఎంటర్
మీరు అవసరం అనుకుంటున్నాను.

36
00:01:28,040 --> 00:01:31,100
Well ఆ అంచనా తప్పు ఏమి ఉంది?

37
00:01:31,100 --> 00:01:34,300
డైనమిక్ మెమరీ కేటాయింపు
విధమైన మాకు మార్గం అనుమతిస్తుంది

38
00:01:34,300 --> 00:01:36,867
ఈ ప్రత్యేక సమస్య చుట్టూ పొందడానికి.

39
00:01:36,867 --> 00:01:38,700
మరియు మార్గం అది చేస్తుంది
గమనికలు ఉపయోగించి ఉంది.

40
00:01:38,700 --> 00:01:42,140
>> మేము గమనికలు ఉపయోగించవచ్చు
డైనమిక్ ప్రాప్తిని పొందండి

41
00:01:42,140 --> 00:01:45,710
అని కేటాయించిన మెమొరీ, మెమొరీ
మీ ప్రోగ్రామ్ వలె కేటాయించింది నడుస్తుంటే.

42
00:01:45,710 --> 00:01:48,290
ఇది కంపైల్ సమయంలో కేటాయించబడుతుంది కాదు.

43
00:01:48,290 --> 00:01:51,570
చేసినప్పుడు మీరు డైనమిక్ కేటాయించాలని
మెమరీ అది ఒక కొలను నుండి వస్తుంది

44
00:01:51,570 --> 00:01:53,795
మెమరీ కుప్ప అని పిలుస్తారు.

45
00:01:53,795 --> 00:01:56,420
మేము చేసిన గతంలో అన్ని మెమరీ
కోర్సు లో పని

46
00:01:56,420 --> 00:01:59,920
పూల్ నుండి వస్తున్నాడు
మెమరీ స్టాక్ అని పిలుస్తారు.

47
00:01:59,920 --> 00:02:02,470
ఒక మంచి మార్గం సాధారణంగా
మనసు మరియు ఈ నియమం పెట్టుకోండి

48
00:02:02,470 --> 00:02:04,720
ఎల్లప్పుడూ నిజాన్ని నిలువరించదు
కానీ అందంగా చాలా దాదాపు

49
00:02:04,720 --> 00:02:09,940
ఎల్లప్పుడూ true-- ఏ ఉంది కలిగి
సమయం మీరు ఒక వేరియబుల్ పేరు ఇచ్చి

50
00:02:09,940 --> 00:02:12,090
బహుశా స్టాక్ లో నివసిస్తూ ఉంటాడు.

51
00:02:12,090 --> 00:02:14,650
మరియు ఏ సమయంలో మీరు లేదు
ఒక వేరియబుల్ పేరు ఇవ్వడం,

52
00:02:14,650 --> 00:02:19,160
మీరు డైనమిక్ మెమరీ చేయవచ్చు ఇది
కేటాయింపు, అది కుప్ప లో నివసిస్తూ ఉంటాడు.

53
00:02:19,160 --> 00:02:22,190
>> ఇప్పుడు నేను రకమైన ప్రదర్శించబడింది చేస్తున్నాను
మెమరీ యొక్క ఈ రెండు కొలనులు ఉంది ఉంటే.

54
00:02:22,190 --> 00:02:24,740
కానీ మీరు ఈ చూసిన
సాధారణంగా ఇది రేఖాచిత్రం,

55
00:02:24,740 --> 00:02:27,290
ఒక ప్రాతినిధ్యాన్ని
ఏం మెమరీ కనిపిస్తుంది

56
00:02:27,290 --> 00:02:30,373
మరియు మేము అన్ని గురించి శ్రద్ధ వెళ్ళడం లేదు చేస్తున్నాం
టాప్ మరియు దిగువన stuff.

57
00:02:30,373 --> 00:02:33,580
మనం పట్టించుకోనట్లు ఈ భాగం
ఇక్కడ మధ్యలో, కుప్ప మరియు స్టాక్.

58
00:02:33,580 --> 00:02:35,570
మీరు గమనిస్తే
ఈ చిత్రంలో చూడటం,

59
00:02:35,570 --> 00:02:38,390
ఈ నిజానికి రెండు కాదు
మెమరీ ప్రత్యేక కొలనులు.

60
00:02:38,390 --> 00:02:42,757
ఇది మెమరీ ఒకటి shared పూల్ వార్తలు
ఇక్కడ మీరు ఈ దృశ్య లో, ప్రారంభం

61
00:02:42,757 --> 00:02:44,590
మీరు దిగువన ప్రారంభం
మరియు భర్తీకి మొదలు

62
00:02:44,590 --> 00:02:48,040
స్టాక్ తో క్రింద, మరియు మీరు నుండి
ఎగువన ప్రారంభం మరియు నింపి మొదలు

63
00:02:48,040 --> 00:02:50,072
కుప్ప తో పై నుండి క్రిందికి.

64
00:02:50,072 --> 00:02:51,780
కానీ అది నిజంగా ఉంది
అదే పూల్, అది కేవలం

65
00:02:51,780 --> 00:02:56,050
వివిధ మచ్చలు, వివిధ ప్రాంతాల్లో
మెమరీలో కేటాయించింది చేస్తున్నారు.

66
00:02:56,050 --> 00:02:59,060
మరియు మీరు రన్నవుట్ చేయవచ్చు
గాని ద్వారా మెమరీ

67
00:02:59,060 --> 00:03:01,240
కుప్ప అన్ని మార్గం వెళ్ళి
దిగువ, లేదా

68
00:03:01,240 --> 00:03:05,440
స్టాక్ టాప్ అన్ని మార్గం వెళ్ళి
లేదా కుప్ప మరియు స్టాక్ కలిగి

69
00:03:05,440 --> 00:03:06,740
ఒకరితోఒకరు కలిసే.

70
00:03:06,740 --> 00:03:09,500
ఆ అన్ని పరిస్థితులు ఉంటుంది
మీ ప్రోగ్రామ్ కారణం

71
00:03:09,500 --> 00:03:11,030
మెమరీ రన్నవుట్.

72
00:03:11,030 --> 00:03:11,952
కాబట్టి గుర్తుంచుకోండి.

73
00:03:11,952 --> 00:03:13,660
మేము గురించి మాట్లాడేటప్పుడు
కుప్ప మరియు స్టాక్

74
00:03:13,660 --> 00:03:17,880
మేము నిజంగా గురించి మాట్లాడుతున్నారు
మెమరీ అదే సాధారణ భాగం, కేవలం

75
00:03:17,880 --> 00:03:21,930
ఆ స్మృతి వివిధ భాగాలను కలిగి ఉంది.

76
00:03:21,930 --> 00:03:24,910
>> కాబట్టి మేము డైనమిక్ ఎలా వస్తుందా
మొదటి స్థానంలో మెమరీ కేటాయించింది?

77
00:03:24,910 --> 00:03:27,740
మా కార్యక్రమం పొందుటకు లేదు ఎలా
ఇది అమలు వంటి మెమరీ?

78
00:03:27,740 --> 00:03:32,660
బాగా సి అనే ఫంక్షన్ అందిస్తుంది
malloc, మెమరీ ఎలొకేటర్, ఇది

79
00:03:32,660 --> 00:03:36,810
మీరు ఒక కాల్, మరియు మీరు పాస్
మీరు ఎన్ని అనుకుంటున్నారు మెమరీ బైట్లు.

80
00:03:36,810 --> 00:03:39,940
మీ ప్రోగ్రామ్ రన్ చేస్తే
మరియు మీరు ఒక పూర్ణాంకం రన్టైమ్ కావాలి,

81
00:03:39,940 --> 00:03:46,040
మీరు నాలుగు బైట్లు మాలోక్ ఉండవచ్చు
జ్ఞాపకశక్తి, malloc నాలుగు కుండలీకరణాలు.

82
00:03:46,040 --> 00:03:48,540
>> మాలోక్ ద్వారా వెళ్తుంది
కుప్ప ద్వారా చూడటం,

83
00:03:48,540 --> 00:03:50,750
మేము డైనమిక్ ఉన్నాము ఎందుకంటే
మెమరీ కేటాయించడం

84
00:03:50,750 --> 00:03:53,500
మరియు అది మీకు తిరిగి వచ్చును
ఆ స్మృతి ఒక పాయింటర్.

85
00:03:53,500 --> 00:03:56,180
ఇది మీరు ఆ మెమొరీ ఇవ్వదు
అది ఒక పేరు ఇవ్వదు,

86
00:03:56,180 --> 00:03:57,950
మీరు దాన్ని ఒక పాయింటర్ ఇస్తుంది.

87
00:03:57,950 --> 00:04:00,780
మళ్ళీ నేను చెప్పవలసింది చెప్పాను కాబట్టి ఆ
అది బహుశా ముఖ్యం

88
00:04:00,780 --> 00:04:03,770
గమనికలు వీడియో వీక్షించారు
మేము ఈ లోకి చాలా దూరం పొందడానికి ముందు.

89
00:04:03,770 --> 00:04:05,940
కాబట్టి malloc జరగబోతోంది
ఒక పాయింటర్ మీరు తిరిగి ఇవ్వాలని.

90
00:04:05,940 --> 00:04:08,950
>> మాలోక్ మీరు ఏ ఇవ్వాలని పోతే
మెమరీ మీరు రన్నవుట్ చేసిన ఎందుకంటే,

91
00:04:08,950 --> 00:04:10,645
అది ఒక నల్ పాయింటర్ మీరు తిరిగి ఇవ్వాలని చేస్తాము.

92
00:04:10,645 --> 00:04:15,282
మీరు మేము ఏమవుతుంది గుర్తు
ప్రయత్నించండి మరియు ఒక నల్ పాయింటర్ dereference?

93
00:04:15,282 --> 00:04:17,019
మేము కుడి, ఒక seg తప్పు గురవుతాయి?

94
00:04:17,019 --> 00:04:18,060
ఆ బహుశా మంచి కాదు.

95
00:04:18,060 --> 00:04:21,579
>> కాబట్టి ప్రతి సమయం మీరు ఒక కాల్ చేయడానికి
ఎప్పుడూ ఎల్లప్పుడూ మీరు malloc

96
00:04:21,579 --> 00:04:25,270
తనిఖీ చెయ్యాలి లేదో
మీరు బ్యాక్ శూన్య ఇచ్చింది పాయింటర్.

97
00:04:25,270 --> 00:04:28,800
అది ఉంటే, మీరు మీ కార్యక్రమం ముగింపు అవసరం
మీరు dereference ప్రయత్నిస్తే, ఎందుకంటే

98
00:04:28,800 --> 00:04:31,360
మీరు వెళుతున్న నల్ పాయింటర్
విభజన లోపంగా బాధలు

99
00:04:31,360 --> 00:04:34,380
మరియు మీ ప్రోగ్రామ్ ఉంది
ఏమైనప్పటికీ క్రాష్ అన్నారు.

100
00:04:34,380 --> 00:04:37,190
సో ఎలా గణాంకపరంగా మేము ఏమి
పూర్ణాంకం పొందటానికి?

101
00:04:37,190 --> 00:04:37,730
>> పూర్ణాంకానికి x.

102
00:04:37,730 --> 00:04:40,010
మేము బహుశా ఆ చేసిన
కొంత, కుడి?

103
00:04:40,010 --> 00:04:43,480
ఈ అనే వేరియబుల్ సృష్టిస్తుంది
స్టాక్ నివసిస్తుంది x.

104
00:04:43,480 --> 00:04:46,190
ఎలా మేము డైనమిక్ పూర్ణాంకం పొందటానికి లేదు?

105
00:04:46,190 --> 00:04:50,010
Int స్టార్ px malloc 4 సమానం.

106
00:04:50,010 --> 00:04:53,050
>> లేదా సంబంధించిన
మేము Int స్టార్ px చెప్పేవాడిని

107
00:04:53,050 --> 00:04:57,680
, Int malloc పరిమాణం సమానం
కొన్ని తక్కువ త్రో

108
00:04:57,680 --> 00:04:59,740
మా కార్యక్రమం చుట్టూ మాయా సంఖ్యలు.

109
00:04:59,740 --> 00:05:04,140
ఈ మాకు పొందటానికి అన్నారు
కుప్ప నుండి మెమరీ నాలుగు బైట్లు,

110
00:05:04,140 --> 00:05:06,720
మరియు చూపుడు మేము పొందుటకు
అది తిరిగి px అంటారు.

111
00:05:06,720 --> 00:05:08,430
మరియు తర్వాత మేము చేసిన కేవలం వంటి
మేము గతంలో చేసిన

112
00:05:08,430 --> 00:05:13,966
చెయ్యవచ్చు px, dereference
ఆ మెమొరీ యాక్సెస్.

113
00:05:13,966 --> 00:05:15,590
ఎలా మేము వినియోగదారు నుండి ఒక పూర్ణ వస్తుందా?

114
00:05:15,590 --> 00:05:17,970
మేము Int x పూర్ణాంకానికి పొందండి సమానం చెప్పగలను.

115
00:05:17,970 --> 00:05:19,930
ఆ అందమైన సూటిగా ఉంది.

116
00:05:19,930 --> 00:05:24,030
మేము ఒక అర్రే సృష్టించడానికి ఏమి కావాలా
స్టాక్ నివసిస్తున్న తేలటం x?

117
00:05:24,030 --> 00:05:28,210
ఆ పేరు stack_array-- తేలుతూ
మా శ్రేణి చదరపు బ్రాకెట్లలో x యొక్క.

118
00:05:28,210 --> 00:05:32,419
ఆ మాకు వ్యూహం సృష్టిస్తుంది
స్టాక్ నివసిస్తున్న తేలటం x.

119
00:05:32,419 --> 00:05:34,960
మేము తేలియాడుతున్న వ్యూహం సృష్టించవచ్చు
ఆ చాలా, కుప్ప లో నివసిస్తూ ఉంటాడు.

120
00:05:34,960 --> 00:05:37,330
సింటాక్స్ ఒక చూడండి ఉండవచ్చు
మరింత గజిబిజిగా చిన్న

121
00:05:37,330 --> 00:05:41,740
కానీ మేము ఫ్లోట్ చెప్పగలను
స్టార్ heap_array సమానం

122
00:05:41,740 --> 00:05:44,360
malloc x సార్లు ఫ్లోట్ యొక్క పరిమాణం.

123
00:05:44,360 --> 00:05:48,160
నేను పట్టుకోండి తగినంత గది అవసరం
x పాయింట్ విలువలు తేలు.

124
00:05:48,160 --> 00:05:51,560
కాబట్టి నేను 100 అవసరం చెప్పడానికి
తేలటం, లేదా 1,000 తేలియాడే.

125
00:05:51,560 --> 00:05:54,810
కాబట్టి ఆ సందర్భంలో అది ఉంటుంది
100 తేలియాడుతున్న 400 బైట్లు,

126
00:05:54,810 --> 00:05:59,080
లేదా 1,000 తేలియాడుతున్న 4,000 బైట్లు,
ప్రతి ఫ్లోట్ తీసుకుంటుంది ఎందుకంటే

127
00:05:59,080 --> 00:06:01,230
స్థలం నాలుగు బైట్లు.

128
00:06:01,230 --> 00:06:05,110
>> ఈ చేయడం తర్వాత నేను ఉపయోగించవచ్చు
heap_array లో చదరపు బ్రాకెట్ సింటాక్స్.

129
00:06:05,110 --> 00:06:08,970
జస్ట్ నేను stack_array చేస్తాను, నేను
వ్యక్తిగతంగా తన మూలకాలు యాక్సెస్ చేయవచ్చు

130
00:06:08,970 --> 00:06:11,590
ఉపయోగించి heap_array సున్నా, heap_array ఒకటి.

131
00:06:11,590 --> 00:06:15,800
కానీ మేము అలా కారణం గుర్తుకు
ఎందుకంటే సి ఒక శ్రేణి పేరు

132
00:06:15,800 --> 00:06:19,990
నిజంగా ఒక పాయింటర్ ఉంది
ఆ శ్రేణి యొక్క మొదటి మూలకం.

133
00:06:19,990 --> 00:06:23,480
మేము ఒక ప్రకటించారు చేస్తున్నారు వాస్తవం కాబట్టి
ఇక్కడ స్టాక్ తెప్పల శ్రేణి

134
00:06:23,480 --> 00:06:24,810
నిజానికి ఒక బిట్ పక్కదారి పట్టిస్తుంది.

135
00:06:24,810 --> 00:06:27,600
మేము నిజంగా ఉంటాయి
అక్కడ రెండవ లైన్ కోడ్

136
00:06:27,600 --> 00:06:32,360
కూడా ఒక భాగం ఒక పాయింటర్ సృష్టించడం
మేము అప్పుడు కొన్ని పని చేసే మెమరీ.

137
00:06:32,360 --> 00:06:35,620
>> ఇక్కడ పెద్ద సమస్య వార్తలు
డైనమిక్ అయితే మెమరీ కేటాయించింది,

138
00:06:35,620 --> 00:06:38,360
ఇది నిజంగా ఎందుకు ఈ ఉంది
కొన్ని మంచి అలవాట్లు అభివృద్ధి ముఖ్యం

139
00:06:38,360 --> 00:06:39,800
మీరు అది పని చేస్తున్నారు.

140
00:06:39,800 --> 00:06:43,060
గణాంకపరంగా ప్రకటించింది కాకుండా
మెమరీ మీ మెమరీ

141
00:06:43,060 --> 00:06:46,790
స్వయంచాలకంగా తిరిగి లేదు
మీ ఫంక్షన్ జరుగుతుంది ఉన్నప్పుడు వ్యవస్థ.

142
00:06:46,790 --> 00:06:49,280
మేము ప్రధాన ఉన్నాయి, మరియు కనుక
ప్రధాన ఒక ఫంక్షన్ కాల్స్

143
00:06:49,280 --> 00:06:53,860
f పూర్తయింది f అది ఎప్పుడు చేయుచున్నాడు సంసార
మరియు ప్రోగ్రామ్ యొక్క నియంత్రణ తిరిగి

144
00:06:53,860 --> 00:06:58,810
తిరిగి, ప్రధాన వరకు మెమొరీ
ఉపయోగించిన f తిరిగి ఇవ్వబడుతుంది.

145
00:06:58,810 --> 00:07:01,250
ఇది మళ్ళీ ఉపయోగించవచ్చు
కొన్ని ఇతర ప్రోగ్రామ్ ద్వారా

146
00:07:01,250 --> 00:07:04,250
లేదా కొన్ని ఇతర చర్య, ఆ
ప్రధాన తర్వాత అని చెపుతాడు.

147
00:07:04,250 --> 00:07:06,970
ఇది మళ్ళీ అదే మెమరీ పైగా ఉపయోగించవచ్చు.

148
00:07:06,970 --> 00:07:09,620
>> మీరు గతికంగా
అయితే మెమరీని కేటాయించాల్సిన

149
00:07:09,620 --> 00:07:14,380
మీరు స్పష్టంగా చెప్పడం కలిగి
మీరు పూర్తి చేసిన వ్యవస్థ.

150
00:07:14,380 --> 00:07:18,370
ఇది అనుకొనుట, మీరు దానిని పై నొక్కి చేస్తాము
మీరు నడుస్తున్న ఒక సమస్యకు దారితీస్తుంది

151
00:07:18,370 --> 00:07:19,290
మెమరీ.

152
00:07:19,290 --> 00:07:22,179
నిజానికి మేము కొన్నిసార్లు చూడండి
మెమొరీ లీక్ దీన్ని.

153
00:07:22,179 --> 00:07:24,970
మరియు కొన్నిసార్లు ఈ మెమరీ లీకేజ్
నిజానికి నిజంగా వినాశకరమైన ఉంటుంది

154
00:07:24,970 --> 00:07:27,020
వ్యవస్థ నటనకు.

155
00:07:27,020 --> 00:07:31,120
>> మీరు తరచుగా ఇంటర్నెట్ వినియోగదారు అయితే
మీరు కొన్ని వెబ్ బ్రౌజర్లు ఉపయోగించుకునే

156
00:07:31,120 --> 00:07:35,630
మరియు నేను ఇక్కడ పేర్లు పేరు, కానీ
కొన్ని వెబ్ బ్రౌజర్లు అక్కడ ఉన్నాయి

157
00:07:35,630 --> 00:07:39,150
నిజానికి కలిగి గాంచాయి
స్థిరంగా పొందడానికి లేని మెమరీ లీకేజ్.

158
00:07:39,150 --> 00:07:44,570
మరియు మీరు మీ బ్రౌజర్ ఓపెన్ వదిలేస్తే
సమయం చాలా కాలం కోసం, రోజులు

159
00:07:44,570 --> 00:07:48,060
మరియు రోజుల లేదా వారాల, మీరు కొన్నిసార్లు
మీ సిస్టమ్ గమనిస్తారు

160
00:07:48,060 --> 00:07:49,790
నిజంగా నెమ్మదిగా, నిజంగా నడుస్తున్న ఉంది.

161
00:07:49,790 --> 00:07:54,640
మరియు ఆ కారణం ఉంది
బ్రౌజర్, మెమరీ కేటాయించింది

162
00:07:54,640 --> 00:07:57,320
కానీ అప్పుడు వ్యవస్థ చెప్పలేదు
అది తో ప్రదర్శనతో.

163
00:07:57,320 --> 00:08:01,000
అందువలన, తక్కువ మెమరీ ఆకులు
మీ ఇతర కార్యక్రమాలు అన్ని కోసం అందుబాటులో

164
00:08:01,000 --> 00:08:04,480
మీరు ఉన్నాము ఎందుకంటే, పంచుకునేందుకు కలిగి
వెబ్ బ్రౌజర్ leaking--

165
00:08:04,480 --> 00:08:06,755
కార్యక్రమం మెమరీ బహిర్గతం ఉంది.

166
00:08:06,755 --> 00:08:08,880
మేము తిరిగి మెమరీ ఇవ్వాలని లేదు ఎలా
మేము అది పూర్తి చేసినప్పుడు?

167
00:08:08,880 --> 00:08:10,838
బాగా అదృష్టవశాత్తూ అది ఒక వార్తలు
దీన్ని చాలా సులభమైన మార్గం.

168
00:08:10,838 --> 00:08:11,710
మేము దానిని విడిపించేందుకు.

169
00:08:11,710 --> 00:08:15,020
ఉచిత అని ఒక ఫంక్షన్ ఉంది,
అది స్మృతి ఒక పాయింటర్ అంగీకరిస్తుంది

170
00:08:15,020 --> 00:08:16,010
మరియు మేము అన్నిటికి ఉన్నాము.

171
00:08:16,010 --> 00:08:18,310
>> కాబట్టి యొక్క మేము చేస్తున్నారు అనుకోండి
మా కార్యక్రమం మధ్యలో,

172
00:08:18,310 --> 00:08:21,970
మేము 50 అక్షరాలు malloc అనుకుంటున్నారా.

173
00:08:21,970 --> 00:08:25,710
మేము చెయ్యవచ్చు వ్యూహం malloc అనుకుంటున్నారా
50 అక్షరాలు సమర్ధుడు.

174
00:08:25,710 --> 00:08:29,109
మరియు మేము తిరిగి ఒక పాయింటర్ పొందండి ఉన్నప్పుడు
ఆ పాయింటర్ యొక్క పేరు పదం.

175
00:08:29,109 --> 00:08:30,900
మేము ఉన్నాము పనులను
పదం చేయబోవడం,

176
00:08:30,900 --> 00:08:33,440
ఆపై మేము ఉన్నప్పుడు
మేము దానిని విడిపించేందుకు పూర్తయింది.

177
00:08:33,440 --> 00:08:37,460
ఇప్పుడు మేము ఆ 50 ఇచ్చాయి
తిరిగి సిస్టమ్కు మెమరీ బైట్లు.

178
00:08:37,460 --> 00:08:40,147
కొన్ని ఇతర చర్య వాటిని ఉపయోగించవచ్చు.

179
00:08:40,147 --> 00:08:43,480
మేము ఒక బాధ గురించి ఆందోళన చెందనవసరం లేదు
మెమొరీ లీక్ మేము పదం విముక్తి ఎందుకంటే.

180
00:08:43,480 --> 00:08:46,639
మేము తిరిగి మెమరీ ఇచ్చాను,
కాబట్టి మేము అది పని పూర్తి చేసిన.

181
00:08:46,639 --> 00:08:48,430
సో మూడు ఉన్నాయి
ఆ తప్పక బంగారు నియమాలు

182
00:08:48,430 --> 00:08:51,700
మీరు ఎప్పుడు ఉన్నా మనస్సు లో ఉంచబడిన
డైనమిక్ మెమరీ పెడుతోంది

183
00:08:51,700 --> 00:08:52,990
malloc తో.

184
00:08:52,990 --> 00:08:56,480
మెమరీ ప్రతి మూసే
మీరు malloc విముక్తి చేయాలి

185
00:08:56,480 --> 00:08:58,430
మీ కార్యక్రమాన్ని ముందు నడుస్తున్న అంతమవుతుంది.

186
00:08:58,430 --> 00:09:02,029
ఇప్పుడు మళ్ళీ, పరికరంలోని లేదా
IDE ఈ విధమైన ఏమైనప్పటికీ మీరు జరుగుతుంది

187
00:09:02,029 --> 00:09:04,820
మీరు కెన్ ఉన్నప్పుడు ఈ ఏమైనప్పటికీ జరగవచ్చు
మీ కార్యక్రమాన్ని రద్దు చేయబడితే,

188
00:09:04,820 --> 00:09:06,880
అన్ని మెమరీ విడుదల అవుతుంది.

189
00:09:06,880 --> 00:09:10,750
కానీ అది సాధారణంగా మంచి కోడింగ్ వార్తలు
ఆచరణలో ఎల్లప్పుడూ, మీరు పూర్తి చేసినప్పుడు,

190
00:09:10,750 --> 00:09:13,810
మీరు mallocd ఏమి విడిపించేందుకు.

191
00:09:13,810 --> 00:09:16,690
>> అన్నాడు ఆ మాత్రమే విషయాలు
మీరు mallocd విముక్తి చేయాలి చేసిన.

192
00:09:16,690 --> 00:09:19,880
మీరు గణాంకపరంగా డిక్లేర్ ఉంటే ఒక
పూర్ణాంక, Int x సెమీ కోలన్,

193
00:09:19,880 --> 00:09:23,500
ఆ స్టాక్ న నివసించే, మీరు
అప్పుడు x విడిపించేందుకు వద్దు.

194
00:09:23,500 --> 00:09:25,970
మీరు చేసిన సో మాత్రమే విషయాలు
mallocd విముక్తి చేయాలి.

195
00:09:25,970 --> 00:09:28,960
>> చివరికి, రెండుసార్లు ఉచితం కాదు ఏదో.

196
00:09:28,960 --> 00:09:31,170
ఆ దారితీస్తుంది
మరొక విచిత్రమైన పరిస్థితి.

197
00:09:31,170 --> 00:09:33,530
మీరు చేసిన ప్రతిదీ
mallocd విముక్తి వుంటుంది.

198
00:09:33,530 --> 00:09:36,000
మీరు చేసిన ఏకైక విషయాలు
malloc విముక్తి చేయాలి.

199
00:09:36,000 --> 00:09:38,730
మరియు రెండుసార్లు ఉచితం కాదు ఏదో.

200
00:09:38,730 --> 00:09:43,660
>> కాబట్టి యొక్క ఇక్కడ ఒక ఉదాహరణ ద్వారా వీడలేదు
కొన్ని గతికంగా కేటాయించబడుతుంది ఏమి

201
00:09:43,660 --> 00:09:46,122
మెమరీ మిశ్రమ లాగా ఉండవచ్చు
కొంత కదలని మెమరీ లో.

202
00:09:46,122 --> 00:09:47,080
ఇక్కడ ఏ సంభవిస్తుంది?

203
00:09:47,080 --> 00:09:48,913
మీరు అనుసరించండి ఉంటే చూడండి
వెంట మరియు ఏమి అంచనా

204
00:09:48,913 --> 00:09:51,720
మేము వెళ్ళి ఏమి జరుగుతుందో
కోడ్ యొక్క ఈ పంక్తులు ద్వారా.

205
00:09:51,720 --> 00:09:53,980
>> కాబట్టి మేము Int m అంటున్నారు.

206
00:09:53,980 --> 00:09:54,840
ఇక్కడికి జరుగుతుంది?

207
00:09:54,840 --> 00:09:56,339
Well ఈ అందంగా సూటిగా ఉంటుంది.

208
00:09:56,339 --> 00:09:59,650
నేను m అనే ఒక పూర్ణాంకం వేరియబుల్ సృష్టించండి.

209
00:09:59,650 --> 00:10:01,400
నేను ఆకుపచ్చ రంగు
ఆ రంగు ఎందుకంటే

210
00:10:01,400 --> 00:10:03,730
నేను మాట్లాడటం చేస్తున్నాను నేను ఉపయోగించే
గురించి పూర్ణాంక వేరియబుల్.

211
00:10:03,730 --> 00:10:05,160
ఇది ఒక బాక్స్ ఉంది.

212
00:10:05,160 --> 00:10:08,400
ఇది మీరు చేయవచ్చు m అని, మరియు
అది లోపలి స్టోర్ పూర్ణాంకాల.

213
00:10:08,400 --> 00:10:12,400
>> నేను ఒక పూర్ణాంకానికి స్టార్ ఏమి చెప్పుకోవాలంటే?

214
00:10:12,400 --> 00:10:13,530
బాగా అందంగా పోలి ఉంది.

215
00:10:13,530 --> 00:10:15,780
నేను ఒక బాక్స్ అని సృష్టించడం నేను.

216
00:10:15,780 --> 00:10:19,100
ఇది హోల్డింగ్ Int యొక్క సామర్థ్యం వార్తలు
నక్షత్రాలు, పూర్ణ గమనికలు.

217
00:10:19,100 --> 00:10:21,570
నేను అలాగే ఇది ఆకుపచ్చ ఇష్ కలరింగ్ చేస్తున్నాను.

218
00:10:21,570 --> 00:10:24,140
>> నేను ఏదో ఉంది తెలుసు
ఒక పూర్ణాంకం చేయాలని,

219
00:10:24,140 --> 00:10:25,852
కానీ అది ఒక పూర్ణ సంఖ్య కాదు కూడా ఉంది.

220
00:10:25,852 --> 00:10:27,310
కానీ అది చాలా చక్కని అదే ఆలోచన.

221
00:10:27,310 --> 00:10:28,101
నేను ఒక బాక్స్ సృష్టించాను.

222
00:10:28,101 --> 00:10:30,070
ఈ కుడి రెండు
ఇప్పుడు స్టాక్ నివసిస్తున్నారు.

223
00:10:30,070 --> 00:10:32,520
నేను వాటిని రెండు పేర్లు ఇచ్చాను.

224
00:10:32,520 --> 00:10:36,750
>> పూర్ణాంకానికి స్టార్ బి Int యొక్క malloc పరిమాణం సమానం.

225
00:10:36,750 --> 00:10:38,560
ఈ ఒక చిన్న గమ్మత్తైన కావచ్చు.

226
00:10:38,560 --> 00:10:44,110
రెండవ పడుతుంది మరియు మీరు ఏమి గురించి ఆలోచించడం
ఈ రేఖాచిత్రం న జరిగే ఆలోచించే.

227
00:10:44,110 --> 00:10:50,210
పూర్ణాంకానికి స్టార్ బి Int యొక్క malloc పరిమాణం సమానం.

228
00:10:50,210 --> 00:10:51,940
>> Well ఈ కేవలం ఒక బాక్స్ సృష్టించడానికి లేదు.

229
00:10:51,940 --> 00:10:53,800
ఈ నిజానికి రెండు పెట్టెలు సృష్టిస్తుంది.

230
00:10:53,800 --> 00:10:58,670
మరియు అది కూడా స్థాపిస్తుంది, నెలకొల్పుతుంది
ఒక సంబంధం ఒక పాయింట్.

231
00:10:58,670 --> 00:11:02,240
మేము ఒక బ్లాక్ కేటాయించింది చేసిన
కుప్ప మీద మెమరీ.

232
00:11:02,240 --> 00:11:05,940
గమనించండి కుడి ఎగువ బాక్స్
ఒక పేరు అక్కడ లేదు.

233
00:11:05,940 --> 00:11:06,760
>> మేము అది mallocd.

234
00:11:06,760 --> 00:11:08,050
అది కుప్ప మీద ఉంది.

235
00:11:08,050 --> 00:11:10,090
కానీ బి ఒక పేరు ఉంది.

236
00:11:10,090 --> 00:11:11,950
ఇది బి అని ఒక పాయింటర్ వేరియబుల్.

237
00:11:11,950 --> 00:11:13,910
స్టాక్ లో నివసిస్తూ ఉంటాడు.

238
00:11:13,910 --> 00:11:18,250
>> కనుక ఇది మెమరీ భాగం ఉంది
మరో ఒకటి చూపాడు.

239
00:11:18,250 --> 00:11:21,840
బి చిరునామా ను కలిగి
మెమరీ ఆ బ్లాక్ యొక్క.

240
00:11:21,840 --> 00:11:23,757
ఇతరత్రా ఒక పేరు లేదు.

241
00:11:23,757 --> 00:11:24,590
కానీ అది చూపాడు.

242
00:11:24,590 --> 00:11:29,760
కాబట్టి మేము Int స్టార్ బి సమానం చెప్పినప్పుడు
Int యొక్క malloc పరిమాణం, అక్కడే ఆ,

243
00:11:29,760 --> 00:11:33,490
అప్ popped ఆ బాణం
అక్కడ కుడి వైపు, ఆ మొత్తం విషయం,

244
00:11:33,490 --> 00:11:36,740
నేను కనిపిస్తాయి ఉంటుంది
మళ్ళీ, ఏమి జరుగుతుందో ఉంది.

245
00:11:36,740 --> 00:11:39,341
ఆ అన్ని జరుగుతుంది
కోడ్ యొక్క సింగిల్ లైన్.

246
00:11:39,341 --> 00:11:41,340
ఇప్పుడు మేము కొద్దిగా ఎక్కువ పొందుతారు
మళ్ళీ సూటిగా.

247
00:11:41,340 --> 00:11:43,330
ఒక ఆంపర్సండ్ చిహ్నం m సమానం.

248
00:11:43,330 --> 00:11:46,280
మీరు ఏమి ఒక రీకాల్
ఆంపర్సండ్ చిహ్నం m సమానం?

249
00:11:46,280 --> 00:11:48,920
Well ఒక m యొక్క చిరునామా గెట్స్ ఉంది.

250
00:11:48,920 --> 00:11:54,150
లేదా, మరింత diagrammatically చాలు
m పాయింట్లు.

251
00:11:54,150 --> 00:11:56,360
>> ఒక బి సమానం.

252
00:11:56,360 --> 00:11:57,560
OK కాబట్టి ఇక్కడ మరొక ఒకటి.

253
00:11:57,560 --> 00:11:59,230
బి సమానం.

254
00:11:59,230 --> 00:12:02,260
ఏం జరగబోతోంది
రేఖాచిత్రం ఈ సమయంలో ఎలా?

255
00:12:02,260 --> 00:12:04,330
>> బాగా గుర్తుచేసుకున్నారు
కార్య ఆపరేటర్లు రచనలు

256
00:12:04,330 --> 00:12:08,960
విలువ కేటాయించి
కుడి ఎడమవైపు విలువ.

257
00:12:08,960 --> 00:12:14,820
M సో బదులుగా పాయింటింగ్, ఒక ఇప్పుడు
బి పాయింట్లకు అదే స్థానానికి చూపాడు.

258
00:12:14,820 --> 00:12:18,900
ఒక A, B సూచించడానికి లేదు
పేరు బి పాయింట్లకు పాయింట్లు.

259
00:12:18,900 --> 00:12:25,280
>> ఒక కోణాల బి ఉంటే చేస్తాను
ఒక ఆంపర్సండ్ చిహ్నం బి సమానం ఉన్నాయి.

260
00:12:25,280 --> 00:12:28,150
కానీ బదులుగా ఒక కేవలం బి సమానం
అర్థం మరియు బి ఇప్పుడు

261
00:12:28,150 --> 00:12:31,770
అదే చిరునామాకు ఎందుకంటే గురిపెట్టి
బి లోపల కేవలం ఒక చిరునామా ఉంది.

262
00:12:31,770 --> 00:12:35,004
ఇప్పుడు ఒక లోపల అదే చిరునామా.

263
00:12:35,004 --> 00:12:37,170
m బహుశా, 10 సమానం
అత్యంత ముక్కుసూటి విషయం

264
00:12:37,170 --> 00:12:38,690
మేము కొద్దిగా చేసిన.

265
00:12:38,690 --> 00:12:40,460
బాక్స్ లో 10 ఉంచండి.

266
00:12:40,460 --> 00:12:45,640
స్టార్ బి m సమానం ప్లస్ 2, నుండి గుర్తు
మా గమనికలు వీడియో ఏమి స్టార్ బి అర్థం.

267
00:12:45,640 --> 00:12:50,230
మేము dereference బి మరియు పెట్టి చూడాలని
ఆ మెమొరీ లోకేషన్ కొన్ని విలువ.

268
00:12:50,230 --> 00:12:51,860
ఈ సందర్భంలో 12 లో.

269
00:12:51,860 --> 00:12:55,300
>> కాబట్టి మేము ఒక పాయింట్ dereference
మేము కేవలం బాణం డౌన్ ప్రయాణం గుర్తుచేసుకున్నారు.

270
00:12:55,300 --> 00:12:58,205
లేదా మరొక విధంగా చెప్పాలంటే, మేము
మెమరీ చిరునామా వెళ్ళండి

271
00:12:58,205 --> 00:12:59,580
మరియు మేము కొన్ని విధంగా అది మార్చటానికి.

272
00:12:59,580 --> 00:13:00,830
మేము అక్కడ కొన్ని విలువ ఉంచాలి.

273
00:13:00,830 --> 00:13:03,960
ఈ సందర్భంలో స్టార్ బి లో
m సమానం ప్లస్ 2 కేవలం ఉంది

274
00:13:03,960 --> 00:13:08,230
వేరియబుల్ వెళ్ళండి బి ద్వారా చూపారు
మెమరీ వెళ్ళండి బి ద్వారా చూపారు

275
00:13:08,230 --> 00:13:11,750
మరియు 12, అక్కడ m ప్లస్ 2 చాలు.

276
00:13:11,750 --> 00:13:14,970
>> ఇప్పుడు నేను బి విడిపించేందుకు.

277
00:13:14,970 --> 00:13:16,490
నేను బి విడిపించేందుకు ఉన్నప్పుడు ఏమి జరుగుతుంది?

278
00:13:16,490 --> 00:13:18,800
నేను ఉచిత అర్థం చెప్పారు ఏమి గుర్తుంచుకో.

279
00:13:18,800 --> 00:13:21,920
నేను బి విడిపించేందుకు ఉన్నప్పుడు నేను ఏమంటున్నారు చేస్తున్నాను?

280
00:13:21,920 --> 00:13:23,410
>> నేను పని పూర్తయింది, కుడి?

281
00:13:23,410 --> 00:13:25,702
నేను ముఖ్యంగా మెమరీ అప్ ఇస్తాయి.

282
00:13:25,702 --> 00:13:26,910
నేను వ్యవస్థ దానిని తిరిగి ఇవ్వాలని.

283
00:13:26,910 --> 00:13:33,010
నేను ఈ ఇకపై అవసరం లేదు
నేను OK, వాటిని చెప్పడం చేస్తున్నాను?

284
00:13:33,010 --> 00:13:37,390
>> ఇప్పుడు నేను చెప్పుకోవాలంటే స్టార్
11 మీరు బహుశా చేయవచ్చు సమానం

285
00:13:37,390 --> 00:13:40,460
ఇప్పటికే చెడు ఏదో చెప్పడానికి
కుడి, ఇక్కడ జరిగే కానుంది?

286
00:13:40,460 --> 00:13:44,160
మరియు నేను బహుశా ప్రయత్నించారు ఉంటే నిజానికి
విభజన లోపంగా పొందుతుంది.

287
00:13:44,160 --> 00:13:47,140
ఇప్పుడు ఎందుకంటే, అయితే
మెమరీ గతంలో ఆ భాగం

288
00:13:47,140 --> 00:13:50,220
నేను ఉందని ఏదో
ఈ సమయంలో యాక్సెస్

289
00:13:50,220 --> 00:13:54,590
ఇప్పుడు నేను మెమరీ యాక్సెస్ చేస్తున్నాను
నాకు యాక్సెస్ కోసం చట్టబద్ధం కాదు.

290
00:13:54,590 --> 00:13:57,330
>> మరియు మేము బహుశా రెడీ
మేము మెమరీ యాక్సెస్ చేసినప్పుడు, గుర్తు

291
00:13:57,330 --> 00:14:00,000
మేము టచ్ చేయాలో చేస్తున్నట్లు,
అత్యంత సాధారణ కారణం

292
00:14:00,000 --> 00:14:01,860
సెగ్మెంటేషన్ యొక్క
తప్పు. కాబట్టి నా ప్రోగ్రామ్

293
00:14:01,860 --> 00:14:05,170
నేను దీన్ని ప్రయత్నించాడు ఉంటే క్రాష్ అవుతుంది.

294
00:14:05,170 --> 00:14:09,910
మరలా అది మంచి పొందుటకు ఒక మంచి ఆలోచన
ఆచరణలో మరియు మంచి అలవాట్లు అమూల్యమయిన

295
00:14:09,910 --> 00:14:12,920
malloc మరియు ఉచిత పనిచేసేటప్పుడు,
కాబట్టి మీరు సెగ్మెంటేషన్ బాధలు లేని

296
00:14:12,920 --> 00:14:15,310
మీరు ఉపయోగించవచ్చు, మరియు ఆ తప్పిదాలు
మీ గతికంగా కేటాయించబడుతుంది

297
00:14:15,310 --> 00:14:17,370
మెమరీ బాధ్యతాయుతంగా.

298
00:14:17,370 --> 00:14:20,300
>> నేను డౌ లాయిడ్ ఉన్నాను ఈ CS50 ఉంది.

299
00:14:20,300 --> 00:14:21,947