[సంగీతాన్ని]
>> డౌ LLOYD: OK కాబట్టి ఒక సలహా ఇక్కడ ప్రారంభించటానికి ముందు.
మీరు వీడియో వీక్షించారు ఉండకపోతే కాబట్టి మీరు మొదటి చేయాలనుకుంటున్నారా ఉండవచ్చు గమనికలు.
ఈ వీడియో ఎందుకంటే మరొక గమనికలు పని యొక్క మార్గం.
>> కనుక ఇది మాట్లాడటానికి జరగబోతోంది కొన్ని అంశాల గురించి
మేము లో కవర్ ఆ వీడియో గమనికలు, మరియు మేము ఉన్నాము
ఇప్పుడు వాటిని ఉపేక్షించ అన్నారు, వారు ఇప్పటికే అని ఊహిస్తూ
విధమైన అర్థం.
కాబట్టి కేవలం మీ సరసమైన హెచ్చరిక వార్తలు మీరు ఈ వీడియో చూస్తూ ఉన్నట్లయితే
మరియు మీరు చూడని గమనికలు వీడియో, అది బలం విధమైన
మీ తలపై ఒక చిన్న బిట్ ఫ్లై.
కాబట్టి అది మంచి కావచ్చు ఆ క్రమంలో అది చూడటానికి.
>> కాబట్టి మేము ఇప్పటికే ఒక చూసిన మార్గం, పాయింటర్లు పని
ఇది మేము ఒక డిక్లేర్ ఉంది వేరియబుల్, మరియు అప్పుడు మేము
ఒక పాయింటర్ మరొక వేరియబుల్ డిక్లేర్ వేరియబుల్, అది చూపాడు.
కాబట్టి మేము సృష్టించిన ఒక ఒక పేరుతో వేరియబుల్, మేము చేసిన
ఒక పేరు తో రెండవ వేరియబుల్ రూపొందించినవారు మరియు మేము రెండవ వేరియబుల్ అభిప్రాయపడుతున్నారు
మొదట.
ఈ విధమైన ఉంది ఒక సమస్య అయితే, అది ఎందుకంటే
సరిగ్గా తెలుసు మాకు అవసరం ఎంత మెమరీ మేము ఉన్నాము
క్షణం అవసరం అన్నారు మా కార్యక్రమం సంగ్రహించబడింది.
>> ఎందుకు అని?
మేము పేరు చెయ్యలేరు అవసరం ఎందుకంటే లేదా సాధ్యం వేరియబుల్స్ యొక్క అన్ని గుర్తించడానికి
మేము ఎదుర్కొనే కొన్ని.
మేము ఉండవచ్చు అని ఒక శ్రేణి కలిగి ఉండవచ్చు సమాచారం చాలా పట్టుకునే సామర్ధ్యాన్ని,
కానీ ఇప్పటికీ కాదు తగినంత ఖచ్చితంగా కచ్చితమైన.
మనం తెలియదు ఉంటే, మనం ఏ ఆలోచన ఉంటే
ఎంత మేము కంపైల్ సమయంలో చేయాలి?
లేదా ఏ మా కార్యక్రమం రెడీ ఉంటే ఒక నిజంగా దీర్ఘ సమయం కోసం అమలు,
వివిధ యూజర్ అంగీకరించడం డేటా, మరియు మేము కాదు నిజంగా
మేము ఉన్నామా అంచనా 1,000 యూనిట్లు అవసరం వెళ్తున్నారు?
>> ఇది మేము చెయ్యవచ్చు ఇష్టం లేదు కమాండ్ లైన్ వద్ద చెప్పటానికి
ఎన్ని అంశాలు ఎంటర్ మీరు అవసరం అనుకుంటున్నాను.
Well ఆ అంచనా తప్పు ఏమి ఉంది?
డైనమిక్ మెమరీ కేటాయింపు విధమైన మాకు మార్గం అనుమతిస్తుంది
ఈ ప్రత్యేక సమస్య చుట్టూ పొందడానికి.
మరియు మార్గం అది చేస్తుంది గమనికలు ఉపయోగించి ఉంది.
>> మేము గమనికలు ఉపయోగించవచ్చు డైనమిక్ ప్రాప్తిని పొందండి
అని కేటాయించిన మెమొరీ, మెమొరీ మీ ప్రోగ్రామ్ వలె కేటాయించింది నడుస్తుంటే.
ఇది కంపైల్ సమయంలో కేటాయించబడుతుంది కాదు.
చేసినప్పుడు మీరు డైనమిక్ కేటాయించాలని మెమరీ అది ఒక కొలను నుండి వస్తుంది
మెమరీ కుప్ప అని పిలుస్తారు.
మేము చేసిన గతంలో అన్ని మెమరీ కోర్సు లో పని
పూల్ నుండి వస్తున్నాడు మెమరీ స్టాక్ అని పిలుస్తారు.
ఒక మంచి మార్గం సాధారణంగా మనసు మరియు ఈ నియమం పెట్టుకోండి
ఎల్లప్పుడూ నిజాన్ని నిలువరించదు కానీ అందంగా చాలా దాదాపు
ఎల్లప్పుడూ true-- ఏ ఉంది కలిగి సమయం మీరు ఒక వేరియబుల్ పేరు ఇచ్చి
బహుశా స్టాక్ లో నివసిస్తూ ఉంటాడు.
మరియు ఏ సమయంలో మీరు లేదు ఒక వేరియబుల్ పేరు ఇవ్వడం,
మీరు డైనమిక్ మెమరీ చేయవచ్చు ఇది కేటాయింపు, అది కుప్ప లో నివసిస్తూ ఉంటాడు.
>> ఇప్పుడు నేను రకమైన ప్రదర్శించబడింది చేస్తున్నాను మెమరీ యొక్క ఈ రెండు కొలనులు ఉంది ఉంటే.
కానీ మీరు ఈ చూసిన సాధారణంగా ఇది రేఖాచిత్రం,
ఒక ప్రాతినిధ్యాన్ని ఏం మెమరీ కనిపిస్తుంది
మరియు మేము అన్ని గురించి శ్రద్ధ వెళ్ళడం లేదు చేస్తున్నాం టాప్ మరియు దిగువన stuff.
మనం పట్టించుకోనట్లు ఈ భాగం ఇక్కడ మధ్యలో, కుప్ప మరియు స్టాక్.
మీరు గమనిస్తే ఈ చిత్రంలో చూడటం,
ఈ నిజానికి రెండు కాదు మెమరీ ప్రత్యేక కొలనులు.
ఇది మెమరీ ఒకటి shared పూల్ వార్తలు ఇక్కడ మీరు ఈ దృశ్య లో, ప్రారంభం
మీరు దిగువన ప్రారంభం మరియు భర్తీకి మొదలు
స్టాక్ తో క్రింద, మరియు మీరు నుండి ఎగువన ప్రారంభం మరియు నింపి మొదలు
కుప్ప తో పై నుండి క్రిందికి.
కానీ అది నిజంగా ఉంది అదే పూల్, అది కేవలం
వివిధ మచ్చలు, వివిధ ప్రాంతాల్లో మెమరీలో కేటాయించింది చేస్తున్నారు.
మరియు మీరు రన్నవుట్ చేయవచ్చు గాని ద్వారా మెమరీ
కుప్ప అన్ని మార్గం వెళ్ళి దిగువ, లేదా
స్టాక్ టాప్ అన్ని మార్గం వెళ్ళి లేదా కుప్ప మరియు స్టాక్ కలిగి
ఒకరితోఒకరు కలిసే.
ఆ అన్ని పరిస్థితులు ఉంటుంది మీ ప్రోగ్రామ్ కారణం
మెమరీ రన్నవుట్.
కాబట్టి గుర్తుంచుకోండి.
మేము గురించి మాట్లాడేటప్పుడు కుప్ప మరియు స్టాక్
మేము నిజంగా గురించి మాట్లాడుతున్నారు మెమరీ అదే సాధారణ భాగం, కేవలం
ఆ స్మృతి వివిధ భాగాలను కలిగి ఉంది.
>> కాబట్టి మేము డైనమిక్ ఎలా వస్తుందా మొదటి స్థానంలో మెమరీ కేటాయించింది?
మా కార్యక్రమం పొందుటకు లేదు ఎలా ఇది అమలు వంటి మెమరీ?
బాగా సి అనే ఫంక్షన్ అందిస్తుంది malloc, మెమరీ ఎలొకేటర్, ఇది
మీరు ఒక కాల్, మరియు మీరు పాస్ మీరు ఎన్ని అనుకుంటున్నారు మెమరీ బైట్లు.
మీ ప్రోగ్రామ్ రన్ చేస్తే మరియు మీరు ఒక పూర్ణాంకం రన్టైమ్ కావాలి,
మీరు నాలుగు బైట్లు మాలోక్ ఉండవచ్చు జ్ఞాపకశక్తి, malloc నాలుగు కుండలీకరణాలు.
>> మాలోక్ ద్వారా వెళ్తుంది కుప్ప ద్వారా చూడటం,
మేము డైనమిక్ ఉన్నాము ఎందుకంటే మెమరీ కేటాయించడం
మరియు అది మీకు తిరిగి వచ్చును ఆ స్మృతి ఒక పాయింటర్.
ఇది మీరు ఆ మెమొరీ ఇవ్వదు అది ఒక పేరు ఇవ్వదు,
మీరు దాన్ని ఒక పాయింటర్ ఇస్తుంది.
మళ్ళీ నేను చెప్పవలసింది చెప్పాను కాబట్టి ఆ అది బహుశా ముఖ్యం
గమనికలు వీడియో వీక్షించారు మేము ఈ లోకి చాలా దూరం పొందడానికి ముందు.
కాబట్టి malloc జరగబోతోంది ఒక పాయింటర్ మీరు తిరిగి ఇవ్వాలని.
>> మాలోక్ మీరు ఏ ఇవ్వాలని పోతే మెమరీ మీరు రన్నవుట్ చేసిన ఎందుకంటే,
అది ఒక నల్ పాయింటర్ మీరు తిరిగి ఇవ్వాలని చేస్తాము.
మీరు మేము ఏమవుతుంది గుర్తు ప్రయత్నించండి మరియు ఒక నల్ పాయింటర్ dereference?
మేము కుడి, ఒక seg తప్పు గురవుతాయి?
ఆ బహుశా మంచి కాదు.
>> కాబట్టి ప్రతి సమయం మీరు ఒక కాల్ చేయడానికి ఎప్పుడూ ఎల్లప్పుడూ మీరు malloc
తనిఖీ చెయ్యాలి లేదో మీరు బ్యాక్ శూన్య ఇచ్చింది పాయింటర్.
అది ఉంటే, మీరు మీ కార్యక్రమం ముగింపు అవసరం మీరు dereference ప్రయత్నిస్తే, ఎందుకంటే
మీరు వెళుతున్న నల్ పాయింటర్ విభజన లోపంగా బాధలు
మరియు మీ ప్రోగ్రామ్ ఉంది ఏమైనప్పటికీ క్రాష్ అన్నారు.
సో ఎలా గణాంకపరంగా మేము ఏమి పూర్ణాంకం పొందటానికి?
>> పూర్ణాంకానికి x.
మేము బహుశా ఆ చేసిన కొంత, కుడి?
ఈ అనే వేరియబుల్ సృష్టిస్తుంది స్టాక్ నివసిస్తుంది x.
ఎలా మేము డైనమిక్ పూర్ణాంకం పొందటానికి లేదు?
Int స్టార్ px malloc 4 సమానం.
>> లేదా సంబంధించిన మేము Int స్టార్ px చెప్పేవాడిని
, Int malloc పరిమాణం సమానం కొన్ని తక్కువ త్రో
మా కార్యక్రమం చుట్టూ మాయా సంఖ్యలు.
ఈ మాకు పొందటానికి అన్నారు కుప్ప నుండి మెమరీ నాలుగు బైట్లు,
మరియు చూపుడు మేము పొందుటకు అది తిరిగి px అంటారు.
మరియు తర్వాత మేము చేసిన కేవలం వంటి మేము గతంలో చేసిన
చెయ్యవచ్చు px, dereference ఆ మెమొరీ యాక్సెస్.
ఎలా మేము వినియోగదారు నుండి ఒక పూర్ణ వస్తుందా?
మేము Int x పూర్ణాంకానికి పొందండి సమానం చెప్పగలను.
ఆ అందమైన సూటిగా ఉంది.
మేము ఒక అర్రే సృష్టించడానికి ఏమి కావాలా స్టాక్ నివసిస్తున్న తేలటం x?
ఆ పేరు stack_array-- తేలుతూ మా శ్రేణి చదరపు బ్రాకెట్లలో x యొక్క.
ఆ మాకు వ్యూహం సృష్టిస్తుంది స్టాక్ నివసిస్తున్న తేలటం x.
మేము తేలియాడుతున్న వ్యూహం సృష్టించవచ్చు ఆ చాలా, కుప్ప లో నివసిస్తూ ఉంటాడు.
సింటాక్స్ ఒక చూడండి ఉండవచ్చు మరింత గజిబిజిగా చిన్న
కానీ మేము ఫ్లోట్ చెప్పగలను స్టార్ heap_array సమానం
malloc x సార్లు ఫ్లోట్ యొక్క పరిమాణం.
నేను పట్టుకోండి తగినంత గది అవసరం x పాయింట్ విలువలు తేలు.
కాబట్టి నేను 100 అవసరం చెప్పడానికి తేలటం, లేదా 1,000 తేలియాడే.
కాబట్టి ఆ సందర్భంలో అది ఉంటుంది 100 తేలియాడుతున్న 400 బైట్లు,
లేదా 1,000 తేలియాడుతున్న 4,000 బైట్లు, ప్రతి ఫ్లోట్ తీసుకుంటుంది ఎందుకంటే
స్థలం నాలుగు బైట్లు.
>> ఈ చేయడం తర్వాత నేను ఉపయోగించవచ్చు heap_array లో చదరపు బ్రాకెట్ సింటాక్స్.
జస్ట్ నేను stack_array చేస్తాను, నేను వ్యక్తిగతంగా తన మూలకాలు యాక్సెస్ చేయవచ్చు
ఉపయోగించి heap_array సున్నా, heap_array ఒకటి.
కానీ మేము అలా కారణం గుర్తుకు ఎందుకంటే సి ఒక శ్రేణి పేరు
నిజంగా ఒక పాయింటర్ ఉంది ఆ శ్రేణి యొక్క మొదటి మూలకం.
మేము ఒక ప్రకటించారు చేస్తున్నారు వాస్తవం కాబట్టి ఇక్కడ స్టాక్ తెప్పల శ్రేణి
నిజానికి ఒక బిట్ పక్కదారి పట్టిస్తుంది.
మేము నిజంగా ఉంటాయి అక్కడ రెండవ లైన్ కోడ్
కూడా ఒక భాగం ఒక పాయింటర్ సృష్టించడం మేము అప్పుడు కొన్ని పని చేసే మెమరీ.
>> ఇక్కడ పెద్ద సమస్య వార్తలు డైనమిక్ అయితే మెమరీ కేటాయించింది,
ఇది నిజంగా ఎందుకు ఈ ఉంది కొన్ని మంచి అలవాట్లు అభివృద్ధి ముఖ్యం
మీరు అది పని చేస్తున్నారు.
గణాంకపరంగా ప్రకటించింది కాకుండా మెమరీ మీ మెమరీ
స్వయంచాలకంగా తిరిగి లేదు మీ ఫంక్షన్ జరుగుతుంది ఉన్నప్పుడు వ్యవస్థ.
మేము ప్రధాన ఉన్నాయి, మరియు కనుక ప్రధాన ఒక ఫంక్షన్ కాల్స్
f పూర్తయింది f అది ఎప్పుడు చేయుచున్నాడు సంసార మరియు ప్రోగ్రామ్ యొక్క నియంత్రణ తిరిగి
తిరిగి, ప్రధాన వరకు మెమొరీ ఉపయోగించిన f తిరిగి ఇవ్వబడుతుంది.
ఇది మళ్ళీ ఉపయోగించవచ్చు కొన్ని ఇతర ప్రోగ్రామ్ ద్వారా
లేదా కొన్ని ఇతర చర్య, ఆ ప్రధాన తర్వాత అని చెపుతాడు.
ఇది మళ్ళీ అదే మెమరీ పైగా ఉపయోగించవచ్చు.
>> మీరు గతికంగా అయితే మెమరీని కేటాయించాల్సిన
మీరు స్పష్టంగా చెప్పడం కలిగి మీరు పూర్తి చేసిన వ్యవస్థ.
ఇది అనుకొనుట, మీరు దానిని పై నొక్కి చేస్తాము మీరు నడుస్తున్న ఒక సమస్యకు దారితీస్తుంది
మెమరీ.
నిజానికి మేము కొన్నిసార్లు చూడండి మెమొరీ లీక్ దీన్ని.
మరియు కొన్నిసార్లు ఈ మెమరీ లీకేజ్ నిజానికి నిజంగా వినాశకరమైన ఉంటుంది
వ్యవస్థ నటనకు.
>> మీరు తరచుగా ఇంటర్నెట్ వినియోగదారు అయితే మీరు కొన్ని వెబ్ బ్రౌజర్లు ఉపయోగించుకునే
మరియు నేను ఇక్కడ పేర్లు పేరు, కానీ కొన్ని వెబ్ బ్రౌజర్లు అక్కడ ఉన్నాయి
నిజానికి కలిగి గాంచాయి స్థిరంగా పొందడానికి లేని మెమరీ లీకేజ్.
మరియు మీరు మీ బ్రౌజర్ ఓపెన్ వదిలేస్తే సమయం చాలా కాలం కోసం, రోజులు
మరియు రోజుల లేదా వారాల, మీరు కొన్నిసార్లు మీ సిస్టమ్ గమనిస్తారు
నిజంగా నెమ్మదిగా, నిజంగా నడుస్తున్న ఉంది.
మరియు ఆ కారణం ఉంది బ్రౌజర్, మెమరీ కేటాయించింది
కానీ అప్పుడు వ్యవస్థ చెప్పలేదు అది తో ప్రదర్శనతో.
అందువలన, తక్కువ మెమరీ ఆకులు మీ ఇతర కార్యక్రమాలు అన్ని కోసం అందుబాటులో
మీరు ఉన్నాము ఎందుకంటే, పంచుకునేందుకు కలిగి వెబ్ బ్రౌజర్ leaking--
కార్యక్రమం మెమరీ బహిర్గతం ఉంది.
మేము తిరిగి మెమరీ ఇవ్వాలని లేదు ఎలా మేము అది పూర్తి చేసినప్పుడు?
బాగా అదృష్టవశాత్తూ అది ఒక వార్తలు దీన్ని చాలా సులభమైన మార్గం.
మేము దానిని విడిపించేందుకు.
ఉచిత అని ఒక ఫంక్షన్ ఉంది, అది స్మృతి ఒక పాయింటర్ అంగీకరిస్తుంది
మరియు మేము అన్నిటికి ఉన్నాము.
>> కాబట్టి యొక్క మేము చేస్తున్నారు అనుకోండి మా కార్యక్రమం మధ్యలో,
మేము 50 అక్షరాలు malloc అనుకుంటున్నారా.
మేము చెయ్యవచ్చు వ్యూహం malloc అనుకుంటున్నారా 50 అక్షరాలు సమర్ధుడు.
మరియు మేము తిరిగి ఒక పాయింటర్ పొందండి ఉన్నప్పుడు ఆ పాయింటర్ యొక్క పేరు పదం.
మేము ఉన్నాము పనులను పదం చేయబోవడం,
ఆపై మేము ఉన్నప్పుడు మేము దానిని విడిపించేందుకు పూర్తయింది.
ఇప్పుడు మేము ఆ 50 ఇచ్చాయి తిరిగి సిస్టమ్కు మెమరీ బైట్లు.
కొన్ని ఇతర చర్య వాటిని ఉపయోగించవచ్చు.
మేము ఒక బాధ గురించి ఆందోళన చెందనవసరం లేదు మెమొరీ లీక్ మేము పదం విముక్తి ఎందుకంటే.
మేము తిరిగి మెమరీ ఇచ్చాను, కాబట్టి మేము అది పని పూర్తి చేసిన.
సో మూడు ఉన్నాయి ఆ తప్పక బంగారు నియమాలు
మీరు ఎప్పుడు ఉన్నా మనస్సు లో ఉంచబడిన డైనమిక్ మెమరీ పెడుతోంది
malloc తో.
మెమరీ ప్రతి మూసే మీరు malloc విముక్తి చేయాలి
మీ కార్యక్రమాన్ని ముందు నడుస్తున్న అంతమవుతుంది.
ఇప్పుడు మళ్ళీ, పరికరంలోని లేదా IDE ఈ విధమైన ఏమైనప్పటికీ మీరు జరుగుతుంది
మీరు కెన్ ఉన్నప్పుడు ఈ ఏమైనప్పటికీ జరగవచ్చు మీ కార్యక్రమాన్ని రద్దు చేయబడితే,
అన్ని మెమరీ విడుదల అవుతుంది.
కానీ అది సాధారణంగా మంచి కోడింగ్ వార్తలు ఆచరణలో ఎల్లప్పుడూ, మీరు పూర్తి చేసినప్పుడు,
మీరు mallocd ఏమి విడిపించేందుకు.
>> అన్నాడు ఆ మాత్రమే విషయాలు మీరు mallocd విముక్తి చేయాలి చేసిన.
మీరు గణాంకపరంగా డిక్లేర్ ఉంటే ఒక పూర్ణాంక, Int x సెమీ కోలన్,
ఆ స్టాక్ న నివసించే, మీరు అప్పుడు x విడిపించేందుకు వద్దు.
మీరు చేసిన సో మాత్రమే విషయాలు mallocd విముక్తి చేయాలి.
>> చివరికి, రెండుసార్లు ఉచితం కాదు ఏదో.
ఆ దారితీస్తుంది మరొక విచిత్రమైన పరిస్థితి.
మీరు చేసిన ప్రతిదీ mallocd విముక్తి వుంటుంది.
మీరు చేసిన ఏకైక విషయాలు malloc విముక్తి చేయాలి.
మరియు రెండుసార్లు ఉచితం కాదు ఏదో.
>> కాబట్టి యొక్క ఇక్కడ ఒక ఉదాహరణ ద్వారా వీడలేదు కొన్ని గతికంగా కేటాయించబడుతుంది ఏమి
మెమరీ మిశ్రమ లాగా ఉండవచ్చు కొంత కదలని మెమరీ లో.
ఇక్కడ ఏ సంభవిస్తుంది?
మీరు అనుసరించండి ఉంటే చూడండి వెంట మరియు ఏమి అంచనా
మేము వెళ్ళి ఏమి జరుగుతుందో కోడ్ యొక్క ఈ పంక్తులు ద్వారా.
>> కాబట్టి మేము Int m అంటున్నారు.
ఇక్కడికి జరుగుతుంది?
Well ఈ అందంగా సూటిగా ఉంటుంది.
నేను m అనే ఒక పూర్ణాంకం వేరియబుల్ సృష్టించండి.
నేను ఆకుపచ్చ రంగు ఆ రంగు ఎందుకంటే
నేను మాట్లాడటం చేస్తున్నాను నేను ఉపయోగించే గురించి పూర్ణాంక వేరియబుల్.
ఇది ఒక బాక్స్ ఉంది.
ఇది మీరు చేయవచ్చు m అని, మరియు అది లోపలి స్టోర్ పూర్ణాంకాల.
>> నేను ఒక పూర్ణాంకానికి స్టార్ ఏమి చెప్పుకోవాలంటే?
బాగా అందంగా పోలి ఉంది.
నేను ఒక బాక్స్ అని సృష్టించడం నేను.
ఇది హోల్డింగ్ Int యొక్క సామర్థ్యం వార్తలు నక్షత్రాలు, పూర్ణ గమనికలు.
నేను అలాగే ఇది ఆకుపచ్చ ఇష్ కలరింగ్ చేస్తున్నాను.
>> నేను ఏదో ఉంది తెలుసు ఒక పూర్ణాంకం చేయాలని,
కానీ అది ఒక పూర్ణ సంఖ్య కాదు కూడా ఉంది.
కానీ అది చాలా చక్కని అదే ఆలోచన.
నేను ఒక బాక్స్ సృష్టించాను.
ఈ కుడి రెండు ఇప్పుడు స్టాక్ నివసిస్తున్నారు.
నేను వాటిని రెండు పేర్లు ఇచ్చాను.
>> పూర్ణాంకానికి స్టార్ బి Int యొక్క malloc పరిమాణం సమానం.
ఈ ఒక చిన్న గమ్మత్తైన కావచ్చు.
రెండవ పడుతుంది మరియు మీరు ఏమి గురించి ఆలోచించడం ఈ రేఖాచిత్రం న జరిగే ఆలోచించే.
పూర్ణాంకానికి స్టార్ బి Int యొక్క malloc పరిమాణం సమానం.
>> Well ఈ కేవలం ఒక బాక్స్ సృష్టించడానికి లేదు.
ఈ నిజానికి రెండు పెట్టెలు సృష్టిస్తుంది.
మరియు అది కూడా స్థాపిస్తుంది, నెలకొల్పుతుంది ఒక సంబంధం ఒక పాయింట్.
మేము ఒక బ్లాక్ కేటాయించింది చేసిన కుప్ప మీద మెమరీ.
గమనించండి కుడి ఎగువ బాక్స్ ఒక పేరు అక్కడ లేదు.
>> మేము అది mallocd.
అది కుప్ప మీద ఉంది.
కానీ బి ఒక పేరు ఉంది.
ఇది బి అని ఒక పాయింటర్ వేరియబుల్.
స్టాక్ లో నివసిస్తూ ఉంటాడు.
>> కనుక ఇది మెమరీ భాగం ఉంది మరో ఒకటి చూపాడు.
బి చిరునామా ను కలిగి మెమరీ ఆ బ్లాక్ యొక్క.
ఇతరత్రా ఒక పేరు లేదు.
కానీ అది చూపాడు.
కాబట్టి మేము Int స్టార్ బి సమానం చెప్పినప్పుడు Int యొక్క malloc పరిమాణం, అక్కడే ఆ,
అప్ popped ఆ బాణం అక్కడ కుడి వైపు, ఆ మొత్తం విషయం,
నేను కనిపిస్తాయి ఉంటుంది మళ్ళీ, ఏమి జరుగుతుందో ఉంది.
ఆ అన్ని జరుగుతుంది కోడ్ యొక్క సింగిల్ లైన్.
ఇప్పుడు మేము కొద్దిగా ఎక్కువ పొందుతారు మళ్ళీ సూటిగా.
ఒక ఆంపర్సండ్ చిహ్నం m సమానం.
మీరు ఏమి ఒక రీకాల్ ఆంపర్సండ్ చిహ్నం m సమానం?
Well ఒక m యొక్క చిరునామా గెట్స్ ఉంది.
లేదా, మరింత diagrammatically చాలు m పాయింట్లు.
>> ఒక బి సమానం.
OK కాబట్టి ఇక్కడ మరొక ఒకటి.
బి సమానం.
ఏం జరగబోతోంది రేఖాచిత్రం ఈ సమయంలో ఎలా?
>> బాగా గుర్తుచేసుకున్నారు కార్య ఆపరేటర్లు రచనలు
విలువ కేటాయించి కుడి ఎడమవైపు విలువ.
M సో బదులుగా పాయింటింగ్, ఒక ఇప్పుడు బి పాయింట్లకు అదే స్థానానికి చూపాడు.
ఒక A, B సూచించడానికి లేదు పేరు బి పాయింట్లకు పాయింట్లు.
>> ఒక కోణాల బి ఉంటే చేస్తాను ఒక ఆంపర్సండ్ చిహ్నం బి సమానం ఉన్నాయి.
కానీ బదులుగా ఒక కేవలం బి సమానం అర్థం మరియు బి ఇప్పుడు
అదే చిరునామాకు ఎందుకంటే గురిపెట్టి బి లోపల కేవలం ఒక చిరునామా ఉంది.
ఇప్పుడు ఒక లోపల అదే చిరునామా.
m బహుశా, 10 సమానం అత్యంత ముక్కుసూటి విషయం
మేము కొద్దిగా చేసిన.
బాక్స్ లో 10 ఉంచండి.
స్టార్ బి m సమానం ప్లస్ 2, నుండి గుర్తు మా గమనికలు వీడియో ఏమి స్టార్ బి అర్థం.
మేము dereference బి మరియు పెట్టి చూడాలని ఆ మెమొరీ లోకేషన్ కొన్ని విలువ.
ఈ సందర్భంలో 12 లో.
>> కాబట్టి మేము ఒక పాయింట్ dereference మేము కేవలం బాణం డౌన్ ప్రయాణం గుర్తుచేసుకున్నారు.
లేదా మరొక విధంగా చెప్పాలంటే, మేము మెమరీ చిరునామా వెళ్ళండి
మరియు మేము కొన్ని విధంగా అది మార్చటానికి.
మేము అక్కడ కొన్ని విలువ ఉంచాలి.
ఈ సందర్భంలో స్టార్ బి లో m సమానం ప్లస్ 2 కేవలం ఉంది
వేరియబుల్ వెళ్ళండి బి ద్వారా చూపారు మెమరీ వెళ్ళండి బి ద్వారా చూపారు
మరియు 12, అక్కడ m ప్లస్ 2 చాలు.
>> ఇప్పుడు నేను బి విడిపించేందుకు.
నేను బి విడిపించేందుకు ఉన్నప్పుడు ఏమి జరుగుతుంది?
నేను ఉచిత అర్థం చెప్పారు ఏమి గుర్తుంచుకో.
నేను బి విడిపించేందుకు ఉన్నప్పుడు నేను ఏమంటున్నారు చేస్తున్నాను?
>> నేను పని పూర్తయింది, కుడి?
నేను ముఖ్యంగా మెమరీ అప్ ఇస్తాయి.
నేను వ్యవస్థ దానిని తిరిగి ఇవ్వాలని.
నేను ఈ ఇకపై అవసరం లేదు నేను OK, వాటిని చెప్పడం చేస్తున్నాను?
>> ఇప్పుడు నేను చెప్పుకోవాలంటే స్టార్ 11 మీరు బహుశా చేయవచ్చు సమానం
ఇప్పటికే చెడు ఏదో చెప్పడానికి కుడి, ఇక్కడ జరిగే కానుంది?
మరియు నేను బహుశా ప్రయత్నించారు ఉంటే నిజానికి విభజన లోపంగా పొందుతుంది.
ఇప్పుడు ఎందుకంటే, అయితే మెమరీ గతంలో ఆ భాగం
నేను ఉందని ఏదో ఈ సమయంలో యాక్సెస్
ఇప్పుడు నేను మెమరీ యాక్సెస్ చేస్తున్నాను నాకు యాక్సెస్ కోసం చట్టబద్ధం కాదు.
>> మరియు మేము బహుశా రెడీ మేము మెమరీ యాక్సెస్ చేసినప్పుడు, గుర్తు
మేము టచ్ చేయాలో చేస్తున్నట్లు, అత్యంత సాధారణ కారణం
సెగ్మెంటేషన్ యొక్క తప్పు. కాబట్టి నా ప్రోగ్రామ్
నేను దీన్ని ప్రయత్నించాడు ఉంటే క్రాష్ అవుతుంది.
మరలా అది మంచి పొందుటకు ఒక మంచి ఆలోచన ఆచరణలో మరియు మంచి అలవాట్లు అమూల్యమయిన
malloc మరియు ఉచిత పనిచేసేటప్పుడు, కాబట్టి మీరు సెగ్మెంటేషన్ బాధలు లేని
మీరు ఉపయోగించవచ్చు, మరియు ఆ తప్పిదాలు మీ గతికంగా కేటాయించబడుతుంది
మెమరీ బాధ్యతాయుతంగా.
>> నేను డౌ లాయిడ్ ఉన్నాను ఈ CS50 ఉంది.