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

2
00:00:03,388 --> 00:00:05,104

3
00:00:05,104 --> 00:00:06,020
डौग लॉयड: ठीक है।

4
00:00:06,020 --> 00:00:07,680
एकल के साथ कार्य करना
चर बहुत मजेदार है।

5
00:00:07,680 --> 00:00:09,500
लेकिन क्या अगर हम चाहते हैं काम करने के लिए
चर का एक बहुत कुछ के साथ,

6
00:00:09,500 --> 00:00:12,760
लेकिन हम में से एक गुच्छा है नहीं करना चाहते हैं
हमारे कोड के आसपास अलग-अलग नाम उड़ान?

7
00:00:12,760 --> 00:00:15,980
इस मामले में, सरणियों हैं
वास्तव में काम में आने वाला।

8
00:00:15,980 --> 00:00:19,510
सारणियों वास्तव में एक मौलिक डेटा कर रहे हैं
किसी भी प्रोग्रामिंग भाषा के लिए संरचना

9
00:00:19,510 --> 00:00:20,260
कि आप प्रयोग करेंगे।

10
00:00:20,260 --> 00:00:24,450
और वे वास्तव में, वास्तव में उपयोगी हो
विशेष रूप से, हम सीएस 50 में, देखेंगे के रूप में।

11
00:00:24,450 --> 00:00:27,870
>> हम धारण करने के लिए सारणियों का उपयोग
एक ही डेटा प्रकार के मूल्यों

12
00:00:27,870 --> 00:00:29,830
सन्निहित स्मृति स्थानों पर।

13
00:00:29,830 --> 00:00:32,430
यही कारण है कि यह एक है, कहने के लिए है
तरीका यह है कि हम समूह कर सकते हैं

14
00:00:32,430 --> 00:00:35,430
साथ में पूर्णांकों का एक गुच्छा
स्मृति या अक्षरों का एक गुच्छा

15
00:00:35,430 --> 00:00:38,270
या वास्तव में स्मृति में तैरता
एक साथ बंद करने और काम

16
00:00:38,270 --> 00:00:41,930
उनके साथ प्रत्येक देने के लिए बिना
एक का अपना अनूठा नाम है, जो कर सकते हैं

17
00:00:41,930 --> 00:00:44,500
थोड़ी देर के बाद बोझिल मिलता है।

18
00:00:44,500 --> 00:00:48,130
>> अब, एक ही रास्ता सरणियों analogize को
अपने स्थानीय पोस्ट के बारे में सोचने के लिए है

19
00:00:48,130 --> 00:00:49,000
एक पल के लिए कार्यालय।

20
00:00:49,000 --> 00:00:51,820
तो प्रोग्रामिंग से दूर कदम
और सिर्फ अपनी आँखें बंद

21
00:00:51,820 --> 00:00:54,120
और अपने मन में कल्पना
अपने स्थानीय पोस्ट ऑफिस।

22
00:00:54,120 --> 00:00:57,160
आमतौर पर, सबसे बाद में
कार्यालयों, एक बड़े बैंक भी नहीं है

23
00:00:57,160 --> 00:01:00,490
दीवार पर एक पोस्ट ऑफिस बॉक्स का।

24
00:01:00,490 --> 00:01:03,510
>> एक सरणी एक विशाल खंड है
सन्निहित स्मृति की,

25
00:01:03,510 --> 00:01:06,120
एक मेल है कि एक ही रास्ता
अपने पोस्ट ऑफिस में बैंक

26
00:01:06,120 --> 00:01:11,230
एक बड़ी जगह पर है
पोस्ट ऑफिस की दीवार।

27
00:01:11,230 --> 00:01:15,750
सारणियों, छोटे में विभाजित कर दिया गया है
हूबहू अंतरिक्ष के आकार के ब्लॉक,

28
00:01:15,750 --> 00:01:19,930
जिनमें से प्रत्येक में एक तत्व कहा जाता है
उसी तरह से पोस्ट की दीवार है कि

29
00:01:19,930 --> 00:01:23,840
कार्यालय, छोटे में विभाजित किया गया है
हूबहू अंतरिक्ष के आकार के ब्लॉक,

30
00:01:23,840 --> 00:01:27,560
जो हम एक PO बॉक्स कहते हैं।

31
00:01:27,560 --> 00:01:31,650
सरणी के प्रत्येक तत्व कर सकते हैं
, डेटा की एक निश्चित राशि की दुकान

32
00:01:31,650 --> 00:01:37,540
प्रत्येक पोस्ट ऑफिस बॉक्स में सक्षम है बस के रूप में
मेल की एक निश्चित राशि धारण करने के लिए।

33
00:01:37,540 --> 00:01:41,540
>> के प्रत्येक तत्व में संग्रहित किया जा सकता है क्या
सरणी एक ही डेटा के चर है

34
00:01:41,540 --> 00:01:45,300
इस तरह के सिर्फ पूर्णांक या चार, के रूप में प्रकार,
अपनी पोस्ट ऑफिस बॉक्स में की तरह,

35
00:01:45,300 --> 00:01:47,300
आप केवल बातें कर सकते हैं फिट
एक समान प्रकार की,

36
00:01:47,300 --> 00:01:50,430
इस तरह के पत्र या छोटे पैकेज के रूप में।

37
00:01:50,430 --> 00:01:55,050
अन्त में, हम में से हर तत्व का उपयोग कर सकते हैं
सीधे सूचकांक संख्या से सरणी,

38
00:01:55,050 --> 00:01:59,770
हम अपने पोस्ट ऑफिस तक पहुंच सकते हैं बस के रूप में
अपने मेलबॉक्स नंबर जानने के द्वारा बॉक्स।

39
00:01:59,770 --> 00:02:02,750
उम्मीद है, कि सादृश्य
आप अपने सिर को पाने में मदद करता है

40
00:02:02,750 --> 00:02:05,540
सरणियों के विचार से चारों ओर
कुछ और करने को सादृश्य

41
00:02:05,540 --> 00:02:08,400
आप शायद हैं कि
साथ पहले से ही परिचित।

42
00:02:08,400 --> 00:02:13,182
>> सी में, एक सरणी के तत्व होते हैं
1 से नहीं, 0 से शुरू अनुक्रमित।

43
00:02:13,182 --> 00:02:14,390
और यह वास्तव में महत्वपूर्ण है।

44
00:02:14,390 --> 00:02:18,530
यही कारण है कि हम और वास्तव में, यह है, सीएस 50 में,
बार और क्यों कंप्यूटर वैज्ञानिकों

45
00:02:18,530 --> 00:02:22,150
0 से गिनती होगी, है
क्योंकि सी सरणी की

46
00:02:22,150 --> 00:02:24,660
हमेशा 0 में शुरू होता है, जो अनुक्रमण,।

47
00:02:24,660 --> 00:02:28,730
एक सरणी n तत्वों के होते हैं तो,
उस सरणी के पहले तत्व

48
00:02:28,730 --> 00:02:32,960
, 0 सूचकांक में स्थित है और
सरणी के अंतिम तत्व

49
00:02:32,960 --> 00:02:36,610
सूचकांक n शून्य से 1 पर स्थित है।

50
00:02:36,610 --> 00:02:43,160
फिर, में n तत्वों है कि अगर वहाँ हमारे
सरणी, पिछले सूचकांक n शून्य से 1 है।

51
00:02:43,160 --> 00:02:46,820
>> इसलिए हमारे सरणी 50 तत्व है, यदि
पहला तत्व, 0 सूचकांक में स्थित है

52
00:02:46,820 --> 00:02:51,060
और पिछले तत्व
सूचकांक 49 पर स्थित है।

53
00:02:51,060 --> 00:02:53,940
दुर्भाग्य से, या सौभाग्य से,
आपके दृष्टिकोण पर निर्भर करता है,

54
00:02:53,940 --> 00:02:56,170
सी यहाँ बहुत उदार है।

55
00:02:56,170 --> 00:02:59,480
यह करने से रोकने नहीं होगा
अपने सरणी की सीमा से बाहर जा रहा है।

56
00:02:59,480 --> 00:03:03,080
आप शून्य तक पहुँच सकता है
अपने सरणी के 3 तत्व

57
00:03:03,080 --> 00:03:07,400
या अपने सरणी के 59 वें तत्व,
अपने सरणी केवल 50 तत्वों की है।

58
00:03:07,400 --> 00:03:11,060
यह से अपने कार्यक्रम बंद नहीं होगा
संकलन, लेकिन चलाते समय,

59
00:03:11,060 --> 00:03:14,350
आप एक मुठभेड़ हो सकता है
खूंखार विभाजन गलती

60
00:03:14,350 --> 00:03:17,460
आप स्मृति का उपयोग करने के लिए शुरू करते हैं
कि क्या की सीमा से बाहर है

61
00:03:17,460 --> 00:03:19,260
क्या आप को देने के लिए अपने कार्यक्रम के लिए कहा।

62
00:03:19,260 --> 00:03:21,250
इसलिए सावधान रहना है।

63
00:03:21,250 --> 00:03:23,120
>> क्या एक सरणी करता है
घोषणा की तरह लग रही है?

64
00:03:23,120 --> 00:03:26,940
हम अस्तित्व में एक सरणी कोड क्या कैसे
जैसे हम किसी भी अन्य चर कोड?

65
00:03:26,940 --> 00:03:31,250
तीन भागों में एक सरणी के लिए कर रहे हैं
एक प्रकार declaration--, एक नाम है,

66
00:03:31,250 --> 00:03:31,880
और एक आकार।

67
00:03:31,880 --> 00:03:34,088
यह एक के समान है
चर घोषणा, जो

68
00:03:34,088 --> 00:03:36,970
सिर्फ एक प्रकार है और एक नाम है,
किया जा रहा आकार तत्व

69
00:03:36,970 --> 00:03:39,860
एक सरणी के लिए विशेष मामला है,
हम उनमें से एक गुच्छा हो रही है क्योंकि

70
00:03:39,860 --> 00:03:41,830
एक ही समय में।

71
00:03:41,830 --> 00:03:45,560
>> इसलिए प्रकार चर किस तरह का है आप
सरणी के प्रत्येक तत्व होना चाहते हैं।

72
00:03:45,560 --> 00:03:47,150
पूर्णांकों की एक सरणी के लिए यह करना चाहते हैं?

73
00:03:47,150 --> 00:03:49,010
फिर, अपने डेटा प्रकार पूर्णांक होना चाहिए।

74
00:03:49,010 --> 00:03:51,760
आप इसे एक होना चाहते हैं
युगल या मंगाई की सरणी?

75
00:03:51,760 --> 00:03:54,545
डेटा प्रकार डबल हो या नाव चाहिए।

76
00:03:54,545 --> 00:03:56,420
नाम क्या है आप
अपने सरणी कॉल करना चाहते हैं।

77
00:03:56,420 --> 00:04:00,970
आप इस विशाल नाम करने के लिए क्या करना चाहते हैं
पूर्णांकों या मंगाई या वर्ण के बैंक

78
00:04:00,970 --> 00:04:03,250
या डबल्स, या जो कुछ भी आपके पास है?

79
00:04:03,250 --> 00:04:04,700
क्या तुम इसे कॉल करना चाहते हैं?

80
00:04:04,700 --> 00:04:06,110
सुंदर आत्म व्याख्यात्मक।

81
00:04:06,110 --> 00:04:08,610
>> चला जाता है, जो अंत में, आकार,
वर्ग कोष्ठक के अंदर,

82
00:04:08,610 --> 00:04:12,180
कितने तत्वों तुम होगा
अपने सरणी शामिल करने के लिए की तरह।

83
00:04:12,180 --> 00:04:13,530
आप कितने पूर्णांकों चाहते हो?

84
00:04:13,530 --> 00:04:15,570
आप कितने मंगाई चाहते हो?

85
00:04:15,570 --> 00:04:19,070
>> तो उदाहरण के लिए, छात्र ग्रेड 40 int।

86
00:04:19,070 --> 00:04:26,020
इस छात्र नामक एक सरणी वाणी
40 पूर्णांकों के होते हैं जो ग्रेड,।

87
00:04:26,020 --> 00:04:28,180
सुंदर आत्म व्याख्यात्मक, मुझे आशा है।

88
00:04:28,180 --> 00:04:29,330
यहाँ एक उदाहरण है।

89
00:04:29,330 --> 00:04:31,560
डबल मेनू कीमतों 8।

90
00:04:31,560 --> 00:04:34,610
यह कहा जाता है एक सरणी बनाता है
होते हैं जो मेनू कीमतों,

91
00:04:34,610 --> 00:04:38,300
आठ युगल के लिए स्मृति में कमरे से।

92
00:04:38,300 --> 00:04:42,000

93
00:04:42,000 --> 00:04:45,750
>> आप हर तत्व के बारे में सोच
प्रकार के डेटा प्रकार की एक सरणी की,

94
00:04:45,750 --> 00:04:49,860
इसलिए, उदाहरण के लिए, एक ही तत्व
int प्रकार की एक सरणी, एक ही तरीका है कि आप

95
00:04:49,860 --> 00:04:52,770
किसी अन्य के बारे में सोचना होगा
int प्रकार के चर,

96
00:04:52,770 --> 00:04:56,440
सभी परिचित संचालन हम उस
संचालन में पहले से चर्चा की

97
00:04:56,440 --> 00:04:58,270
वीडियो समझ कर देगा।

98
00:04:58,270 --> 00:05:01,620
यहाँ तो, हम एक सरणी घोषित कर सकता है
Truthtable बुलाया Booleans की,

99
00:05:01,620 --> 00:05:05,590
जो 10 Booleans के लिए कमरे के होते हैं।

100
00:05:05,590 --> 00:05:09,650
>> और फिर, अभी हम सिर्फ आवंटित कर सकते हैं पसंद
प्रकार के किसी भी अन्य चर के लिए एक मूल्य

101
00:05:09,650 --> 00:05:13,470
बूलियन, हम कुछ कह सकते हैं
Truthtable वर्ग कोष्ठक की तरह

102
00:05:13,470 --> 00:05:18,040
हम से संकेत मिलता है जो कि कैसे 2,
जो सच तालिका के तत्व?

103
00:05:18,040 --> 00:05:20,350
के तीसरे तत्व
सच तालिका, क्योंकि याद है,

104
00:05:20,350 --> 00:05:21,800
हम 0 से गिनती कर रहे हैं।

105
00:05:21,800 --> 00:05:25,690
तो यह है कि हम से संकेत मिलता है कि कैसे है
सच तालिका के तीसरे तत्व।

106
00:05:25,690 --> 00:05:28,680
Truthtable 2, झूठी बराबर होती है
बस हम declare-- सकता है की तरह

107
00:05:28,680 --> 00:05:33,560
या हम किसी भी, बल्कि आवंटित कर सकते हैं
बूलियन प्रकार चर झूठे हो।

108
00:05:33,560 --> 00:05:35,050
>> हम यह भी परिस्थितियों में इसका इस्तेमाल कर सकते हैं।

109
00:05:35,050 --> 00:05:39,000
(truthtable 7 == यदि
कहने के लिए है, जो सच है),

110
00:05:39,000 --> 00:05:42,370
आठवें तत्व है, तो
Truthtable का सच है,

111
00:05:42,370 --> 00:05:46,760
शायद हम एक संदेश मुद्रित करना चाहते हैं
उपयोगकर्ता, printf ("सच है! n") करने के लिए ;.

112
00:05:46,760 --> 00:05:50,290
यही कारण है कि Truthtable कहने के लिए हमें का कारण बनता है
10 सही, सच के बराबर होती है?

113
00:05:50,290 --> 00:05:53,590
खैर, मैं कर सकता हूँ, लेकिन यह बहुत है
खतरनाक है, क्योंकि याद है,

114
00:05:53,590 --> 00:05:56,260
हम 10 Booleans की एक सरणी है।

115
00:05:56,260 --> 00:06:02,340
तो उच्चतम सूचकांक कि
संकलक हमें 9 दिया है।

116
00:06:02,340 --> 00:06:06,010
>> इस कार्यक्रम के संकलन होगा, लेकिन
यदि स्मृति में कुछ और

117
00:06:06,010 --> 00:06:09,110
जहां हम करेंगे मौजूद है
Truthtable 10 जाने की उम्मीद है,

118
00:06:09,110 --> 00:06:13,980
हम एक विभाजन गलती पीड़ित सकता है। हम
इसके साथ दूर हो सकता है, लेकिन सामान्य रूप में,

119
00:06:13,980 --> 00:06:14,710
बहुत खतरनाक है।

120
00:06:14,710 --> 00:06:19,759
तो क्या मैं कर रहा हूँ यहाँ कानूनी सी है,
लेकिन जरूरी नहीं कि सबसे अच्छा कदम।

121
00:06:19,759 --> 00:06:22,300
अब, आप की घोषणा कब और
एक साथ एक सरणी को प्रारंभ,

122
00:06:22,300 --> 00:06:23,960
वास्तव में एक बहुत वहाँ है
विशेष सिंटैक्स कि आप

123
00:06:23,960 --> 00:06:26,250
सरणी को भरने के लिए उपयोग कर सकते हैं
अपने शुरुआती मूल्यों के साथ।

124
00:06:26,250 --> 00:06:30,130
यह करने के लिए बोझिल प्राप्त कर सकते हैं
, आकार 100 के एक सरणी की घोषणा

125
00:06:30,130 --> 00:06:33,430
और फिर कहने के लिए है, तत्व 0
इस के बराबर होती है; तत्व 1 इस के बराबर होती है;

126
00:06:33,430 --> 00:06:34,850
तत्व 2 कि बराबर होती है।

127
00:06:34,850 --> 00:06:36,370
सही, क्या बात है?

128
00:06:36,370 --> 00:06:39,470
>> यह एक छोटा सा सरणी है, तो आप
कुछ इस तरह कर सकता है।

129
00:06:39,470 --> 00:06:44,360
बूल truthtable 3 खुले बराबर होती है
घुंघराले ब्रेस और फिर अल्पविराम

130
00:06:44,360 --> 00:06:48,060
तत्वों की सूची अलग
आप सरणी में डाल करना चाहते हैं।

131
00:06:48,060 --> 00:06:50,520
फिर घुंघराले ब्रेस अर्धविराम बंद करें।

132
00:06:50,520 --> 00:06:53,910
इस की एक सरणी बनाता है
आकार Truthtable नामक तीन,

133
00:06:53,910 --> 00:06:56,090
तत्वों, झूठा सच है, और सच के साथ।

134
00:06:56,090 --> 00:06:59,270
और वास्तव में, प्रारंभ
मैं यहाँ वाक्य रचना है

135
00:06:59,270 --> 00:07:03,350
कर के रूप में बिल्कुल वैसा ही
नीचे व्यक्तिगत तत्व सिंटेक्स।

136
00:07:03,350 --> 00:07:09,380
कोडिंग के इन दो तरीकों से होता है
ठीक उसी सरणी का उत्पादन।

137
00:07:09,380 --> 00:07:11,740
>> इसी तरह, हम पुनरावृति सकता
तत्वों का सब कुछ खत्म

138
00:07:11,740 --> 00:07:15,400
एक पाश का उपयोग कर एक सरणी, जो, में से
तथ्य यह है कि एक बहुत ही जोरदार सिफारिश की है

139
00:07:15,400 --> 00:07:16,790
पर घर व्यायाम।

140
00:07:16,790 --> 00:07:20,720
कैसे आप एक सरणी कैसे बना सकता हूँ
100 पूर्णांक, जहां की

141
00:07:20,720 --> 00:07:23,477
सरणी के प्रत्येक तत्व अपने सूचकांक है?

142
00:07:23,477 --> 00:07:26,560
तो उदाहरण के लिए, हम 100 की एक सरणी है
पूर्णांकों, और पहली तत्व में,

143
00:07:26,560 --> 00:07:27,790
हम 0 डाल करना चाहते हैं।

144
00:07:27,790 --> 00:07:29,810
दूसरा तत्व में, हम एक डाल करना चाहते हैं।

145
00:07:29,810 --> 00:07:33,319
तीसरे तत्व में, हम चाहते हैं
2 डाल करने के लिए; और आगे और आगे।

146
00:07:33,319 --> 00:07:35,360
यह एक बहुत अच्छा है
पर घर व्यायाम है कि क्या करना है।

147
00:07:35,360 --> 00:07:38,190

148
00:07:38,190 --> 00:07:40,220
>> इधर, यह नहीं दिखता है
की तरह बहुत ज्यादा बदल गया है।

149
00:07:40,220 --> 00:07:44,170
लेकिन बीच में है कि नोटिस
वर्ग कोष्ठक, इस बार,

150
00:07:44,170 --> 00:07:45,830
मैं वास्तव में नंबर छोड़े गए गए हैं।

151
00:07:45,830 --> 00:07:48,000
आप उपयोग कर रहे हैं, तो यह बहुत ही
विशेष प्रारंभ

152
00:07:48,000 --> 00:07:50,380
वाक्य रचना एक बनाने के लिए
सरणी, आप वास्तव में नहीं है

153
00:07:50,380 --> 00:07:53,491
आकार संकेत की जरूरत है
सरणी के पहले से।

154
00:07:53,491 --> 00:07:55,740
संकलक काफी चालाक है
वास्तव में आप जानते हैं कि करने के लिए

155
00:07:55,740 --> 00:07:58,980
, आकार 3 की एक सरणी चाहते हैं
आप तीन तत्व डाल क्योंकि

156
00:07:58,980 --> 00:08:00,640
बराबर चिह्न के अधिकार के लिए।

157
00:08:00,640 --> 00:08:04,140
आप चार डाल दिया था, तो यह होता है
आप आकार चार के एक सच तालिका दिया;

158
00:08:04,140 --> 00:08:06,270
और आगे और आगे।

159
00:08:06,270 --> 00:08:09,380
>> सारणियों एक भी करने के लिए ही सीमित नहीं हैं
जो बहुत अच्छा है आयाम।

160
00:08:09,380 --> 00:08:12,000
आप वास्तव में कई हो सकते हैं
पक्ष विनिर्देशकों रूप में आप चाहते।

161
00:08:12,000 --> 00:08:16,470
तो उदाहरण के लिए, यदि आप बनाना चाहते हैं
खेल युद्धपोत के लिए एक बोर्ड है, जो,

162
00:08:16,470 --> 00:08:20,910
तुम कभी खेला है, तो है कि एक खेल है
10 ग्रिड से 10 पर खूंटे के साथ खेला जाता है,

163
00:08:20,910 --> 00:08:22,450
आप इस तरह से एक सरणी बना सकते हैं।

164
00:08:22,450 --> 00:08:26,030
आप Bool कह सकते हैं
युद्धपोत वर्ग ब्रैकेट 10

165
00:08:26,030 --> 00:08:29,590
बंद वर्ग कोष्ठक वर्ग
ब्रैकेट 10 वर्ग ब्रैकेट बंद हुआ।

166
00:08:29,590 --> 00:08:32,710
>> और फिर, आप करने के लिए चुन सकते हैं
एक 10 के रूप में अपने मन में इस व्याख्या

167
00:08:32,710 --> 00:08:35,576
कोशिकाओं के 10 ग्रिड द्वारा।

168
00:08:35,576 --> 00:08:37,409
अब, वास्तव में, स्मृति में,
यह वास्तव में सिर्फ करता है

169
00:08:37,409 --> 00:08:42,440
एक 100 तत्व रहते हैं
एकल आयामी सरणी।

170
00:08:42,440 --> 00:08:46,070
और यह है, वास्तव में, यदि आप के लिए चला जाता है
तीन आयामों या चार या पांच लोगों की है।

171
00:08:46,070 --> 00:08:49,420
यह वास्तव में सिर्फ गुणा होता है
indices-- के सभी

172
00:08:49,420 --> 00:08:51,130
या आकार के सभी
एक साथ specifiers--,

173
00:08:51,130 --> 00:08:53,480
और तुम सिर्फ एक आयामी मिल
उस आकार की सरणी।

174
00:08:53,480 --> 00:08:57,090
>> लेकिन संगठन के संदर्भ में और
दृश्य और मानव धारणा है,

175
00:08:57,090 --> 00:08:59,240
यह एक बहुत आसान हो सकता है
एक ग्रिड के साथ काम करने के लिए

176
00:08:59,240 --> 00:09:02,980
आप एक खेल पर काम कर रहे हैं
टिक टीएसी को पैर की अंगुली या युद्धपोत की तरह,

177
00:09:02,980 --> 00:09:05,179
या कुछ इस तरह का।

178
00:09:05,179 --> 00:09:06,970
यह एक महान अमूर्त है,
बजाय होने की

179
00:09:06,970 --> 00:09:09,340
एक टिक टीएसी को पैर की अंगुली के बारे में सोचने के लिए
नौ वर्ष की एक पंक्ति के रूप में बोर्ड

180
00:09:09,340 --> 00:09:13,810
चौराहों या एक युद्धपोत बोर्ड
100 चौकों की एक पंक्ति के रूप में।

181
00:09:13,810 --> 00:09:16,010
10 ग्रिड या एक तीन से एक 10
तीन से ग्रिड शायद है

182
00:09:16,010 --> 00:09:17,225
एक बहुत अधिक आसान अनुभव करने के लिए।

183
00:09:17,225 --> 00:09:19,820

184
00:09:19,820 --> 00:09:22,280
>> अब, कुछ वास्तव में
सरणियों के बारे में महत्वपूर्ण है।

185
00:09:22,280 --> 00:09:25,950
हम प्रत्येक व्यक्ति का इलाज कर सकते हैं
एक चर के रूप में सरणी के तत्व।

186
00:09:25,950 --> 00:09:27,700
हम जानते हैं कि पहले देखा था
जब हम बताए थे

187
00:09:27,700 --> 00:09:32,240
कुछ Booleans करने के लिए सही मूल्य
या सशर्त में उन्हें परीक्षण।

188
00:09:32,240 --> 00:09:35,960
लेकिन हम पूरे इलाज नहीं कर सकते
चर के रूप में खुद को arrays।

189
00:09:35,960 --> 00:09:41,760
हम, उदाहरण के लिए, एक सरणी प्रदान नहीं कर सकते
असाइनमेंट का उपयोग कर एक और सरणी के लिए

190
00:09:41,760 --> 00:09:42,930
ऑपरेटर।

191
00:09:42,930 --> 00:09:44,640
यह कानूनी सी नहीं है

192
00:09:44,640 --> 00:09:47,920
>> हम example-- के लिए, चाहते हैं क्या
हम चाहते हैं कि उदाहरण में कर रहा होगा

193
00:09:47,920 --> 00:09:50,200
दूसरे में एक सरणी कॉपी करने के लिए किया जाएगा।

194
00:09:50,200 --> 00:09:53,810
हम जानते हैं कि हम वास्तव में क्या करना चाहते हैं
पर कॉपी करने के लिए एक पाश का उपयोग करने की जरूरत है

195
00:09:53,810 --> 00:09:56,550
एक समय में प्रत्येक व्यक्ति तत्व है।

196
00:09:56,550 --> 00:09:58,700
मैं इसे लेने के लिए थोड़ा समय है पता है।

197
00:09:58,700 --> 00:10:04,022
>> तो उदाहरण के लिए, यदि हम इन जोड़ी थी
कोड की लाइनों की, यह काम करेगा?

198
00:10:04,022 --> 00:10:05,230
ठीक है, नहीं, यह सही नहीं होगा?

199
00:10:05,230 --> 00:10:07,860
हम कोशिश कर रहे हैं क्योंकि
पट्टी करने के लिए भोजन आवंटित करने के लिए।

200
00:10:07,860 --> 00:10:09,860
यही कारण है कि काम करने के लिए नहीं जा रहा है,
यह एक सरणी है, क्योंकि

201
00:10:09,860 --> 00:10:13,130
और हम सिर्फ वर्णित
कि कानूनी सी नहीं है कि

202
00:10:13,130 --> 00:10:15,580
>> इसके बजाय, हम करना चाहते हैं
भोजन की सामग्री की नकल

203
00:10:15,580 --> 00:10:18,070
जो है, जो बार में
हम यहाँ क्या करने की कोशिश कर रहे हैं

204
00:10:18,070 --> 00:10:19,970
हम इस तरह एक वाक्य रचना की आवश्यकता होगी।

205
00:10:19,970 --> 00:10:24,170
हम एक पाश के लिए चला जाता है कि राशि
जम्मू से 5 तक के 0 के बराबर है

206
00:10:24,170 --> 00:10:28,390
और हम में से हर यात्रा पर जम्मू वेतन वृद्धि
पाश और इस तरह से निरुपित तत्वों।

207
00:10:28,390 --> 00:10:33,360
यह भी बार नतीजा होगा
किया जा रहा है एक, दो, तीन, चार, पांच,

208
00:10:33,360 --> 00:10:36,730
लेकिन हम बहुत यह यह करना होगा
धीमी तत्व द्वारा-तत्व भी तरह से,

209
00:10:36,730 --> 00:10:40,009
के बजाय सिर्फ द्वारा
पूरे सरणी नकल।

210
00:10:40,009 --> 00:10:42,050
अन्य प्रोग्रामिंग में
भाषाओं, अधिक आधुनिक लोगों,

211
00:10:42,050 --> 00:10:45,610
आप वास्तव में है, अभी क्या कर सकते हैं
कि वाक्य रचना सरल बराबर होती है।

212
00:10:45,610 --> 00:10:49,620
लेकिन सी, दुर्भाग्य से, हम कर रहे हैं
ऐसा करने के लिए अनुमति नहीं है।

213
00:10:49,620 --> 00:10:52,026
>> अब, एक दूसरे को देखते है
बात यह है कि मैं उल्लेख करना चाहते हैं

214
00:10:52,026 --> 00:10:54,650
सरणियों के बारे में कि एक छोटे से किया जा सकता है
थोड़ा मुश्किल पहली बार जब आप

215
00:10:54,650 --> 00:10:55,990
उन लोगों के साथ काम करते हैं।

216
00:10:55,990 --> 00:10:59,860
हम एक वीडियो में चर्चा
चर गुंजाइश के बारे में,

217
00:10:59,860 --> 00:11:04,940
कि जब आप कॉल सी में सबसे चर,
उन्हें कार्यों में, मूल्य द्वारा पारित कर रहे हैं।

218
00:11:04,940 --> 00:11:08,620
आप इसका क्या मतलब याद है
मूल्य से कुछ को पारित करने के लिए?

219
00:11:08,620 --> 00:11:12,570
यह हम की एक प्रतिलिपि बना रहे हैं इसका मतलब
में पारित किया जा रहा है कि चर।

220
00:11:12,570 --> 00:11:16,290
कॉल प्राप्त करने वाला समारोह, समारोह
कि, चर प्राप्त है

221
00:11:16,290 --> 00:11:17,730
चर खुद को नहीं मिलता है।

222
00:11:17,730 --> 00:11:20,850
यह अपने आप ही स्थानीय हो जाता है
यह की नकल के साथ काम करने के लिए।

223
00:11:20,850 --> 00:11:24,070
>> सारणियों, ज़ाहिर है, ऐसा
इस नियम का पालन नहीं।

224
00:11:24,070 --> 00:11:27,600
बल्कि, हम यह कहते हैं क्या
संदर्भ से गुजर रहा है।

225
00:11:27,600 --> 00:11:31,360
कॉल प्राप्त करने वाला वास्तव में
सरणी प्राप्त करता है।

226
00:11:31,360 --> 00:11:34,207
यह प्राप्त नहीं होता है इसकी
इसके बारे में अपने स्थानीय प्रतिलिपि।

227
00:11:34,207 --> 00:11:36,040
और आप के बारे में सोचते हैं, तो
यह, यह समझ में आता है।

228
00:11:36,040 --> 00:11:39,750
सरणियों वास्तव में बड़े हैं, तो यह
इतना समय और प्रयास लेता है

229
00:11:39,750 --> 00:11:44,470
की एक सरणी की एक प्रतिलिपि बनाने के लिए
100 या 1000 या 10,000 तत्वों,

230
00:11:44,470 --> 00:11:48,290
यह एक के लिए इसके लायक नहीं है कि
इसकी एक प्रति प्राप्त करने के लिए कार्य करते हैं,

231
00:11:48,290 --> 00:11:51,037
फिर उसके साथ कुछ काम करते हैं, और
बस कॉपी के साथ किया जा;

232
00:11:51,037 --> 00:11:53,120
यह करने की जरूरत नहीं है
यह अब और चारों ओर लटके।

233
00:11:53,120 --> 00:11:54,710
>> सरणियों हैं क्योंकि कुछ
भारी और बोझिल,

234
00:11:54,710 --> 00:11:56,001
हम सिर्फ संदर्भ द्वारा उनके पास।

235
00:11:56,001 --> 00:12:01,210
हम सिर्फ इतना है कि समारोह पर भरोसा
, कुछ भी नहीं तोड़ कर लिए।

236
00:12:01,210 --> 00:12:03,010
तो यह वास्तव में सरणी प्राप्त करता है।

237
00:12:03,010 --> 00:12:05,290
यह यह की अपनी खुद की स्थानीय प्रतिलिपि नहीं मिलता है।

238
00:12:05,290 --> 00:12:07,170
>> अच्छा तो इसका क्या मतलब है,
तब, जब कॉल प्राप्त करने वाला

239
00:12:07,170 --> 00:12:08,970
सरणी के तत्वों manipulates?

240
00:12:08,970 --> 00:12:10,780
क्या होता है?

241
00:12:10,780 --> 00:12:13,210
अभी के लिए, हम व्याख्या करेंगे
यही कारण है कि वास्तव में इस पर

242
00:12:13,210 --> 00:12:15,320
, क्यों सरणियों होता है
संदर्भ द्वारा पारित कर रहे हैं

243
00:12:15,320 --> 00:12:17,810
और सब कुछ मान द्वारा पारित कर दिया है।

244
00:12:17,810 --> 00:12:20,470
लेकिन मैं तुमसे वादा करता है, हम करेंगे
लौट सकते हैं और आप जवाब दे

245
00:12:20,470 --> 00:12:23,750
बाद में एक वीडियो में यह करने के लिए।

246
00:12:23,750 --> 00:12:28,110
>> यहाँ आप के लिए एक और व्यायाम है
हम सरणियों पर चीजों को लपेट से पहले।

247
00:12:28,110 --> 00:12:31,400
यहाँ कोड का गुच्छा, कि
नहीं विशेष रूप से अच्छा शैली,

248
00:12:31,400 --> 00:12:33,400
सिर्फ मैं चेतावनी है कि बनाती हूँ।

249
00:12:33,400 --> 00:12:36,660
यहाँ में कोई टिप्पणी नहीं है,
जो बहुत बुरा रूप है।

250
00:12:36,660 --> 00:12:39,750
लेकिन यह मैं नहीं जाना चाहता क्योंकि केवल
स्क्रीन पर सब कुछ फिट करने में सक्षम।

251
00:12:39,750 --> 00:12:44,360
>> शीर्ष पर, आप है कि मैं देख सकते हैं
सेट सरणी के लिए दो समारोह घोषणाओं

252
00:12:44,360 --> 00:12:45,820
और पूर्णांक निर्धारित किया है।

253
00:12:45,820 --> 00:12:49,680
सेट सरणी जाहिरा तौर पर एक सरणी लेता है
अपने इनपुट के रूप में चार पूर्णांक।

254
00:12:49,680 --> 00:12:52,767
और सेट पूर्णांक जाहिरा तौर पर लेता है
अपने इनपुट के रूप में एक पूर्णांक।

255
00:12:52,767 --> 00:12:54,350
लेकिन उन दोनों को एक उत्पादन की जरूरत नहीं है।

256
00:12:54,350 --> 00:12:57,689
उत्पादन, वापसी
हर एक शून्य है की, टाइप करें।

257
00:12:57,689 --> 00:12:59,480
मुख्य रूप से, हमारे पास एक
कोड की लाइनों की जोड़ी।

258
00:12:59,480 --> 00:13:02,730
हम एक पूर्णांक चर घोषित
एक कहा जाता है और यह मूल्य 10 आवंटित।

259
00:13:02,730 --> 00:13:07,080
हम चार पूर्णांक एक सरणी की घोषणा
बी कहा जाता है और तत्वों 0, 1 आवंटित,

260
00:13:07,080 --> 00:13:08,730
क्रमश: 2, और 3,।

261
00:13:08,730 --> 00:13:12,190
तो, हम स्थापित करने के लिए एक फोन है
int और एक कॉल सरणी स्थापित करने के लिए।

262
00:13:12,190 --> 00:13:15,910
सेट सरणी और सेट की परिभाषा
पूर्णांक तल पर, नीचे से नीचे हैं।

263
00:13:15,910 --> 00:13:17,640
>> और हां, तो फिर, मैं आप सवाल पूछते हैं।

264
00:13:17,640 --> 00:13:20,770
क्या बाहर मुद्रित हो जाता है
यहां मुख्य के अंत में?

265
00:13:20,770 --> 00:13:23,020
एक प्रिंटआउट कर्नल है। मैं कर रहा हूँ
दो पूर्णांकों को छापता है।

266
00:13:23,020 --> 00:13:28,010
मैं एक की सामग्री को बाहर मुद्रण कर रहा हूँ और
बी वर्ग कोष्ठक 0 की सामग्री।

267
00:13:28,010 --> 00:13:29,880
यहाँ वीडियो रोकें और एक मिनट ले।

268
00:13:29,880 --> 00:13:35,482
आप क्या यह समझ सकते
समारोह के अंत में मुद्रित होगा?

269
00:13:35,482 --> 00:13:38,190
उम्मीद है, यदि आपको याद है
मूल्य से गुजर बीच भेद

270
00:13:38,190 --> 00:13:41,680
और संदर्भ से गुजर रहा है, इस
समस्या यह है आप के लिए भी मुश्किल नहीं था।

271
00:13:41,680 --> 00:13:44,130
जवाब और तुम होगा
पाया है यह है।

272
00:13:44,130 --> 00:13:47,660
आप के रूप में सच में यकीन नहीं कर रहे हैं
यह मामला है क्यों, एक दूसरा ले

273
00:13:47,660 --> 00:13:50,620
वापस जाने के लिए, मैं तो बस क्या था की समीक्षा
सरणियों गुजर के बारे में चर्चा

274
00:13:50,620 --> 00:13:53,450
संदर्भ द्वारा, गुजर बनाम
मूल्य द्वारा अन्य चर,

275
00:13:53,450 --> 00:13:56,680
और उम्मीद है, यह कर दूँगा
एक छोटा सा और भावना।

276
00:13:56,680 --> 00:13:59,760
>> मैं डौग लॉयड हूँ, और इस CS50 है।

277
00:13:59,760 --> 00:14:01,467