1
00:00:00,000 --> 00:00:00,410

2
00:00:00,410 --> 00:00:03,130
>> डेविड जे मालन: तो यह पता चला है कि
एक स्ट्रिंग नकल के रूप में लगभग नहीं है

3
00:00:03,130 --> 00:00:05,750
एक आदिम नकल के रूप में सरल
एक पूर्णांक या एक नाव की तरह.

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
रेखा, स्ट्रिंग टी, एस के बराबर होती है
स्पष्ट रूप से पर्याप्त नहीं था.

9
00:00:21,470 --> 00:00:24,440
की एक पंक्ति के साथ की जगह दो कि
इस तरह, बजाय, लग रहा है.

10
00:00:24,440 --> 00:00:34,020
स्ट्रिंग टी स्ट्रिंग लंबाई की की malloc हो जाता है
एक चार के एस प्लस 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
इस बीच, स्ट्रिंग एस की लंबाई प्लस 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
टी बातिल के बराबर होती है, तो मैं पहले जा रहा हूँ
नि: शुल्क एस के लिए, स्मृति प्राप्त करके लौटे

26
00:01:23,330 --> 00:01:27,120
स्ट्रिंग, और फिर मैं जा रहा हूँ
त्रुटि दर्शाता है, 1 वापसी.

27
00:01:27,120 --> 00:01:30,360
>> सब कुछ ठीक है लेकिन अगर मैं आगे बढ़ने के लिए जा रहा हूँ
एक चार पाश का उपयोग करें और पुनरावृति करने के लिए

28
00:01:30,360 --> 00:01:31,110
इस प्रकार है.

29
00:01:31,110 --> 00:01:36,000
Int के लिए मैं 0, एन बराबरी पाने
एस की स्ट्रिंग लंबाई.

30
00:01:36,000 --> 00:01:40,350
मैं इतने लंबे समय मैं है के रूप में यह करने के लिए जा रहा हूँ
से भी कम या n के बराबर है, ताकि मैं

31
00:01:40,350 --> 00:01:44,460
के माध्यम से और सहित पुनरावृति
एस में अशक्त समाप्त चरित्र.

32
00:01:44,460 --> 00:01:47,450
>> और प्रत्येक यात्रा पर, मैं हूँ
मैं वेतन वृद्धि करने जा रही है.

33
00:01:47,450 --> 00:01:52,496
इस बीच, इस लूप के अंदर, कॉपी
टी i-वीं में है की मैं वें चरित्र

34
00:01:52,496 --> 00:01:59,310
स्थान, यह टी करने के लिए suffices
ब्रैकेट मैं ब्रैकेट मैं हो जाता है.

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