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

2
00:00:02,395 --> 00:00:05,750

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

4
00:00:06,506 --> 00:00:08,880
हम पूर्णांकों के साथ काम किया है,
हम पात्रों के साथ काम किया है,

5
00:00:08,880 --> 00:00:11,930
हम मंगाई काम किया है,
युगल, तार, और bools।

6
00:00:11,930 --> 00:00:14,870
हम सभी बहुत सुंदर समाप्त किया
[अश्राव्य] प्रकार की है कि

7
00:00:14,870 --> 00:00:17,100
साथ में हम सभी के लिए उपलब्ध किया गया है।

8
00:00:17,100 --> 00:00:19,430
लेकिन अब हम अधिक कुछ करना चाहते हैं।

9
00:00:19,430 --> 00:00:20,210
हम इसे कैसे करते हैं?

10
00:00:20,210 --> 00:00:22,560
कैसे हम विभिन्न प्रकार के डेटा बना सकता हूँ?

11
00:00:22,560 --> 00:00:26,130
हम संरचनाओं का उपयोग करके ऐसा कर सकते हैं।

12
00:00:26,130 --> 00:00:30,180
तो संरचनाओं हमें एकजुट करने की अनुमति
विभिन्न प्रकार के चर

13
00:00:30,180 --> 00:00:34,810
एक एकल, नया चर प्रकार में,
जो हम अपने स्वयं के प्रकार का नाम निर्दिष्ट कर सकते हैं।

14
00:00:34,810 --> 00:00:37,570
यह एक बहुत मजबूत है
बात यह है कि ऐसा करने में सक्षम होने के लिए

15
00:00:37,570 --> 00:00:40,900
हम समूह अब कर सकते हैं क्योंकि
विभिन्न प्रकार के डेटा के तत्वों

16
00:00:40,900 --> 00:00:43,910
एक साथ एक तार्किक संबंध है।

17
00:00:43,910 --> 00:00:46,440
हम ऐसा करने में सक्षम किया गया है
एक तरह से सरणियों के साथ, है ना?

18
00:00:46,440 --> 00:00:49,540
हम कर सकते हैं समूह चर
एक ही डेटा प्रकार की

19
00:00:49,540 --> 00:00:53,410
एक साथ एक बड़ी इकाई में
स्मृति, एक सरणी की।

20
00:00:53,410 --> 00:00:56,660
>> लेकिन हम मिश्रण करने में सक्षम नहीं किया गया है
एक साथ विभिन्न प्रकार के डेटा।

21
00:00:56,660 --> 00:01:02,610
हम, एक पूर्णांक जोड़ी, नहीं कह सकता
और एक चरित्र, और एक डबल सभी

22
00:01:02,610 --> 00:01:05,330
एक ही बात में और
एक इकाई है कि कहते हैं।

23
00:01:05,330 --> 00:01:08,830
लेकिन साथ संरचनाओं, या
अक्सर, structs के रूप में भेजा

24
00:01:08,830 --> 00:01:09,585
हम वास्तव में कर सकते हैं।

25
00:01:09,585 --> 00:01:12,370
तो एक संरचना प्रकार है
के एक सुपर चर की तरह।

26
00:01:12,370 --> 00:01:16,530
यह होता है कि एक चर है
इसके अंदर अन्य चर।

27
00:01:16,530 --> 00:01:19,650
तो यहाँ का एक उदाहरण है
एक बहुत ही सरल संरचना।

28
00:01:19,650 --> 00:01:23,380
इस वाक्य रचना लग रही होगी क्या है
एक कार के लिए एक ढांचा बनाने के लिए पसंद करते हैं।

29
00:01:23,380 --> 00:01:25,250
अब, चलो यहाँ वाक्य रचना के माध्यम से चलते हैं।

30
00:01:25,250 --> 00:01:27,400
संरचना, कि
इंगित करता है कि कीवर्ड

31
00:01:27,400 --> 00:01:30,270
मैं यहाँ एक नया डेटा प्रकार पैदा कर रहा हूँ कि।

32
00:01:30,270 --> 00:01:33,860
विशेष रूप से, डेटा प्रकार का नाम है
जैसा कि हम देखेंगे, संरचना कार होने जा रहा।

33
00:01:33,860 --> 00:01:36,640
लेकिन इस टिप की तरह है
संकलक के लिए रवाना हो कि इस

34
00:01:36,640 --> 00:01:42,440
चर का एक समूह के रूप में है कि जा रहा है
एक ही प्रकार का हिस्सा माना जा करने के लिए

35
00:01:42,440 --> 00:01:44,010
एक मिनट में।

36
00:01:44,010 --> 00:01:46,340
>> कारें, संरचना का सिर्फ नाम।

37
00:01:46,340 --> 00:01:50,590
फिर, यहाँ डेटा प्रकार जा रहा है
संरचना कार में ही नहीं, कार हो।

38
00:01:50,590 --> 00:01:53,060
लेकिन अगर आप different-- है तो
यदि आप एकाधिक structs बनाते हैं तो

39
00:01:53,060 --> 00:01:56,950
एक ही कार्यक्रम में, आप की जरूरत है
संरचना और संरचना के बीच भेद।

40
00:01:56,950 --> 00:02:00,140
इसलिए संरचना कार, मैं भी हो सकता है
संरचना छात्र, उदाहरण के लिए,

41
00:02:00,140 --> 00:02:01,790
एक ही कार्यक्रम में।

42
00:02:01,790 --> 00:02:05,980
घुंघराले ब्रेसिज़ के अंदर हैं
तथाकथित क्षेत्र के सभी,

43
00:02:05,980 --> 00:02:07,954
या संरचना के सदस्य हैं।

44
00:02:07,954 --> 00:02:10,370
इसलिए चीजों में से कुछ क्या कर रहे हैं
एक कार में निहित हैं कि?

45
00:02:10,370 --> 00:02:15,270
खैर, यह आमतौर पर एक साल हो गया है है
एक मॉडल का नाम है, और एक लाइसेंस प्लेट,

46
00:02:15,270 --> 00:02:18,000
आमतौर पर है कि एक ओडोमीटर
उस पर मील के कुछ नंबर,

47
00:02:18,000 --> 00:02:19,225
और शायद एक इंजन आकार।

48
00:02:19,225 --> 00:02:23,570
जैसा कि आप देख सकते हैं, मैं ऊपर मिश्रण कर रहा हूँ
पूर्णांकों और वर्ण और युगल।

49
00:02:23,570 --> 00:02:26,420
वे सब होने के लिए जा रहे हैं
इस नए डेटा प्रकार का हिस्सा है।

50
00:02:26,420 --> 00:02:29,750
>> अंत में, अंतिम बात यह है कि मैं क्या करने की जरूरत है,
इस छोटी सी अर्धविराम मत भूलना

51
00:02:29,750 --> 00:02:30,290
अंत में।

52
00:02:30,290 --> 00:02:34,380
हम संरचना को परिभाषित समाप्त करने के बाद,
हम अंत में एक अर्धविराम डाल दिया है।

53
00:02:34,380 --> 00:02:37,325
यह एक बहुत ही आम वाक्य है
गलती की है, एक समारोह के साथ है, क्योंकि

54
00:02:37,325 --> 00:02:40,200
उदाहरण के लिए, तुम सिर्फ होता है
खुले घुंघराले गले लगा, करीब घुंघराले ब्रेस।

55
00:02:40,200 --> 00:02:42,950
तुम पर एक अर्धविराम मत डालो
एक समारोह परिभाषा के अंत।

56
00:02:42,950 --> 00:02:46,430
यह एक समारोह की तरह लग रहा है
परिभाषा, लेकिन यह नहीं है,

57
00:02:46,430 --> 00:02:49,653
और इतने अर्धविराम वहाँ
बस एक चेतावनी है कि आप

58
00:02:49,653 --> 00:02:52,440
क्योंकि, वहाँ डाल की जरूरत है
संकलक अन्यथा नहीं होगा

59
00:02:52,440 --> 00:02:53,510
इसके साथ क्या करना है पता।

60
00:02:53,510 --> 00:02:56,160
यह एक बहुत ही आम त्रुटि है
गलती से बनाने के लिए

61
00:02:56,160 --> 00:02:58,570
जब आप पहली बार संरचनाओं को परिभाषित कर रहे हैं।

62
00:02:58,570 --> 00:02:59,500
>> ठीक।

63
00:02:59,500 --> 00:03:02,824
तो हम आम तौर पर हमारे संरचनाओं को परिभाषित
हमारे कार्यक्रमों के ऊपर से ही

64
00:03:02,824 --> 00:03:05,490
वे शायद जा रहे हैं क्योंकि
कई कार्यों के द्वारा इस्तेमाल किया जाएगा।

65
00:03:05,490 --> 00:03:08,850
हम एक परिभाषित करने के लिए नहीं करना चाहते हैं
एक समारोह के अंदर struct,

66
00:03:08,850 --> 00:03:12,110
फिर हम only-- सकता है क्योंकि
संरचना के दायरे सच

67
00:03:12,110 --> 00:03:13,790
केवल कि समारोह के अंदर मौजूद है।

68
00:03:13,790 --> 00:03:17,450
हम शायद एक संरचना को परिभाषित करने के लिए चाहता हूँ
इसलिए हम कई कार्यों में इसका इस्तेमाल कर सकते हैं,

69
00:03:17,450 --> 00:03:20,670
या शायद कई में
एक साथ बंधे हैं जो फ़ाइलों

70
00:03:20,670 --> 00:03:22,920
हमारे एक कार्यक्रम बनाने के लिए।

71
00:03:22,920 --> 00:03:24,920
कभी-कभी यह भी बजाय
संरचना को परिभाषित करने की

72
00:03:24,920 --> 00:03:27,961
आप कहाँ रखा ऊपर से ही अपने
, पौंड भी शामिल है और अपने पाउंड को परिभाषित करता है

73
00:03:27,961 --> 00:03:32,080
उदाहरण के लिए, आप उन्हें में डाल सकता है
अलग डॉट ज फ़ाइलें, तो जो आप

74
00:03:32,080 --> 00:03:35,020
आधा किलो खुद के शामिल हैं।

75
00:03:35,020 --> 00:03:37,620
>> इसलिए हम संरचना है, लेकिन अब
हम उनमें से अंदर प्राप्त करने की जरूरत है।

76
00:03:37,620 --> 00:03:39,800
हम कैसे के अंदर मिलता है
उपयोग करने के लिए एक संरचना

77
00:03:39,800 --> 00:03:43,530
उन उप चर, उन चर
कि संरचना के अंदर मौजूद हैं?

78
00:03:43,530 --> 00:03:46,810
खैर, हम कुछ कहा जाता है
हमें की अनुमति देता है, जो डॉट ऑपरेटर,

79
00:03:46,810 --> 00:03:50,990
संरचना के क्षेत्र तक पहुँचने के लिए।

80
00:03:50,990 --> 00:03:55,490
उदाहरण के लिए तो, चलो मैं घोषित है कहते हैं
मेरी संरचना डेटा कहीं टाइप

81
00:03:55,490 --> 00:03:59,020
अपने कार्यक्रम के शीर्ष पर, या शायद में
मैं पाउंड है कि एक डॉट ज फ़ाइल शामिल थे।

82
00:03:59,020 --> 00:04:03,360
मैं तो एक नया बनाने के लिए चाहते हैं
कि डेटा प्रकार के चर, मैं कह सकता हूँ

83
00:04:03,360 --> 00:04:06,260
संरचना कार, मेरी कार, अर्धविराम।

84
00:04:06,260 --> 00:04:11,580
मैं पूर्णांक कह सकते हैं, उसी तरह
एक्स, या स्ट्रिंग नाम अर्धविराम।

85
00:04:11,580 --> 00:04:18,100
>> यहां डेटा प्रकार, संरचना कार है
चर का नाम, मेरी कार है

86
00:04:18,100 --> 00:04:23,770
और फिर मैं करने के लिए डॉट ऑपरेटर का उपयोग कर सकते हैं
मेरी कार के विभिन्न क्षेत्रों का उपयोग।

87
00:04:23,770 --> 00:04:27,494
तो मैं अपनी कार में कह सकते हैं
डॉट वर्ष 2011 के बराबर होती है।

88
00:04:27,494 --> 00:04:28,410
यही कारण है कि पूरी तरह से ठीक है।

89
00:04:28,410 --> 00:04:34,210
यदि आपको याद है वर्ष, एक के रूप में परिभाषित किया गया था
इस संरचना कार के अंदर पूर्णांक क्षेत्र

90
00:04:34,210 --> 00:04:35,200
डेटा प्रकार।

91
00:04:35,200 --> 00:04:39,966
संरचना कार डेटा की तो किसी भी चर
प्रकार, ऐसी मेरी कार के रूप में, मैं अपनी कार में कह सकते हैं

92
00:04:39,966 --> 00:04:44,030
डॉट साल के बराबर होती है और उसके बाद आवंटित
यह कुछ पूर्णांक मान, 2011।

93
00:04:44,030 --> 00:04:47,290
मेरी कार डॉट प्लेट CS50 के बराबर होती है।

94
00:04:47,290 --> 00:04:51,180
मेरा कार्ड डॉट ओडोमीटर
50,505 अर्धविराम के बराबर होती है।

95
00:04:51,180 --> 00:04:53,270
उन सब के सब कर रहे हैं
पूरी तरह से ठीक है और वह है

96
00:04:53,270 --> 00:04:57,802
हम का उपयोग कैसे
संरचना के क्षेत्र।

97
00:04:57,802 --> 00:05:00,260
संरचनाएं, हालांकि, की जरूरत नहीं
ढेर पर बनाया जाना है।

98
00:05:00,260 --> 00:05:02,950
बस हम किसी भी अन्य चर की तरह
गतिशील उन्हें आवंटित कर सकते हैं।

99
00:05:02,950 --> 00:05:06,309
हम एक प्रोग्राम है कि हो सकता है
कई इमारतों पैदा हो,

100
00:05:06,309 --> 00:05:08,100
हम कितने पता नहीं है
हम जरूरत के लिए जा रहे हैं

101
00:05:08,100 --> 00:05:10,800
तो हम गतिशील करने की जरूरत है
उन संरचनाओं का आवंटन

102
00:05:10,800 --> 00:05:12,960
हमारे कार्यक्रम के रूप में चल रहा है।

103
00:05:12,960 --> 00:05:16,600
और हम का उपयोग करने के लिए जा रहे हैं, इसलिए यदि
इस संदर्भ में एक संरचना के क्षेत्र,

104
00:05:16,600 --> 00:05:20,660
हम पहली भिन्नता की जरूरत है कि याद करते हैं
संरचना के लिए सूचक,

105
00:05:20,660 --> 00:05:24,810
और फिर हम एक बार भिन्नता
सूचक है, तो हम क्षेत्रों का उपयोग कर सकते हैं।

106
00:05:24,810 --> 00:05:26,830
हम केवल एक है, तो
संरचना के लिए सूचक,

107
00:05:26,830 --> 00:05:32,120
हम सिर्फ सूचक डॉट क्षेत्र नहीं कह सकता
नाम है और हम क्या देख रहे हैं मिलता है।

108
00:05:32,120 --> 00:05:34,259
अपसंदर्भन के अतिरिक्त कदम नहीं है।

109
00:05:34,259 --> 00:05:36,050
तो चलो हम कहते हैं कि
बजाय previous-- की

110
00:05:36,050 --> 00:05:38,770
सिर्फ पिछले उदाहरण की तरह,
इसके बजाय यह घोषणा की

111
00:05:38,770 --> 00:05:43,680
ढेर पर, संरचना कार, मेरी
कार, ​​अर्धविराम, मैं संरचना कार का कहना है

112
00:05:43,680 --> 00:05:48,020
स्टार, एक के लिए एक सूचक
संरचना कार, मेरी कार बुलाया

113
00:05:48,020 --> 00:05:51,250
संरचना कार की malloc आकार के बराबर होती है।

114
00:05:51,250 --> 00:05:54,950
कितने हम का आकार पता लगा लेंगे
अपने नए डेटा प्रकार ऊपर लेता बाइट्स।

115
00:05:54,950 --> 00:05:58,570
तुम जरूरी ही उपयोग करने की आवश्यकता नहीं है
चौड़ाई, पूर्णांक, या चार, या किसी के आकार

116
00:05:58,570 --> 00:05:59,715
निर्मित में डेटा प्रकार के।

117
00:05:59,715 --> 00:06:02,090
संकलक काफी चालाक है
कितने बाइट्स बाहर निकालने के लिए

118
00:06:02,090 --> 00:06:04,170
अपनी नई संरचना के लिए आवश्यक हैं।

119
00:06:04,170 --> 00:06:09,610
इसलिए मैं अपने आप को स्मृति की एक इकाई malloc
एक संरचना कार रखने के लिए बड़ा,

120
00:06:09,610 --> 00:06:12,410
और मैं वापस एक सूचक मिलता है
स्मृति की है कि ब्लॉक करने के लिए,

121
00:06:12,410 --> 00:06:16,090
और कि सूचक मेरी कार को सौंपा है।

122
00:06:16,090 --> 00:06:18,050
>> अब, मैं उपयोग करना चाहते हैं
मेरी कार के क्षेत्रों,

123
00:06:18,050 --> 00:06:22,615
मैं पहली बार अपने कार भिन्नता का उपयोग कर
भिन्नता ऑपरेटर, स्टार

124
00:06:22,615 --> 00:06:26,620
हम संकेत से देखा है कि
वीडियो, और फिर मैं भिन्नता के बाद,

125
00:06:26,620 --> 00:06:32,200
फिर मैं करने के लिए डॉट ऑपरेटर का उपयोग कर सकते हैं
मेरी कार के विभिन्न क्षेत्रों का उपयोग।

126
00:06:32,200 --> 00:06:35,490
वर्ष 2011 के बराबर होती डॉट मेरी कार स्टार।

127
00:06:35,490 --> 00:06:38,480
यही प्रभाव होता है
हम इस मामले में चाहते हैं,

128
00:06:38,480 --> 00:06:41,960
हम गतिशील है क्योंकि
मेरी कार आवंटित।

129
00:06:41,960 --> 00:06:43,610
>> यह सही है, हालांकि, एक तरह से परेशान है?

130
00:06:43,610 --> 00:06:44,818
अब एक दो कदम प्रक्रिया है।

131
00:06:44,818 --> 00:06:47,460
अब हम dereference-- करना है
हम एक स्टार ऑपरेटर है,

132
00:06:47,460 --> 00:06:48,910
और हम एक डॉट ऑपरेटर है।

133
00:06:48,910 --> 00:06:51,660
और आप उम्मीद कर सकते हैं, क्योंकि
सी प्रोग्रामर कम तरीके से प्यार

134
00:06:51,660 --> 00:06:53,740
बातें करने के लिए, वहाँ एक है
छोटा रास्ता यह करने के लिए।

135
00:06:53,740 --> 00:06:57,790
तीर नामक एक और ऑपरेटर है,
जो इस प्रक्रिया को बहुत आसान बना देता है।

136
00:06:57,790 --> 00:07:00,750
तीर जिस तरह काम करता है
यह पहली बार dereferences

137
00:07:00,750 --> 00:07:03,560
बाईं तरफ के सूचक
ऑपरेटर की ओर,

138
00:07:03,560 --> 00:07:06,620
और फिर, के बाद dereferenced होने
बाईं तरफ के सूचक,

139
00:07:06,620 --> 00:07:09,620
यह ठीक है पर क्षेत्र तक पहुँचता है।

140
00:07:09,620 --> 00:07:14,170
और तो पहले हम इस प्रकार था
की मेरी कार, यह सब सामान डॉट स्टार

141
00:07:14,170 --> 00:07:15,880
जैसे वहाँ पर जा रहा एक बहुत कुछ था।

142
00:07:15,880 --> 00:07:22,040
लेकिन क्या हम बजाय क्या कर सकते है- है
मेरी कार तीर वर्ष 2011 के बराबर होती है।

143
00:07:22,040 --> 00:07:23,580
>> फिर, यहाँ क्या हो रहा है?

144
00:07:23,580 --> 00:07:25,720
सबसे पहले, मैं अपनी कार अपसंदर्भन रहा हूँ।

145
00:07:25,720 --> 00:07:27,810
जो फिर से, यहाँ एक सूचक है।

146
00:07:27,810 --> 00:07:31,270
फिर, होने के बाद
मैं, मेरी कार dereferenced

147
00:07:31,270 --> 00:07:35,130
तो खेतों तक पहुँच सकते हैं
साल, थाली, और ओडोमीटर

148
00:07:35,130 --> 00:07:40,020
सिर्फ मैं कर सकता के रूप में पहली होने से पहले
मेरी कार भिन्नता के लिए इस्तेमाल किया सितारा,

149
00:07:40,020 --> 00:07:42,020
और क्षेत्र का उपयोग करने के लिए डॉट।

150
00:07:42,020 --> 00:07:45,290
तो अगर आप, संरचनाओं हो सकता है
संरचनाओं के लिए संकेत हो सकता है,

151
00:07:45,290 --> 00:07:48,360
और आप का उपयोग करने के तरीके हैं
उन संरचनाओं के क्षेत्र,

152
00:07:48,360 --> 00:07:52,600
आप संकेत करने के लिए है कि क्या
उन्हें या चर खुद को।

153
00:07:52,600 --> 00:07:57,640
डॉट या तीर, पर निर्भर करता है
चर कैसे घोषित किया गया था।

154
00:07:57,640 --> 00:08:00,510
मैं डौग लॉयड हूँ, इस CS50 है।

155
00:08:00,510 --> 00:08:01,975