1
00:00:07,360 --> 00:00:09,360
[Powered by Google Translate] चलो arrays के बारे में बात करते हैं.

2
00:00:09,360 --> 00:00:12,780
क्यों तो हम कभी arrays का उपयोग करना चाहते हैं?

3
00:00:12,780 --> 00:00:17,210
अच्छा चलो कहते हैं कि आप एक कार्यक्रम की जरूरत है कि 5 छात्र आईडी की दुकान है.

4
00:00:17,210 --> 00:00:21,270
यह उचित प्रतीत 5 अलग चर हो सकता है.

5
00:00:21,270 --> 00:00:24,240
कारण हम एक बिट में देखेंगे, हम 0 से गिनती शुरू करेंगे.

6
00:00:24,240 --> 00:00:30,700
चर हम होगा int id0, int id1, और इतने पर होगा.

7
00:00:30,700 --> 00:00:34,870
हम एक छात्र आईडी पर प्रदर्शन करना चाहते हैं कोई तर्क में कॉपी और चिपकाया जा आवश्यकता होगी

8
00:00:34,870 --> 00:00:36,870
इन छात्र आईडी में से प्रत्येक के लिए.

9
00:00:36,870 --> 00:00:39,710
यदि हम जाँच के लिए है जो छात्रों CS50 में होना होता है चाहते हैं,

10
00:00:39,710 --> 00:00:43,910
हम पहले की जाँच करने के अगर id0 पाठ्यक्रम में छात्र का प्रतिनिधित्व करता है की आवश्यकता होगी.

11
00:00:43,910 --> 00:00:48,070
तो अगले छात्र के लिए एक ही है, हम कॉपी और id0 के लिए कोड पेस्ट करने की आवश्यकता होगी

12
00:00:48,070 --> 00:00:54,430
और id1 साथ और इतने पर ID2, 3, और 4 के लिए id0 की सभी घटनाओं की जगह.

13
00:00:54,430 --> 00:00:57,560
>> जैसे ही आप सुना है कि हम को कॉपी और पेस्ट करने की आवश्यकता है,

14
00:00:57,560 --> 00:01:00,440
आप यह सोच रही है कि वहाँ एक बेहतर समाधान है शुरू कर देना चाहिए.

15
00:01:00,440 --> 00:01:05,360
अब क्या हुआ अगर आपको पता है आप 5 छात्र आईडी की ज़रूरत नहीं है, लेकिन बल्कि 7?

16
00:01:05,360 --> 00:01:09,570
आप अपने स्रोत कोड में वापस जाने के लिए और एक id5 में जोड़ने की जरूरत है, एक id6,

17
00:01:09,570 --> 00:01:14,260
और कॉपी और पेस्ट की जाँच के लिए तर्क अगर आईडी इन 2 नए आईडी के लिए वर्ग के लिए हैं.

18
00:01:14,260 --> 00:01:19,600
वहाँ इन सब आईडी को एक साथ जोड़ने के लिए कुछ भी नहीं है, और इसलिए वहाँ पूछने का कोई रास्ता नहीं है

19
00:01:19,600 --> 00:01:22,040
कार्यक्रम के माध्यम से 6 आईडी 0 के लिए ऐसा करने के लिए.

20
00:01:22,040 --> 00:01:26,120
खैर अब आप महसूस करते हैं आप 100 छात्र आईडी है.

21
00:01:26,120 --> 00:01:30,770
यह आदर्श से कम करने के लिए अलग से इन आईडी के प्रत्येक घोषणा की जरूरत प्रतीत शुरू हो रहा है,

22
00:01:30,770 --> 00:01:33,760
और कॉपी और पेस्ट उन नए आईडी के लिए किसी भी तर्क.

23
00:01:33,760 --> 00:01:38,380
लेकिन शायद हम निर्धारित कर रहे हैं, और हम इसे सभी 100 छात्रों के लिए करते हैं.

24
00:01:38,380 --> 00:01:42,240
लेकिन क्या अगर तुम नहीं जानते कि कितने छात्रों को वहाँ वास्तव में कर रहे हैं?

25
00:01:42,240 --> 00:01:47,320
वहाँ सिर्फ कुछ n छात्रों और अपने कार्यक्रम के लिए उपयोगकर्ता की कि क्या n है पूछना है.

26
00:01:47,320 --> 00:01:50,250
उह ओह. यह बहुत अच्छी तरह से काम करने के लिए नहीं जा रहा है.

27
00:01:50,250 --> 00:01:53,820
आपका कार्यक्रम केवल छात्रों के कुछ निरंतर संख्या के लिए काम करता है.

28
00:01:53,820 --> 00:01:57,520
>> इन सभी समस्याओं का हल arrays के सौंदर्य है.

29
00:01:57,520 --> 00:01:59,930
तो एक सरणी क्या है?

30
00:01:59,930 --> 00:02:04,480
कुछ प्रोग्रामिंग भाषाओं में एक सरणी प्रकार के लिए थोड़ा और अधिक करने में सक्षम हो सकता है,

31
00:02:04,480 --> 00:02:09,960
लेकिन यहाँ हम बुनियादी सरणी डेटा संरचना पर ध्यान केंद्रित करने के लिए बस के रूप में आप यह सी में देखेंगे

32
00:02:09,960 --> 00:02:14,030
एक सरणी सिर्फ स्मृति का एक बड़ा ब्लॉक है. बस.

33
00:02:14,030 --> 00:02:17,770
जब हम कहते हैं कि हम 10 integers के एक सरणी है, कि बस मतलब हम कुछ ब्लॉक है

34
00:02:17,770 --> 00:02:20,740
स्मृति की है कि काफी बड़े के लिए 10 अलग integers पकड़ है.

35
00:02:29,930 --> 00:02:33,410
यह मानते हुए कि एक पूर्णांक 4 बाइट्स है, इसका मतलब है कि 10 integers के एक सरणी

36
00:02:33,410 --> 00:02:37,180
स्मृति में 40 बाइट्स की एक सतत ब्लॉक है.

37
00:02:42,660 --> 00:02:46,280
यहां तक ​​कि जब आप में बहुआयामी arrays, जो हम यहाँ में नहीं जाऊँगा का उपयोग,

38
00:02:46,280 --> 00:02:49,200
यह अभी भी सिर्फ स्मृति का एक बड़ा ब्लॉक है.

39
00:02:49,200 --> 00:02:51,840
बहुआयामी अंकन बस एक सुविधा है.

40
00:02:51,840 --> 00:02:55,640
यदि आप 3 बहुआयामी सरणी पूर्णांकों की एक 3 है,

41
00:02:55,640 --> 00:03:00,650
तो अपने कार्यक्रम वास्तव में सिर्फ 36 बाइट्स की एक बड़ी बाधा के रूप में इस का इलाज करेंगे.

42
00:03:00,650 --> 00:03:05,460
पूर्णांकों की कुल संख्या 3 3 बार है, और प्रत्येक पूर्णांक 4 बाइट्स लेता है.

43
00:03:05,460 --> 00:03:07,750
>> चलो एक बुनियादी उदाहरण पर एक नज़र रखना.

44
00:03:07,750 --> 00:03:10,660
हम यहाँ की घोषणा arrays के 2 अलग अलग तरीकों से देख सकते हैं.

45
00:03:15,660 --> 00:03:18,580
हम उनमें से एक कार्यक्रम संकलन करने के लिए बाहर टिप्पणी करना होगा

46
00:03:18,580 --> 00:03:20,900
के बाद से हम x दो बार की घोषणा.

47
00:03:20,900 --> 00:03:25,140
हम एक बिट में घोषणाओं के इन 2 प्रकार के बीच मतभेद के कुछ पर एक नज़र रखना होगा.

48
00:03:25,140 --> 00:03:28,560
इन दोनों लाइनों के आकार एन के एक सरणी की घोषणा,

49
00:03:28,560 --> 00:03:30,740
जहां हम # 10 के रूप में एन को परिभाषित करते हैं.

50
00:03:30,740 --> 00:03:34,460
हम बस के रूप में आसानी से एक सकारात्मक पूर्णांक के लिए उपयोगकर्ता से पूछा हो

51
00:03:34,460 --> 00:03:37,250
और हमारे सरणी में तत्वों की एक संख्या के रूप में है कि पूर्णांक प्रयोग किया जाता है.

52
00:03:37,250 --> 00:03:41,960
हमारे छात्र आईडी उदाहरण पहले की तरह, 10 पूरी तरह से अलग घोषित करने की तरह तरह की है

53
00:03:41,960 --> 00:03:49,000
काल्पनिक चर, x0, x1, x2, और इसलिए XN-1.

54
00:03:57,270 --> 00:04:00,840
लाइनों की उपेक्षा कर जहाँ हम सरणी की घोषणा, वर्ग कोष्ठक बरकरार नोटिस

55
00:04:00,840 --> 00:04:02,090
loops के लिए अंदर.

56
00:04:02,090 --> 00:04:09,660
जब हम एक्स की तरह कुछ लिखने [3], मैं सिर्फ एक्स 3 ब्रैकेट के रूप में पढ़ा होगा,

57
00:04:09,660 --> 00:04:13,090
आप यह सोच काल्पनिक x3 के लिए पूछ की तरह कर सकते हैं.

58
00:04:13,090 --> 00:04:17,519
आकार N, इस का मतलब है कि कोष्ठक के अंदर नंबर, एक सरणी के साथ तुलना सूचना

59
00:04:17,519 --> 00:04:22,630
जो हम सूचकांक फोन करता हूँ, 0 से N-1 के लिए कुछ भी किया जा सकता है,

60
00:04:22,630 --> 00:04:25,660
जो एन सूचकांक के एक कुल है.

61
00:04:25,660 --> 00:04:28,260
>> के बारे में सोचते हैं कि यह कैसे काम करता है वास्तव में

62
00:04:28,260 --> 00:04:31,260
याद है कि सरणी में स्मृति का एक बड़ा ब्लॉक है.

63
00:04:31,260 --> 00:04:37,460
यह मानते हुए कि एक पूर्णांक 4 बाइट्स है, पूरे सरणी x स्मृति का एक 40 बाइट ब्लॉक है.

64
00:04:37,460 --> 00:04:41,360
तो बहुत पहले ब्लॉक के 4 बाइट्स x0 को संदर्भित करता है.

65
00:04:45,810 --> 00:04:49,230
एक्स [1] अगले 4 बाइट्स और इतने पर करने के लिए संदर्भित करता है.

66
00:04:49,230 --> 00:04:53,760
इसका मतलब यह है कि एक्स का शुरू सभी कार्यक्रम कभी का ट्रैक रखने की जरूरत है.

67
00:04:55,660 --> 00:04:59,840
यदि आप एक्स [400] का उपयोग करना चाहते हैं, तो इस कार्यक्रम जानता है कि यह बराबर है

68
00:04:59,840 --> 00:05:03,460
एक्स के शुरू होने के बाद 1,600 बाइट्स.

69
00:05:03,460 --> 00:05:08,780
हम कहाँ से 1600 बाइट्स मिल? यह पूर्णांक प्रति बस 400 4 बार बाइट्स है.

70
00:05:08,780 --> 00:05:13,170
>> पर जाने से पहले, यह बहुत महत्वपूर्ण है को एहसास है कि सी में

71
00:05:13,170 --> 00:05:17,080
सूचकांक कि हम सरणी में उपयोग की कोई प्रवर्तन है.

72
00:05:17,080 --> 00:05:23,180
हमारा बड़ा ब्लॉक 10 केवल पूर्णांकों लंबी है, लेकिन कुछ भी नहीं है हम पर चिल्लाना अगर हम एक्स [20] लिखना होगा

73
00:05:23,180 --> 00:05:26,060
या यहाँ तक कि एक्स [-5].

74
00:05:26,060 --> 00:05:28,240
सूचकांक भी एक संख्या होना जरूरी नहीं है.

75
00:05:28,240 --> 00:05:30,630
यह किसी भी मनमाने ढंग से अभिव्यक्ति हो सकती है.

76
00:05:30,630 --> 00:05:34,800
कार्यक्रम में हम से सरणी में सूचकांक पाश के लिए मैं चर का उपयोग करें.

77
00:05:34,800 --> 00:05:40,340
यह एक बहुत ही आम पैटर्न है, i = 0 से सरणी की लंबाई पाशन

78
00:05:40,340 --> 00:05:43,350
और फिर मैं सरणी के लिए सूचकांक के रूप में उपयोग कर रहे हैं.

79
00:05:43,350 --> 00:05:46,160
इस पूरे सरणी को प्रभावी ढंग से खत्म पाश रास्ते में,

80
00:05:46,160 --> 00:05:50,600
और आप या तो सरणी में हर जगह के लिए आवंटित कर सकते हैं या यह कुछ गणना के लिए उपयोग कर सकते हैं.

81
00:05:50,600 --> 00:05:53,920
>> पाश के लिए 1 में, मैं 0 में शुरू होता है,

82
00:05:53,920 --> 00:05:58,680
और तो यह सरणी में हाजिर 0, 2 0 बार मूल्य के लिए आवंटित करेगा.

83
00:05:58,680 --> 00:06:04,370
तो मैं वेतन वृद्धि, और हम सरणी मूल्य 1 बार 2 में पहली जगह आवंटित.

84
00:06:04,370 --> 00:06:10,170
तो ऊपर पर मैं फिर से और इतना वेतन वृद्धि जब तक हम सरणी में N-1 स्थिति असाइन करने के लिए

85
00:06:10,170 --> 00:06:13,370
मूल्य एन 1 2 बार.

86
00:06:13,370 --> 00:06:17,810
तो हम पहले 10 भी संख्या के साथ एक सरणी बनाया है.

87
00:06:17,810 --> 00:06:21,970
शायद evens एक्स की तुलना में एक चर के लिए थोड़ा बेहतर नाम होता है,

88
00:06:21,970 --> 00:06:24,760
लेकिन यह है कि चीजों को दूर दिया जाएगा.

89
00:06:24,760 --> 00:06:30,210
पाश के लिए 2 तो सिर्फ प्रिंट मूल्यों है कि हम पहले से ही सरणी के अंदर संग्रहित है.

90
00:06:30,210 --> 00:06:33,600
>> चलो सरणी घोषणाओं के दोनों प्रकार के साथ कार्यक्रम चलाने की कोशिश

91
00:06:33,600 --> 00:06:36,330
और कार्यक्रम के उत्पादन में एक नज़र रखना.

92
00:06:51,450 --> 00:06:57,020
जहाँ तक के रूप में हम देख सकते हैं, कार्यक्रम घोषणाओं के दोनों प्रकार के लिए उसी तरह व्यवहार करता है.

93
00:06:57,020 --> 00:07:02,230
चलो यह भी क्या होता है पर एक नज़र रखना अगर हम 1 पाश बदल एन पर रोक नहीं

94
00:07:02,230 --> 00:07:05,040
बल्कि 10,000 कहते हैं.

95
00:07:05,040 --> 00:07:07,430
सरणी के अंत से परे एक रास्ता.

96
00:07:14,700 --> 00:07:17,210
उफ़! शायद आप इस पहले देखा है.

97
00:07:17,210 --> 00:07:20,440
सेगमेंटेशन फॉल्ट का मतलब है अपने कार्यक्रम दुर्घटनाग्रस्त हो गया है.

98
00:07:20,440 --> 00:07:24,430
आप इन देख शुरू जब आप स्मृति के क्षेत्रों को छू नहीं होना चाहिए छू.

99
00:07:24,430 --> 00:07:27,870
यहाँ हम एक्स के शुरू से परे 10,000 स्थानों को छू रहे हैं,

100
00:07:27,870 --> 00:07:31,920
जो जाहिर स्मृति में एक जगह हम को छू नहीं होना चाहिए है.

101
00:07:31,920 --> 00:07:37,690
हम में से ज्यादातर तो शायद गलती से 10,000 एन के बजाय नहीं रखा जाएगा,

102
00:07:37,690 --> 00:07:42,930
लेकिन क्या होगा अगर हम कुछ अधिक की तरह सूक्ष्म लिखने से कम या बराबर एन का कहना है

103
00:07:42,930 --> 00:07:46,830
पाश के लिए शर्त के रूप में करने का विरोध किया में एन के कम से कम

104
00:07:46,830 --> 00:07:50,100
याद रखें कि एक सरणी केवल 0 से N-1 इंडेक्स है,

105
00:07:50,100 --> 00:07:54,510
जिसका मतलब है कि सूचकांक एन सरणी के अंत से परे है.

106
00:07:54,510 --> 00:07:58,050
कार्यक्रम के इस मामले में दुर्घटना नहीं है, लेकिन यह अभी भी एक त्रुटि है हो सकता है.

107
00:07:58,050 --> 00:08:01,950
वास्तव में, इस त्रुटि इतना आम है कि यह है खुद के नाम है,

108
00:08:01,950 --> 00:08:03,970
1 त्रुटि से बंद.

109
00:08:03,970 --> 00:08:05,970
>> कि यह मूल के लिए है.

110
00:08:05,970 --> 00:08:09,960
तो सरणी घोषणाओं के 2 प्रकार के बीच मुख्य अंतर क्या हैं?

111
00:08:09,960 --> 00:08:13,960
एक फर्क है, जहां स्मृति की बड़ी ब्लॉक हो जाता है.

112
00:08:13,960 --> 00:08:17,660
पहली घोषणा में, जो मैं ब्रैकेट सरणी प्रकार फोन करता हूँ,

113
00:08:17,660 --> 00:08:20,300
हालांकि यह है कोई एक परंपरागत नाम का मतलब है,

114
00:08:20,300 --> 00:08:22,480
यह ढेर पर जाना होगा.

115
00:08:22,480 --> 00:08:27,450
जबकि 2, जो मैं सूचक सरणी प्रकार फोन करता हूँ, यह ढेर पर जाना होगा.

116
00:08:27,450 --> 00:08:32,480
इसका मतलब यह है कि जब समारोह रिटर्न, ब्रैकेट सरणी स्वतः deallocated हो जाएगा,

117
00:08:32,480 --> 00:08:36,419
के रूप में आप explicitily सूचक सरणी पर नि: शुल्क फोन करना चाहिए जबकि

118
00:08:36,419 --> 00:08:38,010
या फिर आप एक स्मृति रिसाव है.

119
00:08:38,010 --> 00:08:42,750
इसके अतिरिक्त, ब्रैकेट सरणी वास्तव में एक चर नहीं है.

120
00:08:42,750 --> 00:08:45,490
यह महत्वपूर्ण है. यह सिर्फ एक प्रतीक है.

121
00:08:45,490 --> 00:08:49,160
आप इसे एक निरंतर है कि संकलक आप के लिए चयन के रूप में सोच सकते हैं.

122
00:08:49,160 --> 00:08:52,970
इसका मतलब यह है कि हम कुछ नहीं कर सकते x + + ब्रैकेट प्रकार के साथ की तरह,

123
00:08:52,970 --> 00:08:56,240
हालांकि इस सूचक प्रकार के साथ पूरी तरह से वैध है.

124
00:08:56,240 --> 00:08:58,270
>> सूचक प्रकार एक चर है.

125
00:08:58,270 --> 00:09:01,510
सूचक प्रकार के लिए, हम स्मृति के 2 अलग - अलग ब्लॉक है.

126
00:09:01,510 --> 00:09:06,060
चर ही x ढेर में संग्रहीत किया जाता है और सिर्फ एक ही सूचक है,

127
00:09:06,060 --> 00:09:08,620
लेकिन स्मृति के बड़े ब्लॉक ढेर पर संग्रहीत किया जाता है.

128
00:09:08,620 --> 00:09:11,010
ढेर पर चर x बस पता संग्रहीत करता

129
00:09:11,010 --> 00:09:14,010
बड़ा ब्लॉक के ढेर पर स्मृति की.

130
00:09:14,010 --> 00:09:17,370
इस का एक निहितार्थ ऑपरेटर के आकार के साथ है.

131
00:09:17,370 --> 00:09:22,480
यदि आप ब्रैकेट सरणी के आकार के लिए पूछना है, यह आप स्मृति की बड़ी ब्लॉक के आकार दे देंगे,

132
00:09:22,480 --> 00:09:24,620
40 बाइट की तरह कुछ,

133
00:09:24,620 --> 00:09:26,920
लेकिन अगर आप सरणी के सूचक प्रकार के आकार के लिए पूछना,

134
00:09:26,920 --> 00:09:32,740
यह तुम चर x ही है, जो उपकरण पर होने की संभावना सिर्फ 4 बाइट्स के आकार दे देंगे.

135
00:09:32,740 --> 00:09:36,530
सूचक सरणी प्रकार का उपयोग करना, यह असंभव है सीधे के लिए पूछ

136
00:09:36,530 --> 00:09:38,530
स्मृति के बड़े ब्लॉक के आकार.

137
00:09:38,530 --> 00:09:42,530
यह आमतौर पर प्रतिबंध के बाद से हम बहुत मुश्किल से ही आकार नहीं करना चाहता है

138
00:09:42,530 --> 00:09:46,980
की स्मृति का बड़ा ब्लॉक है, और हम आम तौर पर यह गणना अगर हम यह जरूरत हो सकता है.

139
00:09:46,980 --> 00:09:51,490
>> अंत में, ब्रैकेट सरणी के लिए हमें एक सरणी आरंभ करने के लिए एक शॉर्टकट के साथ प्रदान करने के लिए होता है.

140
00:09:51,490 --> 00:09:56,130
चलो देखते हैं कि कैसे हम पहले 10 भी शॉर्टकट initilization का उपयोग integers लिख सकता.

141
00:10:11,220 --> 00:10:14,470
सूचक सरणी के साथ, वहाँ इस तरह एक शॉर्टकट के लिए एक रास्ता नहीं है.

142
00:10:14,470 --> 00:10:18,120
यह सिर्फ क्या आप arrays के साथ कर सकते हैं के लिए एक परिचय है.

143
00:10:18,120 --> 00:10:20,990
वे लगभग हर कार्यक्रम आप लिखने में दिखाते हैं.

144
00:10:20,990 --> 00:10:24,390
उम्मीद है अब आप छात्र आईडी उदाहरण करने का एक बेहतर तरीका देख सकते हैं

145
00:10:24,390 --> 00:10:26,710
वीडियो की शुरुआत से.

146
00:10:26,710 --> 00:10:29,960
>> मेरा नाम रोब Bowden है, और इस CS50 है.