1
00:00:00,000 --> 00:00:06,030
>> [संगीत बजाना]

2
00:00:06,030 --> 00:00:08,390
>> डौग लॉयड: सूचक है, यहाँ हम कर रहे हैं।

3
00:00:08,390 --> 00:00:11,080
यह शायद करने के लिए जा रहा है
सबसे कठिन विषय हो

4
00:00:11,080 --> 00:00:12,840
हम CS50 में के बारे में बात करते हैं।

5
00:00:12,840 --> 00:00:15,060
और अगर आप पढ़ा है
संकेत के बारे में कुछ भी

6
00:00:15,060 --> 00:00:19,080
आप एक छोटा सा हो सकता से पहले
डरा देता है इस वीडियो में जा रहा है।

7
00:00:19,080 --> 00:00:21,260
यह संकेत सच है
आप की क्षमता की अनुमति नहीं

8
00:00:21,260 --> 00:00:23,740
शायद पेंच
बहुत बुरी तरह से आप कर रहे हैं जब

9
00:00:23,740 --> 00:00:27,450
चर, और डेटा के साथ काम कर रहा है,
और अपने कार्यक्रम दुर्घटना के कारण।

10
00:00:27,450 --> 00:00:30,490
लेकिन वे वास्तव में बहुत उपयोगी हो
और वे हमें एक बहुत बढ़िया तरीका अनुमति देते हैं

11
00:00:30,490 --> 00:00:33,340
वापस डेटा पारित करने के लिए और
आगे कार्यों के बीच,

12
00:00:33,340 --> 00:00:35,490
कि हम अन्यथा नहीं कर पा रहे हैं।

13
00:00:35,490 --> 00:00:37,750
>> और तो क्या हम वास्तव में
ट्रेन है यहाँ क्या करना चाहते हैं

14
00:00:37,750 --> 00:00:41,060
आप अच्छा सूचक अनुशासन है, इसलिए करने के लिए
आप प्रभावी रूप से संकेत का उपयोग कर सकते हैं कि

15
00:00:41,060 --> 00:00:43,850
अपने कार्यक्रमों है कि ज्यादा बेहतर बनाने के लिए।

16
00:00:43,850 --> 00:00:48,220
जैसा कि मैंने कहा संकेत हमें एक अलग देना
रास्ते कार्यों के बीच डेटा पारित करने के लिए।

17
00:00:48,220 --> 00:00:50,270
अब आप से याद करते हैं
पहले के एक वीडियो है, जब

18
00:00:50,270 --> 00:00:53,720
हम के बारे में बात कर रहे थे
चर गुंजाइश है, मैंने उल्लेख

19
00:00:53,720 --> 00:01:00,610
कि हम दोनों के बीच पारित कि सभी डेटा
सी में कार्यों मूल्य द्वारा पारित कर दिया है।

20
00:01:00,610 --> 00:01:03,070
और मुझे लगता है कि प्रयोग नहीं किया है
अवधि मैं वहाँ का मतलब है, क्या

21
00:01:03,070 --> 00:01:07,170
हम डेटा की प्रतियां गुजर रहे हैं कि था।

22
00:01:07,170 --> 00:01:12,252
हम एक समारोह के लिए एक चर के पास,
हम वास्तव में चर गुजर नहीं कर रहे हैं

23
00:01:12,252 --> 00:01:13,210
समारोह के लिए, है ना?

24
00:01:13,210 --> 00:01:17,670
हम की एक प्रति गुजर रहे हैं
समारोह के लिए कि डेटा।

25
00:01:17,670 --> 00:01:20,760
समारोह क्या यह होगा करता है
और यह कुछ मूल्य की गणना करता है,

26
00:01:20,760 --> 00:01:23,180
और हो सकता है कि हम उस मूल्य का उपयोग
यह इसे वापस देता है।

27
00:01:23,180 --> 00:01:26,700
>> एक अपवाद के लिए वहां गया था
मूल्य के पास से गुजर का यह नियम,

28
00:01:26,700 --> 00:01:31,210
और हम यह है कि क्या करने के लिए वापस आ गया हूँ
इस वीडियो में बाद में एक छोटी है।

29
00:01:31,210 --> 00:01:34,880
हम बजाय संकेत का उपयोग करते हैं
चर का उपयोग कर के,

30
00:01:34,880 --> 00:01:38,180
या चर उपयोग करने के बजाय
खुद को या चर की प्रतियां

31
00:01:38,180 --> 00:01:43,790
हम अब चारों ओर चर पारित कर सकते हैं
एक अलग तरह के कार्यों के बीच।

32
00:01:43,790 --> 00:01:46,550
यह हम करते हैं तो इसका मतलब है कि
एक समारोह में एक परिवर्तन,

33
00:01:46,550 --> 00:01:49,827
कि परिवर्तन वास्तव में ले जाएगा
एक अलग समारोह में प्रभाव।

34
00:01:49,827 --> 00:01:52,160
फिर, यह कुछ ऐसा है कि
हम पहले से नहीं कर सका

35
00:01:52,160 --> 00:01:56,979
और आप कभी स्वैप करने की कोशिश की है, तो
एक समारोह में दो चर के मूल्य,

36
00:01:56,979 --> 00:01:59,270
यदि आप इस समस्या पर ध्यान दिया है
जीव की तरह, है ना?

37
00:01:59,270 --> 00:02:04,340
>> हम एक्स और वाई, और हम स्वैप करने के लिए चाहते हैं
स्वैप नामक एक समारोह के लिए उनके पास है,

38
00:02:04,340 --> 00:02:08,680
समारोह के अंदर स्वैप
चर विनिमय मूल्यों करते हैं।

39
00:02:08,680 --> 00:02:12,600
एक से दो हो जाता है, दो हो जाता है
एक है, लेकिन हम वास्तव में नहीं है

40
00:02:12,600 --> 00:02:16,890
मूल में कुछ भी बदल
समारोह, कॉलर में।

41
00:02:16,890 --> 00:02:19,550
क्योंकि हम नहीं कर सकते, हम कर रहे हैं केवल
उनमें से प्रतियों के साथ काम कर रहे हैं।

42
00:02:19,550 --> 00:02:24,760
हालांकि संकेत के साथ, हम कर सकते हैं
वास्तव में एक समारोह के लिए एक्स और वाई गुजरती हैं।

43
00:02:24,760 --> 00:02:26,960
यही कारण है कि समारोह कर सकते हैं
उनके साथ कुछ और।

44
00:02:26,960 --> 00:02:29,250
और उन चर मूल्यों
वास्तव में बदल सकते हैं।

45
00:02:29,250 --> 00:02:33,710
तो यह है कि में काफी बदलाव है
डेटा के साथ काम करने की हमारी क्षमता।

46
00:02:33,710 --> 00:02:36,100
>> हम में गोता लगाने से पहले
संकेत, मैं इसके लायक है लगता है

47
00:02:36,100 --> 00:02:38,580
कुछ ही मिनटों के लिए ले जा
यहाँ बुनियादी बातों को वापस जाओ।

48
00:02:38,580 --> 00:02:41,000
और कैसे पर एक नजर है
कंप्यूटर स्मृति काम करता है

49
00:02:41,000 --> 00:02:45,340
इन दो विषयों जा रहे हैं क्योंकि
वास्तव में बहुत परस्पर हो।

50
00:02:45,340 --> 00:02:48,480
शायद आप सभी को पता हो,
अपने कंप्यूटर सिस्टम पर

51
00:02:48,480 --> 00:02:51,310
आप एक हार्ड ड्राइव है या
शायद एक ठोस राज्य ड्राइव,

52
00:02:51,310 --> 00:02:54,430
फ़ाइल भंडारण स्थान को किसी प्रकार का।

53
00:02:54,430 --> 00:02:57,950
यह कहीं आमतौर पर है
250 गीगाबाइट की पड़ोस

54
00:02:57,950 --> 00:02:59,810
अब टेराबाइट्स की शायद एक जोड़े के लिए।

55
00:02:59,810 --> 00:03:02,270
और इस बात की है, जहां सब है आपके
फाइलों अंततः रहते हैं,

56
00:03:02,270 --> 00:03:04,870
आपके कंप्यूटर बंद होने के बाद भी
बंद, आप इसे वापस बारी कर सकते हैं

57
00:03:04,870 --> 00:03:09,190
और आप अपनी फाइल देखते हैं मिल जाएगा
फिर आप अपने सिस्टम को रिबूट जब।

58
00:03:09,190 --> 00:03:14,820
लेकिन एक हार्ड डिस्क ड्राइव की तरह डिस्क ड्राइव,
एक HDD, या एक ठोस राज्य ड्राइव, एक एसएसडी,

59
00:03:14,820 --> 00:03:16,050
सिर्फ भंडारण के लिए जगह है।

60
00:03:16,050 --> 00:03:20,400
>> हम वास्तव में कुछ नहीं कर सकते
हार्ड डिस्क में है कि डेटा,

61
00:03:20,400 --> 00:03:22,080
या एक ठोस राज्य ड्राइव में।

62
00:03:22,080 --> 00:03:24,950
वास्तव में बदलने के क्रम में
डेटा या इसे चारों ओर ले जाने,

63
00:03:24,950 --> 00:03:28,800
हम करने के लिए इसे ले जाने के लिए
राम, रैंडम एक्सेस मेमोरी।

64
00:03:28,800 --> 00:03:31,170
अब राम, आप एक बहुत कुछ है
आपके कंप्यूटर में से कम है।

65
00:03:31,170 --> 00:03:34,185
आप ने कहीं न कहीं हो सकता है
512 मेगाबाइट का पड़ोस

66
00:03:34,185 --> 00:03:38,850
यदि आप एक पुराने कंप्यूटर है,
शायद करने के लिए दो, चार, आठ, 16,

67
00:03:38,850 --> 00:03:41,820
संभवतः भी एक छोटे से
अधिक, राम के गीगाबाइट।

68
00:03:41,820 --> 00:03:46,390
तो यह है कि बहुत छोटी है, लेकिन है कि
जहां अस्थिर डेटा के सभी मौजूद है।

69
00:03:46,390 --> 00:03:48,270
हम चीजों को बदल सकते हैं कि जहां।

70
00:03:48,270 --> 00:03:53,350
लेकिन हम अपने कंप्यूटर बंद करते हैं,
रैम में डेटा के सभी नष्ट हो जाता है।

71
00:03:53,350 --> 00:03:57,150
>> हम हार्ड डिस्क की आवश्यकता है तो यही कारण है
इसके बारे में और अधिक स्थायी स्थान के लिए,

72
00:03:57,150 --> 00:03:59,720
यह exists- इतना है कि यह होगा
वास्तव में बुरा हो, तो हर बार हम

73
00:03:59,720 --> 00:04:03,310
हमारे कंप्यूटर बंद कर दिया हर
हमारी प्रणाली में फ़ाइल obliterated किया गया था।

74
00:04:03,310 --> 00:04:05,600
इसलिए हम राम के अंदर काम करते हैं।

75
00:04:05,600 --> 00:04:09,210
और हर बार हम के बारे में बात कर रहे हैं
स्मृति, बहुत सुंदर, CS50 में,

76
00:04:09,210 --> 00:04:15,080
हम राम, न हार्ड डिस्क के बारे में बात कर रहे हैं।

77
00:04:15,080 --> 00:04:18,657
>> इसलिए हम स्मृति में चीजों को ले जाते हैं,
यह अंतरिक्ष की एक निश्चित राशि लेता है।

78
00:04:18,657 --> 00:04:20,740
डेटा प्रकार के सभी कि
हम साथ काम कर रहा है

79
00:04:20,740 --> 00:04:23,480
ऊपर ले अलग
रैम में अंतरिक्ष की मात्रा।

80
00:04:23,480 --> 00:04:27,600
तो हर बार जब आप एक पूर्णांक बनाने
स्मृति के चर, चार बाइट्स

81
00:04:27,600 --> 00:04:30,750
यदि आप ऐसा रैम में अलग सेट कर रहे हैं
कि पूर्णांक के साथ काम कर सकते हैं।

82
00:04:30,750 --> 00:04:34,260
आप पूर्णांक घोषणा कर सकते हैं,
इसे बदलने के लिए, यह आवंटित

83
00:04:34,260 --> 00:04:36,700
incremented एक मूल्य 10 को
एक, इतने पर और इतने पर से।

84
00:04:36,700 --> 00:04:39,440
में होने की जरूरत है कि सभी
राम, और आप चार बाइट्स मिल

85
00:04:39,440 --> 00:04:42,550
हर एक के लिए साथ काम करने के लिए
कि तुम बनाने के पूर्णांक।

86
00:04:42,550 --> 00:04:45,410
>> हर चरित्र आप
बनाने के एक बाइट हो जाता है।

87
00:04:45,410 --> 00:04:48,160
यही कारण है कि अंतरिक्ष है अभी कितना है
एक चरित्र को स्टोर करने की जरूरत है।

88
00:04:48,160 --> 00:04:51,310
हर नाव, एक असली
नंबर, चार बाइट्स हो जाता है

89
00:04:51,310 --> 00:04:53,390
यह एक डबल जब तक
परिशुद्धता चल बिन्दु

90
00:04:53,390 --> 00:04:56,510
करने के लिए आपको अनुमति देता है जो संख्या है,
अधिक सटीक या अधिक अंक

91
00:04:56,510 --> 00:04:59,300
दशमलव बिंदु के बाद
सटीक खोने के बिना,

92
00:04:59,300 --> 00:05:01,820
जो स्मृति के आठ बाइट्स हाथ में ले लिया।

93
00:05:01,820 --> 00:05:06,730
लंबे समय से चाहता है, वास्तव में बड़ी पूर्णांकों,
यह भी स्मृति के आठ बाइट्स हाथ में ले लिया।

94
00:05:06,730 --> 00:05:09,000
कितने स्मृति के बाइट्स
तार लेते हो?

95
00:05:09,000 --> 00:05:12,990
अच्छा चलो कि प्रश्न में एक पिन डाल दिया
अब के लिए है, लेकिन हम इसे वापस करने के लिए आया हूँ।

96
00:05:12,990 --> 00:05:17,350
>> तो वापस स्मृति के इस विचार के रूप में करने के लिए
बाइट आकार की कोशिकाओं का एक बड़ा सरणी।

97
00:05:17,350 --> 00:05:20,871
यही कारण है कि वास्तव में यह सब है, यह है
कोशिकाओं की सिर्फ एक विशाल सरणी,

98
00:05:20,871 --> 00:05:23,370
बस किसी भी अन्य सरणी की तरह है कि
आप से परिचित हैं और देखते हैं,

99
00:05:23,370 --> 00:05:26,430
हर तत्व को छोड़कर एक बाइट व्यापक है।

100
00:05:26,430 --> 00:05:30,030
और सिर्फ एक सरणी की तरह,
हर तत्व एक पता है।

101
00:05:30,030 --> 00:05:32,120
एक सरणी के प्रत्येक तत्व
एक सूचकांक है, और हम है

102
00:05:32,120 --> 00:05:36,302
तथाकथित ऐसा करने के लिए है कि सूचकांक का उपयोग कर सकते हैं
सरणी पर रैंडम एक्सेस।

103
00:05:36,302 --> 00:05:38,510
हम पर शुरू करने के लिए नहीं है
सरणी की शुरुआत

104
00:05:38,510 --> 00:05:40,569
हर माध्यम से पुनरावृति
एकल तत्व क्या है,

105
00:05:40,569 --> 00:05:41,860
हम क्या देख रहे हो खोजने के लिए।

106
00:05:41,860 --> 00:05:45,790
हम सिर्फ मैं करने के लिए प्राप्त करना चाहते हैं, कह सकते हैं
15 वीं तत्व या 100 वां तत्व।

107
00:05:45,790 --> 00:05:49,930
और अगर आप सिर्फ इतना है कि संख्या में पारित कर सकते हैं
और आप देख रहे हैं मूल्य मिलता है।

108
00:05:49,930 --> 00:05:54,460
>> इसी तरह हर स्थान
स्मृति में एक पता होता है।

109
00:05:54,460 --> 00:05:57,320
तो अपनी स्मृति हो सकता है
कुछ इस तरह दिखेगा।

110
00:05:57,320 --> 00:06:01,420
यहाँ का एक बहुत छोटा हिस्सा है
स्मृति, इस स्मृति के 20 बाइट्स है।

111
00:06:01,420 --> 00:06:04,060
पहले 20 बाइट्स क्योंकि मेरी
तल पर वहाँ के पते

112
00:06:04,060 --> 00:06:08,890
3, 2, 1, 0 कर रहे हैं, और इसलिए
19 के लिए सभी रास्ते पर।

113
00:06:08,890 --> 00:06:13,190
और मैं चर घोषणा कब और
मैं उनके साथ काम करने के लिए शुरू करते हैं,

114
00:06:13,190 --> 00:06:15,470
सिस्टम स्थापित करने के लिए जा रहा है
मेरे लिए एक तरफ कुछ जगह

115
00:06:15,470 --> 00:06:17,595
इस स्मृति में काम करने के लिए
मेरी चर के साथ।

116
00:06:17,595 --> 00:06:21,610
तो मैंने चार सी पूंजी के बराबर होती है, का कहना है कि हो सकता है
एच और क्या होने जा रहा है?

117
00:06:21,610 --> 00:06:23,880
खैर व्यवस्था करने के लिए जा रहा है
मुझे एक बाइट के लिए अलग निर्धारित करें।

118
00:06:23,880 --> 00:06:27,870
इस मामले में यह बाइट नंबर चुना
चार, पता चार पर बाइट,

119
00:06:27,870 --> 00:06:31,310
और यह स्टोर करने के लिए जा रहा है
मेरे लिए वहाँ में पत्र राजधानी एच।

120
00:06:31,310 --> 00:06:34,350
मैं तो पूर्णांक गति कहते हैं
सीमा से यह बात है, 65 के बराबर होती है

121
00:06:34,350 --> 00:06:36,806
एक तरफ चार सेट करने के लिए जा रहा
मेरे लिए स्मृति के बाइट्स।

122
00:06:36,806 --> 00:06:39,180
और यह उन लोगों के इलाज के लिए जा रहा है
एक इकाई के रूप में चार बाइट्स

123
00:06:39,180 --> 00:06:41,305
हम काम कर रहे हैं, क्योंकि
साथ यहाँ एक पूर्णांक है।

124
00:06:41,305 --> 00:06:44,350
और यह वहाँ में 65 स्टोर करने के लिए जा रहा है।

125
00:06:44,350 --> 00:06:47,000
>> अब पहले से ही मैं एक तरह से कर रहा हूँ
आप एक झूठ का एक सा बता रही है,

126
00:06:47,000 --> 00:06:50,150
ठीक है, हम जानते हैं कि क्योंकि
कंप्यूटर बाइनरी में काम करते हैं।

127
00:06:50,150 --> 00:06:53,100
वे समझ नहीं आता
जरूरी नहीं कि एक राजधानी एच क्या है

128
00:06:53,100 --> 00:06:57,110
या एक 65 वे केवल, क्या है
द्विआधारी, शून्य और लोगों को समझते हैं।

129
00:06:57,110 --> 00:06:59,000
और तो वास्तव में क्या
हम वहाँ में भंडारण कर रहे हैं

130
00:06:59,000 --> 00:07:03,450
पत्र एच और नंबर 65, नहीं है
बल्कि द्विआधारी अभ्यावेदन

131
00:07:03,450 --> 00:07:06,980
क्या है, जो देखो
इस तरह छोटे से कुछ।

132
00:07:06,980 --> 00:07:10,360
और विशेष रूप में
पूर्णांक चर के संदर्भ में,

133
00:07:10,360 --> 00:07:13,559
यह सिर्फ इसे में थूक नहीं जा रहा है
यह एक चार के रूप में व्यवहार करने के लिए नहीं जा रहा है

134
00:07:13,559 --> 00:07:15,350
बाइट हिस्सा जरूरी
यह वास्तव में हो रहा है

135
00:07:15,350 --> 00:07:19,570
चार एक बाइट हिस्सा के रूप में व्यवहार करने के लिए,
जो कुछ इस तरह लग सकता है।

136
00:07:19,570 --> 00:07:22,424
और यहां तक ​​कि यह नहीं है
पूरी तरह सच है, या तो

137
00:07:22,424 --> 00:07:24,840
कहा जाता है कुछ की वजह
हम नहीं कर रहे हैं, जो एक endianness,

138
00:07:24,840 --> 00:07:26,965
, अब में शामिल होने के लिए जा रहा था लेकिन
आप के बारे में उत्सुक हैं,

139
00:07:26,965 --> 00:07:29,030
आप थोड़ा पर पढ़ सकते हैं
और बड़े endianness।

140
00:07:29,030 --> 00:07:31,640
लेकिन इस तर्क की खातिर,
इस वीडियो की खातिर,

141
00:07:31,640 --> 00:07:34,860
बस उस में है, मान लेते हैं
तथ्य यह है, कैसे संख्या 65 से होगा

142
00:07:34,860 --> 00:07:36,970
में प्रतिनिधित्व किया
हर सिस्टम पर स्मृति,

143
00:07:36,970 --> 00:07:38,850
यह पूरी तरह सच नहीं है, हालांकि।

144
00:07:38,850 --> 00:07:41,700
>> लेकिन वास्तव में सिर्फ मिल जाने
पूरी तरह से सभी बाइनरी से छुटकारा,

145
00:07:41,700 --> 00:07:44,460
और सिर्फ एच के रूप में के बारे में सोचते
और 65 है, यह एक बहुत आसान है

146
00:07:44,460 --> 00:07:47,900
की तरह इसके बारे में सोचने के लिए
एक इंसान के रूप में है।

147
00:07:47,900 --> 00:07:51,420
ठीक है, यह भी लगता है, तो शायद एक
थोड़ा यादृच्छिक कि I've- मेरे प्रणाली

148
00:07:51,420 --> 00:07:55,130
बाइट्स 5, 6, 7 मुझे हार नहीं मानी,
और 8 पूर्णांक स्टोर करने के लिए।

149
00:07:55,130 --> 00:07:58,580
उस के लिए एक कारण है, भी है जो
हम अभी में मिलता है, लेकिन पर्याप्त नहीं होगा

150
00:07:58,580 --> 00:08:00,496
यह है कि क्या कहना है
कंप्यूटर यहाँ क्या कर रहा है

151
00:08:00,496 --> 00:08:02,810
शायद अपने हिस्से पर एक अच्छा कदम है।

152
00:08:02,810 --> 00:08:06,020
मुझे है कि स्मृति देने के लिए नहीं
जरूरी वापस करने के लिए वापस।

153
00:08:06,020 --> 00:08:10,490
अब यह क्या करने जा रहा है, हालांकि
मैं एक और स्ट्रिंग प्राप्त करना चाहते हैं,

154
00:08:10,490 --> 00:08:13,080
उपनाम कहा जाता है, और मैं चाहता हूँ
वहाँ में लॉयड रख दिया।

155
00:08:13,080 --> 00:08:18,360
मैं एक फिट की जरूरत के लिए जा रहा हूँ
चरित्र, उस के प्रत्येक पत्र

156
00:08:18,360 --> 00:08:21,330
एक आवश्यकता होती जा रही
चरित्र, स्मृति की एक बाइट।

157
00:08:21,330 --> 00:08:26,230
मैं अपने सरणी में लॉयड डाल सकता है तो अगर
इस तरह मैं ठीक है, जाने के लिए बहुत अच्छा रहा हूँ?

158
00:08:26,230 --> 00:08:28,870
क्या कमी है?

159
00:08:28,870 --> 00:08:31,840
>> हर स्ट्रिंग हम काम करते हैं कि याद रखें
सी बैकस्लैश शून्य के साथ समाप्त होता है के साथ,

160
00:08:31,840 --> 00:08:33,339
और हम यहाँ, या तो यह है कि न आना नहीं कर सकते।

161
00:08:33,339 --> 00:08:36,090
हम एक तरफ एक बाइट निर्धारित करने की आवश्यकता
स्मृति की तो हम उस धारण करने के लिए

162
00:08:36,090 --> 00:08:39,130
हमारे स्ट्रिंग समाप्त हो गया जब पता है।

163
00:08:39,130 --> 00:08:41,049
तो फिर इस व्यवस्था
जिस तरह से बातें की

164
00:08:41,049 --> 00:08:42,799
स्मृति पराक्रम में दिखाई देते हैं
एक छोटी सी यादृच्छिक हो

165
00:08:42,799 --> 00:08:44,870
लेकिन यह वास्तव में कैसे
सबसे प्रणालियों के डिजाइन किए हैं।

166
00:08:44,870 --> 00:08:48,330
गुणकों पर उन्हें लाइन
चार में से, कारणों के लिए फिर से

167
00:08:48,330 --> 00:08:50,080
हम की जरूरत नहीं है कि
अब सही में मिलता है।

168
00:08:50,080 --> 00:08:53,060
लेकिन यह इतना है कि कहने के लिए पर्याप्त
कोड के इन तीन लाइनों के बाद,

169
00:08:53,060 --> 00:08:54,810
इस स्मृति की तरह लग सकता है।

170
00:08:54,810 --> 00:08:58,930
मैं स्मृति स्थानों की जरूरत है
4, 8, और 12, मेरे डेटा रखने के लिए

171
00:08:58,930 --> 00:09:01,100
यह मेरी स्मृति की तरह लग सकता है।

172
00:09:01,100 --> 00:09:04,062
>> और बस विशेष रूप से होना
यहाँ, जब पंडिताऊ

173
00:09:04,062 --> 00:09:06,020
हम स्मृति के बारे में बात कर रहे हैं
पते आमतौर पर हम

174
00:09:06,020 --> 00:09:08,390
इसलिए हेक्सादशमलव अंकन का उपयोग करना।

175
00:09:08,390 --> 00:09:12,030
तो क्यों न हम इन सभी को परिवर्तित नहीं करते
हेक्साडेसिमल नोटेशन करने के लिए दशमलव से

176
00:09:12,030 --> 00:09:15,010
सिर्फ इतना है कि आम तौर पर है, क्योंकि
हम कैसे स्मृति को देखें।

177
00:09:15,010 --> 00:09:17,880
तो बजाय के माध्यम से 0 होने का
19, क्या हमारे पास शून्य है

178
00:09:17,880 --> 00:09:20,340
शून्य X1 तीन के माध्यम से एक्स शून्य।

179
00:09:20,340 --> 00:09:23,790
उन स्मृति के 20 बाइट्स हैं कि हम
या हम इस छवि में देख रहे हैं है

180
00:09:23,790 --> 00:09:25,540
यहीं।

181
00:09:25,540 --> 00:09:29,310
>> तो यह है कि कहा जा रहा है की सब, चलो
एक पल के लिए स्मृति से दूर कदम

182
00:09:29,310 --> 00:09:30,490
और वापस संकेत करने के लिए।

183
00:09:30,490 --> 00:09:32,420
यहाँ सबसे महत्वपूर्ण है
बात को याद

184
00:09:32,420 --> 00:09:34,070
हम संकेत के साथ काम करना शुरू कर के रूप में।

185
00:09:34,070 --> 00:09:36,314
एक सूचक कुछ भी नहीं है
एक पते से अधिक है।

186
00:09:36,314 --> 00:09:38,230
मैं फिर से, क्योंकि यह कहूँगा
यह महत्वपूर्ण है कि

187
00:09:38,230 --> 00:09:42,730
एक सूचक कुछ भी नहीं है
एक पते से अधिक है।

188
00:09:42,730 --> 00:09:47,760
सूचक स्थानों के पते हैं
स्मृति में चर कहाँ रहते हैं।

189
00:09:47,760 --> 00:09:52,590
यह उम्मीद है कि एक हो जाता है कि यह जानते हुए
आसान थोड़ा सा उनके साथ काम करने के लिए।

190
00:09:52,590 --> 00:09:54,550
मुझे पसंद है एक और बात
ऐसा करने के लिए तरह के लिए है

191
00:09:54,550 --> 00:09:58,510
के नेत्रहीन क्या प्रतिनिधित्व करने आरेख
कोड के विभिन्न लाइनों के साथ हो रहा है।

192
00:09:58,510 --> 00:10:00,660
और हम इस एक जोड़ी करूँगा
संकेत में कई बार,

193
00:10:00,660 --> 00:10:03,354
और हम गतिशील के बारे में बात करते हैं
स्मृति आवंटन के रूप में अच्छी तरह से।

194
00:10:03,354 --> 00:10:06,020
मैं इन रेखाचित्रों कि क्योंकि उन्हें लगता है
विशेष रूप से उपयोगी हो सकता है।

195
00:10:06,020 --> 00:10:09,540
>> मैं उदाहरण के लिए कहते तो अगर, पूर्णांक कश्मीर
अपने कोड में, क्या हो रहा है?

196
00:10:09,540 --> 00:10:12,524
वैसे मूल रूप से क्या हो रहा है
मैं, मेरे लिए अलग सेट स्मृति हो रही है

197
00:10:12,524 --> 00:10:14,690
लेकिन मैं यह भी पसंद नहीं है
मुझे लगता है कि जैसे इसके बारे में सोचो

198
00:10:14,690 --> 00:10:16,300
एक बॉक्स की तरह इसके बारे में सोचना अच्छा लगता है।

199
00:10:16,300 --> 00:10:20,090
मैं एक बॉक्स है और यह बात है
हरे रंग की वजह से मैं

200
00:10:20,090 --> 00:10:21,750
हरे बक्से में पूर्णांकों डाल सकते हैं।

201
00:10:21,750 --> 00:10:23,666
यह एक चरित्र मैं था, तो
एक नीले बॉक्स हो सकता है।

202
00:10:23,666 --> 00:10:27,290
मैं निर्माण कर रहा हूँ लेकिन अगर मैं हमेशा से कहते हैं,
पूर्णांकों पकड़ कर सकते हैं कि एक बॉक्स

203
00:10:27,290 --> 00:10:28,950
बॉक्स है कि हरे रंग का है।

204
00:10:28,950 --> 00:10:33,020
और मैं एक स्थायी मार्कर ले लो
और मैं इसके पक्ष पर कश्मीर में लिखें।

205
00:10:33,020 --> 00:10:37,590
इसलिए मुझे लगता है, कश्मीर नामक एक बॉक्स है
जिसमें मैं पूर्णांकों डाल सकते हैं।

206
00:10:37,590 --> 00:10:41,070
मैं पूर्णांक कश्मीर का कहना है कि जब इसलिए, कि
क्या मेरे सिर में होता है।

207
00:10:41,070 --> 00:10:43,140
मैं कश्मीर पाँच के बराबर होती है कहते हैं, मैं क्या कर रहा हूँ?

208
00:10:43,140 --> 00:10:45,110
खैर, मैं पाँच डाल रहा हूँ
बॉक्स में, सही है।

209
00:10:45,110 --> 00:10:48,670
यह तो, बहुत सीधा है
मैं पूर्णांक कश्मीर, कश्मीर नामक एक बॉक्स बनाने का कहना है।

210
00:10:48,670 --> 00:10:52,040
अगर मैं, कश्मीर 5 के बराबर होती है कहना
बॉक्स में पाँच डाल दिया।

211
00:10:52,040 --> 00:10:53,865
उम्मीद है कि एक छलांग के बहुत ज्यादा नहीं है।

212
00:10:53,865 --> 00:10:55,990
चीजें एक जाना जहां यहाँ है
हालांकि दिलचस्प थोड़ा।

213
00:10:55,990 --> 00:11:02,590
मैं int * पी कहते हैं, मैं अच्छी तरह से नहीं है, भले
यह जरूरी नहीं कि इसका मतलब क्या है,

214
00:11:02,590 --> 00:11:06,150
यह स्पष्ट रूप से कुछ मिल गया है
एक पूर्णांक के साथ क्या करना है।

215
00:11:06,150 --> 00:11:08,211
इसलिए मैं रंग करने के लिए जा रहा हूँ
हरे-ish इस बॉक्स,

216
00:11:08,211 --> 00:11:10,210
मैं इसे कुछ मिल गया है पता
एक पूर्णांक के साथ क्या करना,

217
00:11:10,210 --> 00:11:13,400
लेकिन यह एक पूर्णांक में ही नहीं है,
यह एक int सितारा है क्योंकि।

218
00:11:13,400 --> 00:11:15,390
कुछ थोड़ा नहीं है
इसके बारे में अलग है।

219
00:11:15,390 --> 00:11:17,620
तो एक पूर्णांक के शामिल है,
लेकिन अन्यथा यह है

220
00:11:17,620 --> 00:11:19,830
से बहुत अलग नहीं
क्या हम के बारे में बात कर रहे थे।

221
00:11:19,830 --> 00:11:24,240
यह एक बॉक्स है, इसकी एक लेबल मिला
यह एक लेबल पी पहने हुए है,

222
00:11:24,240 --> 00:11:27,280
और यह धारण करने में सक्षम है
उन लोगों के हैं जो कुछ पूर्णांक सितारों।

223
00:11:27,280 --> 00:11:29,894
वे क्या कुछ हो
पूर्णांकों के साथ स्पष्ट रूप से।

224
00:11:29,894 --> 00:11:31,060
यहाँ अंतिम पंक्ति यद्यपि।

225
00:11:31,060 --> 00:11:37,650
मैं कहना है कि अगर पी = एवं कश्मीर, वाह,
क्या सिर्फ सही, क्या हुआ?

226
00:11:37,650 --> 00:11:41,820
इसलिए इस यादृच्छिक संख्या, मालूम होता है यादृच्छिक
नंबर, वहाँ बॉक्स में फेंक दिया जाता है।

227
00:11:41,820 --> 00:11:44,930
है कि सभी, पी है
कश्मीर का पता हो जाता है।

228
00:11:44,930 --> 00:11:52,867
कश्मीर स्मृति में रहती है जहां इसलिए मैं चिपका रहा हूँ,
इसका पता, इसकी बाइट्स का पता।

229
00:11:52,867 --> 00:11:55,200
मैं क्या कर रहा हूँ सभी मैं कह रहा हूँ है
कि मूल्य मैं जा रहा हूँ क्या है

230
00:11:55,200 --> 00:11:59,430
मेरे बॉक्स कहा जाता पी के अंदर डाल दिया।

231
00:11:59,430 --> 00:12:02,080
और ये बातें कर रहे हैं, क्योंकि
संकेत, और लग रही है क्योंकि

232
00:12:02,080 --> 00:12:04,955
शून्य एक्स की तरह एक स्ट्रिंग पर
आठ शून्य सी सात चार से आठ

233
00:12:04,955 --> 00:12:07,790
दो शून्य शायद है
बहुत सार्थक नहीं।

234
00:12:07,790 --> 00:12:12,390
हम आम तौर पर संकेत जब कल्पना,
हम वास्तव में संकेत के रूप में ऐसा करते हैं।

235
00:12:12,390 --> 00:12:17,000
पी हमें जानकारी देता है
हम स्मृति में कश्मीर खोजने की जरूरत है।

236
00:12:17,000 --> 00:12:19,120
तो बुनियादी तौर पर पी उस में एक तीर है।

237
00:12:19,120 --> 00:12:21,670
और हम लंबाई चलना
उस तीर का, कल्पना

238
00:12:21,670 --> 00:12:25,280
यह आप पर चल सकता है कुछ है, अगर हम
तीर की लंबाई के साथ चलना है,

239
00:12:25,280 --> 00:12:29,490
उस तीर का बहुत नोक पर, हम
स्मृति में स्थान मिलेगा

240
00:12:29,490 --> 00:12:31,390
जहां कश्मीर रहती है।

241
00:12:31,390 --> 00:12:34,360
और कहा कि वास्तव में महत्वपूर्ण है
कश्मीर रहती है जहां हम जानते हैं क्योंकि एक बार,

242
00:12:34,360 --> 00:12:37,870
हम डेटा के साथ काम करने के लिए शुरू कर सकते हैं
कि स्मृति स्थान के अंदर।

243
00:12:37,870 --> 00:12:40,780
हम एक नन्हा हो रही है हालांकि
अब के लिए खुद से आगे काटा।

244
00:12:40,780 --> 00:12:42,240
>> तो एक सूचक क्या है?

245
00:12:42,240 --> 00:12:45,590
एक सूचक जिसका एक डेटा आइटम है
मूल्य एक स्मृति पता है।

246
00:12:45,590 --> 00:12:49,740
यह थी कि शून्य एक्स आठ शून्य सामान कि
पर जा रहा है, कि एक स्मृति पता था।

247
00:12:49,740 --> 00:12:52,060
यही कारण है कि स्मृति में एक स्थान था।

248
00:12:52,060 --> 00:12:55,080
और एक सूचक के प्रकार
तरह का वर्णन

249
00:12:55,080 --> 00:12:56,930
डेटा का आप पर मिल जाएगा
कि स्मृति पता।

250
00:12:56,930 --> 00:12:58,810
तो पूर्णांक स्टार भाग अभी भी वहीं है।

251
00:12:58,810 --> 00:13:03,690
मुझे लगता है कि तीर का पालन करते हैं, तो यह है
एक स्थान के लिए मुझे नेतृत्व करने के लिए जा रहा है।

252
00:13:03,690 --> 00:13:06,980
और उस स्थान, क्या मैं
मेरे उदाहरण में वहाँ मिल जाएगा,

253
00:13:06,980 --> 00:13:08,240
एक हरे रंग का डिब्बा है।

254
00:13:08,240 --> 00:13:12,650
ऐसा लगता है कि क्या हो रहा है, एक पूर्णांक है मैं
मुझे लगता है कि पता करने के लिए जाना है, तो मिल जाएगा।

255
00:13:12,650 --> 00:13:14,830
एक के डेटा प्रकार
सूचक का वर्णन क्या

256
00:13:14,830 --> 00:13:17,936
आपको लगता है कि स्मृति पते पर मिलेगा।

257
00:13:17,936 --> 00:13:19,560
तो यहाँ हालांकि वास्तव में अच्छी बात है।

258
00:13:19,560 --> 00:13:25,090
सूचक हमें पारित करने की अनुमति
कार्यों के बीच चर।

259
00:13:25,090 --> 00:13:28,520
और वास्तव में चर पारित
और उन की प्रतियां पारित नहीं।

260
00:13:28,520 --> 00:13:32,879
हम जानते हैं क्योंकि अगर वास्तव में, जहां
स्मृति में एक चर खोजने के लिए,

261
00:13:32,879 --> 00:13:35,670
हम की एक प्रतिलिपि बनाने की जरूरत नहीं है
यह है, हम सिर्फ उस स्थान पर जा सकते हैं

262
00:13:35,670 --> 00:13:37,844
और कहा कि चर के साथ काम करते हैं।

263
00:13:37,844 --> 00:13:40,260
सार संकेत में तो प्रकार
का एक कंप्यूटर वातावरण बनाने

264
00:13:40,260 --> 00:13:42,360
एक बहुत अधिक वास्तविक दुनिया की तरह, सही है।

265
00:13:42,360 --> 00:13:44,640
>> तो यहाँ एक सादृश्य है।

266
00:13:44,640 --> 00:13:48,080
मैं एक नोटबुक है कि हम कहते हैं,
सही है, और यह नोटों से भरा है।

267
00:13:48,080 --> 00:13:50,230
और मैं आप इसे अद्यतन करना चाहते हैं।

268
00:13:50,230 --> 00:13:53,960
आप एक समारोह कर रहे हैं कि
अपडेट नोटों, सही है।

269
00:13:53,960 --> 00:13:56,390
रास्ते में हम किया गया है
अब तक काम कर रहा है, क्या

270
00:13:56,390 --> 00:14:02,370
आप अपनी नोटबुक ले जाएगा जो होता है,
आप कॉपी की दुकान में जाना होगा

271
00:14:02,370 --> 00:14:06,410
आप में से एक जेरोक्स कॉपी कर दूँगा
नोटबुक के हर पेज।

272
00:14:06,410 --> 00:14:09,790
आप वापस अपनी नोटबुक छोड़ देंगे
मेरी मेज पर जब आप कर रहे,

273
00:14:09,790 --> 00:14:14,600
तुम जाओ और में चीजों को बाहर पार करेंगे मेरी
तारीख या गलत से बाहर हैं कि नोटबुक,

274
00:14:14,600 --> 00:14:19,280
और फिर तुम वापस करने के लिए पारित करेंगे
मुझे जेरोक्स पृष्ठों के ढेर

275
00:14:19,280 --> 00:14:22,850
कि अपनी नोटबुक की एक प्रतिकृति के साथ है
आप इसे करने के लिए बनाया गया है कि परिवर्तन।

276
00:14:22,850 --> 00:14:27,040
और उस बिंदु पर, के रूप में यह मेरे लिए है
बुला समारोह, फोन करने वाले के रूप में,

277
00:14:27,040 --> 00:14:30,582
अपने नोट्स लेने के लिए तय करने के लिए और
अपनी नोटबुक में उन्हें वापस एकीकृत।

278
00:14:30,582 --> 00:14:32,540
तो कदम की एक बहुत कुछ है
यहाँ शामिल, सही है।

279
00:14:32,540 --> 00:14:34,850
जैसे कि यह बेहतर नहीं होगा
मैं सिर्फ इतना कहना है, अगर अरे, आप कर सकते हैं

280
00:14:34,850 --> 00:14:38,370
के लिए अपनी नोटबुक अद्यतन
मुझे, अगर आप अपनी नोटबुक हाथ

281
00:14:38,370 --> 00:14:40,440
और आप चीजों को लेने के लिए और
सचमुच उन्हें बाहर पार

282
00:14:40,440 --> 00:14:42,810
और अपनी नोटबुक में अपने नोट्स का अद्यतन करें।

283
00:14:42,810 --> 00:14:45,140
और फिर मुझे अपनी नोटबुक वापस दे।

284
00:14:45,140 --> 00:14:47,320
यही कारण है कि की तरह है क्या
संकेत, हमें ऐसा करने की अनुमति

285
00:14:47,320 --> 00:14:51,320
वे इस माहौल में एक बहुत बनाने
हम वास्तविकता में कैसे काम अधिक की तरह।

286
00:14:51,320 --> 00:14:54,640
>> कि इतना सब क्या सही है
एक सूचक, चलो बात है

287
00:14:54,640 --> 00:14:58,040
संकेत सी में काम करते हैं, और कैसे के बारे में
कैसे हम उन लोगों के साथ काम करने के लिए शुरू कर सकते हैं।

288
00:14:58,040 --> 00:15:02,550
इसलिए एक बहुत ही सरल सूचक नहीं है,
सी में शून्य सूचक कहा जाता है।

289
00:15:02,550 --> 00:15:04,830
कुछ भी नहीं करने के लिए शून्य सूचक अंक।

290
00:15:04,830 --> 00:15:08,310
यह है जैसे कि यह शायद लगता है
वास्तव में नहीं है और एक बहुत ही उपयोगी चीज,

291
00:15:08,310 --> 00:15:10,500
लेकिन हम एक देखेंगे के रूप में
पर बाद में थोड़ा, तथ्य

292
00:15:10,500 --> 00:15:15,410
इस शून्य सूचक है कि मौजूद है
वास्तव में सच में काम में आ सकता है।

293
00:15:15,410 --> 00:15:19,090
और अगर आप एक सूचक बनाने के लिए जब भी, और
आप अपने मूल्य immediately- सेट नहीं है

294
00:15:19,090 --> 00:15:21,060
स्थापित करने का एक उदाहरण
अपने मूल्य तुरंत

295
00:15:21,060 --> 00:15:25,401
वापस एक जोड़े स्लाइड होगी
मैं पी-कश्मीर के बराबर होती है जहां उन्होंने कहा कि

296
00:15:25,401 --> 00:15:28,740
पीके के रूप में, कश्मीर का पता हो जाता है
हम, कि क्या मतलब देखेंगे

297
00:15:28,740 --> 00:15:32,990
हम उस कोड को कैसे देखेंगे shortly-
हम कुछ करने के लिए अपने मूल्य निर्धारित नहीं करते हैं

298
00:15:32,990 --> 00:15:35,380
तुरंत सार्थक,
आपको हमेशा करना चाहिए

299
00:15:35,380 --> 00:15:37,480
अशक्त करने के लिए बात करने के लिए अपने सूचक निर्धारित किया है।

300
00:15:37,480 --> 00:15:40,260
आप इसे कुछ भी करने के लिए बात करने के लिए स्थापित करना चाहिए।

301
00:15:40,260 --> 00:15:43,614
>> यही कारण है कि तुलना में बहुत अलग है
यह है के रूप में सिर्फ मूल्य छोड़ने

302
00:15:43,614 --> 00:15:45,530
और फिर एक की घोषणा
सूचक है और सिर्फ यह सोचते

303
00:15:45,530 --> 00:15:48,042
कि शायद ही कभी सच है क्योंकि यह शून्य है।

304
00:15:48,042 --> 00:15:50,000
तो तुम हमेशा की स्थापना करनी चाहिए
एक सूचक का मूल्य

305
00:15:50,000 --> 00:15:55,690
आप अपने मूल्य निर्धारित नहीं करते हैं अशक्त करने के लिए
तुरंत कुछ सार्थक करने के लिए।

306
00:15:55,690 --> 00:15:59,090
आप देख सकते हैं एक सूचक का मूल्य है कि क्या
समानता ऑपरेटर का उपयोग रिक्त है

307
00:15:59,090 --> 00:16:05,450
(==), बस आप किसी भी पूर्णांक तुलना पसंद
मूल्यों या चरित्र मूल्यों का उपयोग (==)

308
00:16:05,450 --> 00:16:06,320
भी।

309
00:16:06,320 --> 00:16:10,994
यह लगातार की एक विशेष प्रकार का है
आप परीक्षण करने के लिए उपयोग कर सकते हैं कि मूल्य।

310
00:16:10,994 --> 00:16:13,160
तो यह है कि एक बहुत ही सरल था
सूचक, शून्य सूचक।

311
00:16:13,160 --> 00:16:15,320
एक और रास्ता बनाने के लिए
एक सूचक निकालने के लिए है

312
00:16:15,320 --> 00:16:18,240
एक चर का पता
आप पहले से ही बनाया है,

313
00:16:18,240 --> 00:16:22,330
और आप इस का उपयोग करते हैं
ऑपरेटर का पता निष्कर्षण।

314
00:16:22,330 --> 00:16:26,720
जो कि हम पहले से ही पहले देखा है
पहले चित्र उदाहरण में मुझे पता चला है।

315
00:16:26,720 --> 00:16:31,450
एक्स हम है कि एक चर रहा है तो अगर
पहले से ही प्रकार पूर्णांक का बनाया है,

316
00:16:31,450 --> 00:16:35,110
तब और एक्स एक पूर्णांक के लिए एक संकेत है।

317
00:16:35,110 --> 00:16:39,810
और एक्स है-, और निकालने के लिए जा रहा है याद
सही पर बात की पता।

318
00:16:39,810 --> 00:16:45,350
और एक सूचक बस एक पता है के बाद से,
की तुलना में और एक्स एक पूर्णांक के लिए एक संकेत है

319
00:16:45,350 --> 00:16:48,560
जिसका मूल्य जहां स्मृति एक्स जीवन में है।

320
00:16:48,560 --> 00:16:50,460
यह एक्स की पता है।

321
00:16:50,460 --> 00:16:53,296
तो और एक्स एक्स का पता है।

322
00:16:53,296 --> 00:16:55,670
चलो इस एक कदम आगे ले चलो
आगे और कुछ करने के लिए कनेक्ट

323
00:16:55,670 --> 00:16:58,380
मैं एक पूर्व वीडियो में alluded।

324
00:16:58,380 --> 00:17:06,730
आगमन युगल की एक सरणी है, तो है
और आगमन वर्ग कोष्ठक मैं एक सूचक है

325
00:17:06,730 --> 00:17:08,109
एक डबल करने के लिए।

326
00:17:08,109 --> 00:17:08,970
ठीक।

327
00:17:08,970 --> 00:17:12,160
मैं, यदि वर्ग कोष्ठक आगमन
आगमन, युगल की एक सरणी है

328
00:17:12,160 --> 00:17:19,069
फिर मैं वर्ग ब्रैकेट आगमन
उस सरणी की मैं वें तत्व,

329
00:17:19,069 --> 00:17:29,270
और & वर्ग कोष्ठक आगमन मैं जहां में है
स्मृति आगमन की मैं वें तत्व मौजूद है।

330
00:17:29,270 --> 00:17:31,790
>> इसलिए निहितार्थ यहां क्या हो रहा है?

331
00:17:31,790 --> 00:17:34,570
एक सरणियों नाम, निहितार्थ
इस पूरी बात की,

332
00:17:34,570 --> 00:17:39,290
एक सरणी का नाम है
वास्तव में अपने आप में एक सूचक।

333
00:17:39,290 --> 00:17:41,170
आप काम कर रहा है
सभी के साथ संकेत के साथ

334
00:17:41,170 --> 00:17:45,290
आप एक सरणी का उपयोग किया है कि हर बार।

335
00:17:45,290 --> 00:17:49,090
उदाहरण से याद रखें
चर गुंजाइश पर,

336
00:17:49,090 --> 00:17:53,420
मैं वर्तमान वीडियो के अंत के पास
हम एक समारोह के लिए है, जहां एक उदाहरण

337
00:17:53,420 --> 00:17:56,890
कहा जाता सेट पूर्णांक और एक
समारोह सेट सरणी बुलाया।

338
00:17:56,890 --> 00:18:00,490
और अपनी चुनौती निर्धारित करने के लिए
चाहे या नहीं, या क्या

339
00:18:00,490 --> 00:18:03,220
हम बाहर मुद्रित कि मानों
समारोह के अंत में,

340
00:18:03,220 --> 00:18:05,960
मुख्य कार्यक्रम के अंत में।

341
00:18:05,960 --> 00:18:08,740
>> आपको लगता है कि उदाहरण से याद करते हैं
या आप वीडियो देखा है,

342
00:18:08,740 --> 00:18:13,080
आप के लिए कॉल तुम्हें-जब पता है कि
सेट पूर्णांक प्रभावी रूप से कुछ भी नहीं है।

343
00:18:13,080 --> 00:18:16,390
लेकिन कॉल सरणी करता है स्थापित करने के लिए।

344
00:18:16,390 --> 00:18:19,280
और मैं की तरह क्यों भुला
उस समय मामला था।

345
00:18:19,280 --> 00:18:22,363
मैं सिर्फ यह अच्छी तरह से, यह एक सरणी है, ने कहा कि
खास है, आप जानते हैं, एक कारण नहीं है।

346
00:18:22,363 --> 00:18:25,020
कारण यह है कि एक सरणी की है
नाम, वास्तव में सिर्फ एक सूचक है

347
00:18:25,020 --> 00:18:28,740
और इस विशेष वहाँ
वर्ग कोष्ठक वाक्य रचना कि

348
00:18:28,740 --> 00:18:30,510
साथ काम करने के लिए चीजें बहुत अच्छे हैं।

349
00:18:30,510 --> 00:18:34,410
और वे एक का विचार करना
एक बहुत कम डराना सूचक,

350
00:18:34,410 --> 00:18:36,800
वे तरह कर रहे हैं और यही वजह है कि
उस तरीके से प्रस्तुत किया।

351
00:18:36,800 --> 00:18:38,600
लेकिन वास्तव में सरणियों सिर्फ संकेत दिए गए हैं।

352
00:18:38,600 --> 00:18:41,580
और यही कारण है कि जब हम
, सरणी के लिए एक परिवर्तन किया

353
00:18:41,580 --> 00:18:44,880
हम एक पैरामीटर के रूप में एक सरणी से पारित कर दिया जब
एक समारोह के लिए या एक तर्क के रूप में

354
00:18:44,880 --> 00:18:50,110
सरणी के एक समारोह के लिए, सामग्री
वास्तव में दोनों कॉल प्राप्त करने वाला में बदल

355
00:18:50,110 --> 00:18:51,160
और कॉलर में।

356
00:18:51,160 --> 00:18:55,846
के हर दूसरे प्रकार के लिए कौन सा
हमने देखा चर मामला नहीं था।

357
00:18:55,846 --> 00:18:58,970
तो यह है कि में रखने के लिए बस कुछ है
आप संकेत के साथ काम कर रहे हैं जब मन,

358
00:18:58,970 --> 00:19:01,610
है कि एक का नाम
सरणी वास्तव में एक सूचक

359
00:19:01,610 --> 00:19:04,750
उस सरणी के पहले तत्व के।

360
00:19:04,750 --> 00:19:08,930
>> ठीक है तो अब हम इन सब है
तथ्यों, चलो ठीक है, जा रहा रखने दें।

361
00:19:08,930 --> 00:19:11,370
क्यों हम के बारे में परवाह करते हैं
जहां कुछ रहता है।

362
00:19:11,370 --> 00:19:14,120
मैंने कहा ठीक है की तरह, यह सुंदर है
कुछ रहता है, जहां पता करने के लिए उपयोगी

363
00:19:14,120 --> 00:19:17,240
तो तुम वहाँ जाना है और इसे बदल सकते हैं।

364
00:19:17,240 --> 00:19:19,390
इसके साथ काम करते हैं और वास्तव में
बात यह है कि आप

365
00:19:19,390 --> 00:19:23,710
कि चर ले प्रभाव के लिए करना चाहते हैं,
और इसके बारे में कुछ नकल पर प्रभावी नहीं।

366
00:19:23,710 --> 00:19:26,150
इस अपसंदर्भन कहा जाता है।

367
00:19:26,150 --> 00:19:28,690
हम संदर्भ में जाना और
हम वहाँ मूल्य बदल जाते हैं।

368
00:19:28,690 --> 00:19:32,660
हम एक सूचक है और यदि हां यह कहा जाता है
पीसी, और यह एक चरित्र के लिए अंक,

369
00:19:32,660 --> 00:19:40,610
फिर हम * पीसी और * पीसी है कह सकते हैं
हम चलते हैं तो हम क्या मिलेगा के नाम

370
00:19:40,610 --> 00:19:42,910
पता पीसी के लिए।

371
00:19:42,910 --> 00:19:47,860
क्या हम वहाँ मिल जाएगा एक चरित्र है और
* पीसी हम उस पर आंकड़ों को देखें कैसे

372
00:19:47,860 --> 00:19:48,880
स्थान।

373
00:19:48,880 --> 00:19:54,150
तो हम जैसे कुछ कह सकते हैं
* पीसी = डी या ऐसा कुछ,

374
00:19:54,150 --> 00:19:59,280
और कहा कि इसका मतलब है कि जो कुछ भी
, स्मृति पता पीसी पर था

375
00:19:59,280 --> 00:20:07,040
जो कुछ भी चरित्र पहले से था
हम पीसी = डी * कहना है कि अगर वहाँ है, अब डी है।

376
00:20:07,040 --> 00:20:10,090
>> यहाँ तो हम साथ फिर से जाना
कुछ अजीब सी चीज नहीं है, सही है।

377
00:20:10,090 --> 00:20:14,560
इसलिए हम होने के रूप में पहले से * देखा है
किसी भी तरह के डेटा प्रकार का हिस्सा है,

378
00:20:14,560 --> 00:20:17,160
और अब यह प्रयोग किया जा रहा है
एक अलग संदर्भ

379
00:20:17,160 --> 00:20:19,605
एक स्थान पर डेटा का उपयोग करने के लिए।

380
00:20:19,605 --> 00:20:22,480
मैं इसे एक छोटे से भ्रामक है पता है और
कि वास्तव में यह पूरा का हिस्सा है

381
00:20:22,480 --> 00:20:25,740
जैसे, क्यों संकेत इस पौराणिक कथाओं है
उन्हें चारों ओर इतनी जटिल होने के रूप में,

382
00:20:25,740 --> 00:20:28,250
ईमानदारी से, एक वाक्य रचना समस्या की तरह है।

383
00:20:28,250 --> 00:20:31,810
लेकिन * दोनों ही संदर्भों में इस्तेमाल किया जाता है,
दोनों प्रकार के नाम के हिस्से के रूप में,

384
00:20:31,810 --> 00:20:34,100
और हम एक छोटे से देखेंगे
भी बाकी बाद में कुछ।

385
00:20:34,100 --> 00:20:36,490
और अभी है
भिन्नता ऑपरेटर।

386
00:20:36,490 --> 00:20:38,760
तो यह संदर्भ के लिए चला जाता है,
यह डेटा तक पहुँचता

387
00:20:38,760 --> 00:20:43,000
सूचक के स्थान पर और
आप अपनी मर्जी से यह हेरफेर करने के लिए अनुमति देता है।

388
00:20:43,000 --> 00:20:45,900
>> अब इस के समान है
अपने पड़ोसी का दौरा, सही है।

389
00:20:45,900 --> 00:20:48,710
यदि आप जानते हैं कि क्या आपके
पड़ोसी आप कर रहे हैं, रहता है

390
00:20:48,710 --> 00:20:50,730
अपने पड़ोसी के साथ बाहर फांसी नहीं।

391
00:20:50,730 --> 00:20:53,510
आप को कुछ नहीं जानते
जहां वे रहते हैं पता है,

392
00:20:53,510 --> 00:20:56,870
लेकिन उस से मतलब नहीं है कि
कि ज्ञान होने के पुण्य

393
00:20:56,870 --> 00:20:59,170
आप उन लोगों के साथ बातचीत कर रहे हैं।

394
00:20:59,170 --> 00:21:01,920
आप उन लोगों के साथ बातचीत करने के लिए चाहते हैं,
आप अपने घर के पास जाना है

395
00:21:01,920 --> 00:21:03,760
आप जहां वे रहते हैं के लिए जाना है।

396
00:21:03,760 --> 00:21:07,440
और तुम हो कि एक बार,
तो आप बातचीत कर सकते हैं

397
00:21:07,440 --> 00:21:09,420
उनके साथ केवल आपके लिए चाहता हूँ की तरह।

398
00:21:09,420 --> 00:21:12,730
और इसी प्रकार चर के साथ,
आप उनका पता करने के लिए जाने की जरूरत है

399
00:21:12,730 --> 00:21:15,320
आप उन्हें बातचीत करना चाहते हैं,
अगर आप अभी पता नहीं कर सकते हैं।

400
00:21:15,320 --> 00:21:21,495
और अगर आप पता करने के लिए जाने का रास्ता है
*, भिन्नता ऑपरेटर का उपयोग करने के लिए।

401
00:21:21,495 --> 00:21:23,620
आप क्या होता है क्या लगता है
हम कोशिश करते हैं और भिन्नता है, तो

402
00:21:23,620 --> 00:21:25,260
जिसका मूल्य एक सूचक रिक्त है?

403
00:21:25,260 --> 00:21:28,470
अशक्त याद है कि
सूचक कुछ भी करने के लिए अंक।

404
00:21:28,470 --> 00:21:34,110
आप कोशिश करते हैं और भिन्नता तो अगर
कुछ भी नहीं एक पता कुछ भी नहीं करने के लिए जाने के लिए या,

405
00:21:34,110 --> 00:21:36,800
आप क्या होता है लगता है?

406
00:21:36,800 --> 00:21:39,630
वैसे आप अनुमान लगाया है, तो विभाजन
गलती, तुम सही होगा।

407
00:21:39,630 --> 00:21:41,390
आप कोशिश करते हैं और भिन्नता तो
एक शून्य सूचक,

408
00:21:41,390 --> 00:21:43,140
आप एक विभाजन पीड़ित
गलती। पर रुको,

409
00:21:43,140 --> 00:21:45,820
मुझे लगता है कि, आप नहीं बताया
आप नहीं जा रहे हैं

410
00:21:45,820 --> 00:21:49,220
के अपने मूल्य निर्धारित करने के लिए अपने
कुछ सार्थक करने के लिए सूचक,

411
00:21:49,220 --> 00:21:51,000
तुम अशक्त करने के लिए सेट करना चाहिए?

412
00:21:51,000 --> 00:21:55,290
मैंने किया था और वास्तव में विभाजन
गलती एक अच्छे व्यवहार की तरह है।

413
00:21:55,290 --> 00:21:58,680
>> क्या तुमने कभी एक चर घोषित किया है और
तुरंत अपने मूल्य नहीं सौंपा?

414
00:21:58,680 --> 00:22:02,680
तो तुम सिर्फ int x कहना; तुम नहीं करते
वास्तव में कुछ भी करने के लिए आवंटित

415
00:22:02,680 --> 00:22:05,340
और फिर बाद में अपने कोड में,
आप एक्स के मूल्य प्रिंट आउट

416
00:22:05,340 --> 00:22:07,650
अभी भी नहीं हो रही है
कुछ भी करने के लिए इसे सौंपा।

417
00:22:07,650 --> 00:22:10,370
बार-बार आपको मिलेगा
शून्य है, लेकिन कभी कभी आप

418
00:22:10,370 --> 00:22:15,000
कुछ यादृच्छिक संख्या में मिलता है, और हो सकता है
आप यह कहाँ से आया पता नहीं है।

419
00:22:15,000 --> 00:22:16,750
इसी तरह बातें कर सकते हैं
संकेत के साथ होता है।

420
00:22:16,750 --> 00:22:20,110
आप एक सूचक घोषित
पूर्णांक * उदाहरण के लिए पी,

421
00:22:20,110 --> 00:22:23,490
और तुम, एक मूल्य को आवंटित नहीं है
आप स्मृति के लिए चार बाइट्स मिलता है।

422
00:22:23,490 --> 00:22:25,950
के जो भी चार बाइट्स
सिस्टम स्मृति कर सकते हैं

423
00:22:25,950 --> 00:22:28,970
कुछ सार्थक मूल्य है कि लगता है।

424
00:22:28,970 --> 00:22:31,760
और वहाँ गया हो सकता है
वहां पहले से ही है कि कुछ

425
00:22:31,760 --> 00:22:34,190
किसी अन्य के द्वारा की जरूरत नहीं रह जाती है
समारोह, तुम बस है तो

426
00:22:34,190 --> 00:22:35,900
जो कुछ भी डेटा नहीं था।

427
00:22:35,900 --> 00:22:40,570
>> क्या आप भिन्नता करने की कोशिश करता है, तो
तुम वहाँ थे नहीं- कि कुछ पता

428
00:22:40,570 --> 00:22:43,410
पहले से ही बाइट्स और जानकारी में
वहाँ, कि अपने सूचक में अब है।

429
00:22:43,410 --> 00:22:47,470
, आप कोशिश करते हैं और कि सूचक भिन्नता
आप कुछ स्मृति के साथ खिलवाड़ किया जा सकता है

430
00:22:47,470 --> 00:22:49,390
आप का इरादा नहीं था कि
यह सभी के साथ गड़बड़ करने के लिए।

431
00:22:49,390 --> 00:22:51,639
और वास्तव में आप कर सकते हैं
वास्तव में विनाशकारी कुछ,

432
00:22:51,639 --> 00:22:54,880
की तरह एक और कार्यक्रम को तोड़ने,
या, एक अन्य समारोह को तोड़ने

433
00:22:54,880 --> 00:22:58,289
या कि दुर्भावनापूर्ण कुछ करना
तुम सब पर क्या करने का इरादा नहीं था।

434
00:22:58,289 --> 00:23:00,080
यह क्यों है और इसलिए है कि
वास्तव में एक अच्छा विचार

435
00:23:00,080 --> 00:23:04,030
आप यदि अशक्त करने के लिए अपने संकेत स्थापित करने के लिए
कुछ सार्थक करने के लिए उन्हें निर्धारित नहीं है।

436
00:23:04,030 --> 00:23:06,760
यह शायद बेहतर है
अपने कार्यक्रम के लिए दिन के अंत

437
00:23:06,760 --> 00:23:09,840
यह करने के लिए तो दुर्घटना के लिए
कुछ है कि शिकंजा

438
00:23:09,840 --> 00:23:12,400
एक अन्य कार्यक्रम के लिए या किसी अन्य समारोह।

439
00:23:12,400 --> 00:23:15,207
यही कारण है कि व्यवहार भी शायद है
बस के दुर्घटनाग्रस्त होने से कम आदर्श।

440
00:23:15,207 --> 00:23:17,040
यह क्यों है और इसलिए है कि
वास्तव में एक अच्छी आदत

441
00:23:17,040 --> 00:23:20,920
अपने संकेत सेट करने में लाने के लिए
आप उन्हें सेट नहीं करते हैं तो अशक्त करने के लिए

442
00:23:20,920 --> 00:23:24,540
एक सार्थक मूल्य के लिए
क्या आप जानते हैं कि तुरंत, एक मूल्य

443
00:23:24,540 --> 00:23:27,260
और कहा कि तुम भिन्नता सुरक्षित रूप से कर सकते हैं।

444
00:23:27,260 --> 00:23:32,240
>> तो चलो अब वापस आते हैं और एक नज़र रखना
स्थिति के समग्र वाक्य रचना में।

445
00:23:32,240 --> 00:23:37,400
मैं int * पी कहते हैं ;, मैं सिर्फ क्या किया है?

446
00:23:37,400 --> 00:23:38,530
मैंने क्या किया है यह है।

447
00:23:38,530 --> 00:23:43,290
मैं पी का मूल्य एक पता है
सभी संकेत कर रहे हैं बस क्योंकि

448
00:23:43,290 --> 00:23:44,660
पतों।

449
00:23:44,660 --> 00:23:47,750
मैं कर सकता हूँ भिन्नता पी
* ऑपरेटर का उपयोग।

450
00:23:47,750 --> 00:23:51,250
बहुत से यहां इस संदर्भ में,
शीर्ष * प्रकार का हिस्सा है याद करते हैं।

451
00:23:51,250 --> 00:23:53,510
इंट * डेटा प्रकार है।

452
00:23:53,510 --> 00:23:56,150
लेकिन मैं भिन्नता कर सकते हैं
* ऑपरेटर का उपयोग कर पी,

453
00:23:56,150 --> 00:24:01,897
और मैं ऐसा करते हैं, मुझे लगता है कि पता करने के लिए जाना है,
मैं उस पते पर क्या मिलेगा?

454
00:24:01,897 --> 00:24:02,855
मैं एक पूर्णांक मिलेगा।

455
00:24:02,855 --> 00:24:05,910
तो पूर्णांक * पी मूल रूप से है
कह रही है, पी एक पता है।

456
00:24:05,910 --> 00:24:09,500
मैं पी सकते हैं भिन्नता और यदि
मुझे क्या करना है, मैं एक पूर्णांक मिलेगा

457
00:24:09,500 --> 00:24:11,920
कि स्मृति स्थान पर।

458
00:24:11,920 --> 00:24:14,260
>> ठीक है तो मैं एक और ने कहा कि
सितारों के साथ कष्टप्रद बात

459
00:24:14,260 --> 00:24:17,060
और यहाँ है कि जहां
सितारों के साथ कष्टप्रद बात है।

460
00:24:17,060 --> 00:24:21,640
यदि आप कभी भी घोषित करने की कोशिश की है
एक ही प्रकार के एकाधिक चर

461
00:24:21,640 --> 00:24:24,409
कोड की एक ही लाइन पर?

462
00:24:24,409 --> 00:24:27,700
तो एक पल के लिए, कि लाइन का नाटक
मैं वास्तव में हरे रंग में वहाँ है कोड

463
00:24:27,700 --> 00:24:29,366
वहाँ नहीं है और यह सिर्फ पूर्णांक एक्स, वाई, जेड कहते हैं ;.

464
00:24:29,366 --> 00:24:31,634

465
00:24:31,634 --> 00:24:34,550
क्या ऐसा होगा वास्तव में बनाने के लिए है
आप के लिए तीन पूर्णांक चर,

466
00:24:34,550 --> 00:24:36,930
एक बुलाया एक्स, एक बुलाया
वाई, और एक Z बुलाया।

467
00:24:36,930 --> 00:24:41,510
इसके बिना यह करने के लिए एक रास्ता है
तीन लाइनों पर विभाजित करने के लिए कर रही है।

468
00:24:41,510 --> 00:24:43,890
>> सितारों प्राप्त जहां यहाँ है
हालांकि फिर से परेशान है,

469
00:24:43,890 --> 00:24:49,200
* वास्तव में हिस्सा है क्योंकि
दोनों प्रकार का नाम और भाग की

470
00:24:49,200 --> 00:24:50,320
चर नाम की।

471
00:24:50,320 --> 00:24:56,430
और इसलिए मैं कहना है कि अगर पूर्णांक * पिक्सल, PY, PZ, क्या मैं
वास्तव में मिलता है एक पूर्णांक के लिए एक संकेत है

472
00:24:56,430 --> 00:25:01,650
पिक्सल और दो पूर्णांकों, PY और PZ बुलाया।

473
00:25:01,650 --> 00:25:04,950
और कहा कि शायद नहीं क्या हो रहा है
हम यह अच्छा नहीं है, चाहते हैं।

474
00:25:04,950 --> 00:25:09,290
>> मैं कई संकेत बनाने के लिए चाहते हैं तो
एक ही लाइन पर, एक ही प्रकार की,

475
00:25:09,290 --> 00:25:12,140
मैं वास्तव में क्या जरूरत है और तारे,
ऐसा करने के लिए * पंजाब, * पीसी, पूर्णांक * देहात का कहना है।

476
00:25:12,140 --> 00:25:17,330

477
00:25:17,330 --> 00:25:20,300
अब बस वाले ने कहा कि
और अब, आप यह कह

478
00:25:20,300 --> 00:25:22,170
आप शायद ऐसा कभी नहीं होगा।

479
00:25:22,170 --> 00:25:25,170
और यह ईमानदारी से शायद एक अच्छी बात है
आप अनजाने में हो सकता है क्योंकि

480
00:25:25,170 --> 00:25:26,544
एक स्टार है, ऐसा कुछ न आना।

481
00:25:26,544 --> 00:25:29,290
यह शायद घोषित करने के लिए शायद सबसे अच्छा है
अलग-अलग लाइनों पर संकेत,

482
00:25:29,290 --> 00:25:31,373
लेकिन यह सिर्फ एक और एक है
उन कष्टप्रद वाक्य रचना की

483
00:25:31,373 --> 00:25:35,310
करना है कि सितारों के साथ बातें
साथ काम करने के लिए इतना मुश्किल संकेत दिए।

484
00:25:35,310 --> 00:25:39,480
यह सिर्फ इस वाक्यात्मक क्योंकि है
गंदगी आप के माध्यम से काम करना है।

485
00:25:39,480 --> 00:25:41,600
अभ्यास के साथ करता है
वास्तव में दूसरी प्रकृति हो।

486
00:25:41,600 --> 00:25:45,410
मैं अभी भी अभी भी उसके साथ गलतियाँ करते हैं
10 साल के लिए प्रोग्रामिंग के बाद,

487
00:25:45,410 --> 00:25:49,630
अगर कुछ होता है, इसलिए परेशान मत हो
आप के लिए, यह ईमानदारी से बहुत आम है।

488
00:25:49,630 --> 00:25:52,850
यह एक तरह से सच है
वाक्य रचना का एक दोष।

489
00:25:52,850 --> 00:25:54,900
>> ठीक है तो मैं एक तरह से वादा किया
हम फिर से आना होता है कि

490
00:25:54,900 --> 00:25:59,370
कैसे बड़े की अवधारणा को एक स्ट्रिंग है।

491
00:25:59,370 --> 00:26:02,750
वैसे मैं एक है कि अगर मैंने तुमसे कहा
स्ट्रिंग, हम किस तरह का सच है

492
00:26:02,750 --> 00:26:04,140
आप के लिए पूरे समय झूठ बोल रहा।

493
00:26:04,140 --> 00:26:06,181
कहा जाता कोई डेटा प्रकार है
स्ट्रिंग, और वास्तव में मैं

494
00:26:06,181 --> 00:26:09,730
में से एक में यह उल्लेख किया है हमारी
डेटा प्रकार पर जल्द से जल्द वीडियो,

495
00:26:09,730 --> 00:26:13,820
कि स्ट्रिंग एक डेटा प्रकार था कि
CS50.h. में आप के लिए बनाया गया था

496
00:26:13,820 --> 00:26:17,050
आप # शामिल करने की जरूरत
इसका इस्तेमाल करने के क्रम में CS50.h।

497
00:26:17,050 --> 00:26:19,250
>> खैर स्ट्रिंग सिर्फ सच है
कुछ के लिए एक उर्फ

498
00:26:19,250 --> 00:26:23,600
, चार * कहा जाता है एक
एक चरित्र के लिए सूचक।

499
00:26:23,600 --> 00:26:26,010
खैर संकेत, याद है,
सिर्फ पते हैं।

500
00:26:26,010 --> 00:26:28,780
तो आकार क्या है
एक स्ट्रिंग के बाइट्स में?

501
00:26:28,780 --> 00:26:29,796
वैसे यह चार या आठ है।

502
00:26:29,796 --> 00:26:32,170
और कारण है कि मैं कहना है कि चार या
आठ इसकी वजह यह वास्तव में है

503
00:26:32,170 --> 00:26:36,730
आप उपयोग कर रहे हैं, तो सिस्टम पर निर्भर करता है
CS50 आईडीई, चार * एक चार का आकार है

504
00:26:36,730 --> 00:26:39,340
* यह एक 64-बिट सिस्टम है, आठ है।

505
00:26:39,340 --> 00:26:43,850
स्मृति में हर पता 64 बिट्स लंबा है।

506
00:26:43,850 --> 00:26:48,270
आप CS50 उपकरण का उपयोग कर रहे हैं
या किसी भी 32-बिट मशीन का उपयोग कर,

507
00:26:48,270 --> 00:26:51,640
और आप उस अवधि 32-बिट सुना है
मशीन, एक 32-बिट मशीन क्या है?

508
00:26:51,640 --> 00:26:56,090
वैसे यह बस हर मतलब है कि
स्मृति में पता 32 बिट लंबा है।

509
00:26:56,090 --> 00:26:59,140
और तो 32 बिट चार बाइट्स है।

510
00:26:59,140 --> 00:27:02,710
तो एक चार * चार या आठ है
अपने सिस्टम के आधार पर बाइट्स।

511
00:27:02,710 --> 00:27:06,100
और वास्तव में किसी भी प्रकार के डेटा,
और किसी भी डेटा के लिए एक सूचक

512
00:27:06,100 --> 00:27:12,030
सभी संकेत अभी नहीं हैं, टाइप
पते, चार या आठ बाइट्स हैं।

513
00:27:12,030 --> 00:27:14,030
तो चलो इस पर फिर से आना चलो
चित्र और के निष्कर्ष निकाल दें

514
00:27:14,030 --> 00:27:18,130
यहां एक छोटे से व्यायाम के साथ इस वीडियो।

515
00:27:18,130 --> 00:27:21,600
यहाँ तो हम से दूर छोड़ दिया आरेख है
वीडियो के बहुत शुरुआत में।

516
00:27:21,600 --> 00:27:23,110
मैं * पी = 35 का कहना है कि यदि ऐसा है तो अब क्या होता है?

517
00:27:23,110 --> 00:27:26,370

518
00:27:26,370 --> 00:27:30,530
तो यह * पी = 35, जब मैं कहता हूँ क्या मतलब है?

519
00:27:30,530 --> 00:27:32,420
एक दूसरा ले लो।

520
00:27:32,420 --> 00:27:34,990
* पी।

521
00:27:34,990 --> 00:27:39,890
यहां संदर्भ में, * है
भिन्नता ऑपरेटर।

522
00:27:39,890 --> 00:27:42,110
तो जब भिन्नता
ऑपरेटर, प्रयोग किया जाता है

523
00:27:42,110 --> 00:27:48,520
पता की ओर इशारा करने के लिए हमें जाना
पी द्वारा, और हम हम क्या मिल बदल जाते हैं।

524
00:27:48,520 --> 00:27:55,270
तो * पी = 35 प्रभावी ढंग से
तस्वीर के लिए इस करता है।

525
00:27:55,270 --> 00:27:58,110
तो यह वाक्य रचना मूल रूप से है
के लिए समान कश्मीर = 35 के बाद कहा।

526
00:27:58,110 --> 00:28:00,740

527
00:28:00,740 --> 00:28:01,930
>> एक और।

528
00:28:01,930 --> 00:28:05,510
मैं पूर्णांक मीटर कहते हैं, मैं बना
एम नामक एक नया चर।

529
00:28:05,510 --> 00:28:08,260
एक नया बॉक्स, यह एक हरे बॉक्स क्योंकि है
यह एक पूर्णांक आयोजित करने जा रहा है,

530
00:28:08,260 --> 00:28:09,840
और यह मीटर लेबल है।

531
00:28:09,840 --> 00:28:14,960
मैं मीटर = 4 कहते हैं, मैं एक डाल
लगता है कि बॉक्स में पूर्णांक।

532
00:28:14,960 --> 00:28:20,290
कहते पी = एंड एम, कैसे करता है
इस चित्र परिवर्तन?

533
00:28:20,290 --> 00:28:28,760
पी = एंड एम, आप क्या याद करना
और ऑपरेटर करता है या कहा जाता है?

534
00:28:28,760 --> 00:28:34,430
कि और कुछ चर नाम याद रखें
एक चर नाम का पता है।

535
00:28:34,430 --> 00:28:38,740
तो क्या हम कह रहे है
पी एम का पता हो जाता है।

536
00:28:38,740 --> 00:28:42,010
और इसलिए प्रभावी रूप से क्या होता है
आरेख कि अब कोई अंक पी है

537
00:28:42,010 --> 00:28:46,420
मीटर करने के लिए है, लेकिन अंक कश्मीर के लिए।

538
00:28:46,420 --> 00:28:48,470
>> फिर संकेत बहुत हैं
साथ काम करने के लिए मुश्किल

539
00:28:48,470 --> 00:28:50,620
और वे का एक बहुत ले
अभ्यास है, लेकिन क्योंकि

540
00:28:50,620 --> 00:28:54,150
आप अनुमति देने के लिए अपनी क्षमता का
कार्यों के बीच डेटा पारित करने के लिए

541
00:28:54,150 --> 00:28:56,945
और वास्तव में उन लोगों के लिए है
परिवर्तनों को प्रभावी,

542
00:28:56,945 --> 00:28:58,820
चारों ओर अपने सिर हो रही है
वास्तव में महत्वपूर्ण है।

543
00:28:58,820 --> 00:29:02,590
यह शायद सबसे जटिल है
हम CS50 में चर्चा विषय,

544
00:29:02,590 --> 00:29:05,910
लेकिन मूल्य कि आप
संकेत का उपयोग करने से मिलता है

545
00:29:05,910 --> 00:29:09,200
अब तक जटिलताओं outweighs
कि उन्हें सीखने से आते हैं।

546
00:29:09,200 --> 00:29:12,690
इसलिए मैं आप की शुभकामनाएं
भाग्य संकेत के बारे में सीखने।

547
00:29:12,690 --> 00:29:15,760
मैं डौग लॉयड हूँ, इस CS50 है।

548
00:29:15,760 --> 00:29:17,447