1
00:00:00,000 --> 00:00:02,310
[Powered by Google Translate] [4 सप्ताह जारी रहेगा]

2
00:00:02,310 --> 00:00:04,240
[डेविड जे Malan हार्वर्ड विश्वविद्यालय]

3
00:00:04,240 --> 00:00:07,290
[यह CS50 है. - CS50.TV]

4
00:00:07,290 --> 00:00:11,290
>> इस CS50 है, और यह 4 सप्ताह के अंत है.

5
00:00:11,290 --> 00:00:14,030
तो कुछ अच्छी खबर है और कुछ बुरी खबर है.

6
00:00:14,030 --> 00:00:26,240
सोमवार पर नहीं व्याख्यान अगले सप्ताह, कोई समस्या नहीं. [छात्रों जयकार]

7
00:00:26,240 --> 00:00:28,680
आप की तरह है, जहां यह जा रहा है नहीं जा रहे हैं.

8
00:00:28,680 --> 00:00:31,590
लेकिन हम इस पर अगले बुधवार के बजाय करते हैं,

9
00:00:31,590 --> 00:00:37,740
और वहाँ भी पाठ्यक्रम 1 शुक्रवार व्याख्यान के अनुसार अगले शुक्रवार इतना है कि हम ट्रैक पर रह सकते हैं.

10
00:00:37,740 --> 00:00:40,580
लेकिन सब कुछ सामान्य रूप से फिल्माया जाएगा, तो चिंता करने की नहीं है.

11
00:00:40,580 --> 00:00:44,100
>> और संबंध के साथ 0 प्रश्नोत्तरी क्या हम सप्ताह के अंत की ओर करूँगा

12
00:00:44,100 --> 00:00:47,140
है पाठ्यक्रम के होमपेज cs50.net एक स्पष्टीकरण पर पोस्ट

13
00:00:47,140 --> 00:00:50,160
उम्मीदों के किस तरह आप जब यह पहली प्रश्नोत्तरी के लिए आता है चाहिए.

14
00:00:50,160 --> 00:00:55,100
सामान्य में, यह एकाधिक विकल्प, सच झूठी, कम जवाब, लघु कोडिंग समस्याओं का होगा.

15
00:00:55,100 --> 00:00:57,360
आप करने के लिए बराबर लागू करने के लिए उम्मीद की जा नहीं जा रहे हैं

16
00:00:57,360 --> 00:01:00,030
एक समस्या यह है कि आप एक pset पर देखना होगा, जिसके लिए आप एक कंप्यूटर है

17
00:01:00,030 --> 00:01:03,240
debugger और पसंद है, लेकिन वहाँ छोटे कोडन समस्या हो जाएगी.

18
00:01:03,240 --> 00:01:06,900
>> और वास्तव में, सबसे अच्छा क्या CS50 quizzes की भावना पाने के गाइड की तरह कर रहे हैं

19
00:01:06,900 --> 00:01:09,180
cs50.net के लिए जाना है, लिंक क्विज़ जाना है,

20
00:01:09,180 --> 00:01:11,920
और आप पिछले कई वर्षों quizzes के लायक देख सकते हैं.

21
00:01:11,920 --> 00:01:16,600
बस एहसास है कि पाठ्यक्रम हमेशा साल से अधिक ही नहीं किया गया है.

22
00:01:16,600 --> 00:01:18,510
कभी कभी हम कभी कभी घटाना, जोड़ने के लिए,

23
00:01:18,510 --> 00:01:20,670
इसलिए यदि आप एक उन पुराने quizzes कुछ विषय देखें

24
00:01:20,670 --> 00:01:25,380
कि तुम्हें पता नहीं है कि यह किस बारे में बात कर रहा है, यह भी है कि हम इसे कवर किया

25
00:01:25,380 --> 00:01:27,210
या कि हम इसे कवर नहीं किया.

26
00:01:27,210 --> 00:01:31,110
लेकिन समीक्षा के रूप, इस रविवार, सोमवार, और मंगलवार

27
00:01:31,110 --> 00:01:34,770
के रूप में अच्छी तरह से एक कोर्स रविवार की रात को व्यापक समीक्षा सत्र के रूप में -

28
00:01:34,770 --> 00:01:37,500
समय और स्थान के लिए पाठ्यक्रम के मुखपृष्ठ पर घोषणा की जानी -

29
00:01:37,500 --> 00:01:40,120
आप सभी एक पाठ्यक्रम शिक्षण साथियों के साथ समीक्षा करने का अवसर है

30
00:01:40,120 --> 00:01:44,830
दोनों अनुभाग में और एक पूर्ण वर्ग के रूप में इस वर्ष के लिए, सामग्री,

31
00:01:44,830 --> 00:01:48,400
और सामान्य रूप से उन के रूप में अच्छी तरह से फिल्माया जाएगा.

32
00:01:48,400 --> 00:01:53,380
>> सही सभी. तो आगे की हलचल के बिना, पारित पर एक टिप्पणी / विफल रहता है और जोड़ें / ड्रॉप.

33
00:01:53,380 --> 00:01:57,980
आप अपने नोट्स कल रात में देखा जा सकता है, और यह वास्तव में सिर्फ कुछ अतिरिक्त आश्वासन

34
00:01:57,980 --> 00:02:01,250
कि अगर आप उन लोगों के बीच विशेष रूप से कम आराम या कहीं बीच में हैं

35
00:02:01,250 --> 00:02:04,870
और आप अपने सिर पर में सिर्फ एक छोटा सा महसूस कर रहे हैं,

36
00:02:04,870 --> 00:02:08,430
एहसास है कि वास्तव में काफी सामान्य है, और वहाँ जगह में एक पर्याप्त समर्थन संरचना है,

37
00:02:08,430 --> 00:02:13,530
जिनमें से एक कार्यालय घंटे अपने ईमेल पिछली रात के प्रति सभी को और अधिक सुधार लाने पर आमादा थे,

38
00:02:13,530 --> 00:02:16,520
और भी एहसास है कि पास की तरह एक विकल्प है / इस तरह एक वर्ग के लिए विफल

39
00:02:16,520 --> 00:02:21,540
वास्तव में एक तंत्र के रूप में इस तरह से एक कोर्स के किनारे दूर ले मतलब है,

40
00:02:21,540 --> 00:02:24,200
इतना है कि फिर अगर आप उन 10, 15, 20 घंटे खर्च कर रहे हैं

41
00:02:24,200 --> 00:02:28,160
सिर्फ कुछ pset पाने के लिए काम करने की कोशिश कर रहा है और आप जानते हैं कि आप जिस तरह के 90-95% कर रहे हैं वहाँ

42
00:02:28,160 --> 00:02:32,100
लेकिन आप कुछ लानत बग नहीं मिल, एक पास में कर सकते हैं / मॉडल है कि तरह की है ठीक विफल.

43
00:02:32,100 --> 00:02:36,230
>> विचार यह है कि उस तंत्र के साथ तुम तो अपने अन्य psets पर ध्यान केंद्रित करने जा सकते हैं

44
00:02:36,230 --> 00:02:39,530
या सोने या जो कुछ भी यह है कि आप पर ध्यान केंद्रित करना चाहते हैं.

45
00:02:39,530 --> 00:02:43,390
तो पता है कि तुम इस आने वाले मंगलवार तक - तकनीकी रूप से 5 सोमवार,

46
00:02:43,390 --> 00:02:50,840
लेकिन यह एक छुट्टी है, तो इस आने वाले मंगलवार - पास से स्विच / वर्गीकृत या ठीक इसके विपरीत विफल करने के लिए.

47
00:02:50,840 --> 00:02:54,450
और अगर आप करारा पर वास्तव में कर रहे हैं और पूरी तरह छोड़ने के बारे में सोच रहे हैं,

48
00:02:54,450 --> 00:02:56,440
व्याख्यान के बाद मुझे पकड़ या मुझे एक चिट्ठी छोड़ कृपया.

49
00:02:56,440 --> 00:02:59,990
हम कम से कम चैट करने के लिए प्यार करता हूँ इससे पहले कि आप अलविदा चाहते हैं.

50
00:02:59,990 --> 00:03:03,470
सही सभी. तो हम पिछली बार से प्रशिक्षण के पहियों लेने शुरू कर दिया.

51
00:03:03,470 --> 00:03:06,030
विशेष रूप से, हम स्ट्रिंग पर ध्यान केंद्रित किया.

52
00:03:06,030 --> 00:03:09,740
स्ट्रिंग कुछ है कि CS50 पुस्तकालय में घोषित है,

53
00:03:09,740 --> 00:03:14,340
विशेष रूप से कि cs50.h नामक एक फाइल में जो हम करने के लिए इस सप्ताह और अगले ढूंढना शुरू कर देंगे.

54
00:03:14,340 --> 00:03:17,250
लेकिन स्ट्रिंग वास्तव में सिर्फ कुछ का सरलीकरण है

55
00:03:17,250 --> 00:03:20,980
कि एक छोटे से अधिक arcanely चार * के रूप में वर्णित है.

56
00:03:20,980 --> 00:03:24,090
CHAR हम से परिचित हैं. यह सिर्फ एक ही चरित्र है.

57
00:03:24,090 --> 00:03:28,010
लेकिन क्या * सोमवार के रूप में निरूपित किया जाता है? >> [छात्र] एक सूचक.

58
00:03:28,010 --> 00:03:31,290
एक संकेतक. और एक सूचक क्या है? >> [छात्र] पता.

59
00:03:31,290 --> 00:03:33,420
>> यह एक पता, स्मृति में एक स्थान की तरह है.

60
00:03:33,420 --> 00:03:35,910
एक पते या स्थान या स्मृति क्या है?

61
00:03:35,910 --> 00:03:40,290
फिर, हम सभी के एक टमटम या राम के 2 गीगाबाइट के साथ लैपटॉप इन दिनों सबसे अधिक संभावना है,

62
00:03:40,290 --> 00:03:44,160
और इसका मतलब है कि आप एक अरब या दो अरब बाइट्स स्मृति के लायक है.

63
00:03:44,160 --> 00:03:46,240
और यह वास्तव में क्या यह शारीरिक रूप से की तरह लग रहा है कोई फर्क नहीं पड़ता है,

64
00:03:46,240 --> 00:03:51,220
लेकिन विश्वास पर रखना है कि आप सभी व्यक्तिगत बाइट्स है कि अपने लैपटॉप की संख्या कर सकते हैं -

65
00:03:51,220 --> 00:03:54,580
यह 0 बाइट है, यह 1 बाइट है, इस बाइट 2 अरब -

66
00:03:54,580 --> 00:03:56,100
और कहा कि वास्तव में एक कंप्यूटर क्या करता है.

67
00:03:56,100 --> 00:04:00,030
जब आप एक ही चरित्र के लिए जगह आवंटित है, उदाहरण के लिए,

68
00:04:00,030 --> 00:04:02,480
यह स्पष्ट रूप से करने के लिए अपने कंप्यूटर की स्मृति में कहीं रहते है,

69
00:04:02,480 --> 00:04:05,860
और शायद यह बाइट 12345 नंबर पर है,

70
00:04:05,860 --> 00:04:08,470
और कहा कि कहीं आपके कंप्यूटर की मेमोरी में यहाँ है.

71
00:04:08,470 --> 00:04:12,630
और फिर उस चरित्र के पते 12345 है.

72
00:04:12,630 --> 00:04:16,140
>> अब, 0 के माध्यम से अब इस प्रकार अब तक सप्ताह में, हम वास्तव में परवाह नहीं है

73
00:04:16,140 --> 00:04:19,170
क्योंकि स्मृति बातों में हम आम तौर पर जहां प्रतीकों का उपयोग संग्रहीत हैं,

74
00:04:19,170 --> 00:04:22,540
चर, और arrays वास्तव में हमारे डेटा को पाने के लिए.

75
00:04:22,540 --> 00:04:24,950
लेकिन सोमवार और सभी को और अधिक आज के रूप में, अब आप के पास जा रहे हैं

76
00:04:24,950 --> 00:04:27,710
लेखन कार्यक्रमों के साथ सभी को और अधिक अर्थपूर्ण क्षमताओं

77
00:04:27,710 --> 00:04:31,330
वास्तव में एक कंप्यूटर की स्मृति में हेरफेर लेकिन आप देखते हैं फिट,

78
00:04:31,330 --> 00:04:33,720
दोनों अच्छे उद्देश्यों और बुरे के लिए,

79
00:04:33,720 --> 00:04:39,620
कीड़े इस सामान सीखने में इस बिंदु पर एक बहुत ही आम परिणाम जा रहा है.

80
00:04:39,620 --> 00:04:42,460
लेकिन यह वास्तव में क्या करने के लिए एक चार * क्या मतलब है?

81
00:04:42,460 --> 00:04:46,140
चलो आगे वापस करने के लिए जाने - और हम Binky करने के लिए वापस आने के रूप में आज का वादा किया.

82
00:04:46,140 --> 00:04:48,670
चलो एक सरल उदाहरण के लिए चलते हैं.

83
00:04:48,670 --> 00:04:53,060
मुझे compare.c के रूप में इस फाइल को बचाने के लिए, और मुझे बस कुछ टेम्पलेट कोड यहाँ मिल

84
00:04:53,060 --> 00:05:00,490
इतना stdio.h में शामिल हैं, मुझे भी अपने आप को देने में शामिल cs50.h. मैं वहाँ में ज़ूम करेंगे.

85
00:05:00,490 --> 00:05:05,850
मुझे मुख्य int मुख्य (शून्य) लेखन शुरू करते हैं, और अब मैं इस तरह से कुछ करना चाहते हैं:

86
00:05:05,850 --> 00:05:13,520
printf ("मुझे एक स्ट्रिंग दे:") और फिर मैं प्रयोग करेंगे स्ट्रिंग है GetString हो जाता है

87
00:05:13,520 --> 00:05:16,750
उपयोगकर्ता से एक स्ट्रिंग मिलता है, तो मैं एक दूसरे के लिए उपयोगकर्ता पूछने के लिए जा रहा हूँ.

88
00:05:16,750 --> 00:05:21,870
("मुझे एक स्ट्रिंग दे:") और मैं उन्हें है कि मिल GetString के माध्यम से पूछने के लिए जा रहा हूँ.

89
00:05:21,870 --> 00:05:27,020
मैं इसे कहते हैं, क्योंकि टी के बाद आता है और एक स्ट्रिंग के लिए एक अच्छा नाम है अगर यह बहुत सामान्य है.

90
00:05:27,020 --> 00:05:30,030
तो GetString, और अब मैं सिर्फ एक मानसिक स्वास्थ्य की जांच करना चाहते हैं और मैं कहने जा रहा हूँ

91
00:05:30,030 --> 00:05:39,770
अगर (एस टी ==) तो मैं सिर्फ उपयोगकर्ता बता printf ("आप एक ही बात पर \ n टाइप") जा रहा हूँ;

92
00:05:39,770 --> 00:05:45,520
और मैं बाहर की तरह ("आप टाइप कुछ अलग \ n") कुछ प्रिंट लिए जा रहा हूँ

93
00:05:45,520 --> 00:05:48,460
या जो भी सजा हो जाएगा. तो ऐसा कुछ.

94
00:05:48,460 --> 00:05:52,200
फिर हमेशा की तरह, मैं 0 जो सिर्फ signified कुछ भी नहीं बुरा हुआ कि वापस कर देंगे,

95
00:05:52,200 --> 00:05:54,400
और मुझे आगे जाना है और संकलन और इस कार्यक्रम को चलाने के लिए जा रहा हूँ.

96
00:05:54,400 --> 00:05:56,540
>> लेकिन सोमवार को हम इस कार्यक्रम भागा,

97
00:05:56,540 --> 00:06:00,420
और वास्तव में बताया गया है कि हैलो हैलो नहीं है और अलविदा अलविदा नहीं है.

98
00:06:00,420 --> 00:06:03,140
व्यवहार हमने देखा कि एक छोटे से इस तरह से अधिक था.

99
00:06:03,140 --> 00:06:11,450
चलो मुझे अपने स्रोत निर्देशिका में जाना है, यहाँ में ज़ूम, और चलो बनाने की तुलना करते हैं.

100
00:06:11,450 --> 00:06:14,570
ठीक संकलित. मुझे चलाने की तुलना करें. मुझे एक स्ट्रिंग दे: नमस्कार.

101
00:06:14,570 --> 00:06:16,300
मुझे एक स्ट्रिंग दे: नमस्कार.

102
00:06:16,300 --> 00:06:18,000
आप कुछ अलग टाइप!

103
00:06:18,000 --> 00:06:22,650
खैर, मुझे 50 50, की तरह सरल कुछ करने की कोशिश. आप कुछ अलग टाइप!

104
00:06:22,650 --> 00:06:25,740
हाय, हाय. तो जाहिर है, कुछ और यहाँ पर जा रहा है.

105
00:06:25,740 --> 00:06:28,440
लेकिन क्या क्यों के लिए विवरण था?

106
00:06:28,440 --> 00:06:33,850
जाहिर है, 12 लाइन पूरी तरह से बेकार है.

107
00:06:34,300 --> 00:06:39,430
मौलिक यहाँ समस्या क्या है? हाँ. >> [छात्र] यह पते की तुलना है.

108
00:06:39,430 --> 00:06:41,850
हाँ, बिल्कुल. यह वास्तव में पते की तुलना है

109
00:06:41,850 --> 00:06:44,580
जिसमें HELLO और HELLO संग्रहीत हैं.

110
00:06:44,580 --> 00:06:48,290
यह पत्र HELLO तुलना नहीं है फिर और फिर,

111
00:06:48,290 --> 00:06:52,370
क्योंकि वास्तव में क्या हुआ है, यह सब समय हम GetString का उपयोग कर रहा है -

112
00:06:52,370 --> 00:06:56,130
यह ब्लैकबोर्ड फिर हमारे कंप्यूटर की मेमोरी है,

113
00:06:56,130 --> 00:07:00,100
और चलो का कहना है कि मैं एक चर एस की घोषणा के बाद GetString फोन.

114
00:07:00,100 --> 00:07:01,930
मेरी स्मृति की तरह दिखता है?

115
00:07:01,930 --> 00:07:07,070
चलो मनमाने ढंग से कहना है कि इस तरह दिखता है. यह एक वर्ग है.

116
00:07:07,070 --> 00:07:09,040
और बहुत ज्यादा किसी भी समय मैं स्क्रीन पर स्मृति का एक टुकड़ा तैयार किया है

117
00:07:09,040 --> 00:07:12,860
अगर यह 32 बिट है कि मैं इस तरह से किया गया है चौकों ड्राइंग उपकरण में क्योंकि वास्तव में,

118
00:07:12,860 --> 00:07:17,380
एक सूचक, पते, 32 बिट है. यह एक int के रूप में ही है.

119
00:07:17,380 --> 00:07:19,420
यह कंप्यूटर प्रणाली के आधार पर भिन्न हो सकते हैं.

120
00:07:19,420 --> 00:07:24,630
तुम में से जो थोड़ा तथ्य यह है कि अपने मैक या पीसी 64 बिट से परिचित हैं,

121
00:07:24,630 --> 00:07:28,120
कि वास्तव में अर्थ है कि आपके कंप्यूटर में 64 बिट संकेत का उपयोग कर रहा है,

122
00:07:28,120 --> 00:07:33,730
64 बिट पते और कि का upsides के बीच अपने कंप्यूटर

123
00:07:33,730 --> 00:07:35,560
पुराने की तुलना में अधिक हो सकता है RAM.

124
00:07:35,560 --> 00:07:39,240
लंबी कहानी संक्षेप, वापस दिन में जब कंप्यूटर केवल 32 बिट का इस्तेमाल किया

125
00:07:39,240 --> 00:07:42,740
पते का प्रतिनिधित्व करते हैं, बाइट्स की सबसे बड़ी संख्या में आप का प्रतिनिधित्व कर सकता है

126
00:07:42,740 --> 00:07:46,280
उस मामले में किया गया था क्या हुआ अगर आप 32 बिट है?

127
00:07:46,280 --> 00:07:49,590
4 तो अरब, ठीक है, क्योंकि 2 32 4 अरब है.

128
00:07:49,590 --> 00:07:51,370
यह संख्या पाठ्यक्रम में आवर्ती है.

129
00:07:51,370 --> 00:07:55,240
>> तो अगर आप केवल 32 बिट, उच्चतम नंबर पर आप भरोसा कर सकते हैं लगभग 4 अरब.

130
00:07:55,240 --> 00:07:58,750
लेकिन यह है कि कुछ साल पहले तक कंप्यूटर की एक मौलिक सीमा

131
00:07:58,750 --> 00:08:01,180
क्योंकि अगर आप केवल 4 अरब के रूप में उच्च भरोसा कर सकते हैं,

132
00:08:01,180 --> 00:08:05,270
यह कोई फर्क नहीं पड़ता अगर तुम राम के 8 गीगाबाइट या भी राम की 5 गीगाबाइट खरीदने;

133
00:08:05,270 --> 00:08:07,780
आपको लगता है कि उच्च गिनती नहीं है, तो यह बेकार था कर सकते हैं.

134
00:08:07,780 --> 00:08:11,430
आप केवल अपने कंप्यूटर की स्मृति के पहले 3 या 4 गीगाबाइट का उपयोग कर सकता है.

135
00:08:11,430 --> 00:08:14,410
वह एक मुद्दे के कम है, और आप मैकबुक पेशेवरों और Dells खरीद सकते हैं

136
00:08:14,410 --> 00:08:17,680
राम के 8 गीगाबाइट या अधिक भी इन दिनों के साथ.

137
00:08:17,680 --> 00:08:24,100
लेकिन अगर मैं इस कार्यक्रम में काफी बस एक सूचक आवंटित, एक सूचक कहा जाता है,

138
00:08:24,100 --> 00:08:28,370
इसे इस तरह से स्क्रीन पर लग रही है क्योंकि वास्तव में हम वापस छील इस परत की जरूरत हो सकती है.

139
00:08:28,370 --> 00:08:33,520
मैं कह स्ट्रिंग रखने के लिए, लेकिन सोमवार के रूप में, स्ट्रिंग वास्तव में चार *

140
00:08:33,520 --> 00:08:35,590
कुछ चरित्र का पता.

141
00:08:35,590 --> 00:08:39,280
तो चलो कि प्रशिक्षण पहिया बंद ले यद्यपि हम अब के लिए GetString का उपयोग जारी रखेंगे.

142
00:08:39,280 --> 00:08:42,600
इसलिए मैं घोषित किया है, और यह स्मृति का एक हिस्सा है, 32 बिट है.

143
00:08:42,600 --> 00:08:47,370
डिफ़ॉल्ट रूप से स्मृति में यहाँ क्या है? >> [अश्राव्य छात्र प्रतिक्रिया]

144
00:08:47,370 --> 00:08:50,040
वह क्या है? >> [छात्र] कचरा. >> कचरा. बिल्कुल सही.

145
00:08:50,040 --> 00:08:54,610
यदि आप एक चर में प्रोग्रामर एक मूल्य नहीं डाल दिया है, जो जानता है कि यह क्या है?

146
00:08:54,610 --> 00:08:57,990
कभी कभी तुम भाग्यशाली हो और यह 0 है, जो एक अच्छी, साफ डिफ़ॉल्ट मान की तरह है,

147
00:08:57,990 --> 00:09:00,310
लेकिन जैसा कि हम सोमवार को देखा, कभी कभी यह पूरी तरह बकवास है,

148
00:09:00,310 --> 00:09:04,130
वास्तव में कुछ बड़ा सकारात्मक या नकारात्मक संख्या है कि कहाँ से आया था?

149
00:09:05,350 --> 00:09:07,010
हाँ. >> [छात्र] पहले समारोह. >> हाँ.

150
00:09:07,010 --> 00:09:10,170
>> अक्सर समारोह में कहा कि क्योंकि इससे पहले याद करने के लिए बुलाया गया,

151
00:09:10,170 --> 00:09:13,920
के रूप में आप फोन स्मृति में कार्य करते हैं, वे नीचे से अधिक से अधिक स्थान ऊपर ले,

152
00:09:13,920 --> 00:09:17,040
और समारोह रिटर्न के रूप में जल्द से जल्द, कि स्मृति reused हो जाता है

153
00:09:17,040 --> 00:09:20,890
अगले आदमी है कि बुलाया जाता है, जो अपनी स्मृति का एक ही टुकड़ा का उपयोग कर रहा है.

154
00:09:20,890 --> 00:09:23,450
और यदि आप बाईं वहाँ कचरा, पिछले मूल्यों है,

155
00:09:23,450 --> 00:09:28,190
हम कुछ मूल्य वाले के रूप में वास्तव में जब हम वहाँ कुछ भी नहीं डाल दिया है गलती हो सकती है.

156
00:09:28,190 --> 00:09:30,960
तो इस बिंदु पर हमारे रैम इस तरह दिखता है.

157
00:09:30,960 --> 00:09:36,030
अब 7 लाइन के दाएँ हाथ की ओर हम GetString बुला रहे हैं,

158
00:09:36,030 --> 00:09:40,150
जो हम सप्ताह के लिए किया गया है अब कर रहे हैं, लेकिन क्या वास्तव में कर रही GetString है?

159
00:09:40,150 --> 00:09:43,350
CS50 कर्मचारियों द्वारा लिखा GetString एक छोटे से बुद्धिमान है

160
00:09:43,350 --> 00:09:46,500
कि में उपयोगकर्ता के रूप में जल्द ही के रूप में शुरू होता है टाइपिंग कुंजी और हिट दर्ज करें,

161
00:09:46,500 --> 00:09:50,010
GetString बाहर आंकड़े कितने keystrokes उपयोगकर्ता हिट किया था,

162
00:09:50,010 --> 00:09:53,360
कितने अक्षर मैं के लिए रैम आवंटित करने की जरूरत नहीं है.

163
00:09:53,360 --> 00:09:55,660
और जहां कि राम से आता है, कौन जानता है?

164
00:09:55,660 --> 00:09:58,930
यह आपके कंप्यूटर की 2 गीगाबाइट मेमोरी की whatnot में कहीं है.

165
00:09:58,930 --> 00:10:05,200
लेकिन लगता है कि कंप्यूटर HELLO शब्द के लिए अंतरिक्ष सही यहाँ पाया.

166
00:10:05,200 --> 00:10:08,710
शब्द मैं टाइप एच ई एल एल ओ था.

167
00:10:08,710 --> 00:10:13,510
और अगर हम अक्षरों के एक दृश्य के रूप में इस आकर्षित है, तो हम इसे इस तरह से आकर्षित हो सकता है.

168
00:10:13,510 --> 00:10:17,860
लेकिन मैं 1 अतिरिक्त काम करने की जरूरत है. क्या सी में किसी भी स्ट्रिंग के अंत में अंतर्गत आता है?

169
00:10:17,860 --> 00:10:20,710
अशक्त चरित्र है, जो हम \ 0 के रूप में लिखें.

170
00:10:20,710 --> 00:10:23,980
यह तकनीकी संख्या 0, लेकिन बैकस्लैश सभी स्पष्ट करता है

171
00:10:23,980 --> 00:10:28,150
कि यह सचमुच 0 संख्या, पूर्णांक 0;

172
00:10:28,150 --> 00:10:32,440
यह, उदाहरण के लिए, 0 बोली - गंदें शब्द बोलना है कि आप कीबोर्ड पर टाइप हो सकता है के लिए नहीं है.

173
00:10:32,440 --> 00:10:33,940
तो यह HELLO है.

174
00:10:33,940 --> 00:10:36,350
>> और क्या हम सोमवार को कहा था कि GetString तरह एक समारोह

175
00:10:36,350 --> 00:10:39,580
वास्तव में इन सभी सप्ताह लौटने?

176
00:10:39,580 --> 00:10:43,960
यह प्रतिशत से एक स्ट्रिंग लौट नहीं है कि क्योंकि वास्तव में नहीं अर्थ करता है

177
00:10:43,960 --> 00:10:47,710
क्योंकि तार मौजूद नहीं है. वे CS50 पुस्तकालय में एक निर्माण की तरह कर रहे हैं.

178
00:10:47,710 --> 00:10:51,300
क्या वास्तव में एक स्ट्रिंग है, और अधिक तकनीकी? >> [छात्र] यह पहली चरित्र है.

179
00:10:51,300 --> 00:10:55,950
बिल्कुल सही. यह काफी बस पहले चरित्र का पता है कि उपयोगकर्ता अंदर टाइप

180
00:10:55,950 --> 00:11:02,810
तो अगर मेरे शब्द HELLO यह बाइट संख्या 123 पर और फिर बाइट संख्या 124 पर समाप्त हो जाती है,

181
00:11:02,810 --> 00:11:08,320
125, 126, और बहुत आगे है, अगर मैं 0 से अभी तक मेरे बाइट्स की संख्या

182
00:11:08,320 --> 00:11:12,650
वास्तव में GetString लौट रहा है कि क्या सचमुच संख्या 123 है.

183
00:11:12,650 --> 00:11:19,270
तो क्या हो जाता है में डाल संख्या 123, नहीं पत्र एच शब्द है नमस्कार,

184
00:11:19,270 --> 00:11:23,130
काफी बस पता जिस पर मैं HELLO के पहले अक्षर को पा सकते हैं.

185
00:11:23,130 --> 00:11:26,500
लेकिन वह पर्याप्त तरह प्रतीत नहीं होता. मैं आप एक स्ट्रिंग के लिए पूछा, चरित्र एक नहीं.

186
00:11:26,500 --> 00:11:32,970
तो हम या कंप्यूटर कैसे जानते हो Ello तरह एच के साथ आते हैं कि?

187
00:11:35,760 --> 00:11:37,460
समझौते की तरह हम क्या है? हाँ.

188
00:11:37,460 --> 00:11:40,100
[छात्र] यह अपने आप कह कुछ और वर्ण खोजने रहता है. वास्तव में. >>

189
00:11:40,100 --> 00:11:44,570
>> इस सम्मेलन मानव कंप्यूटर है जिससे जब आप तार के साथ काम कर रहे हैं,

190
00:11:44,570 --> 00:11:49,410
अन्यथा अब चार सितारों के रूप में जाना जाता है, तो आप बस यह पता लगाने की

191
00:11:49,410 --> 00:11:54,350
जहां जीवन में हर स्ट्रिंग के अंत वास्तव में सिर्फ पाश के लिए एक के साथ इसे खत्म पुनरावृति है,

192
00:11:54,350 --> 00:11:57,820
एक समय पाश, जो कुछ भी है, ताकि जब आप स्ट्रिंग के अंत

193
00:11:57,820 --> 00:12:02,160
अब तुम उस से अनुमान कर सकते हैं, ओह, पूरे शब्द HELLO था.

194
00:12:02,160 --> 00:12:04,820
पूर्व प्रोग्रामिंग अनुभव के साथ आप उन जावा में जानते हो सकता है

195
00:12:04,820 --> 00:12:09,880
तुम सिर्फ फोन की लंबाई कर सकते हैं और अन्य भाषाओं में आप लंबाई या इसी तरह के कॉल कर सकते हैं.

196
00:12:09,880 --> 00:12:14,060
वजह यह है कि भाषाओं का एक बहुत में, विशेष रूप से बातें भाषा वस्तु उन्मुख कहा जाता है,

197
00:12:14,060 --> 00:12:18,580
कुछ की लंबाई ही डेटा के टुकड़े के समझाया अंदर की तरह है,

198
00:12:18,580 --> 00:12:24,000
हम बहुत समझाया आईडी और नाम और सोमवार को एक छात्र के अंदर घरों की तरह.

199
00:12:24,000 --> 00:12:28,700
लेकिन सी बहुत कम स्तर है. वहाँ कोई वस्तु या कक्षाएं हैं, अगर आप उन शब्दों के बारे में सुना है.

200
00:12:28,700 --> 00:12:31,490
तुम सब है वास्तव में स्मृति पते है.

201
00:12:31,490 --> 00:12:35,540
तो यह दिलचस्प डेटा संरचनाओं का प्रतिनिधित्व के पुराने ढंग का रास्ता की तरह है.

202
00:12:35,540 --> 00:12:38,760
आप पहली चरित्र के पते की तरह एक शुरुआत मान

203
00:12:38,760 --> 00:12:42,340
और फिर सिर्फ कुछ मनमाने ढंग से परंपरा है कि हर किसी का पालन करने के लिए सहमत हैं.

204
00:12:42,340 --> 00:12:46,420
तो कैसे स्ट्रिंग की लंबाई कार्यान्वित किया जाता है, तो हम प्रस्ताव किया था?

205
00:12:46,420 --> 00:12:51,360
Strlen, strlen, जो आप में से कुछ अब कुछ बार इस्तेमाल किया है. यह बहुत आसान है, है ना?

206
00:12:51,360 --> 00:12:53,060
यह कोड के 2 लाइनों की तरह है.

207
00:12:53,060 --> 00:12:56,140
यह बहुत ज्यादा किसी प्रकार की एक के लिए पाश के साथ हो सकता है, एक अतिरिक्त स्थानीय चर.

208
00:12:56,140 --> 00:13:00,540
लेकिन strlen सिर्फ एक सूचक ले और फिर \ 0 के लिए तलाश शुरू करते है.

209
00:13:00,540 --> 00:13:05,190
>> और जैसे ही वह यह पाता है, यह कदम है कि यह है कि स्ट्रिंग में ले लिया है की कुल संख्या लौट सकते हैं.

210
00:13:05,190 --> 00:13:07,150
इसलिए हम इस से अनुमान क्या अगले पर चला जाता है.

211
00:13:07,150 --> 00:13:11,850
तो लगता है कि मैं टी घोषणा के रूप में मैं 10 लाइन में किया है.

212
00:13:11,850 --> 00:13:14,280
यह कुछ कचरा मूल्य है. पहली बार में कौन जानता है?

213
00:13:14,280 --> 00:13:18,490
लेकिन 10 की लाइन के दाएँ हाथ की ओर पर मैं फिर GetString बुला रहा हूँ.

214
00:13:18,490 --> 00:13:20,050
कौन जानता है, जहां यह समाप्त होता है?

215
00:13:20,050 --> 00:13:23,830
चलो मनमाने ढंग से कहना है कि ऑपरेटिंग सिस्टम यह यहाँ तरह के लिए कमरे में पाया.

216
00:13:23,830 --> 00:13:28,610
मैं संयोग एच ई एल एल ओ लिखें फिर से होगा,

217
00:13:28,610 --> 00:13:31,260
और इसलिए हम तस्वीर का एक ही तरह आकर्षित कर सकते हैं.

218
00:13:31,260 --> 00:13:34,290
लेकिन तथ्य यह है कि मैं इस तस्वीर को दोबारा बनाई है, विचार है

219
00:13:34,290 --> 00:13:37,720
क्योंकि कि यह एक से अधिक विभिन्न नमस्कार.

220
00:13:37,720 --> 00:13:43,920
तो यहाँ यह 456 स्थान हो सकता है, यह 457 है, और बहुत आगे है.

221
00:13:43,920 --> 00:13:47,170
तो क्या डाल दिया जाता है जहां एक बार प्रश्न चिह्न था?

222
00:13:47,170 --> 00:13:50,190
इस मामले में 456.

223
00:13:50,190 --> 00:13:53,540
हम इन नंबरों मनमाने ढंग से उठा रहे हैं क्योंकि वास्तव में आज के बाद

224
00:13:53,540 --> 00:13:57,110
हम क्या है कुछ के पते के बारे में इतना परवाह नहीं जा रहे हैं.

225
00:13:57,110 --> 00:14:02,690
हम सब के बारे में परवाह है कि हम बाहर HELLO तरह डेटा के कुछ टुकड़े का पता लगाने कर सकते हैं.

226
00:14:02,690 --> 00:14:07,100
>> तो वास्तव में ज्यादातर लोगों के कंप्यूटर विज्ञान के क्षेत्र में क्या करते हैं जब स्मृति पते के बारे में बात कर रही

227
00:14:07,100 --> 00:14:10,210
और संकेत के बारे में विशेष रूप से बात कर रही है,

228
00:14:10,210 --> 00:14:14,220
कौन परवाह करता है, जहां यह सब वास्तव में है, बजाय बाहर figuring 123 परेशान

229
00:14:14,220 --> 00:14:17,440
हम सिर्फ इतना पता है कि यह कुछ संख्यात्मक पते पर है -

230
00:14:17,440 --> 00:14:22,180
हम दुनिया सरल और बस का कहना है कि है कि चरित्र की ओर इशारा करते है

231
00:14:22,180 --> 00:14:25,080
और टी कि चरित्र की ओर इशारा करते है.

232
00:14:25,080 --> 00:14:27,430
और तथ्य यह है कि यह एक तीर काफी जानबूझकर है

233
00:14:27,430 --> 00:14:31,610
क्योंकि सचमुच अब एच और टी में इशारा कर रहा है अन्य एच पर इशारा कर रहा है

234
00:14:31,610 --> 00:14:34,720
क्योंकि दिन के अंत में, यह बात पता क्या है नहीं करता,

235
00:14:34,720 --> 00:14:40,240
लेकिन यह बात है कि हम कोड के कुछ टुकड़े के साथ उस पते को व्यक्त करने की क्षमता है.

236
00:14:40,240 --> 00:14:42,730
हम वास्तव में इन पतों चालाकी से नहीं है बस अभी तक

237
00:14:42,730 --> 00:14:47,770
तो हम देखेंगे जहां हम interject और सॉर्ट के संकेत के साथ बातें करते हैं,

238
00:14:47,770 --> 00:14:52,030
लेकिन अब के लिए लाइन में 12 सचमुच क्या हम मूल्यों की तुलना कर रहे हैं

239
00:14:52,030 --> 00:14:55,500
12 लाइन में इस कहानी के अनुसार?

240
00:14:56,570 --> 00:15:01,290
हम कह रहे हैं कि 123 456 के बराबर बराबर है? और कहा कि निश्चित रूप से मामला नहीं है.

241
00:15:01,290 --> 00:15:05,320
और धारणात्मक भी, यह सूचक निश्चित रूप से इस रूप में ही नहीं है

242
00:15:05,320 --> 00:15:09,500
क्योंकि आप दो बार GetString कहा जाता है, और GetString चालाक सुपर होने की कोशिश नहीं करता,

243
00:15:09,500 --> 00:15:12,470
यह एहसास नहीं की कोशिश करता है, ओह, आप HELLO 5 मिनट पहले टाइप;

244
00:15:12,470 --> 00:15:15,090
मुझे आप एक ही सूचक के रूप में मैं तुम से पहले दे दी,

245
00:15:15,090 --> 00:15:18,450
यह सिर्फ स्मृति का एक नया हिस्सा हर बार जब आप यह कहते हैं का आवंटन.

246
00:15:18,450 --> 00:15:20,350
>> तो हम इस समस्या को कैसे तय करते हैं?

247
00:15:20,350 --> 00:15:24,270
उच्च स्तर अगर मैं HELLO और HELLO तार की तुलना करना चाहते हैं -

248
00:15:24,270 --> 00:15:28,680
मैं संकेत के बारे में परवाह नहीं है - मैं सवाल का जवाब देने के बारे में कैसे जाना है,

249
00:15:28,680 --> 00:15:31,980
क्या उपयोगकर्ता एक ही बात लिखें? यहाँ क्या आवश्यक है? हाँ.

250
00:15:31,980 --> 00:15:35,200
[छात्र] एक समारोह का प्रयोग करें. >> मैं बॉक्स के बाहर एक समारोह का उपयोग कर सकते हैं.

251
00:15:35,200 --> 00:15:38,170
मैं एक strcmp, s-टी आर - ग - मीटर पी बुलाया समारोह का उपयोग कर सकते हैं,

252
00:15:38,170 --> 00:15:41,190
सिर्फ कह स्ट्रिंग तुलना के संक्षिप्त संस्करण.

253
00:15:41,190 --> 00:15:45,070
और अगर हम में जाना है, उदाहरण के लिए, 2 तुलना जो आज हैंडआउट्स के बीच है,

254
00:15:45,070 --> 00:15:46,690
मुझे लगता है कि वास्तव में करते हैं.

255
00:15:46,690 --> 00:15:51,750
मैं नीचे 26 या ऐसा करने के लिए और सब कुछ लाइन 1 से ही रखा है,

256
00:15:51,750 --> 00:15:54,360
और अब नोटिस यह हिस्सा सिर्फ एक छोटा सा बदल गया है.

257
00:15:54,360 --> 00:15:57,690
चलो एक पल के लिए 28 लाइन की उपेक्षा और इस पर एक ही ध्यान केंद्रित.

258
00:15:57,690 --> 00:16:00,410
क्या हम सोमवार कहा था कि str तुलना नहीं करता है?

259
00:16:00,410 --> 00:16:05,200
यह इस मामले में 2 संकेत, और टी लेने की प्रक्रिया संभालती है,

260
00:16:05,200 --> 00:16:08,480
सॉर्ट के लगभग उन 2 पत्र पर अपनी उंगली डाल,

261
00:16:08,480 --> 00:16:11,530
और यह करना चाहिए कि क्या एक समय या पाश के लिए पाश की तरह कुछ है,

262
00:16:11,530 --> 00:16:16,050
और यह कहते हैं कि ये वही कर रहे हैं? यदि हां, तो यह उंगलियों या संकेत आगे बढ़ता रहता है.

263
00:16:16,050 --> 00:16:17,970
ये वही कर रहे हैं, ये वही है, ये वही,

264
00:16:17,970 --> 00:16:22,710
इन एक ही, ये वही है? ऊह और मैं दोनों है और टी में स्ट्रिंग के अंत में हूँ.

265
00:16:22,710 --> 00:16:26,780
मैं किसी भी विरोधाभासों नहीं मिला है. हाँ, इन तारों वही कर रहे हैं.

266
00:16:26,780 --> 00:16:31,940
और क्या str वापसी की तुलना करता है अगर 2 तार वही कर रहे हैं, जाहिरा तौर पर? शून्य.

267
00:16:31,940 --> 00:16:35,900
0 इस मामले में तो अच्छा है क्योंकि अगर यह -1 या +1 देता है,

268
00:16:35,900 --> 00:16:40,560
इसका मतलब है कि है कि सिर्फ t वर्णानुक्रम के पहले या टी के बाद आने वाला है.

269
00:16:40,560 --> 00:16:43,760
और क्यों कि उपयोगी हो करने के लिए एक समारोह में कहा कि आपको बताता है जो स्ट्रिंग से पहले आता है

270
00:16:43,760 --> 00:16:46,720
या के बाद एक शब्दकोश में?

271
00:16:46,720 --> 00:16:48,740
[छात्र] खोज की जा रही है. >> खोज और छँटाई.

272
00:16:48,740 --> 00:16:51,730
>> तो तुम द्विआधारी खोज या बुलबुला तरह की तरह बातें करते हैं या छंटाई संविलय

273
00:16:51,730 --> 00:16:53,230
जहाँ आप चीजों की तुलना है.

274
00:16:53,230 --> 00:16:56,420
इस प्रकार अब तक हम कुछ कोनों में कटौती की तरह है और केवल छँटाई के बारे में बात की

275
00:16:56,420 --> 00:16:59,430
संख्या के संदर्भ में है क्योंकि यह अच्छा और आसान करने के बारे में बात करते हैं,

276
00:16:59,430 --> 00:17:02,430
लेकिन आप निश्चित रूप से तार, सेब और केले की तुलना कर सकते हैं,

277
00:17:02,430 --> 00:17:05,349
क्योंकि अगर सेब केले से पहले आते हैं, इसी तरह करने के लिए जाना जाता है,

278
00:17:05,349 --> 00:17:09,319
आप के चारों ओर तार स्थानांतरित कर सकते हैं रोब तरह सिर्फ स्मृति में मर्ज प्रकार के साथ वीडियो में

279
00:17:09,319 --> 00:17:15,880
और हम चयन छंटाई, प्रविष्टि तरह है, और बुलबुला तरह के साथ मंच पर यहाँ था.

280
00:17:15,880 --> 00:17:18,710
तो और जहां हम ले सकते हैं? चलो इस प्रयास करें.

281
00:17:18,710 --> 00:17:23,980
चलो की तरह है कि एक पल के लिए सबक भूल जाते हैं और अब कोशिश करते हैं और निम्नलिखित करना 1.c प्रतिलिपि बनाने के.

282
00:17:23,980 --> 00:17:26,800
21 लाइन में मैं में प्रिंट कुछ कह रहा हूँ,

283
00:17:26,800 --> 00:17:28,520
तो मैं उपयोगकर्ता से एक स्ट्रिंग हो रही है,

284
00:17:28,520 --> 00:17:30,690
तो मैं इस जाँच कर रहा हूँ.

285
00:17:30,690 --> 00:17:33,620
हम वास्तव में इस आदत में नहीं डाल दिया है अभी तक, लेकिन अब ऐसा करने के.

286
00:17:33,620 --> 00:17:40,990
वास्तव में वापस करने के लिए इस परत छील. यह वास्तव में चार * है. इस आदमी वास्तव में चार * है.

287
00:17:40,990 --> 00:17:45,690
तो क्या यह अगर == Null जाँच हो मतलब है?

288
00:17:45,690 --> 00:17:48,380
यह पता चला है कि जब आप GetString तरह एक समारोह कॉल

289
00:17:48,380 --> 00:17:51,540
या अधिक आम तौर पर सिर्फ एक कंप्यूटर पूछने के लिए आप कुछ स्मृति दे,

290
00:17:51,540 --> 00:17:53,030
कुछ गलत हो सकता है.

291
00:17:53,030 --> 00:17:56,630
तुम पागल हो और स्मृति का एक terabyte के लिए कंप्यूटर में पूछ सकते हैं

292
00:17:56,630 --> 00:18:01,780
स्मृति बाइट्स कि सिर्फ कंप्यूटर में मौजूद नहीं है के अरबों के लिए पूछ रही द्वारा,

293
00:18:01,780 --> 00:18:05,130
लेकिन GetString और अन्य कार्यों तुम पर चिल्ला के कुछ तरह की जरूरत है

294
00:18:05,130 --> 00:18:06,820
अगर आप बहुत ज्यादा के लिए कहा है.

295
00:18:06,820 --> 00:18:10,450
और जिस तरह से GetString इस करता है अगर आप और अधिक स्मृति के लिए कहा है

296
00:18:10,450 --> 00:18:14,250
से कंप्यूटर में उपलब्ध है, भले ही वह सुपर, सुपर कम संभावना है

297
00:18:14,250 --> 00:18:17,730
क्योंकि हम में से कोई एक खरब वर्ण लिखें और फिर हिट दर्ज करने के लिए जा रहे हैं,

298
00:18:17,730 --> 00:18:21,980
लेकिन कम संभावना है हालांकि यह हो सकता है, मैं अभी भी इसके लिए बस के मामले में जाँच करना चाहते हैं,

299
00:18:21,980 --> 00:18:26,120
और विशेष मूल्य GetString, जवाब, और अन्य कार्यों कि रिटर्न

300
00:18:26,120 --> 00:18:30,630
अगर कुछ गलत हो गया है, सभी टोपियां में रिक्त है.

301
00:18:30,630 --> 00:18:36,520
>> और क्या नल है? नल सिर्फ इतना एक सूचक का प्रतिनिधित्व करने के लिए होता है. यह स्मृति पता 0 है.

302
00:18:36,520 --> 00:18:40,800
दुनिया है कि मनमाने ढंग से फैसला किया है, अगर यह मेरे कंप्यूटर की मेमोरी है - तुम क्या जानते हैं -

303
00:18:40,800 --> 00:18:46,260
हम सिर्फ हर कंप्यूटर की स्मृति के 1 बाइट चोरी करने के लिए जा रहे हैं, और यह 0 स्थान है.

304
00:18:46,260 --> 00:18:49,560
हम यह नल का एक उपनाम देने के लिए जा रहे हैं, और हम वादा करने के लिए जा रहे हैं

305
00:18:49,560 --> 00:18:52,660
कि हम वास्तव में असली डेटा वहाँ कभी नहीं रखा जाएगा

306
00:18:52,660 --> 00:18:56,770
क्योंकि हम सिर्फ मनमाने ढंग से एक विशेष मूल्य, 0, उर्फ ​​नल की जरूरत है,

307
00:18:56,770 --> 00:19:00,230
इतना है कि हम उपयोगकर्ताओं पर चिल्लाना अगर कुछ गलत हो जाता है.

308
00:19:00,230 --> 00:19:03,590
अन्यथा आप नहीं जानते हो सकता है 0 मतलब है कि यहाँ कुछ रखा

309
00:19:03,590 --> 00:19:05,490
या इसका मतलब यह है कि कुछ गलत हो गया?

310
00:19:05,490 --> 00:19:09,190
हम सभी सहमत हैं कि रिक्त मतलब नहीं लौट रहा था,

311
00:19:09,190 --> 00:19:11,700
कोई वास्तविक पते लौट रहा था.

312
00:19:11,700 --> 00:19:15,210
अब, यहाँ मैं सिर्फ मैं मानव सम्मेलन अपनाने हूँ मुख्य से 1 वापसी

313
00:19:15,210 --> 00:19:17,040
अगर कुछ गलत हो जाता है.

314
00:19:17,040 --> 00:19:20,650
ऐसा इसलिए है क्योंकि मुख्य वापसी सम्मेलन 0 अगर अच्छी वापसी है,

315
00:19:20,650 --> 00:19:22,990
1 या अगर कुछ बुरा अन्य मूल्य.

316
00:19:22,990 --> 00:19:28,200
लेकिन GetString और किसी भी समारोह है कि स्मृति रिक्त रिटर्न में सौदों अगर कुछ बुरा हो जाता है.

317
00:19:28,200 --> 00:19:33,480
>> ठीक है. तो दुर्भाग्य से, 27 लाइन, हालांकि यह है सुपर आसान है, पूरी तरह से स्ट्रिंग कॉपी करने में विफल रहता है.

318
00:19:33,480 --> 00:19:35,740
क्यों? हम देख सकते हैं कि इस के रूप में इस प्रकार है.

319
00:19:35,740 --> 00:19:40,120
मैं 27 लाइन में दावा के एक प्रतिलिपि बनाने और यह टी बुला रहा हूँ.

320
00:19:40,120 --> 00:19:45,790
तो मैं 2 तार इस समय के लिए उपयोगकर्ता नहीं पूछ रहा हूँ, मैं बस में मूल्य कह रहा हूँ

321
00:19:45,790 --> 00:19:47,870
के रूप में अच्छी तरह से टी में रखा जाना चाहिए.

322
00:19:47,870 --> 00:19:52,890
तो अब सिर्फ प्रदर्शित करने के लिए यह कैसे टूटी हुई है, लाइन में 29 आगे मैं क्या कर रहा हूँ?

323
00:19:52,890 --> 00:19:56,980
पहले मैं जाँच कर रहा हूँ अगर टी की लंबाई 0 से अधिक है.

324
00:19:56,980 --> 00:19:59,330
वहाँ कुछ वहाँ स्ट्रिंग है. उपयोगकर्ता अंदर कुछ टाइप

325
00:19:59,330 --> 00:20:03,410
32 कर रही लाइन, जाहिरा तौर पर क्या है?

326
00:20:03,410 --> 00:20:08,910
[अश्राव्य छात्र प्रतिक्रिया] >> को राइट. आप किस तरह का मैं क्या कहा यह कर रहा है से अनुमान कर सकते हैं.

327
00:20:08,910 --> 00:20:13,200
लेकिन तकनीकी तौर पर, यह क्या कर रहा है? टी [0] का प्रतिनिधित्व करता है?

328
00:20:13,200 --> 00:20:15,140
[छात्र] 0 चरित्र. >> [Malan] 0 चरित्र.

329
00:20:15,140 --> 00:20:19,620
या, मानव की तरह, टी में 1 चरित्र, जो कुछ भी है, एच हो सकता है इस मामले में.

330
00:20:19,620 --> 00:20:24,990
और toupper यह क्या कहता है. यह टी के 0 चरित्र capitalizes और यह परिवर्तन है.

331
00:20:24,990 --> 00:20:28,430
तो इसका मतलब है कि टी के 0 चरित्र ले, यह अपरकेस,

332
00:20:28,430 --> 00:20:30,320
और यह है कि एक ही स्थान में वापस डाल दिया.

333
00:20:30,320 --> 00:20:35,540
तो अगर मैं लोअरकेस में हैलो टाइप, यह एक राजधानी एच. लोअरकेस ज बदलना चाहिए

334
00:20:35,540 --> 00:20:41,400
लेकिन समस्या यह है कि लाइनों में 35 और 36 है कि मैं क्या करने के बारे हूँ हमें और टी के लिए बाहर मुद्रित है.

335
00:20:41,400 --> 00:20:43,120
और अपने कूबड़ क्या है?

336
00:20:43,120 --> 00:20:47,250
मैं वास्तव में क्या कर रहा हूँ कि अगर मैं सभी लोअरकेस में हैलो में टाइप करने के लिए जा रहे हैं?

337
00:20:47,250 --> 00:20:52,280
क्या मुद्रित हो रहा है? >> [अश्राव्य छात्र प्रतिक्रिया] >> वह क्या है?

338
00:20:52,280 --> 00:20:58,360
[छात्र] बिग एच और बाकी छोटे. >> बड़ा एच और बाकी है, जिसमें छोटे के लिए, या एस टी?

339
00:20:58,360 --> 00:21:03,170
दोनों [छात्र]. >> दोनों. बिल्कुल सही. तो देखते हैं यहाँ क्या हो रहा है.

340
00:21:03,170 --> 00:21:08,380
>> मुझे आगे जाना है और इस संकलन. इस copy1 है, तो copy1 बनाते हैं. सही सभी.

341
00:21:08,380 --> 00:21:14,840
अंदर ज़ूम चलो मुझे आगे जाना और copy1 चलाने के, दर्ज करें, कुछ तो कहो: हैलो लोअरकेस में.

342
00:21:14,840 --> 00:21:19,570
यह प्रतिलिपि पूंजीकृत है, लेकिन यह स्पष्ट तौर पर मूल रूप में अच्छी तरह से पूंजीकृत,

343
00:21:19,570 --> 00:21:22,070
क्योंकि अब इस कहानी में क्या होता है?

344
00:21:22,070 --> 00:21:27,030
27 लाइन में मैं वास्तव में स्ट्रिंग नकल नहीं लग रहे हो,

345
00:21:27,030 --> 00:21:30,450
लेकिन फिर भी तुम intuitively आशा व्यक्त की है हो सकता है कि मामला हो,

346
00:21:30,450 --> 00:21:33,680
यदि आप इस तस्वीर के बारे में सोचते हैं, क्या वास्तव में मैंने किया है?

347
00:21:33,680 --> 00:21:35,410
तस्वीर के आधा ही है.

348
00:21:35,410 --> 00:21:39,390
तो चलो समय में वापस रोल इतना है कि टी अभी तक की कहानी में मौजूद नहीं है.

349
00:21:39,390 --> 00:21:43,160
एस कहानी में मौजूद है, लेकिन हम हैलो इस समय लोअरकेस.

350
00:21:43,160 --> 00:21:46,710
तो मुझे ठीक मैं क्या वास्तव में अंदर टाइप

351
00:21:46,710 --> 00:21:51,280
इस मामले में हम ज ए एल एल ओ है.

352
00:21:51,280 --> 00:21:58,050
हम यह वर्ण के एक दृश्य के रूप में आकर्षित करेंगे, मेरे विभाजक लाइनों यहाँ डाल दिया और मेरे \ 0.

353
00:21:58,050 --> 00:22:05,980
तो यह है कि जहां हम 24-ish के माध्यम के रूप में 1 पंक्ति के रूप में जल्द ही दे या ले है, मार डाला.

354
00:22:05,980 --> 00:22:07,800
यह मेरी स्मृति की तस्वीर है.

355
00:22:07,800 --> 00:22:10,800
जब मैं 27 लाइन के लिए मिलता है, क्या होता है?

356
00:22:10,800 --> 00:22:14,730
पहले की तरह, मैं एक सूचक है, जो मैं इस वर्ग के रूप में आकर्षित करेंगे.

357
00:22:14,730 --> 00:22:19,740
यह टी कहा जाता है. और डिफ़ॉल्ट रूप से अपने मूल्य क्या है? कौन जानता है? कुछ कचरा मूल्य.

358
00:22:19,740 --> 00:22:22,060
>> तो मैं सार हूँ कि एक प्रश्न चिह्न के रूप में दूर.

359
00:22:22,060 --> 00:22:27,670
और के रूप में जल्द ही के रूप में 27 लाइन के दाएँ हाथ की ओर निष्पादित करता है, मैं क्या हूँ टी के अंदर डाल रही हो?

360
00:22:27,670 --> 00:22:30,770
एक ही बात है कि में है.

361
00:22:30,770 --> 00:22:34,120
तो अगर हम एक पल के लिए तीर के इस अमूर्त को हटा दें और हम कहते हैं,

362
00:22:34,120 --> 00:22:40,330
ओह, यह स्मृति लोड पते 123 है, जब आप कहते हैं कि टी है, सेमीकोलन हो जाता है,

363
00:22:40,330 --> 00:22:42,700
आप सचमुच 123 यहाँ डाल रहे हैं.

364
00:22:42,700 --> 00:22:45,200
अब अगर हम किस तरह के चित्रों के साथ फिर से हमारी दुनिया को आसान बनाने के लिए,

365
00:22:45,200 --> 00:22:48,750
आप वास्तव में क्या किया है सिर्फ अपनी दुनिया में एक और तीर

366
00:22:48,750 --> 00:22:52,910
कि टी से एक ही सटीक स्ट्रिंग की ओर इशारा करते है.

367
00:22:52,910 --> 00:22:59,730
तो जब लाइन 31 और 32 में मैं वास्तव में [0] टी को बदलने के बारे में जाने के लिए,

368
00:22:59,730 --> 00:23:05,580
टी क्या है [0] जाहिरा तौर पर अब साथ पर्याय बन गया है? [0]

369
00:23:05,580 --> 00:23:07,030
तो यह है कि जो हो रहा है सब है.

370
00:23:07,030 --> 00:23:09,900
और भी हालांकि इस तरह का मानना ​​है कि एक छोटे से कम स्तर और रहस्यमय

371
00:23:09,900 --> 00:23:12,760
और इस तरह शायद intuitively यह सिर्फ काम किया जाना चाहिए की तरह लगता है -

372
00:23:12,760 --> 00:23:15,410
मैं चीजों की प्रतियां पहले बनाया है और यह सिर्फ काम -

373
00:23:15,410 --> 00:23:18,590
यदि आप वास्तव में एक स्ट्रिंग वास्तव में क्या है के बारे में सोचते हैं, यह एक चार * है.

374
00:23:18,590 --> 00:23:21,700
खैर, वह क्या है? यह कुछ चरित्र का पता है.

375
00:23:21,700 --> 00:23:24,930
तो शायद यह और अधिक समझ में आता है कि जब आप कुछ करने की कोशिश

376
00:23:24,930 --> 00:23:29,220
सुपर प्रतीत होता है इस तरह सरल है, आप सब कर रहे नकल एक स्मृति पता है.

377
00:23:29,220 --> 00:23:32,530
आप वास्तव में स्वयं स्ट्रिंग के साथ कुछ भी नहीं कर रहे हैं.

378
00:23:32,530 --> 00:23:37,500
तो भी अगर आप पता नहीं कैसे आप कोड में इस समस्या का समाधान होगा,

379
00:23:37,500 --> 00:23:45,080
उच्च स्तर, धारणा, हम क्या करने की ज़रूरत है क्रम में एस की सत्य प्रतिलिपि टा बनाने, जाहिरा तौर पर?

380
00:23:46,670 --> 00:23:48,820
हाँ. >> [छात्र] यह एक नया स्थान दे? वास्तव में. >>

381
00:23:48,820 --> 00:23:50,800
>> हम एक ब्रांड नए स्थान देने की जरूरत है.

382
00:23:50,800 --> 00:23:55,230
हम किसी भी तरह से एक दुनिया में जो हम स्मृति का एक नया हिस्सा बनाने की जरूरत है,

383
00:23:55,230 --> 00:24:00,090
जो सिर्फ स्पष्टता के लिए मैं इस एक के ठीक नीचे आकर्षित है, लेकिन यह वहाँ होने की जरूरत नहीं है.

384
00:24:00,090 --> 00:24:04,880
लेकिन यह एक ही आकार के होने की जरूरत है, तो मैं एक ही जगह में इन ऊर्ध्वाधर लाइनों आकर्षित करेंगे.

385
00:24:04,880 --> 00:24:09,720
यह ठीक है अगर यह सब कचरा शुरू है. कौन जानता है कि वहाँ क्या था?

386
00:24:09,720 --> 00:24:13,850
लेकिन 1 कदम करने के लिए मुझे बहुत स्मृति के रूप में देने के लिए किया जा रहा है के रूप में मैं की जरूरत

387
00:24:13,850 --> 00:24:18,630
हैलो की एक प्रतिलिपि फिट करने के लिए, तो बाहर आंकड़ा कैसे ज को कॉपी करने के लिए यहाँ, यहाँ ई,

388
00:24:18,630 --> 00:24:20,390
एल यहाँ और बहुत आगे है.

389
00:24:20,390 --> 00:24:24,880
लेकिन यह पहले से ही एक छोटे से स्पष्ट लग रहा है यहां तक ​​कि अगर विवरण में से कुछ अभी भी सार चाहिए.

390
00:24:24,880 --> 00:24:28,690
इस मामले में इस स्ट्रिंग कॉपी, यह सिर्फ एक पाश या एक समय पाश के लिए है

391
00:24:28,690 --> 00:24:31,580
या कुछ और है जिसके साथ आप सभी को और अधिक परिचित हो गए.

392
00:24:31,580 --> 00:24:35,970
तो चलो इस प्रयास करें. चलो मुझे copy2.c में जाना.

393
00:24:35,970 --> 00:24:43,270
Copy2.c में हम 27 लाइन के अलावा लगभग एक ही कार्यक्रम है.

394
00:24:43,270 --> 00:24:47,260
यह थोड़ा जटिल दिखता है, लेकिन अगर हम इसे तोड़ने के नीचे टुकड़ा टुकड़ा करके,

395
00:24:47,260 --> 00:24:48,950
बाएँ हाथ की ओर ही है.

396
00:24:48,950 --> 00:24:52,790
चार * स्मृति में इस बात को बनाता है, एक प्रश्न चिह्न के साथ यद्यपि

397
00:24:52,790 --> 00:24:54,680
क्योंकि हमें पता नहीं है क्या डिफ़ॉल्ट रूप से वहाँ है.

398
00:24:54,680 --> 00:24:57,920
दाएँ हाथ की ओर हम अब एक नया समारोह malloc, शुरू कर रहे हैं,

399
00:24:57,920 --> 00:25:00,640
के लिए स्मृति आवंटित, मुझे स्मृति दे,

400
00:25:00,640 --> 00:25:06,900
और यह स्पष्ट तौर पर कितने तर्क, कितने कोष्ठकों के अंदर बातें? लेता है

401
00:25:09,660 --> 00:25:12,130
मैं 1 और 2 के बुड़बुड़ाना सुना है, लेकिन यह सिर्फ 1 है.

402
00:25:12,130 --> 00:25:15,320
वहाँ कोई अल्पविराम है, जिसका अर्थ है वहाँ कोष्ठकों के अंदर सिर्फ एक बात है.

403
00:25:15,320 --> 00:25:17,720
हालांकि वहाँ अन्य कोष्ठकों है, मुझे पर प्रकाश डाला

404
00:25:17,720 --> 00:25:21,460
बाह्यतम कोष्ठक के अंदर क्या है, और यह इस अभिव्यक्ति है:

405
00:25:21,460 --> 00:25:25,880
(Strlen () + 1) * sizeof (चार).

406
00:25:25,880 --> 00:25:29,190
इसलिए यदि हम वास्तव में इस के माध्यम से लगता है, यह कह रहा है मुझे एस के लंबाई दे.

407
00:25:29,190 --> 00:25:34,440
मैं क्यों कर रहा हूँ, हालांकि, लंबाई पर 1 जोड़ने? >> [अश्राव्य छात्र प्रतिक्रिया]

408
00:25:34,440 --> 00:25:40,200
बिल्कुल सही. हम पूंछ में इस आदमी के लिए जगह की जरूरत है, 6 चरित्र कि कोई अंग्रेजी अर्थ है

409
00:25:40,200 --> 00:25:42,250
लेकिन विशेष प्रोग्रामेटिक अर्थ है.

410
00:25:42,250 --> 00:25:46,800
>> तो हम उस के लिए एक + 1 की जरूरत है क्योंकि strlen रिटर्न मानव लंबाई की उम्मीद,

411
00:25:46,800 --> 00:25:50,890
नमस्ते या 5, यह आप अतिरिक्त अशक्त चरित्र नहीं देना नहीं है.

412
00:25:50,890 --> 00:25:52,980
तो मैं स्वयं 1 + के साथ जोड़ने के लिए.

413
00:25:52,980 --> 00:25:56,060
और फिर, * (चार) के आकार, हम इस से पहले नहीं देखा है.

414
00:25:56,060 --> 00:25:57,480
यह तकनीकी रूप से एक समारोह नहीं है.

415
00:25:57,480 --> 00:26:04,150
यह एक विशेष कीवर्ड है कि बस आपको बताता है क्या आकार एक कंप्यूटर पर कुछ डेटा प्रकार की है

416
00:26:04,150 --> 00:26:06,980
क्योंकि वास्तव में, हम में से कुछ 32 बिट कंप्यूटर है.

417
00:26:06,980 --> 00:26:10,900
मैं घर पर एक बहुत पुराने कंप्यूटर है, और यह केवल 32 बिट का उपयोग करने के लिए संकेत का प्रतिनिधित्व.

418
00:26:10,900 --> 00:26:13,900
और यदि ऐसा है तो मैं एक डेटा प्रकार के आकार किया था, यह 32 बिट हो सकता है.

419
00:26:13,900 --> 00:26:18,300
लेकिन अगर मैं अपने नए फैंसी कंप्यूटर का उपयोग कर रहा हूँ, मैं वापस 64 बिट्स के मूल्य मिल सकता है

420
00:26:18,300 --> 00:26:20,510
एक पते की तरह कुछ के लिए.

421
00:26:20,510 --> 00:26:25,400
तो इस मामले में, बस सुपर सुरक्षित करने के लिए, हम कठिन कोड की तरह कुछ करने के लिए नहीं जा रहे हैं -

422
00:26:25,400 --> 00:26:28,740
ठीक है, क्या हम अब तक क्या कहा है के अनुसार चार के आकार के है?

423
00:26:28,740 --> 00:26:34,450
हम बहुत ज्यादा मौखिक रूप से कहा है कि यह 1 बाइट है, और कहा कि बोर्ड भर में बहुत ज्यादा सच है.

424
00:26:34,450 --> 00:26:37,000
लेकिन फिर, मान्यताओं को खराब हो जाते हैं.

425
00:26:37,000 --> 00:26:40,850
वे छोटी गाड़ी सॉफ्टवेयर के लिए नेतृत्व अगर लोग तरीके आप का इरादा नहीं था में अपने सॉफ्टवेयर का उपयोग.

426
00:26:40,850 --> 00:26:44,750
तो चलो सार यह दूर है और बस अधिक generically कहना

427
00:26:44,750 --> 00:26:46,830
मैं स्मृति के कई विखंडू की जरूरत

428
00:26:46,830 --> 00:26:50,210
और स्मृति का एक हिस्सा एक चरित्र के आकार के बराबर होना चाहिए,

429
00:26:50,210 --> 00:26:54,870
जो वास्तव में 1 इस मामले में बराबर है, लेकिन यह यह लेखन की एक अधिक सामान्य तरीका है.

430
00:26:54,870 --> 00:27:00,460
तो अगर शब्द हैलो है, कितने बाइट्स malloc जाहिरा तौर पर करता है हैलो के लिए आवंटित?

431
00:27:00,460 --> 00:27:04,980
छह [छात्र]. छह. >> बिल्कुल के रूप में कई के रूप में हम स्क्रीन पर प्रश्न चिह्न है.

432
00:27:04,980 --> 00:27:07,800
और फिर एक अब GetString की अपनी समझ के आधार पर लगता है

433
00:27:07,800 --> 00:27:12,790
क्या malloc शायद वापस नहीं करता है? >> [छात्र] पता.

434
00:27:12,790 --> 00:27:17,020
क्या है की एक पते? स्मृति का पहला हिस्सा.

435
00:27:17,020 --> 00:27:20,670
>> हमें पता नहीं क्या है वहाँ है, क्योंकि कुछ अन्य समारोह

436
00:27:20,670 --> 00:27:23,010
इस स्मृति हो सकता है पहले.

437
00:27:23,010 --> 00:27:28,380
लेकिन malloc, GetString तरह, स्मृति की पहली बाइट का पता देता है

438
00:27:28,380 --> 00:27:30,540
कि यह एक तरफ आप के लिए निर्धारित किया गया है.

439
00:27:30,540 --> 00:27:38,380
हालांकि, ऐसा नहीं करता है क्या इस रिक्त में एक बैकस्लैश अशक्त चरित्र के साथ भरने के लिए है

440
00:27:38,380 --> 00:27:43,030
क्योंकि यह मुड़ता बाहर आप malloc का उपयोग करने के लिए कुछ भी आवंटित कर सकते हैं: ints, तार, arrays,

441
00:27:43,030 --> 00:27:45,700
मंगाई, छात्र संरचनाओं.

442
00:27:45,700 --> 00:27:47,750
आप पूरी तरह से malloc generically का उपयोग कर सकते हैं.

443
00:27:47,750 --> 00:27:51,470
यह परवाह नहीं है या पता है कि आप के लिए स्मृति का आवंटन कर रहे हैं है.

444
00:27:51,470 --> 00:27:55,810
तो यह malloc के लिए अभिमान एक \ 0 रखा जाएगा

445
00:27:55,810 --> 00:27:58,340
स्मृति के हर हिस्सा के अंत में यह आपको दे रही है

446
00:27:58,340 --> 00:28:02,620
क्योंकि इस \ 0 बात सिर्फ तार के लिए एक सम्मेलन है.

447
00:28:02,620 --> 00:28:06,310
यह ints के लिए इस्तेमाल नहीं किया है, यह तैरता के लिए इस्तेमाल नहीं किया है, यह छात्रों के लिए इस्तेमाल नहीं किया है.

448
00:28:06,310 --> 00:28:11,730
और इसलिए malloc के साथ पकड़ लिया है कि बोझ आप पर पूरी तरह से प्रोग्रामर है

449
00:28:11,730 --> 00:28:16,790
याद करने के लिए आप कितने बाइट्स आवंटित की है और पाश के लिए एक कभी इस्तेमाल

450
00:28:16,790 --> 00:28:21,570
या एक जबकि पाश और स्मृति का हिस्सा दिया गया है की सीमा पिछले जाने.

451
00:28:21,570 --> 00:28:23,540
दूसरा रास्ता रखो, जैसे ही आप स्मृति को आबंटित करने के लिए,

452
00:28:23,540 --> 00:28:28,510
आप ऑपरेटिंग सिस्टम नहीं पूछ सकते हैं, ओह, जिस तरह से यह स्मृति का एक हिस्सा का कितना बड़ा था?

453
00:28:28,510 --> 00:28:32,080
यह आप पर निर्भर करता है याद करने के लिए अगर आपको लगता है कि मूल्य की जरूरत है.

454
00:28:32,080 --> 00:28:34,330
>> तो देखते हैं कैसे मैं इस स्मृति का उपयोग करने के लिए आगे बढ़ें.

455
00:28:34,330 --> 00:28:38,430
लाइन 28 और 29 में मैं ऐसा क्यों कर रहा हूँ?

456
00:28:39,850 --> 00:28:42,260
बस कुल मानसिक स्वास्थ्य की जांच.

457
00:28:42,260 --> 00:28:45,110
बस के मामले में कुछ गलत हो गया है, मैं स्मृति के कुछ पागल राशि के लिए पूछना

458
00:28:45,110 --> 00:28:48,690
या मैं इतने सारे चीजें कंप्यूटर पर चल रहा है कि वहाँ अभी पर्याप्त स्मृति नहीं है,

459
00:28:48,690 --> 00:28:51,780
कुछ की तरह है कि मैं कम से कम करने के लिए अशक्त की जांच करने के लिए करना चाहते हैं.

460
00:28:51,780 --> 00:28:55,260
हकीकत में, अधिकांश कंप्यूटर आप भ्रम दे देंगे कि हर कार्यक्रम

461
00:28:55,260 --> 00:28:57,080
अपने रैम की संपूर्णता का उपयोग कर सकते हैं,

462
00:28:57,080 --> 00:29:00,740
लेकिन फिर भी, शायद कुछ पागल लंबी स्ट्रिंग में उपयोगकर्ता प्रकार अगर क्योंकि वे एक बुरा आदमी हो

463
00:29:00,740 --> 00:29:03,440
और वे वास्तव में इसे में अपने कार्यक्रम या हैक दुर्घटना की कोशिश कर रहे हैं,

464
00:29:03,440 --> 00:29:07,300
आप कम से कम malloc की वापसी मूल्य की जांच करना चाहते हैं और क्या यह शून्य के बराबर होती है.

465
00:29:07,300 --> 00:29:11,630
और अगर यह होता है, चलो बस अब छोड़ दिया है क्योंकि मैं नहीं जानता कि क्या है कि मामले में क्या करने के लिए.

466
00:29:11,630 --> 00:29:13,950
मैं स्ट्रिंग कैसे कॉपी करूं? वहाँ कुछ तरीके से ऐसा कर है.

467
00:29:13,950 --> 00:29:18,850
वहाँ str सी में कार्यों की प्रतिलिपि बनाने के लिए, लेकिन यह सुपर आसान है के लिए हमें इस तरह से करने के लिए पुराने जमाने.

468
00:29:18,850 --> 00:29:23,110
>> पहले मुझे बाहर आंकड़ा क्या है की लंबाई है.

469
00:29:23,110 --> 00:29:26,930
मैं पाश में डाल सकता है, लेकिन बजाय मैं बस यह बाहर डाल स्पष्टता के लिए यहाँ.

470
00:29:26,930 --> 00:29:30,610
तो पता अब मूल स्ट्रिंग की लंबाई, जो जाहिरा तौर पर 5 भंडार.

471
00:29:30,610 --> 00:29:35,290
फिर मेरे लिए पाश में मैं 0 से iterating रहा हूँ n करने के लिए,

472
00:29:35,290 --> 00:29:40,940
और मैं हर पुनरावृति पर डाल रहा हूँ मैं [] टी के अंदर [i].

473
00:29:40,940 --> 00:29:45,060
तो है कि मैं क्या मेरे 2 से पहले तार पर उंगली उठाई साथ निहित.

474
00:29:45,060 --> 00:29:49,260
पाश के लिए यह इस तरह दोहराता है, मैं यहाँ में घंटे नकल करने के लिए जा रहा हूँ,

475
00:29:49,260 --> 00:29:52,890
यहाँ, यहाँ में एल में ई क्योंकि यह है, यह टी है.

476
00:29:52,890 --> 00:29:58,770
और फिर अंत में, 35 लाइन में मैं यह क्यों कर रहा हूँ?

477
00:29:58,770 --> 00:30:03,770
मुझे यकीन है कि मैं स्ट्रिंग टी को समाप्त कर रहा हूँ बनाने की जरूरत है.

478
00:30:03,770 --> 00:30:06,170
और मैं इसे इस तरह से किया सुपर स्पष्ट हो.

479
00:30:06,170 --> 00:30:09,510
लेकिन प्रस्ताव है, कोई अगर तुम सकता है, ऐसा करने का एक अलग तरीका है.

480
00:30:09,510 --> 00:30:13,930
मैं वास्तव में 35 लाइन की जरूरत नहीं है. वहाँ एक और तरीका यह करने के है.

481
00:30:13,930 --> 00:30:18,880
हाँ. >> [अश्राव्य छात्र प्रतिक्रिया >> कहते हैं कि यह ज़ोर.

482
00:30:18,880 --> 00:30:20,960
[छात्र] से कम या बराबर. वास्तव में. >>

483
00:30:20,960 --> 00:30:24,450
हम सिर्फ कम से कम या बराबर n, जो सामान्य रूप से खराब रहा है कह सकते हैं

484
00:30:24,450 --> 00:30:28,190
लगभग हमेशा जब हम बात हम भरोसा कर रहे हैं के लिए एक समान करने के लिए जाना है क्योंकि

485
00:30:28,190 --> 00:30:30,000
हम एक कदम बहुत दूर जाना है.

486
00:30:30,000 --> 00:30:32,170
लेकिन याद रखना, हम कितने बाइट्स आवंटित किया?

487
00:30:32,170 --> 00:30:37,210
हम strlen एस के आवंटित, तो 5 + 1 6 के एक कुल के लिए.

488
00:30:37,210 --> 00:30:39,980
तो इस मामले में हम इस तरह से कुछ कर सकता है

489
00:30:39,980 --> 00:30:46,450
इतना है कि हम बहुत अंत में, लेकिन अभी भी नहीं हैलो \ 0 नकल कर रहे हैं.

490
00:30:46,450 --> 00:30:49,860
वैकल्पिक रूप से, हम एक str प्रतिलिपि बुलाया समारोह का उपयोग, strcpy सकता है,

491
00:30:49,860 --> 00:30:51,700
लेकिन यह है कि लगभग रूप में बहुत मज़ा नहीं होगा.

492
00:30:51,700 --> 00:30:54,000
लेकिन यह है कि यह सब हुड के नीचे होता है.

493
00:30:54,000 --> 00:30:56,050
फिर अंत में, हम पहले के रूप में एक ही बात करते हैं.

494
00:30:56,050 --> 00:31:01,620
मैं टी भुनाने के लिए और फिर मैं दावा है कि मूल इस प्रतिलिपि और ऐसा लग रहा है की तरह लग रहा है.

495
00:31:01,620 --> 00:31:08,570
तो चलो अब इस कोशिश. मुझे यहाँ में जाना. Copy2 बनाओ. हम में ज़ूम और copy2 चलने देंगे.

496
00:31:08,570 --> 00:31:13,840
मैं लोअरकेस में हैलो में टाइप करने के लिए जा रहा हूँ, और वास्तव में मैं मूल रूप में हैलो लोअरकेस

497
00:31:13,840 --> 00:31:16,930
लेकिन नकल के लिए हैलो राजधानी.

498
00:31:16,930 --> 00:31:20,300
लेकिन मैं अभी तक नहीं कर रहा हूँ. मैं यहाँ 1 आखिरी बात करने की जरूरत है.

499
00:31:20,300 --> 00:31:28,000
स्पष्ट रूप से 46 और 47 स्मृति मुक्त है, लेकिन है कि वास्तव में क्या मतलब है?

500
00:31:28,000 --> 00:31:33,250
मैं क्या कर रहा हूँ, तुम्हें क्या लगता है, द्वारा 46 लाइन और 47 लाइन बुला?

501
00:31:33,250 --> 00:31:38,900
क्या प्रभाव है? हाँ.

502
00:31:38,900 --> 00:31:43,140
[अश्राव्य छात्र प्रतिक्रिया] वास्तव में. >>

503
00:31:43,140 --> 00:31:46,380
>> तुम सिर्फ ऑपरेटिंग सिस्टम कह रहे हैं, हे, इस स्मृति के लिए धन्यवाद.

504
00:31:46,380 --> 00:31:48,320
अब आप इसे किसी और के लिए उपयोग कर सकते हैं.

505
00:31:48,320 --> 00:31:50,790
और यहाँ कचरा मूल्यों का एक आदर्श उदाहरण है.

506
00:31:50,790 --> 00:31:55,430
मैं सिर्फ इस स्मृति का इस्तेमाल किया है नीचे 2 स्थानों में शब्द लिखने हैलो,

507
00:31:55,430 --> 00:31:57,490
यहाँ, यहाँ, यहाँ, और.

508
00:31:57,490 --> 00:32:00,910
तो यह 0 घंटे - ई - एल एल ओ \ है.

509
00:32:00,910 --> 00:32:06,960
लेकिन तब मैं 46 लाइन और 47 लाइन कहते हैं, और आप जानते हैं कि क्या तस्वीर के मामले में होता है?

510
00:32:06,960 --> 00:32:10,010
दरअसल, रुको, इस तस्वीर पुरानी है.

511
00:32:10,010 --> 00:32:12,550
एक बार जब हम प्रतिलिपि बनाते हैं, इस आदमी वास्तव में यहाँ इशारा कर रहा है,

512
00:32:12,550 --> 00:32:16,110
तो चलो संख्या को हटाने और सिर्फ अमूर्त दूर हमारे तीर के रूप में फिर से.

513
00:32:16,110 --> 00:32:19,370
इस तस्वीर में क्या होता है जब मैं मुफ्त कॉल?

514
00:32:19,370 --> 00:32:22,750
[अश्राव्य छात्र प्रतिक्रिया भी नहीं >>.

515
00:32:22,750 --> 00:32:29,510
यदि मैं और एस टी पर मुफ्त कॉल - एक चाल सवाल की तरह सभी में इस तस्वीर को बदल नहीं करता है

516
00:32:29,510 --> 00:32:33,880
s बुला और बुला क्योंकि सिर्फ ऑपरेटिंग सिस्टम बताता है,

517
00:32:33,880 --> 00:32:39,010
अरे, आप इस स्मृति फिर से उपयोग कर सकते हैं, लेकिन यह इस अशक्त करने के लिए परिवर्तन नहीं करता है

518
00:32:39,010 --> 00:32:41,840
या कुछ विशेष चरित्र, यह इस को बदल नहीं करता है,

519
00:32:41,840 --> 00:32:47,350
यह ज या ई या या कुछ और करने के लिए या तो जगह में या एल ओ एल बदल नहीं है.

520
00:32:47,350 --> 00:32:51,610
तस्वीर के मामले में, जैसे ही आप फोन मुक्त, कुछ भी नहीं बदलता.

521
00:32:51,610 --> 00:32:56,570
और उसमें कचरा मूल्यों का मूल है, क्योंकि अगर मैं तो बाद में इस कार्यक्रम में

522
00:32:56,570 --> 00:33:01,010
GetString या malloc या ऐसा कुछ के साथ और अधिक स्मृति के लिए ऑपरेटिंग सिस्टम पूछते हैं कि

523
00:33:01,010 --> 00:33:04,900
और ऑपरेटिंग सिस्टम कहते हैं, ज़रूर, मैं स्मृति के 12 बाइट्स बस मुक्त कर दिया है,

524
00:33:04,900 --> 00:33:08,080
इन का उपयोग करें, क्या आप को सौंप दिया जा रहे हैं?

525
00:33:08,080 --> 00:33:10,830
आप के लिए स्मृति का एक हिस्सा है कि हम आम तौर पर आकर्षित करेगा सौंप दिया जा रहे हैं

526
00:33:10,830 --> 00:33:13,700
सवाल के निशान के साथ, लेकिन उन सवाल के निशान क्या कर रहे हैं?

527
00:33:13,700 --> 00:33:17,000
वे ज ए एल एल ओ, ज ए एल एल ओ होना होगा.

528
00:33:17,000 --> 00:33:20,940
हमारे नए कचरा मूल्यों के रूप में जल्द ही के रूप में आपको लगता है कि स्मृति को मुक्त कर रहे हैं.

529
00:33:20,940 --> 00:33:22,750
>> वहाँ एक असली दुनिया निहितार्थ यहाँ भी है.

530
00:33:22,750 --> 00:33:24,720
यह राम के साथ क्या होता है, लेकिन अपने कंप्यूटर

531
00:33:24,720 --> 00:33:26,720
वास्तव में डिस्क के साथ ही काम करते हैं.

532
00:33:26,720 --> 00:33:30,620
हम इस बारे में विशेष रूप से एक भविष्य समस्या सेट है कि फोरेंसिक पर केंद्रित के साथ बात करेंगे.

533
00:33:30,620 --> 00:33:36,170
लेकिन क्या वास्तव में होता है अगर आप अपने डेस्कटॉप पर कुछ संवेदनशील वित्तीय फ़ाइल

534
00:33:36,170 --> 00:33:39,600
या कुछ ढांचे के JPEG और आप इसे अपने कचरे में खींचें,

535
00:33:39,600 --> 00:33:44,390
क्या होता है जब आप इसे कचरा या रीसायकल बिन में खींचें?

536
00:33:44,390 --> 00:33:47,240
तुम्हें पता था कि मैं किस बारे में बात कर रहा था. [हँसी]

537
00:33:47,240 --> 00:33:52,370
क्या होता है जब आप अपने रीसायकल बिन या कचरा कर सकते हैं में सबूत है कि घसीटा है?

538
00:33:52,370 --> 00:33:55,920
[अश्राव्य छात्र प्रतिक्रिया]

539
00:33:55,920 --> 00:33:58,000
ठीक है, तो सावधान. क्या होता है जब आपको लगता है?

540
00:33:58,000 --> 00:34:01,030
संक्षिप्त जवाब कुछ भी नहीं है, है ना?

541
00:34:01,030 --> 00:34:04,790
ढांचे के रूप में या संवेदनशील फ़ाइल अभी भी सिर्फ वहाँ कहीं बैठे अपनी हार्ड ड्राइव में.

542
00:34:04,790 --> 00:34:07,940
हम में से अधिकांश कम से कम कठिन रास्ता है कि आप अपने कचरा खाली करने की जरूरत है सीखा है

543
00:34:07,940 --> 00:34:10,429
या अपने रीसायकल बिन वास्तव में फ़ाइलों को नष्ट करने के लिए.

544
00:34:10,429 --> 00:34:13,440
और वास्तव में, जब आप ठीक क्लिक करें या नियंत्रण अपने कचरा पर क्लिक कर सकते हैं

545
00:34:13,440 --> 00:34:15,580
या फ़ाइल, रद्दी खाली करें या जो कुछ भी का चयन करें

546
00:34:15,580 --> 00:34:21,420
और आप वास्तव में रद्दी खाली करना है कर सकते हैं या बिन, क्या वास्तव में इस तस्वीर के लिए होता है तो?

547
00:34:22,810 --> 00:34:25,969
अधिक कुछ भी नहीं है. तो वास्तव में कुछ भी नहीं डिस्क पर होता है.

548
00:34:25,969 --> 00:34:30,880
>> और अगर हम सिर्फ अस्थायी रूप से पीछे हटना और लिखने - I'll सिर्फ इस के पीछे का उपयोग करें.

549
00:34:30,880 --> 00:34:34,639
तो अब कहानी राम, जो है जहाँ प्रोग्राम मौजूद से बदल रहा है

550
00:34:34,639 --> 00:34:39,250
जब आप उन्हें डिस्क पर चल रहे हैं, जो है, जहां वे लंबे समय तक संग्रहित कर रहे हैं

551
00:34:39,250 --> 00:34:42,920
यहां तक ​​कि जब सत्ता से बाहर अब के लिए चला जाता है - और हम भविष्य में इस लिए आया हूँ -

552
00:34:42,920 --> 00:34:46,380
चलो बस बहाना है कि यह आपके कंप्यूटर के हार्ड ड्राइव के अंदर का प्रतिनिधित्व करता है

553
00:34:46,380 --> 00:34:50,110
क्योंकि दिन में वापस वे परिपत्र डिस्क फ्लॉपी डिस्क की तरह ज्यादा इस्तेमाल किया.

554
00:34:50,110 --> 00:34:55,130
तो अगर आप कुछ संवेदनशील एक्सेल फ़ाइल है, यह स्मृति के इस हिस्सा ले सकता है

555
00:34:55,130 --> 00:34:59,770
आपके कंप्यूटर की डिस्क पर, और मैं सिर्फ एक ही मनमाना 1s और 0s ड्राइंग हूँ.

556
00:34:59,770 --> 00:35:03,970
जब आप अपने कचरे की तरह है कि फ़ाइल खींचें या बिन पुनरावृत्ति कर सकते हैं,

557
00:35:03,970 --> 00:35:07,750
सचमुच कुछ भी नहीं होता है, क्योंकि एप्पल और माइक्रोसॉफ्ट का फैसला किया है

558
00:35:07,750 --> 00:35:10,450
कचरा कर सकते हैं और रीसायकल बिन वास्तव में सिर्फ एक अस्थायी प्लेसहोल्डर है.

559
00:35:10,450 --> 00:35:14,710
शायद अंततः ओएस यह आप के लिए खाली है, लेकिन आम तौर पर, यह कुछ भी नहीं है,

560
00:35:14,710 --> 00:35:17,090
कम से कम जब तक आप वास्तव में अंतरिक्ष पर कम कर रहे हैं.

561
00:35:17,090 --> 00:35:20,870
>> हालांकि, जब आप खाली कचरा या खाली रीसायकल बिन जाना

562
00:35:20,870 --> 00:35:23,460
इसी तरह, इस तस्वीर के लिए कुछ भी नहीं होता है.

563
00:35:23,460 --> 00:35:28,590
वह यह होता है कि आपके कंप्यूटर पर कहीं और है, वहाँ तालिका के किसी तरह का है.

564
00:35:28,590 --> 00:35:35,400
यह एक छोटे से पत्रक धोखा है कि कहते हैं कि, चलो कहते हैं, resume.doc तरह तरह की है,

565
00:35:35,400 --> 00:35:40,920
तो एक माइक्रोसॉफ्ट वर्ड फ़ाइल को अपनी हार्ड डिस्क पर 123 स्थान पर रहते थे में अपने को फिर से शुरू,

566
00:35:40,920 --> 00:35:43,710
और स्मृति रैम में नहीं है, लेकिन अपनी हार्ड डिस्क पर,

567
00:35:43,710 --> 00:35:49,050
और अपने ढांचे के रूप में 456 पर JPEG रहता है, और अपने Excel फ़ाइल में 789 या जहाँ भी रहता है.

568
00:35:49,050 --> 00:35:53,640
जब आप वास्तव में कचरा या रीसायकल बिन खाली करके फ़ाइलों को हटाने के लिए,

569
00:35:53,640 --> 00:35:59,530
इस तस्वीर बदल नहीं है. 0s और 1s अपनी हार्ड ड्राइव पर कहीं भी जाना नहीं है.

570
00:35:59,530 --> 00:36:03,930
लेकिन इस मेज, एक तरह के इस छोटे से डेटाबेस, परिवर्तन करता है.

571
00:36:03,930 --> 00:36:08,750
जब आप अपने को फिर से शुरू हटाते हैं, यह है फ़ाइल के रूप में हालांकि कुछ समझ में नष्ट कर दिया है,

572
00:36:08,750 --> 00:36:12,790
लेकिन सभी कंप्यूटर जहां कि बात अपनी हार्ड ड्राइव पर रहता है भूल नहीं है.

573
00:36:12,790 --> 00:36:17,870
0s और 1s कि अपने को फिर से शुरू या इन फ़ाइलों के अन्य किसी भी रचना अभी भी बरकरार हैं.

574
00:36:17,870 --> 00:36:21,960
>> तो अगर आप इस गलती से किया था, वहाँ अभी भी एक गैर शून्य संभावना है

575
00:36:21,960 --> 00:36:25,800
है कि आप अपने डेटा को ठीक Norton उपयोगिताएँ या कुछ वाणिज्यिक सॉफ्टवेयर का उपयोग कर सकते हैं

576
00:36:25,800 --> 00:36:29,810
जीवन में जिसका उद्देश्य 0s और 1s उस तरह का अनाथ किया गया लगता है,

577
00:36:29,810 --> 00:36:33,300
यहाँ भूल लेकिन यहाँ छोड़ दिया है, जिससे कि आप अपने डेटा को वापस प्राप्त कर सकते हैं.

578
00:36:33,300 --> 00:36:38,410
या पुलिस या एफबीआई के साथ फोरेंसिक जांचकर्ताओं वास्तव में एक हार्ड ड्राइव ले जाएगा

579
00:36:38,410 --> 00:36:42,550
और वास्तव में 0s और 1s कि JPEGs की तरह देखो, Excel फ़ाइलों की तरह देखने के पैटर्न के लिए देखो,

580
00:36:42,550 --> 00:36:46,400
और उन्हें इस तरह भले ही कंप्यूटर उन्हें भूल गया है वहाँ ठीक हो जाते हैं.

581
00:36:46,400 --> 00:36:49,820
इतना ही वास्तव में जिस तरह से करने के लिए डेटा को हटाने के लिए, के रूप में हम भविष्य में चर्चा करेंगे,

582
00:36:49,820 --> 00:36:54,190
हाथ धोने या फ़ाइल या हार्ड डिस्क से मिटा है -

583
00:36:54,190 --> 00:36:56,540
आप वास्तव में 0s और 1s छुटकारा नहीं मिल सकता है

584
00:36:56,540 --> 00:36:59,440
क्योंकि अन्यथा आप एक गीगाबाइट हार्ड ड्राइव के साथ शुरू होता है

585
00:36:59,440 --> 00:37:02,380
और आप एक मेगाबाइट हार्ड ड्राइव के साथ अंत में अगर आप लगातार को हटाने थे,

586
00:37:02,380 --> 00:37:04,380
सचमुच 0s और 1s.

587
00:37:04,380 --> 00:37:06,310
तो तुम क्या करना होगा अगर तुम सच में अपने पटरियों को कवर करना चाहता था

588
00:37:06,310 --> 00:37:10,510
और बुनियादी समस्या यह है कि वहाँ अभी भी 0s और 1s डिस्क पर?

589
00:37:10,510 --> 00:37:14,930
मैं gesticulating किसी को देखना है कि आप शारीरिक डिवाइस तोड़ना होगा. यह काम करेगा.

590
00:37:14,930 --> 00:37:19,600
[हँसी] लेकिन है कि यदि एक महंगी समाधान की तरह है, क्या और अधिक उचित होगा?

591
00:37:19,600 --> 00:37:23,270
हाँ. >> [छात्र] उन्हें अधिलेखित. >> उन्हें क्या साथ ओवरराइट करें? >> [छात्र] अन्य डेटा.

592
00:37:23,270 --> 00:37:29,070
अन्य डेटा. तुम बस 0s या 1s या 0s सब, सभी 1s के साथ अपनी डिस्क अधिलेखित कर सकते हैं.

593
00:37:29,070 --> 00:37:31,230
>> और कहा कि वास्तव में सॉफ्टवेयर के कुछ क्या करता है.

594
00:37:31,230 --> 00:37:33,570
आप सॉफ्टवेयर खरीदने के लिए कर सकते हैं या भी मुफ्त सॉफ्टवेयर,

595
00:37:33,570 --> 00:37:36,610
और यहां तक ​​कि मैक ओएस के लिए इन दिनों में बनाया गया है, कम Windows में ऐसा है,

596
00:37:36,610 --> 00:37:38,660
सुरक्षित मिटा करने की क्षमता है.

597
00:37:38,660 --> 00:37:41,960
वास्तव में, अगर तुम आज सभी घर चलाने के लिए चाहते हैं यदि आप एक मैक है और ऐसा करते हैं,

598
00:37:41,960 --> 00:37:45,740
अगर आप अपने कचरे में कुछ सामान मिला है, तो आप सुरक्षित ट्रैश को खाली कर सकते हैं कर सकते हैं,

599
00:37:45,740 --> 00:37:47,610
जो कि वास्तव में करता है.

600
00:37:47,610 --> 00:37:53,350
बस मिटा यहाँ फ़ाइलें बजाय, यह 0s और 1s यहाँ से मिटा नहीं है,

601
00:37:53,350 --> 00:38:01,240
बल्कि, यह सिर्फ उन सब बदलता है, उदाहरण के लिए 0s और डॉट, डॉट, डॉट,.

602
00:38:01,240 --> 00:38:05,330
तो एक अपने भविष्य के psets के वास्तव में जानबूझकर डेटा ठीक हो जाएगा -

603
00:38:05,330 --> 00:38:08,430
तस्वीरें कि हम लोगों, स्थानों, परिसर में और चीजों की लिया है

604
00:38:08,430 --> 00:38:12,810
जिसके लिए हम एक डिजिटल कैमरे के मेमोरी कार्ड की एक फोरेंसिक छवि बना देंगे,

605
00:38:12,810 --> 00:38:17,120
जो सटीक एक ही विचार है - और आप के लिए वास्तव में खोजने के लिए चुनौती दी जा होगा

606
00:38:17,120 --> 00:38:20,160
पैटर्न है जो आपकी हार्ड ड्राइव पर JPEGs का प्रतिनिधित्व करते हैं,

607
00:38:20,160 --> 00:38:23,610
बहुत कि पूर्व छात्र जिसका ईमेल की तरह मैं एक कुछ हफ्ते पहले पढ़ा था

608
00:38:23,610 --> 00:38:25,860
अपनी बहन की फोटो को ठीक करने के लिए.

609
00:38:25,860 --> 00:38:30,300
क्यों नहीं हम एक 5 मिनट का ब्रेक लेने के यहाँ, और हम स्मृति पर अधिक के साथ फिर से इकट्ठा करना होगा.

610
00:38:33,030 --> 00:38:38,610
तो यहाँ जहां चीजें एक छोटे से दिमाग झुकने मिलता है, लेकिन यह एक बहुत शक्तिशाली कदम है

611
00:38:38,610 --> 00:38:40,480
यह सभी को और अधिक समझने की ओर.

612
00:38:40,480 --> 00:38:42,900
यहाँ एक pointers.c कार्यक्रम बुलाया है.

613
00:38:42,900 --> 00:38:45,430
यह आज नमूना कोड के बीच है.

614
00:38:45,430 --> 00:38:51,280
सूचना है कि पहले कुछ लाइनों में, 19 22 के माध्यम से, हम कर रहे हैं GetString की तरह कुछ है

615
00:38:51,280 --> 00:38:54,460
और एक पते लौटने, यह एस में भंडारण.

616
00:38:54,460 --> 00:38:58,380
3 pset के लिए भी आज के बाद यदि आप चाहते हैं लेकिन pset 4 और पर

617
00:38:58,380 --> 00:39:01,030
जहां आप अपने आप से दूर इन प्रशिक्षण के पहियों लेने शुरू कर सकते हैं,

618
00:39:01,030 --> 00:39:04,030
वहाँ कोई बहाना है कि तार अब अस्तित्व के लिए एक कारण है.

619
00:39:04,030 --> 00:39:07,030
यह निश्चित रूप से करने के लिए सिर्फ चार * कह शुरू करने के लिए ठीक है.

620
00:39:07,030 --> 00:39:12,610
>> एक अलग रूप में, ऑनलाइन संदर्भ में और किताबों में आप अक्सर सितारा चर के लिए बगल में देख सकते हैं.

621
00:39:12,610 --> 00:39:15,600
आप भी यह दोनों पक्षों के आसपास रिक्त स्थान देख सकते हैं.

622
00:39:15,600 --> 00:39:17,680
उन सब के सब कार्यात्मक सही हैं.

623
00:39:17,680 --> 00:39:21,180
अभी के लिए, हालांकि, हम इस दृष्टिकोण पर मानकीकरण सुपर स्पष्ट बनाना होगा

624
00:39:21,180 --> 00:39:24,000
कि चार * चरित्र सूचक कह की तरह है.

625
00:39:24,000 --> 00:39:25,680
यह डेटा प्रकार है.

626
00:39:25,680 --> 00:39:28,730
और फिर चर का नाम भी इस मामले में है.

627
00:39:28,730 --> 00:39:31,180
तो हम एक स्ट्रिंग मिल गया है और हम यह कहा जाता है.

628
00:39:31,180 --> 00:39:35,180
और फिर यहाँ नीचे लगता है कि मैं वास्तव में प्रवंचना का एक छोटा सा कर रहा हूँ.

629
00:39:35,180 --> 00:39:39,080
यह सूचक अंकगणित, जो सुपर सरल की तरह है कहा जाता है.

630
00:39:39,080 --> 00:39:41,790
यह बस का अर्थ है जोड़ सकते हैं और संकेत संख्या घटाना.

631
00:39:41,790 --> 00:39:43,660
लेकिन यह वास्तव में काम करता है.

632
00:39:43,660 --> 00:39:49,170
जाहिरा तौर पर इस कार्यक्रम के अंत परिणाम है कि इस तरह के प्रति पंक्ति है स्ट्रिंग 1 चरित्र प्रिंट -

633
00:39:49,170 --> 00:39:54,920
अभी तो हम कहाँ जा रहा है खराब, संकेत कर सकते हैं, चलाने के संकेत, मुझे अंदर ज़ूम

634
00:39:54,920 --> 00:39:58,940
अब मुझे HELLO और प्रकार दर्ज की तरह कुछ में टाइप करते हैं

635
00:39:58,940 --> 00:40:01,080
और यह प्रति पंक्ति 1 चरित्र प्रिंट.

636
00:40:01,080 --> 00:40:04,730
पहले 2, जब तक हम वर्ग कोष्ठक अंकन के साथ ऐसा किया होता.

637
00:40:04,730 --> 00:40:09,760
हम एक पाश के लिए है और हम एस के printf करना चाहते हैं [i] और हम है कि फिर से और फिर से कर सकता हूँ

638
00:40:09,760 --> 00:40:11,950
प्रत्येक पंक्ति के अंत में एक बैकस्लैश n के साथ.

639
00:40:11,950 --> 00:40:16,800
लेकिन इस कार्यक्रम अलग है. इस कार्यक्रम का उपयोग कर रहा है, सचमुच, गणित.

640
00:40:16,800 --> 00:40:18,860
तो क्या हो रहा है यहाँ?

641
00:40:18,860 --> 00:40:24,720
सब से पहले, पहले भी इस पाश निष्पादित करता है, क्या, बस स्पष्ट होना, वास्तव में है?

642
00:40:24,720 --> 00:40:27,270
एस है? >> [छात्र] पता. >> पता.

643
00:40:27,270 --> 00:40:32,980
>> और यह पता हैलो के मामले में है, उस शब्द में 1 चरित्र है, जो ज रहा है.

644
00:40:32,980 --> 00:40:37,370
इतना इस विशिष्ट उदाहरण में है, ज के पते.

645
00:40:37,370 --> 00:40:41,850
तो यह क्या है करना मतलब यह नहीं है मैं +?

646
00:40:41,850 --> 00:40:46,280
खैर, मैं इस में 0 पर पाश के लिए शुरू होता है. हम है कि कई बार किया है.

647
00:40:46,280 --> 00:40:49,760
मैं स्ट्रिंग की लंबाई के लिए जाना है, जाहिरा तौर पर जा रहा है.

648
00:40:49,760 --> 00:40:53,950
तो इस लूप की पहली यात्रा पर, मैं स्पष्ट रूप से 0 है.

649
00:40:53,950 --> 00:41:01,740
तो इस अभिव्यक्ति कह रहा है मैं +, बल्कि एस +0- कि जाहिर है सिर्फ.

650
00:41:01,740 --> 00:41:04,320
तो यहाँ * क्या है?

651
00:41:04,320 --> 00:41:08,530
अब हम एक अलग तरह से स्टार का उपयोग कर रहे हैं.

652
00:41:08,530 --> 00:41:13,080
मुझे आगे जाना है और टी से छुटकारा मिलता है क्योंकि हम टी और एस की प्रतियां के बारे में बात कर रहे हैं.

653
00:41:13,080 --> 00:41:15,540
अब हम सिर्फ एक एस शामिल कहानी बताना चाहता हूँ.

654
00:41:15,540 --> 00:41:20,090
और इसलिए इस पल में, प्रकार स्ट्रिंग होने के बाद, हमारी दुनिया काफी की तरह लग रहा है यह पहले किया था

655
00:41:20,090 --> 00:41:26,630
सिर्फ ज के पते भंडारण और अधिक आम तौर पर स्ट्रिंग में इशारा हैलो साथ.

656
00:41:26,630 --> 00:41:33,170
अगर मैं अब पसंद करते है * एक पंक्ति (s + i), इस बाहर की कोशिश करते हैं.

657
00:41:33,170 --> 00:41:40,140
तो * (मैं +). मुझे इस सरल क्योंकि यह 0 है, तो यह * (0 एस) है.

658
00:41:40,140 --> 00:41:43,790
खैर, एक मिनट रुको. आगे सरल. * (ओं) है.

659
00:41:43,790 --> 00:41:47,020
खैर, अब कोष्ठकों बेवकूफ की तरह कर रहे हैं, तो अब बस करो * चलो.

660
00:41:47,020 --> 00:41:50,540
तो इस लूप डाला है कि लाइन है कि, 26 की पहली यात्रा में,

661
00:41:50,540 --> 00:41:53,650
बहुत ज्यादा इस मुद्रण करने के लिए बराबर है.

662
00:41:53,650 --> 00:41:56,040
* S डेटा प्रकार क्या है?

663
00:41:56,040 --> 00:42:00,770
इस संदर्भ में, क्योंकि स्टार के लिए अपने आप के पास होना होता है,

664
00:42:00,770 --> 00:42:04,930
लेकिन और अधिक विशेष रूप से, क्योंकि हम अब और नहीं की घोषणा कर रहे हैं,

665
00:42:04,930 --> 00:42:09,730
अब हम एक चर नहीं बना रहे हैं, वहाँ 26 लाइन में चार * का कोई जिक्र नहीं है,

666
00:42:09,730 --> 00:42:14,280
वहाँ कीवर्ड स्ट्रिंग का कोई जिक्र नहीं है, हम सिर्फ एक चर कहा जाता है का उपयोग कर रहे हैं,

667
00:42:14,280 --> 00:42:19,650
यह पता चला है अब सितारा थोड़ा अलग है और, बेशक, अर्थ भ्रमित.

668
00:42:19,650 --> 00:42:26,590
* यहाँ मतलब एस और प्रिंट में पता करने के लिए जाने के लिए जो कुछ भी है.

669
00:42:26,590 --> 00:42:33,750
* है, तो यहाँ है Chutes और सीढ़ी की तरह तरह के तीर का पालन - यहाँ.

670
00:42:33,750 --> 00:42:35,850
तो यह * s है.

671
00:42:35,850 --> 00:42:39,060
>> तो क्या 26 लाइन में है कि पाश की पहली यात्रा पर मुद्रित हो जाता है?

672
00:42:39,060 --> 00:42:42,170
मैं बाहर% ग, जो एक चरित्र के लिए प्लेसहोल्डर है मुद्रित करते हैं,

673
00:42:42,170 --> 00:42:48,520
तो एक नई लाइन के लिए एक \ n. * (मैं +) जहां मैं 0 है बस.

674
00:42:48,520 --> 00:42:53,670
तो क्या चार मैं% ग के लिए में जगह? एच.

675
00:42:53,670 --> 00:42:56,900
शायद आप कहाँ जा रहा है देख सकते हैं - पाश की अगली यात्रा में -

676
00:42:56,900 --> 00:43:01,350
अगले चलना मैं स्पष्ट रूप से एक है, तो इसका मतलब यह है एक एस,

677
00:43:01,350 --> 00:43:05,580
और अब तो मैं कोष्ठकों की जरूरत है क्योंकि अब स्टार के लिए कहने की जरूरत है

678
00:43:05,580 --> 00:43:08,620
स्मृति पते एस 1 के लिए जाना.

679
00:43:08,620 --> 00:43:14,170
क्या है? चलो समय में वापस रोल और कहते हैं कि इस तीर अब वास्तव में हमें कोई एहसान नहीं कर रही है.

680
00:43:14,170 --> 00:43:18,450
अधिक विशेष रूप से चलो का कहना है कि यह संख्या 123 है भंडारण

681
00:43:18,450 --> 00:43:25,110
क्योंकि इस स्ट्रिंग की शुरुआत हैलो, यह पता है 123, 124 है, और बहुत आगे है.

682
00:43:25,110 --> 00:43:30,550
तो दूसरी यात्रा पर जब मैं एक कह रहा हूँ, कि एक 123 कह की तरह है,

683
00:43:30,550 --> 00:43:35,340
अन्यथा 124 के रूप में जाना जाता है, तो क्या चार दूसरी यात्रा पर मुद्रित हो जाता है?

684
00:43:35,340 --> 00:43:37,850
स्मृति 124 पते पर ई.

685
00:43:37,850 --> 00:43:44,440
तो फिर +, 125, 126, 127, और इस लूप शुक्र बंद हो जाता है इससे पहले कि हम यहाँ मिल

686
00:43:44,440 --> 00:43:49,040
क्योंकि मैं strlen का उपयोग कर रहा हूँ यकीन है कि मैं बहुत अधिक गिनती नहीं है.

687
00:43:49,040 --> 00:43:50,810
तो यह है कि यह भी है.

688
00:43:50,810 --> 00:43:55,000
फिर, यह है बस के रूप में हालांकि हम एक सप्ताह पहले किया था.

689
00:43:55,000 --> 00:43:59,200
मुझे यह लाइन पर नीचे लिख भले ही हम दोनों नहीं करना चाहती.

690
00:43:59,200 --> 00:44:02,500
अब यह समान है इस के लिए.

691
00:44:02,500 --> 00:44:08,310
>> तो भले ही एस एक स्ट्रिंग है, के रूप में हम सप्ताह के लिए किया गया है यह फोन, वास्तव में एक चार * है.

692
00:44:08,310 --> 00:44:13,270
तो अगर हम सुपर गुदा होना चाहते हैं, तो यह वास्तव में उचित है विशिष्ट चरित्र लिखने

693
00:44:13,270 --> 00:44:17,490
ith इन संख्यात्मक पते और इस स्टार ऑपरेटर का उपयोग कर के स्थान पर,

694
00:44:17,490 --> 00:44:20,470
लेकिन स्पष्ट रूप से, यह सिर्फ इतना क्लीनर है. तो यह बुरा नहीं है.

695
00:44:20,470 --> 00:44:26,720
27 लाइन यहाँ कर रोकने के लिए कोई कारण नहीं है, लेकिन 26 ही कार्यात्मक,

696
00:44:26,720 --> 00:44:31,570
और यह कार्यात्मक वास्तव में कारण है कि हम इस प्रकार अब तक चर्चा कर रहा है के लिए एक ही है.

697
00:44:31,570 --> 00:44:33,650
और अंत में, 29 बस अच्छा अभ्यास है.

698
00:44:33,650 --> 00:44:38,420
एस के मुक्त बुला मतलब है कि अब तुम वापस स्मृति कि GetString तुम्हें दे दिया दे रहे हैं

699
00:44:38,420 --> 00:44:41,630
क्योंकि फिर, सोमवार के रूप में मैंने उल्लेख किया है, सप्ताह के लिए GetString

700
00:44:41,630 --> 00:44:44,180
अपने कोड में एक बग शुरू किया गया है.

701
00:44:44,180 --> 00:44:46,490
सप्ताह के लिए अपने कोड स्मृति लीक किया गया है

702
00:44:46,490 --> 00:44:49,970
आप है जिससे स्मृति के लिए GetString पूछ लेकिन आप यह कभी नहीं किया गया वापस देने.

703
00:44:49,970 --> 00:44:53,410
और कहा कि जानबूझकर हमारे द्वारा pedagogically करने के लिए चुना गया था

704
00:44:53,410 --> 00:44:55,880
क्योंकि यह अभी भी बहुत जल्दी पर के बारे में सोचना है.

705
00:44:55,880 --> 00:44:57,710
लेकिन अब हम अधिक समरूपता की जरूरत है.

706
00:44:57,710 --> 00:45:00,830
यदि आप स्मृति के लिए कंप्यूटर पूछना, रूप में GetString के लिए मामला है,

707
00:45:00,830 --> 00:45:02,820
के रूप में मामला malloc के लिए जाहिरा तौर पर,

708
00:45:02,820 --> 00:45:07,970
अब आप pset 4 आगे के लिए भी मुक्त ऐसे किसी भी स्मृति चाहिए.

709
00:45:07,970 --> 00:45:11,650
Int n कह से अलग है पर ध्यान दें.

710
00:45:11,650 --> 00:45:15,040
आप इस मुक्त करने की जरूरत नहीं क्योंकि आप GetString फोन नहीं किया है

711
00:45:15,040 --> 00:45:16,890
और आप malloc फोन नहीं किया.

712
00:45:16,890 --> 00:45:20,610
>> और अगर आप GetInt बुलाया के रूप में हम अंततः देखेंगे,

713
00:45:20,610 --> 00:45:25,520
GetInt आप के लिए स्मृति का आवंटन नहीं किया है क्योंकि आप वास्तव में चारों ओर integers पारित कर सकते हैं

714
00:45:25,520 --> 00:45:29,430
और मंगाई और घर का काम अभी जिस तरह से हम सप्ताह के लिए कर दिया गया है.

715
00:45:29,430 --> 00:45:33,960
स्ट्रिंग्स, हालांकि, विशेष कर रहे हैं क्योंकि वास्तव में वे कई वर्ण की अभिलाग कर रहे हैं.

716
00:45:33,960 --> 00:45:37,450
तो वे सिर्फ घर का काम और मंगाई और ints से अलग कर रहे हैं और पसंद है.

717
00:45:37,450 --> 00:45:39,980
लेकिन हम है कि लंबे समय से पहले वापस करने के लिए आया हूँ.

718
00:45:39,980 --> 00:45:44,920
संकेत की इस शुरुआत पर कोई सवाल? हाँ.

719
00:45:44,920 --> 00:45:49,690
[अश्राव्य छात्र प्रश्न]

720
00:45:49,690 --> 00:45:51,440
आह, बहुत अच्छा सवाल है.

721
00:45:51,440 --> 00:45:55,790
कुछ चीजें सी वास्तव में आप के लिए करता है, जो सुविधाजनक है,

722
00:45:55,790 --> 00:46:00,110
यह आप के लिए बाहर के आंकड़े क्या आकार डेटा प्रकार की है

723
00:46:00,110 --> 00:46:03,060
और फिर आप के लिए गुणा की उस तरह करता है.

724
00:46:03,060 --> 00:46:06,610
यह घर का काम के मामले में अप्रासंगिक है क्योंकि लगभग हमेशा एक चार 1 बाइट है,

725
00:46:06,610 --> 00:46:08,150
तो यह सिर्फ काम करता है.

726
00:46:08,150 --> 00:46:11,220
लेकिन चर्चा के लिए, यदि आप वास्तव integers मुद्रण कर रहे थे

727
00:46:11,220 --> 00:46:15,500
और तुम बाहर कुछ मूल्य है कि एक पूर्णांक में इशारा किया गया था मुद्रित करने की कोशिश कर रहे थे,

728
00:46:15,500 --> 00:46:20,720
इसी प्रकार आप 4 + करने की जरूरत नहीं * मैं सिर्फ इसलिए कि एक int 4 बाइट्स है.

729
00:46:20,720 --> 00:46:25,780
सूचक गणित का मतलब है कि सी और संकलक आप के लिए सभी कि गणित करते हैं.

730
00:46:25,780 --> 00:46:29,190
आप सभी के बारे में परवाह है मानवीय भावना की तरह में गिनती है. हाँ.

731
00:46:29,190 --> 00:46:35,200
[छात्र] यदि आप एक के अंदर पाश के लिए एक स्ट्रिंग की घोषणा करने के लिए, आप इसे बाद में स्वतंत्र है?

732
00:46:35,200 --> 00:46:36,760
अच्छा सवाल है.

733
00:46:36,760 --> 00:46:41,390
>> यदि आप एक पाश के लिए स्ट्रिंग के अंदर घोषित कर दिया, तो आप इसे बाद में स्वतंत्र है की क्या ज़रूरत है?

734
00:46:41,390 --> 00:46:47,520
आप केवल स्मृति मुक्त करने की जरूरत है है कि आप GetString या malloc के साथ आवंटित.

735
00:46:47,520 --> 00:46:53,110
तो अगर तुम सिर्फ का कहना है कि कुछ पसंद - मुझे घुंघराले ब्रेसिज़ डाल दिया तो अब सभी कोड से संबंधित है.

736
00:46:53,110 --> 00:46:58,580
यदि आप buggily यद्यपि, कुछ इस तरह किया, चार * टी एस =

737
00:46:58,580 --> 00:47:03,450
आप मुक्त टी की जरूरत नहीं है क्योंकि टी malloc या GetString के किसी भी उल्लेख शामिल नहीं किया करते.

738
00:47:03,450 --> 00:47:08,960
इसके विपरीत यदि आप इस किया, GetString, तो हाँ, आप मुक्त टी की आवश्यकता होगी.

739
00:47:08,960 --> 00:47:14,350
और वास्तव में, अपने ही है कि करने का मौका इस लूप के अंदर अब दायरे से ही जारी करने के लिए है,

740
00:47:14,350 --> 00:47:16,060
कि हम अतीत में चर्चा की है.

741
00:47:16,060 --> 00:47:18,830
अन्यथा आप स्मृति का आवंटन होगी, स्मृति आवंटन, स्मृति आवंटन

742
00:47:18,830 --> 00:47:21,230
और कार्यक्रम के अंत में, क्योंकि आप कि लूप के बाहर हो,

743
00:47:21,230 --> 00:47:24,240
t मौजूद नहीं है, लेकिन आप कभी नहीं बताया ऑपरेटिंग सिस्टम

744
00:47:24,240 --> 00:47:26,750
कि आपको लगता है कि स्मृति अब जरूरत नहीं है.

745
00:47:26,750 --> 00:47:30,430
और 4 या 5 pset के लिए लंबे समय से पहले, हम आपको एक वेलग्रिंड नामक कार्यक्रम के साथ लैस हूँ,

746
00:47:30,430 --> 00:47:34,160
जो आत्मा में GDB के लिए इसी तरह की है कि यह कुछ हद तक एक रहस्यमय इंटरफ़ेस का मिल गया है,

747
00:47:34,160 --> 00:47:35,750
लेकिन जीवन में अपने उद्देश्य के लिए आप मदद करने के लिए है.

748
00:47:35,750 --> 00:47:39,380
और वेलग्रिंड एक प्रोग्राम है कि भविष्य में अपने कार्यक्रमों की खोज करेंगे

749
00:47:39,380 --> 00:47:42,550
स्मृति लीक के लिए देख रहे हैं, चाहे GetString या malloc से,

750
00:47:42,550 --> 00:47:47,800
जो हम सभी को और अधिक का उपयोग कर के रूप में हम के रूप में ज्यादा CS50 पुस्तकालय का उपयोग करना बंद कर देते हैं शुरू करेंगे.

751
00:47:47,800 --> 00:47:53,030
हम अंत में अब शब्दावली की तरह और सिद्धांत में मानसिक मॉडल की तरह है

752
00:47:53,030 --> 00:47:55,170
जिसके साथ इस टूटे हुए कार्यक्रम को हल करने के लिए.

753
00:47:55,170 --> 00:47:59,410
>> तो, इस टूटे हुए कार्यक्रम में स्वैप स्वैप के अंदर काम करता है,

754
00:47:59,410 --> 00:48:05,280
लेकिन यह मुख्य में वास्तव में काम नहीं किया है क्योंकि एक्स और वाई, याद में मुख्य पारित कर दिया है,

755
00:48:05,280 --> 00:48:07,260
और उन में मूल्यों द्वारा पारित किए गए, तो बात करने के लिए.

756
00:48:07,260 --> 00:48:09,330
उन की प्रतियां को स्वैप करने के लिए दिए गए थे.

757
00:48:09,330 --> 00:48:12,520
स्वैप के अंत तक एक और ख वास्तव में विमर्श किया गया था,

758
00:48:12,520 --> 00:48:16,120
लेकिन निश्चित रूप से एक्स और वाई, के रूप में हम सोमवार को चर्चा की, नहीं किया गया था.

759
00:48:16,120 --> 00:48:19,940
इसलिए मैं हरे रंग में प्रस्ताव है कि यह वास्तव में यहाँ समाधान है.

760
00:48:19,940 --> 00:48:22,640
और वास्तव में, मुझे मेरे सितारे चाल बस अनुरूप होना

761
00:48:22,640 --> 00:48:24,440
हालांकि, फिर से, कार्यात्मक यह कोई फर्क नहीं करता है.

762
00:48:24,440 --> 00:48:28,730
भविष्य हफ्तों में हम कब और क्यों यह बात करता है समझाता हूँ.

763
00:48:28,730 --> 00:48:30,600
तो अब हरे रंग में एक समाधान है.

764
00:48:30,600 --> 00:48:33,700
सच कहूँ तो, यह एक पूरी बहुत messier लग रहा है क्योंकि मैं इन सितारों के सभी है.

765
00:48:33,700 --> 00:48:35,380
मुझे एक बात बिंदु.

766
00:48:35,380 --> 00:48:40,040
शीर्ष पंक्ति यहाँ जहाँ यह कहते हैं int * एक और int ख *

767
00:48:40,040 --> 00:48:42,820
मौलिक रूप से एक ही बात कर के रूप में यह हमेशा किया है.

768
00:48:42,820 --> 00:48:47,070
यह 2 तर्क या पैरामीटर की घोषणा को स्वैप करने के लिए,

769
00:48:47,070 --> 00:48:49,940
जो पहले के एक int सूचक है कहा जाता है,

770
00:48:49,940 --> 00:48:53,100
जिनमें से 2 एक int ख बुलाया सूचक है.

771
00:48:53,100 --> 00:48:55,770
केवल एक चीज है कि इस बिंदु पर नए तथ्य यह है कि वहाँ एक स्टार है.

772
00:48:55,770 --> 00:48:59,340
>> इसका क्या मतलब है? एक एक int नहीं है, ख एक int नहीं है.

773
00:48:59,340 --> 00:49:04,100
एक एक int के पते और बी एक अलग int के पता है.

774
00:49:04,100 --> 00:49:06,980
यहाँ नीचे, यह है जहां मैं मानता हूँ सी भ्रमित हो जाता है.

775
00:49:06,980 --> 00:49:09,790
अब हम एक स्टार का उपयोग कर रहे हैं, लेकिन यह इस संदर्भ में अलग - अलग अर्थ है.

776
00:49:09,790 --> 00:49:13,150
क्योंकि हम संकेत की घोषणा नहीं कर के रूप में हम यहाँ हैं कर रहे हैं,

777
00:49:13,150 --> 00:49:15,500
यहाँ हम चीजों dereferencing कर रहे हैं.

778
00:49:15,500 --> 00:49:21,520
तकनीकी रूप से तो, स्वैप के अंदर 1, 2, और 3 लाइन के इस संदर्भ में स्टार

779
00:49:21,520 --> 00:49:24,560
भिन्नता ऑपरेटर, जो बस का अर्थ है वहाँ जाओ.

780
00:49:24,560 --> 00:49:27,400
तो बस के रूप में मेरी उंगली घंटे के लिए तीर का पालन किया है,

781
00:49:27,400 --> 00:49:31,100
* एक का मतलब है कि पता करने के लिए जाना है और मुझे int है कि वहाँ है.

782
00:49:31,100 --> 00:49:34,250
* ख का मतलब है पता करने के लिए जाने के लिए और मेरे पास क्या है.

783
00:49:34,250 --> 00:49:40,730
तो चलो सोमवार अब एक तख्ते के ढेर का उपयोग करने से तस्वीर redraw,

784
00:49:40,730 --> 00:49:43,130
के नीचे एक मुख्य होने जा रहा है,

785
00:49:43,130 --> 00:49:47,600
जो के ऊपरी एक स्वैप होने जा रहा है,

786
00:49:47,600 --> 00:49:50,880
तो यह है कि हमारी दुनिया सोमवार तरह दिखता है, इस तरह,.

787
00:49:50,880 --> 00:49:53,620
यहाँ स्मृति का एक हिस्सा है कि मुख्य उपयोग करने के लिए जा रहा है.

788
00:49:53,620 --> 00:49:56,520
>> सोमवार से याद है कि इस कार्यक्रम सिर्फ 2 चर था,

789
00:49:56,520 --> 00:50:01,930
एक एक्स और एक y बुलाया कहा जाता है, और मैं संख्या 1 और 2 डाल दिया था.

790
00:50:01,930 --> 00:50:06,580
अब जब मैं कॉल की तरह स्वैप मैं सोमवार को किया था,

791
00:50:06,580 --> 00:50:11,000
पहले जब मैं इस कार्यक्रम के लाल संस्करण का इस्तेमाल किया है, जो इस तरह दिखता है,

792
00:50:11,000 --> 00:50:17,470
मैं 2 पैरामीटर, ए और बी है, और हम यहाँ और यहाँ क्या लिखा था?

793
00:50:17,470 --> 00:50:21,160
बस 1 और 2, सचमुच एक्स और वाई की प्रतियां.

794
00:50:21,160 --> 00:50:23,070
आज हम बदल जाते हैं.

795
00:50:23,070 --> 00:50:28,510
आज ints में पारित करने के बजाय एक और ख हम 2 पतों में पारित करने के लिए जा रहे हैं.

796
00:50:28,510 --> 00:50:34,290
उन पतों ints करने के लिए बात करने के लिए हो सकता है, लेकिन उन पतों खुद ints नहीं कर रहे हैं.

797
00:50:34,290 --> 00:50:37,330
वे पते हैं. यह बजाय एक डाक पते की तरह है.

798
00:50:37,330 --> 00:50:40,580
तो अब हम सिर्फ अपने आप को स्क्रीन पर एक छोटे से अधिक विस्तार देने की जरूरत है.

799
00:50:40,580 --> 00:50:43,250
यह मेरे कंप्यूटर की स्मृति के रूप में यह सब दिन हो गया है.

800
00:50:43,250 --> 00:50:45,120
अब हम कुछ मनमाने ढंग से नंबर योजना की जरूरत है.

801
00:50:45,120 --> 00:50:50,580
तो चलो बस कहना है, संयोग से, कि इस स्मृति पता 123, 124 है.

802
00:50:50,580 --> 00:50:55,660
चलो बस का कहना है कि यह 125 है, यह 126 है, और बहुत आगे है, लेकिन यह है कि पूरी तरह से मनमाना है.

803
00:50:55,660 --> 00:50:58,590
हम सिर्फ मेरी स्मृति में कुछ नंबर योजना की जरूरत है.

804
00:50:58,590 --> 00:51:04,030
तो अब जब मैं वास्तव में एक्स और वाई में गुजरती हैं, मैं एक्स और वाई में पारित करने के लिए नहीं जा रहा हूँ;

805
00:51:04,030 --> 00:51:08,400
मैं x और y के डाक पते में इतनी बात करने के लिए, पारित करने के लिए जा रहा हूँ

806
00:51:08,400 --> 00:51:11,870
तो क्या हो जाता है यहाँ और यहाँ संग्रहीत 1 और 2 नहीं है कि,

807
00:51:11,870 --> 00:51:16,030
लेकिन अगर आप अपने छोटे पाठ देख सकते हैं, यहाँ और यहाँ में पारित हो जाता है?

808
00:51:16,030 --> 00:51:23,340
[अश्राव्य छात्र प्रतिक्रिया] वास्तव में. >> 123 यहाँ डाल दिया जाता है और 124 यहाँ डाल दिया जाता है.

809
00:51:23,340 --> 00:51:28,910
>> अब, क्योंकि मैं यह बहुत पहले लाइन अप यहाँ रास्ते में शीर्ष पर स्टार का उपयोग किया है,

810
00:51:28,910 --> 00:51:34,340
मेरे कार्यक्रम बस है कि 123 और 124 जानता है, भले ही वे स्पष्ट रूप से कर रहे हैं integers

811
00:51:34,340 --> 00:51:40,160
कि किसी भी मानव नोटिस सकता है, वे पते, संख्यात्मक पते के रूप में व्याख्या की जानी चाहिए.

812
00:51:40,160 --> 00:51:43,250
वे में और खुद को ints नहीं हैं, वे पते हो,

813
00:51:43,250 --> 00:51:46,120
और है कि क्योंकि मैं स्पष्ट रूप से सितारों वहाँ डाल दिया.

814
00:51:46,120 --> 00:51:51,360
तो अब मेरे वास्तविक कोड है कि यहाँ क्या होता है की 1, 2, और 3 लाइन में?

815
00:51:51,360 --> 00:51:53,380
चलो चित्र के बाकी आकर्षित.

816
00:51:53,380 --> 00:51:56,980
Tmp की तरह है यह सोमवार को किया गया था. Tmp के बारे में कुछ खास नहीं है.

817
00:51:56,980 --> 00:52:03,060
यह सिर्फ एक स्थानीय 32 बिट परिवर्तनशील है, और के अंदर है कि मैं जाहिरा तौर पर * एक के मूल्य भंडारण हूँ.

818
00:52:03,060 --> 00:52:08,580
अब, अगर मैं सिर्फ इतना कहा tmp = एक, मैं यहाँ क्या रखा जाएगा? >> [छात्र] 123.

819
00:52:08,580 --> 00:52:10,370
123. लेकिन नहीं है कि मैं क्या कर रहा हूँ.

820
00:52:10,370 --> 00:52:13,670
मैं कह रहा हूँ tmp = * एक. स्टार का मतलब है वहाँ जाओ.

821
00:52:13,670 --> 00:52:19,370
तो यहाँ एक है, 123. मैं वहाँ कैसे जाना है? नाटक की तरह एक तीर है.

822
00:52:19,370 --> 00:52:24,460
खैर, यह है, 1. तो tmp में जमा हो जाता है, जाहिरा तौर पर? बस 1.

823
00:52:24,460 --> 00:52:29,620
तो दूसरे शब्दों में, tmp * एक * एक साधन है पता है कि एक वर्तमान में है,

824
00:52:29,620 --> 00:52:31,320
जो कि जाहिरा तौर पर 123 है.

825
00:52:31,320 --> 00:52:33,910
>> ठीक है, यहाँ हम 123 स्थान पर हैं, मैं 1 संख्या देखते हैं,

826
00:52:33,910 --> 00:52:35,670
तो मैं 1 संख्या वहाँ रखा जा रहा हूँ.

827
00:52:35,670 --> 00:52:39,020
अब मैं क्या 2 लाइन में करते हैं, * एक = ख *?

828
00:52:39,020 --> 00:52:44,570
यह एक एक छोटे से अधिक शामिल है, क्योंकि अब एक क्या है? यह 123 है.

829
00:52:44,570 --> 00:52:50,220
तो * एक कहाँ है? सही है, जहां मैं पहले था. तो वहाँ जाओ. ठीक है.

830
00:52:50,220 --> 00:52:53,420
अब, अंत में, और फिर अंत में यह समझ बनाने के लिए शुरू करने के लिए, उम्मीद है,

831
00:52:53,420 --> 00:53:00,280
* ख मतलब क्या ख में है? 124. तो मुझे वहाँ जाने की जरूरत है, जो 2 है.

832
00:53:00,280 --> 00:53:03,430
तो क्या मैं कहाँ रखा है?

833
00:53:03,430 --> 00:53:10,100
2 यहाँ में चला जाता है, क्योंकि * ख * एक में चला जाता है. तो मैं ऐसा करूँगा.

834
00:53:10,100 --> 00:53:13,120
और आप पहले से ही देखते हैं, शायद कर सकते हैं, कि हम इतना करीब हो

835
00:53:13,120 --> 00:53:17,710
इस बेवकूफ, सरल समस्या को हल करने के लिए पहली बार के लिए सही ढंग से

836
00:53:17,710 --> 00:53:20,920
क्योंकि अब हम अभी भी एक्स क्या था की एक याद है,

837
00:53:20,920 --> 00:53:23,230
हम 2 प्रतियां है, वैसे y के,

838
00:53:23,230 --> 00:53:25,850
लेकिन अब लाइन 3 * ख कहते हैं.

839
00:53:25,850 --> 00:53:31,080
तो यहाँ ख है. * ख का मतलब है वहाँ जाओ. इसलिए जहां स्थान 124 है?

840
00:53:31,080 --> 00:53:35,560
जाहिरा तौर पर यह यहाँ है. तो मैं यहाँ क्या रखा है? जाहिर है, tmp.

841
00:53:35,560 --> 00:53:39,600
तो अब मैं यह कर. इसलिए मैं यहाँ 1 और 2 यहाँ है.

842
00:53:39,600 --> 00:53:43,560
और अब क्या यह सब, 123, 124, और 1 के बारे में?

843
00:53:43,560 --> 00:53:47,910
के रूप में जल्द ही स्वैप रिटर्न के रूप में, इस स्मृति के रूप में अच्छा के रूप में खो दिया है

844
00:53:47,910 --> 00:53:51,070
क्योंकि स्वैप रिटर्न, ऑपरेटिंग सिस्टम के रूप में के रूप में जल्द ही

845
00:53:51,070 --> 00:53:54,190
भविष्य में उस स्मृति को फिर से उपयोग करने के लिए स्वतंत्र है.

846
00:53:54,190 --> 00:53:58,870
चारों ओर केवल इस तथाकथित ढेर के नीचे मुख्य स्मृति चिपक जाती है.

847
00:53:58,870 --> 00:54:01,470
>> और इसलिए हम अंत में अब एक काम संस्करण है.

848
00:54:01,470 --> 00:54:06,310
मुझे swap.c में जाओ, और निम्नलिखित नोटिस.

849
00:54:06,310 --> 00:54:11,280
कार्यक्रम के शीर्ष पर मैं अपने प्रोटोटाइप के लिए बदल दिया है int * एक और int * ख.

850
00:54:11,280 --> 00:54:15,000
केवल एक चीज मैं से हरे रंग लाल, जो बुरा था, जो अच्छा है जाने बदल तो,

851
00:54:15,000 --> 00:54:17,350
मैं आज इन सितारों जोड़ा.

852
00:54:17,350 --> 00:54:21,520
लेकिन फिर नीचे में यहाँ ही स्वैप मैं नकल करने के लिए किया था, पेस्ट क्या स्लाइड पर बस गया था.

853
00:54:21,520 --> 00:54:24,140
यहाँ सितारा, मैं यहाँ एक सितारा है कि प्रोटोटाइप से मेल खाता है -

854
00:54:24,140 --> 00:54:27,930
और फिर इन सब बातों के अब tmp के अलावा तारों है

855
00:54:27,930 --> 00:54:30,680
एक अस्थायी चर का उपयोग करें, क्योंकि वहाँ कोई नई बात नहीं है.

856
00:54:30,680 --> 00:54:33,040
मैं सिर्फ एक int के लिए अस्थायी भंडारण की जरूरत है.

857
00:54:33,040 --> 00:54:34,820
तो हम वहाँ एक स्टार की जरूरत नहीं है.

858
00:54:34,820 --> 00:54:39,310
हम सिर्फ स्टार की जरूरत है ताकि हम मनमाने ढंग से सीमा के इस तरह पार कर सकते हैं

859
00:54:39,310 --> 00:54:42,900
अपने कंप्यूटर की स्मृति में इन 2 फ्रेम के बीच.

860
00:54:42,900 --> 00:54:45,630
लेकिन एक आखिरी बात करने के लिए बदल गया है, और आप इसे झलक है हो सकता है पहले से ही है.

861
00:54:45,630 --> 00:54:48,810
क्या दूसरी लाइन अब स्पष्ट रूप से अलग है? >> [छात्र] और एक्स.

862
00:54:48,810 --> 00:54:53,270
>> हाँ, इतना 25 कोड की अंतिम पंक्ति मैं इस के लिए बदलने के काम करने की जरूरत है.

863
00:54:53,270 --> 00:54:58,360
एक सप्ताह पहले और यहां तक ​​कि सोमवार को 25 रेखा इस तरह देखा, एक्स और वाई स्वैप

864
00:54:58,360 --> 00:55:02,020
और यह सिर्फ टूट गया था क्योंकि अगर आप कहते हैं कि स्वैप (एक्स, वाई)

865
00:55:02,020 --> 00:55:05,660
एक्स और वाई की प्रतियां को स्वैप करने के लिए दे रहे हैं, तो अपनी बात कर रहा है,

866
00:55:05,660 --> 00:55:09,080
लेकिन आप वास्तव में एक्स और y ही कभी नहीं बदल रहे हैं.

867
00:55:09,080 --> 00:55:12,880
तो भी अगर आप कोड में एम्परसेंड के साथ इस चरित्र कभी नहीं देखा है पहले,

868
00:55:12,880 --> 00:55:15,860
बस एक अनुमान ले. एम्परसेंड क्या करता है, जाहिरा तौर पर करते हैं?

869
00:55:15,860 --> 00:55:17,890
[छात्र] पते लेता है. >> पते लेता है.

870
00:55:17,890 --> 00:55:21,160
तो एम्परसेंड कह रहा है मुझे एक्स के पते दे.

871
00:55:21,160 --> 00:55:25,590
कौन जानता है कि वह कहाँ है? यह 123 होना होता है. मुझे परवाह नहीं है. बस मुझे एक्स के पते दे.

872
00:55:25,590 --> 00:55:28,340
और y मुझे y के पते दे मतलब है.

873
00:55:28,340 --> 00:55:34,450
और कहानी पूरी तरह से चित्र के साथ संगत है कि बिंदु पर हम एक पल पहले आकर्षित किया.

874
00:55:34,450 --> 00:55:38,310
>> तो मैं संकेत मानता है, निश्चित रूप से मेरे लिए, जब मैं पहली बार इस सीखने शुरू कर दिया है,

875
00:55:38,310 --> 00:55:40,570
निश्चित रूप से मुश्किल बातें मेरे मन के चारों ओर लपेट में से एक थे.

876
00:55:40,570 --> 00:55:43,760
लेकिन एहसास है, खासकर के रूप में हम इन चीजों की तरह साथ खेलते रहना,

877
00:55:43,760 --> 00:55:48,030
अगर आप इन सुपर सरल प्रकार के लिए नीचे तोड़ने के बौद्धिक समस्याओं शुष्क

878
00:55:48,030 --> 00:55:52,270
सिर्फ संख्या के आसपास चलती है, संकेत के साथ भ्रम की एक बहुत कुछ करने के लिए जवाब

879
00:55:52,270 --> 00:55:56,590
वास्तव में ये बहुत बुनियादी यांत्रिकी से प्राप्त किया जा सकता है.

880
00:55:56,590 --> 00:55:59,070
यहाँ एक पता है. स्टार के साथ वहाँ जाओ.

881
00:55:59,070 --> 00:56:03,830
या इसके विपरीत, यहाँ एक एम्परसेंड है. चित्रा बाहर वास्तव में क्या पता है.

882
00:56:03,830 --> 00:56:06,270
सही सभी.

883
00:56:06,270 --> 00:56:09,000
तो इस स्मृति के सभी कहाँ से आ रहा है?

884
00:56:09,000 --> 00:56:12,360
हम समय की एक जोड़ी इस तस्वीर तैयार की है, और मैं वादा रखने के लिए हम इसे वापस करने के लिए आया हूँ,

885
00:56:12,360 --> 00:56:14,920
लेकिन यहाँ अपने कंप्यूटर की स्मृति का प्रतिनिधित्व है

886
00:56:14,920 --> 00:56:17,420
कि एक छोटे से हमारे चॉकबोर्ड से लेबल यहाँ और अधिक है.

887
00:56:17,420 --> 00:56:21,590
अपने कार्यक्रम के लिए सम्मान के साथ शीर्ष पर पाठ खंड का प्रतिनिधित्व करता है?

888
00:56:21,590 --> 00:56:26,090
[अश्राव्य छात्र प्रतिक्रिया] क्षमा करें? >> फिर से कहो.

889
00:56:26,090 --> 00:56:28,660
[छात्र] वास्तविक कार्यक्रम. >> वास्तविक कार्यक्रम.

890
00:56:28,660 --> 00:56:32,430
>> तो 0s और 1s कि आप सी कोड लिखने के बाद संकलित किया है और फिर चल बजना

891
00:56:32,430 --> 00:56:35,910
और 0s और 1s समाप्त होता है वहाँ स्मृति में tucked हो रही है

892
00:56:35,910 --> 00:56:38,570
क्योंकि जब आप डबल अपने मैक या पीसी पर एक आइकन पर क्लिक करें

893
00:56:38,570 --> 00:56:43,010
या आपके शीघ्र मारियो की तरह एक कमांड चलाने के लिए, अपने 0s और 1s डिस्क से

894
00:56:43,010 --> 00:56:45,700
स्मृति में लोड इतना है कि कंप्यूटर उन्हें हेरफेर कर सकते

895
00:56:45,700 --> 00:56:47,540
और उन्हें और अधिक जल्दी निष्पादित.

896
00:56:47,540 --> 00:56:50,880
तो initialized डेटा और uninitialized डेटा, हम उन लोगों के बारे में बात नहीं होगा,

897
00:56:50,880 --> 00:56:52,420
लेकिन उन सिर्फ वैश्विक चर रहे हैं.

898
00:56:52,420 --> 00:56:54,710
प्रारंभिकीकरण वैश्विक चर का मतलब है कि आप मूल्यों को दे दिया है;

899
00:56:54,710 --> 00:56:59,300
uninitialized वैश्विक चर का मतलब है कि आपने अभी तक मूल्यों को नहीं दिया था.

900
00:56:59,300 --> 00:57:01,900
तो फिर वहाँ इन वातावरण चर जो मैं पूरी तरह से मेरे हाथ की लहर है,

901
00:57:01,900 --> 00:57:04,860
लेकिन वे वहाँ हैं और है कि अपने उपयोगकर्ता नाम की तरह दुकानों बातें

902
00:57:04,860 --> 00:57:08,090
और निचले स्तर के विवरण के अन्य प्रकार.

903
00:57:08,090 --> 00:57:12,880
लेकिन अपने स्मृति लेआउट के juiciest टुकड़े इस बात ढेर और ढेर कहा जाता है.

904
00:57:12,880 --> 00:57:17,470
फिर ढेर करने के लिए स्पष्ट हो, स्मृति है कि जब भी कार्य कहा जाता है प्रयोग किया जाता है,

905
00:57:17,470 --> 00:57:19,710
जब वहाँ स्थानीय चर

906
00:57:19,710 --> 00:57:22,120
और वहाँ मानकों जब भी आसपास हैं पारित किया जा रहा है.

907
00:57:22,120 --> 00:57:24,490
कि सब के सब ढेर में होता है.

908
00:57:24,490 --> 00:57:29,570
ढेर के बारे में हम बात नहीं की है, लेकिन एक अनुमान है जो ढेर का उपयोग करता है.

909
00:57:31,120 --> 00:57:32,690
बस स्मृति का एक अलग हिस्सा है.

910
00:57:32,690 --> 00:57:36,620
यह यहाँ शीर्ष पर तैयार किया जाना होता है, लेकिन है कि एक मनमाना सचित्र सम्मेलन है.

911
00:57:36,620 --> 00:57:41,670
कौन ढेर से जाहिरा तौर पर किया गया है सप्ताह के लिए स्मृति का उपयोग कर रहे हैं?

912
00:57:41,670 --> 00:57:44,830
यह तकनीकी रूप से है, लेकिन आप परोक्ष रूप से. >> [छात्र] GetString.

913
00:57:44,830 --> 00:57:47,950
GetString और malloc. तो यहाँ बुनियादी फर्क है.

914
00:57:47,950 --> 00:57:51,300
>> पिछले कुछ हफ्तों के लिए आप जानते हैं कि अगर आप स्मृति की जरूरत है, बस एक चर घोषणा.

915
00:57:51,300 --> 00:57:54,560
यदि आप स्मृति की बहुत जरूरत है, तो एक सही अपने कार्य के अंदर सरणी की घोषणा.

916
00:57:54,560 --> 00:57:59,620
लेकिन समस्या है जिसका हम सामना कर रखा है अगर आप चर स्थानीय कार्यों की अंदर की घोषणा,

917
00:57:59,620 --> 00:58:05,340
के रूप में जल्द ही समारोह रिटर्न के रूप में, स्मृति और उन चर क्या होता है?

918
00:58:05,340 --> 00:58:09,620
बस यह की तरह नहीं रह गया है तुम्हारा, है ना? यह धारणात्मक की तरह गायब हो जाता है.

919
00:58:09,620 --> 00:58:13,950
यह अभी भी शारीरिक रूप से वहाँ है, जाहिर है, लेकिन यह अब अपने उपयोग करने का अधिकार है.

920
00:58:13,950 --> 00:58:17,160
यह स्पष्ट रूप से समस्याग्रस्त है अगर आप जीवन में कार्य लिखने के लिए चाहते हैं

921
00:58:17,160 --> 00:58:20,440
कि वास्तव में स्मृति आवंटित और वापस दे इसे तुरंत नहीं.

922
00:58:20,440 --> 00:58:24,180
बिन्दु में प्रकरण: जीवन में है GetString उद्देश्य के लिए अग्रिम में कोई विचार है

923
00:58:24,180 --> 00:58:26,390
कैसे मैं कीबोर्ड पर टाइप करने के लिए जा रहा हूँ एक स्ट्रिंग के बड़े,

924
00:58:26,390 --> 00:58:30,390
लेकिन यह स्मृति आवंटित दाऊद या नमस्ते पकड़ करने में सक्षम हो गया है

925
00:58:30,390 --> 00:58:32,860
या एक पूरी निबंध कि उपयोगकर्ता अंदर टाइप किया सकता है

926
00:58:32,860 --> 00:58:35,280
तो GetString malloc का उपयोग किया गया.

927
00:58:35,280 --> 00:58:38,910
Malloc इसलिए ढेर नहीं का उपयोग किया जाना चाहिए;

928
00:58:38,910 --> 00:58:40,770
बजाय यह इस बात ढेर कहा जाता है का उपयोग कर रहा है.

929
00:58:40,770 --> 00:58:44,430
स्मृति के बारे में अलग कुछ नहीं है. यह तेजी से धीमी है या नहीं या ऐसा कुछ है.

930
00:58:44,430 --> 00:58:46,570
यह एक अलग स्थान में सिर्फ शारीरिक रूप से है.

931
00:58:46,570 --> 00:58:50,120
>> लेकिन नियम है कि स्मृति कि ढेर पर आवंटित है

932
00:58:50,120 --> 00:58:56,180
कभी नहीं लिया जाएगा आप से दूर जब तक आप कहते हैं - एक अनुमान ले - मुक्त.

933
00:58:56,180 --> 00:59:00,510
इसके विपरीत करके, किसी भी स्मृति आप सिर्फ एक सरणी की घोषणा के द्वारा ढेर पर के लिए पूछना

934
00:59:00,510 --> 00:59:03,320
या एक चर घोषित करने जैसे हम सप्ताह के लिए कर दिया गया है,

935
00:59:03,320 --> 00:59:05,640
जो मूलभूत रूप से ढेर पर समाप्त होता है.

936
00:59:05,640 --> 00:59:09,550
और उस समय के 90% काम करता है, लेकिन उन दुर्लभ अवसरों पर

937
00:59:09,550 --> 00:59:12,470
जहाँ आप के लिए स्मृति आवंटित करने के लिए और इसे रखने के आसपास चाहते हैं,

938
00:59:12,470 --> 00:59:14,730
तो आप malloc तरह एक समारोह का उपयोग करने की आवश्यकता है.

939
00:59:14,730 --> 00:59:19,370
या हम GetString, जो बारी में malloc का उपयोग करता है जैसे एक समारोह का इस्तेमाल किया.

940
00:59:19,370 --> 00:59:23,300
चलो देखते हैं जहां यह नीचे तोड़ने के लिए और फिर हो सकता Binky पर एक तिरछी नज़र रखना.

941
00:59:23,300 --> 00:59:25,820
हम भविष्य में वापस कि करने के लिए आया हूँ.

942
00:59:25,820 --> 00:59:29,270
यहाँ एक सुपर सरल कार्यक्रम है कि पहले 2 लाइनों में क्या करता है?

943
00:59:29,270 --> 00:59:33,460
अंग्रेजी में, कोड के इन पहले 2 लाइनों के अंदर क्या करते हो के मुख्य?

944
00:59:33,460 --> 00:59:35,600
[अश्राव्य छात्र प्रतिक्रिया]

945
00:59:35,600 --> 00:59:37,880
सावधान. यह मेरे एक्स या वाई के पते देना नहीं है.

946
00:59:37,880 --> 00:59:41,840
[छात्र] ints के लिए संकेत देता है. >> अच्छा है. मुझे पूर्णांकों 2 संकेत दे.

947
00:59:41,840 --> 00:59:45,130
दूसरे शब्दों में, मुझे स्मृति के 2 हिस्सा है कि मैं आज ड्राइंग रखने देने के लिए,

948
00:59:45,130 --> 00:59:46,950
हालांकि मैं इसे अब वर्गों के रूप में काट दिया था.

949
00:59:46,950 --> 00:59:50,000
मुझे स्मृति के 2 विखंडू दे, एक एक्स कहा जाता है, एक y कहा जाता है -

950
00:59:50,000 --> 00:59:54,320
पहले मैं उन्हें एस और टी कहा जाता है - और स्मृति की है कि हिस्सा के प्रकार क्या है?

951
00:59:54,320 --> 00:59:57,160
यह एक पते की दुकान करने के लिए जा रहा है.

952
00:59:57,160 --> 00:59:59,110
यह int * प्रकार की है.

953
00:59:59,110 --> 01:00:01,630
>> तो एक int के पते अंततः x में रहते हैं,

954
01:00:01,630 --> 01:00:03,860
एक int के पते के अंत में y में रहते हैं,

955
01:00:03,860 --> 01:00:08,460
लेकिन शुरू में एक्स और वाई के अंदर क्या है? कौन जानता है? कचरा मान.

956
01:00:08,460 --> 01:00:10,180
यह संकेत के साथ कोई लेना - देना नहीं है.

957
01:00:10,180 --> 01:00:12,720
यदि हम वहाँ कुछ है, जो जानता है कि क्या वास्तव में वहाँ है नहीं डाल दिया है?

958
01:00:12,720 --> 01:00:18,950
अब एक्स. यहाँ क्या होता है? अब यह कानूनी है क्योंकि x एक सूचक है. यह एक int * है.

959
01:00:18,950 --> 01:00:21,870
तो इसका मतलब है कि मैं एक्स में स्मृति में से कुछ हिस्सा का पता लगा सकते हैं.

960
01:00:21,870 --> 01:00:25,120
Malloc क्या वापस नहीं करता है? बिल्कुल सही, यह पते देता है,

961
01:00:25,120 --> 01:00:28,510
स्मृति की एक पूरी हिस्सा में पहली बाइट के पते.

962
01:00:28,510 --> 01:00:31,140
कितने बाइट जाहिरा तौर पर इस उदाहरण के लिए आवंटन, उपकरण में?

963
01:00:31,140 --> 01:00:33,510
एक int के आकार क्या है? 4.

964
01:00:33,510 --> 01:00:36,600
यदि आप एक सप्ताह के लिए वापस लगता है, यह सुपर महत्वपूर्ण नहीं है हमेशा याद रखें कि,

965
01:00:36,600 --> 01:00:38,870
लेकिन इस मामले में यह पता करने के लिए उपयोगी है, 4 बाइट्स.

966
01:00:38,870 --> 01:00:41,770
तो यह ढेर 4 बाइट्स पर आवंटन है

967
01:00:41,770 --> 01:00:46,110
और यह मेरे लिए पहले एक का पता मनमाने ढंग से वापस लौट रही है.

968
01:00:46,110 --> 01:00:47,700
अब, एक्स क्या कर रहा है?

969
01:00:47,700 --> 01:00:52,200
एक * x 42 = क्या कर रहा है?

970
01:00:52,200 --> 01:00:57,150
यदि कहानी में इस बिंदु पर हम एक्स, जो कुछ कचरा मूल्य के साथ इस तरह दिखता है,

971
01:00:57,150 --> 01:01:04,120
अब यह कुछ कचरा मूल्य के साथ y, 3 लाइन में अब मैं 4 बाइट्स आवंटित है.

972
01:01:04,120 --> 01:01:06,950
इस तस्वीर को अनिवार्य रूप से इस तरह दिखता है.

973
01:01:06,950 --> 01:01:12,010
या अधिक विशेष रूप से, अगर यह मनमाना 123 पता है, यह है कि क्या हमारी कहानी अब की तरह दिखता है.

974
01:01:12,010 --> 01:01:23,940
* X 42 = अब क्या मतलब है? इसका मतलब है कि पते 123 जाओ और संख्या 42 वहाँ डाल दिया.

975
01:01:23,940 --> 01:01:26,220
मैं इन लाइनों आकर्षित करने की जरूरत नहीं है क्योंकि हम तार नहीं कर रहे हैं.

976
01:01:26,220 --> 01:01:29,480
>> मैं सिर्फ इस तरह करना चाहिए यह लिखा है, और सिर्फ प्रदर्शन खातिर,

977
01:01:29,480 --> 01:01:33,240
42 एक int तरह के रूप में अंतरिक्ष के एक बहुत लेता है, 4 बाइट्स.

978
01:01:33,240 --> 01:01:35,960
तो है कि वहाँ क्या हुआ है, लेकिन अब वहाँ एक समस्या है.

979
01:01:35,960 --> 01:01:40,580
* Y = 13. यहाँ क्या होने जा रहा है?

980
01:01:40,580 --> 01:01:46,470
समस्या * y हमारे सरलीकृत दुनिया में है बस का अर्थ है y में पता करने के लिए जाना है.

981
01:01:46,470 --> 01:01:48,590
Y में क्या है? यह कुछ कचरा मान है.

982
01:01:48,590 --> 01:01:53,150
तो चलो मान लेते हैं कि कि कचरा मूल्य 5551212 है, ऐसा कुछ पागल.

983
01:01:53,150 --> 01:01:56,750
* Y मतलब के लिए 5551212 को संबोधित जाओ.

984
01:01:56,750 --> 01:02:00,450
कि यहाँ की तरह है. यह उदाहरण के लिए मौजूद नहीं है.

985
01:02:00,450 --> 01:02:05,310
तो * y 13 का मतलब है मैं 13 यहाँ आकर्षित करने की कोशिश कर रहा हूँ हो जाता है. यह अस्तित्व में नहीं है.

986
01:02:05,310 --> 01:02:08,790
मैं ब्लैकबोर्ड के खंड को पार कर लिया है. मुझे क्या मिलेगा?

987
01:02:08,790 --> 01:02:14,930
क्योंकि मैं स्मृति में डालने की कोशिश कर रहा हूँ कि गुप्त संदेश में विभाजन गलती

988
01:02:14,930 --> 01:02:19,470
एक जगह है कि अस्तित्व में नहीं है पर 13 की तरह एक मूल्य.

989
01:02:19,470 --> 01:02:23,900
इस कार्यक्रम के बाकी ठीक है, लेकिन उस बिंदु यह नहीं है जब तक काम कर सकते हैं.

990
01:02:23,900 --> 01:02:25,350
तो चलो इस कहानी बताने की कोशिश.

991
01:02:25,350 --> 01:02:27,830
हम वापस एक बार हम हेक्स के बारे में बात की है कि करने के लिए आया हूँ.

992
01:02:27,830 --> 01:02:30,290
चलो यह करने के लिए वापस जाने और इस Binky बुलाया बात के साथ समाप्त

993
01:02:30,290 --> 01:02:33,710
याद जो एक स्टैनफोर्ड प्रोफेसर के घर पर बैठे claymation साथ खेल है,

994
01:02:33,710 --> 01:02:36,380
वास्तव में है कि एक ही कार्यक्रम की कहानी बताओ.

995
01:02:36,380 --> 01:02:40,580
यह बस के बारे में 3 मिनट तक. यहाँ हम Binky है.

996
01:02:40,580 --> 01:02:45,030
[वीडियो पर पुरुष वक्ता] हे Binky, उठो. यह सूचक मज़ा के लिए समय है.

997
01:02:45,030 --> 01:02:50,080
[Binky] वह क्या है? संकेत के बारे में जानें? ओह, वाह!

998
01:02:50,080 --> 01:02:53,700
[पुरुष वक्ता खैर, शुरू करने के लिए, मुझे लगता है कि हम एक जोड़े संकेत की जरूरत के लिए जा रहे हैं.

999
01:02:53,700 --> 01:02:57,890
>> [Binky] ठीक है. यह कोड 2 संकेत जो integers के लिए बात कर सकते हैं आवंटित.

1000
01:02:57,890 --> 01:03:02,220
[पुरुष वक्ता] ठीक है. खैर, मैं 2 संकेत देखते हैं, लेकिन वे कुछ भी करने के लिए ओर इशारा करते हो ऐसा नहीं लगता.

1001
01:03:02,220 --> 01:03:05,550
[Binky] यह सही है. प्रारंभ में, संकेत कुछ भी करने के लिए बात नहीं है.

1002
01:03:05,550 --> 01:03:09,270
बातें वे करने के लिए बिंदु pointees कहा जाता है, और उन्हें स्थापित करने में एक अलग कदम है.

1003
01:03:09,270 --> 01:03:12,330
[पुरुष वक्ता ओह, सही, सही है. मुझे पता था. pointees अलग हैं.

1004
01:03:12,330 --> 01:03:15,630
एर, तो आप कैसे एक pointee आवंटित?

1005
01:03:15,630 --> 01:03:21,510
[Binky] ठीक है. इस कोड को एक नई पूर्णांक pointee आबंटित करता है, और इस भाग x यह करने के लिए बात करने के लिए सेट है.

1006
01:03:21,510 --> 01:03:23,500
[पुरुष वक्ता] हे, कि बेहतर लग रहा है.

1007
01:03:23,500 --> 01:03:26,030
तो इसे बनाने के लिए कुछ करना है. >> [Binky] ठीक है.

1008
01:03:26,030 --> 01:03:30,300
मैं सूचक x भिन्नता अपने pointee में 42 नंबर की दुकान.

1009
01:03:30,300 --> 01:03:34,410
इस चाल के लिए मैं अपने dereferencing के जादू की छड़ी की आवश्यकता होगी.

1010
01:03:34,410 --> 01:03:38,610
[पुरुष वक्ता] अपने अपसंदर्भन के जादू की छड़ी? यह बहुत अच्छा है.

1011
01:03:38,610 --> 01:03:44,230
[Binky] इस कोड की तरह दिखता है. मैं सिर्फ संख्या निर्धारित करेंगे और ... [ध्वनि popping]

1012
01:03:44,230 --> 01:03:46,100
[पुरुष वक्ता] हे, देखो, यह हो जाता है.

1013
01:03:46,100 --> 01:03:50,990
तो एक्स पर एक भिन्नता कर तीर अपने pointee का उपयोग करने के लिए इस प्रकार है,

1014
01:03:50,990 --> 01:03:53,230
इस मामले में 42 स्टोर करने के लिए.

1015
01:03:53,230 --> 01:03:57,630
अरे, यह अन्य सूचक, y के माध्यम से 13 नंबर की दुकान का उपयोग करने के लिए प्रयास करें.

1016
01:03:57,630 --> 01:04:03,250
[Binky] ठीक है. मैं बस यहाँ जाऊँगा y करने के लिए और 13 नंबर की स्थापना की

1017
01:04:03,250 --> 01:04:08,360
और तो dereferencing और बस की छड़ी ले ... [आवाज गूंज] वाह!

1018
01:04:08,360 --> 01:04:10,980
[पुरुष वक्ता] हे हे, कि काम नहीं किया.

1019
01:04:10,980 --> 01:04:14,870
>> कहो, Binky, मुझे नहीं लगता कि y अपसंदर्भन एक अच्छा विचार है

1020
01:04:14,870 --> 01:04:17,880
क्योंकि ऊपर pointee की स्थापना के लिए एक अलग कदम है

1021
01:04:17,880 --> 01:04:19,850
और मुझे नहीं लगता कि हम कभी भी यह किया है.

1022
01:04:19,850 --> 01:04:21,770
[Binky] हम्म, अच्छी बात है.

1023
01:04:21,770 --> 01:04:26,640
[पुरुष वक्ता] हाँ. हम सूचक y आवंटित लेकिन हम सेट एक pointee की बात यह कभी नहीं.

1024
01:04:26,640 --> 01:04:28,780
[Binky] हम्म, बहुत चौकस है.

1025
01:04:28,780 --> 01:04:30,690
[पुरुष वक्ता अरे, आप अच्छा देख रहे हैं वहाँ, Binky.

1026
01:04:30,690 --> 01:04:34,160
आप इसे ठीक कर सकते हैं इतना है कि एक्स के रूप में एक ही pointee y अंक? >> [Binky] ज़रूर.

1027
01:04:34,160 --> 01:04:37,100
मैं अपने सूचक काम के जादू की छड़ी का उपयोग करेंगे.

1028
01:04:37,100 --> 01:04:39,070
[पुरुष वक्ता] है कि पहले की तरह एक समस्या हो रहा है?

1029
01:04:39,070 --> 01:04:40,840
[Binky] नहीं, इस pointees स्पर्श नहीं करता है.

1030
01:04:40,840 --> 01:04:44,780
यह सिर्फ एक सूचक परिवर्तन करने के लिए एक के रूप में एक ही बात करने के लिए बात है. [ध्वनि popping]

1031
01:04:44,780 --> 01:04:48,570
[पुरुष वक्ता] ओह, मैं देख रहा हूँ. अब एक्स के रूप में एक ही जगह के लिए y अंक.

1032
01:04:48,570 --> 01:04:51,140
तो इंतजार. अब y तय हो गई है. यह एक pointee है.

1033
01:04:51,140 --> 01:04:54,520
तो तुम फिर dereferencing 13 पर भेजने की छड़ी की कोशिश कर सकते हैं.

1034
01:04:54,520 --> 01:04:58,130
[Binky] उह, ठीक है. यहाँ जाता है. [ध्वनि popping]

1035
01:04:58,130 --> 01:05:01,250
[पुरुष वक्ता] अरे, कि देखो. अब अपसंदर्भन y पर काम करता है.

1036
01:05:01,250 --> 01:05:05,200
और क्योंकि संकेत है कि एक pointee साझा कर रहे हैं, वे दोनों 13 देखते हैं.

1037
01:05:05,200 --> 01:05:06,910
[Binky] हाँ, साझा. जो भी हो.

1038
01:05:06,910 --> 01:05:08,880
>> तो हम स्थानों अब स्विच करने के लिए जा रहे हैं?

1039
01:05:08,880 --> 01:05:11,420
[पुरुष वक्ता] ओह, देखो, हम समय से बाहर रहे. >> [Binky] लेकिन -

1040
01:05:11,420 --> 01:05:13,880
[पुरुष वक्ता] बस 3 सूचक नियमों को याद रखें.

1041
01:05:13,880 --> 01:05:18,630
नंबर 1, बुनियादी संरचना है कि आप एक सूचक है और यह एक pointee अधिक अंक.

1042
01:05:18,630 --> 01:05:23,120
लेकिन सूचक और pointee अलग कर रहे हैं, और आम त्रुटि के लिए एक सूचक है

1043
01:05:23,120 --> 01:05:25,680
लेकिन यह एक pointee देना भूल जाते हैं.

1044
01:05:25,680 --> 01:05:29,580
नंबर 2, सूचक dereferencing सूचक में शुरू होता है और अधिक से अधिक अपने तीर के बाद

1045
01:05:29,580 --> 01:05:31,060
अपने pointee का उपयोग.

1046
01:05:31,060 --> 01:05:34,340
जैसा कि हम जानते हैं कि सभी, यह केवल काम करता है अगर वहाँ एक pointee है,

1047
01:05:34,340 --> 01:05:36,460
जो की तरह वापस हो जाता है के लिए नंबर 1 पर राज.

1048
01:05:36,460 --> 01:05:39,870
नंबर 3, सूचक काम एक सूचक लेता है और यह परिवर्तन

1049
01:05:39,870 --> 01:05:42,390
एक और सूचक के रूप में एक ही pointee बात.

1050
01:05:42,390 --> 01:05:45,890
तो असाइनमेंट के बाद, 2 संकेत pointee ही बात करेंगे.

1051
01:05:45,890 --> 01:05:47,800
कभी कभी कि साझा कहा जाता है.

1052
01:05:47,800 --> 01:05:50,910
>> और कहा कि सब वहाँ यह सच है. अब अलविदा.

1053
01:05:50,910 --> 01:05:55,840
यह Binky है. यह CS50 है. हम अगले सप्ताह आप देखेंगे. [वाहवाही]

1054
01:05:55,840 --> 01:05:59,000
>> [CS50.TV]