>> డేవిడ్ J. మలన్: ఆ అవుతుంది ఒక స్ట్రింగ్ కాపీ దాదాపు కాదు
, ఒక ఆదిమ కాపీ సాధారణ ఒక Int లేదా ఫ్లోట్ వంటి.
అన్ని తరువాత, హుడ్ కింద ఒక స్ట్రింగ్ క్రమం అక్షరాలు.
కాబట్టి ఒక స్ట్రింగ్ కాపీ, అందువలన, ఉంది ఆ మొత్తం క్రమం యొక్క కాపీ ఉంటాయి
అక్షరాలు.
>> యొక్క ఆ తిరిగి మా కిందికి వస్తాయి గత అమలు మరియు ఈ చీల్చివేయు
లైన్, స్ట్రింగ్ t, s సమానం స్పష్టంగా పెరగలేదు.
యొక్క ఒక లైన్ భర్తీ లెట్ ఈ వంటి, బదులుగా, కనిపిస్తోంది.
స్ట్రింగ్ t స్ట్రింగ్ పొడవు యొక్క malloc గెట్స్ ఒక చార్ యొక్క s ప్లస్ 1 సార్లు పరిమాణం.
>> ఇప్పుడు మాత్రం కొంచెం కోట్ ఉంది కోడ్ యొక్క ఈ లైన్ లో.
మొదటి, malloc, చిన్న కోసం మెమరీ కేటాయింపు, మరియు
ఫంక్షన్ ఆ చేస్తుంది.
పూర్ణాంకం కారణంగా, మీరు తిరిగి మెమరీ భాగం యొక్క చిరునామా
అనేక బైట్లు.
ఇంతలో, స్ట్రింగ్ s యొక్క పొడవు ప్లస్ 1 మేము కావలసిన సూచించడానికి అర్థం
లు ఇప్పటికే ఆక్రమించింది అనేక బైట్లు, దాని శూన్య టెర్మినేటర్, సహా
ఒక స్ట్రింగ్ చివరిలో బాక్ స్లాష్ 0.
>> ఇంతలో, నేను తప్పనిసరిగా గుర్తు లేదు ఒక చార్ కూడా, ఎంత పెద్ద
చాలా కంప్యూటర్లలో అది కేవలం 1 అయితే బైట్, నేను చార్ యొక్క పరిమాణం పిలుస్తాను
డైనమిక్ గుర్తించడానికి ఎలా పెద్ద ఒక వ్యక్తి పాత్ర.
ఒకసారి కలిసి గుణించాలి, నేను తిరిగి నేను అవసరమైన బైట్లు మొత్తం సంఖ్య.
>> కానీ malloc ఏ విఫలమైతే మేము అవసరం మెమరీ తిరిగి?
క్రింది నేను ఉత్తమ ఆ తనిఖీ ఇష్టం.
T శూన్య సమానం, అప్పుడు నేను మొదటి వెళుతున్న ఉచిత లు, మెమరీ కూర్చుంటోంది తిరిగి
స్ట్రింగ్, మరియు నేను వెళుతున్న లోపం అర్థంతో, 1 తిరిగి.
>> అన్ని బాగా ఉంటే కానీ, నేను ముందుకు వెళుతున్న నాలుగు లూప్ ఉపయోగించడానికి మరియు iterate కు
క్రింది.
Int కోసం నేను 0, n సమానం పొందండి s యొక్క స్ట్రింగ్ పొడవు.
నేను కాబట్టి నేను ఉంది ఈ వెళుతున్న కంటే తక్కువ లేదా n సమానంగా కాబట్టి నేను
ద్వారా సహా iterate లు శూన్య రద్దు పాత్ర.
>> మరియు ప్రతి పునరావృతం న, నేను ఉన్నాను నేను పెంచడం అన్నారు.
ఇంతలో, ఈ లూప్ యొక్క లోపల, కాపీ t యొక్క i-th లోకి s యొక్క i-th పాత్ర
నగర, దానిని చేయడానికి సంతృప్తి పరుస్తుంది బ్రాకెట్ నేను s బ్రాకెట్ నేను గెట్స్.
>> ఇప్పుడు, సేవ్ సంకలనం లెట్, మరియు ఈ కొత్త కార్యక్రమం అమలు.
కాపీ 1 డాట్ స్లాష్ ప్రతిని 1.
నేను ఏదో వంటి సే చేస్తాము హలో అన్ని చిన్న లో.
మరియు కృతజ్ఞతగా, ఈ సమయంలో నా అసలు మారదు.
హలో అన్ని చిన్న లో.
కానీ కాపీ, నిజానికి, క్యాపిటల్స్.