1
00:00:00,000 --> 00:00:00,340

2
00:00:00,340 --> 00:00:01,960
>> स्पीकर 1: चलो अब ठीक करने दें
कि पिछले कार्यक्रम.

3
00:00:01,960 --> 00:00:04,920
और इस बार, के लिए स्पष्ट रूप से आवंटित करते हैं
कुछ स्मृति में जो

4
00:00:04,920 --> 00:00:06,550
उपयोगकर्ता के इनपुट संग्रहीत किया जाएगा.

5
00:00:06,550 --> 00:00:09,600
ऐसा करने के लिए, चलो कि पहली पर सान जाने
हम एस घोषित जहां कोड की लाइन

6
00:00:09,600 --> 00:00:11,590
पहले एक चार सितारा हो.

7
00:00:11,590 --> 00:00:14,210
इस बार, चलो फिर से घोषित
यह इस प्रकार है -

8
00:00:14,210 --> 00:00:19,380
चार के ब्रैकेट 16, उदाहरण के लिए,
बंद कोष्ठक.

9
00:00:19,380 --> 00:00:23,690
>> दूसरे शब्दों में, कोई करने के लिए की घोषणा करते हैं
अब एक चरित्र का एक पता होना,

10
00:00:23,690 --> 00:00:26,610
लेकिन 16 अक्षरों का नहीं बल्कि एक सरणी.

11
00:00:26,610 --> 00:00:30,295
इस तरह, उपयोगकर्ता के लिए 15 में टाइप कर सकते हैं
वर्ण और अभी के लिए कमरे में छोड़

12
00:00:30,295 --> 00:00:31,570
एक अशक्त टर्मिनेटर.

13
00:00:31,570 --> 00:00:35,870
बचाने के लिए आगे बढ़ना, संकलन,
और इस कार्यक्रम को चलाने.

14
00:00:35,870 --> 00:00:40,770
Scanf2 डॉट स्लेश scanf2 बनाओ.

15
00:00:40,770 --> 00:00:45,100
चलो अब नमस्ते की तरह एक स्ट्रिंग टाइप करते,
और हम नमस्कार के लिए धन्यवाद दिया हो.

16
00:00:45,100 --> 00:00:46,440
>> अब, एक समस्या अभी भी है.

17
00:00:46,440 --> 00:00:50,140
मैं केवल केवल है जो, नमस्कार में टाइप
अशक्त के लिए पांच अक्षर, प्लस 1

18
00:00:50,140 --> 00:00:50,445
टर्मिनेटर.

19
00:00:50,445 --> 00:00:53,610
यह केवल साथ छोड़ देता है
छह बाइट्स के लिए एक की जरूरत है.

20
00:00:53,610 --> 00:00:56,740
>> लेकिन दुर्भाग्य से, हम केवल
कुल 16 आवंटित.

21
00:00:56,740 --> 00:01:01,305
तो अगर 16 में उपयोगकर्ता वास्तव प्रकार
वर्ण, या 17, या कई सौ

22
00:01:01,305 --> 00:01:04,410
वर्ण, हम अभी भी करने के लिए नहीं जा रहे हैं
के लिए स्मृति में पर्याप्त जगह

23
00:01:04,410 --> 00:01:05,400
उपयोगकर्ता के इनपुट.

24
00:01:05,400 --> 00:01:07,750
और वास्तव में, यह क्या करता है
उपयोगकर्ता इनपुट हो रही है तो

25
00:01:07,750 --> 00:01:08,940
सामान्य रूप में मुश्किल.

26
00:01:08,940 --> 00:01:12,270
हम कार्यान्वित क्यों और वास्तव में, यह है
पहले में मिल स्ट्रिंग समारोह

27
00:01:12,270 --> 00:01:13,900
CS50 पुस्तकालय में जगह -

28
00:01:13,900 --> 00:01:16,900
उन को संभालने के लिए बाहर निकालने के लिए
स्थितियों जहाँ प्रयोक्ता प्रकार में

29
00:01:16,900 --> 00:01:19,710
हम अधिक से अधिक वर्ण
शुरू में प्रत्याशित.

30
00:01:19,710 --> 00:01:21,750
>> सच कहूँ तो, बिना पूरी तरह से
इस कार्यक्रम को फिर से लिखना,

31
00:01:21,750 --> 00:01:23,290
कोई स्वच्छ समाधान है.

32
00:01:23,290 --> 00:01:26,970
बल्कि, हमें क्या करना होगा मिलता है
एक पर उपयोगकर्ता एक से एक चरित्र

33
00:01:26,970 --> 00:01:28,860
समय, फिर और फिर.

34
00:01:28,860 --> 00:01:32,510
और प्रत्येक बिंदु पर हम हम कर रहे हैं एहसास अगर
स्मृति से बाहर है, हम पर करना होगा

35
00:01:32,510 --> 00:01:36,450
उस बिंदु में वापस जाने के लिए और reallocate
कुछ और स्मृति, उपयोगकर्ता की प्रति

36
00:01:36,450 --> 00:01:39,400
हमारा पहला हिस्सा से पिछले इनपुट
नई में स्मृति की,

37
00:01:39,400 --> 00:01:40,810
स्मृति का बड़ा हिस्सा.

38
00:01:40,810 --> 00:01:44,610
और उसके बाद फिर से उस प्रक्रिया को दोहराने और
उपयोगकर्ता प्रदान किया जाता है फिर जब तक

39
00:01:44,610 --> 00:01:45,860
अपने या अपने इनपुट.

40
00:01:45,860 --> 00:01:48,246