1 00:00:00,000 --> 00:00:00,410 2 00:00:00,410 --> 00:00:03,130 >> డేవిడ్ J. మలన్: ఆ అవుతుంది ఒక స్ట్రింగ్ కాపీ దాదాపు కాదు 3 00:00:03,130 --> 00:00:05,750 , ఒక ఆదిమ కాపీ సాధారణ ఒక Int లేదా ఫ్లోట్ వంటి. 4 00:00:05,750 --> 00:00:09,190 అన్ని తరువాత, హుడ్ కింద ఒక స్ట్రింగ్ క్రమం అక్షరాలు. 5 00:00:09,190 --> 00:00:13,130 కాబట్టి ఒక స్ట్రింగ్ కాపీ, అందువలన, ఉంది ఆ మొత్తం క్రమం యొక్క కాపీ ఉంటాయి 6 00:00:13,130 --> 00:00:14,240 అక్షరాలు. 7 00:00:14,240 --> 00:00:17,470 >> యొక్క ఆ తిరిగి మా కిందికి వస్తాయి గత అమలు మరియు ఈ చీల్చివేయు 8 00:00:17,470 --> 00:00:21,470 లైన్, స్ట్రింగ్ t, s సమానం స్పష్టంగా పెరగలేదు. 9 00:00:21,470 --> 00:00:24,440 యొక్క ఒక లైన్ భర్తీ లెట్ ఈ వంటి, బదులుగా, కనిపిస్తోంది. 10 00:00:24,440 --> 00:00:34,020 స్ట్రింగ్ t స్ట్రింగ్ పొడవు యొక్క malloc గెట్స్ ఒక చార్ యొక్క s ప్లస్ 1 సార్లు పరిమాణం. 11 00:00:34,020 --> 00:00:36,320 >> ఇప్పుడు మాత్రం కొంచెం కోట్ ఉంది కోడ్ యొక్క ఈ లైన్ లో. 12 00:00:36,320 --> 00:00:39,330 మొదటి, malloc, చిన్న కోసం మెమరీ కేటాయింపు, మరియు 13 00:00:39,330 --> 00:00:40,700 ఫంక్షన్ ఆ చేస్తుంది. 14 00:00:40,700 --> 00:00:44,740 పూర్ణాంకం కారణంగా, మీరు తిరిగి మెమరీ భాగం యొక్క చిరునామా 15 00:00:44,740 --> 00:00:45,960 అనేక బైట్లు. 16 00:00:45,960 --> 00:00:50,090 ఇంతలో, స్ట్రింగ్ s యొక్క పొడవు ప్లస్ 1 మేము కావలసిన సూచించడానికి అర్థం 17 00:00:50,090 --> 00:00:54,690 లు ఇప్పటికే ఆక్రమించింది అనేక బైట్లు, దాని శూన్య టెర్మినేటర్, సహా 18 00:00:54,690 --> 00:00:57,050 ఒక స్ట్రింగ్ చివరిలో బాక్ స్లాష్ 0. 19 00:00:57,050 --> 00:01:00,170 >> ఇంతలో, నేను తప్పనిసరిగా గుర్తు లేదు ఒక చార్ కూడా, ఎంత పెద్ద 20 00:01:00,170 --> 00:01:04,340 చాలా కంప్యూటర్లలో అది కేవలం 1 అయితే బైట్, నేను చార్ యొక్క పరిమాణం పిలుస్తాను 21 00:01:04,340 --> 00:01:08,210 డైనమిక్ గుర్తించడానికి ఎలా పెద్ద ఒక వ్యక్తి పాత్ర. 22 00:01:08,210 --> 00:01:12,550 ఒకసారి కలిసి గుణించాలి, నేను తిరిగి నేను అవసరమైన బైట్లు మొత్తం సంఖ్య. 23 00:01:12,550 --> 00:01:14,680 >> కానీ malloc ఏ విఫలమైతే మేము అవసరం మెమరీ తిరిగి? 24 00:01:14,680 --> 00:01:16,730 క్రింది నేను ఉత్తమ ఆ తనిఖీ ఇష్టం. 25 00:01:16,730 --> 00:01:23,330 T శూన్య సమానం, అప్పుడు నేను మొదటి వెళుతున్న ఉచిత లు, మెమరీ కూర్చుంటోంది తిరిగి 26 00:01:23,330 --> 00:01:27,120 స్ట్రింగ్, మరియు నేను వెళుతున్న లోపం అర్థంతో, 1 తిరిగి. 27 00:01:27,120 --> 00:01:30,360 >> అన్ని బాగా ఉంటే కానీ, నేను ముందుకు వెళుతున్న నాలుగు లూప్ ఉపయోగించడానికి మరియు iterate కు 28 00:01:30,360 --> 00:01:31,110 క్రింది. 29 00:01:31,110 --> 00:01:36,000 Int కోసం నేను 0, n సమానం పొందండి s యొక్క స్ట్రింగ్ పొడవు. 30 00:01:36,000 --> 00:01:40,350 నేను కాబట్టి నేను ఉంది ఈ వెళుతున్న కంటే తక్కువ లేదా n సమానంగా కాబట్టి నేను 31 00:01:40,350 --> 00:01:44,460 ద్వారా సహా iterate లు శూన్య రద్దు పాత్ర. 32 00:01:44,460 --> 00:01:47,450 >> మరియు ప్రతి పునరావృతం న, నేను ఉన్నాను నేను పెంచడం అన్నారు. 33 00:01:47,450 --> 00:01:52,496 ఇంతలో, ఈ లూప్ యొక్క లోపల, కాపీ t యొక్క i-th లోకి s యొక్క i-th పాత్ర 34 00:01:52,496 --> 00:01:59,310 నగర, దానిని చేయడానికి సంతృప్తి పరుస్తుంది బ్రాకెట్ నేను s బ్రాకెట్ నేను గెట్స్. 41 00:01:59,320 --> 00:02:02,750 >> ఇప్పుడు, సేవ్ సంకలనం లెట్, మరియు ఈ కొత్త కార్యక్రమం అమలు. 42 00:02:02,750 --> 00:02:06,690 కాపీ 1 డాట్ స్లాష్ ప్రతిని 1. 43 00:02:06,690 --> 00:02:09,460 నేను ఏదో వంటి సే చేస్తాము హలో అన్ని చిన్న లో. 44 00:02:09,460 --> 00:02:12,280 మరియు కృతజ్ఞతగా, ఈ సమయంలో నా అసలు మారదు. 45 00:02:12,280 --> 00:02:13,660 హలో అన్ని చిన్న లో. 46 00:02:13,660 --> 00:02:15,540 కానీ కాపీ, నిజానికి, క్యాపిటల్స్. 47 00:02:37,120 --> 00:02:38,963