1
00:00:07,632 --> 00:00:10,270
[Powered by Google Translate] जोर्डन JOZWIAK: प्रकार कास्टिंग, सरल अर्थों में, एक

2
00:00:10,270 --> 00:00:13,300
द्वारा कुछ डेटा के एक कंप्यूटर की व्याख्या बदल

3
00:00:13,300 --> 00:00:16,560
संकेत या स्पष्ट रूप से अपने डेटा प्रकार बदल रहा है.

4
00:00:16,560 --> 00:00:19,940
एक नाव, या इसके विपरीत एक int के रूप में बदलने के रूप में इस तरह के.

5
00:00:19,940 --> 00:00:21,550
प्रकार कास्टिंग समझ, हमें जरूरत है

6
00:00:21,550 --> 00:00:22,680
बुनियादी बातों के साथ शुरू करते हैं -

7
00:00:22,680 --> 00:00:24,140
डेटा प्रकार खुद को.

8
00:00:24,140 --> 00:00:26,960
सी की तरह कंप्यूटर भाषाओं में, सभी चर कुछ प्रकार है

9
00:00:26,960 --> 00:00:29,690
डेटा प्रकार है कि कैसे कंप्यूटर निर्धारित करता है, और इसी तरह के

10
00:00:29,690 --> 00:00:32,140
उपयोगकर्ता, कि चर की व्याख्या करता है.

11
00:00:32,140 --> 00:00:35,160
एक int, लंबे, नाव, और जैसे संख्यात्मक डेटा प्रकार

12
00:00:35,160 --> 00:00:38,110
डबल, सब अपनी अनूठी विशेषताएं हैं और कर रहे हैं

13
00:00:38,110 --> 00:00:41,370
लिए पर्वतमाला और सटीक बदलती के मूल्यों को निर्दिष्ट करने के लिए इस्तेमाल किया.

14
00:00:41,370 --> 00:00:44,800
प्रकार कास्टिंग हमारे जैसे एक चल बिन्दु संख्या लेने के लिए अनुमति देता है

15
00:00:44,800 --> 00:00:49,170
दशमलव पहले 3.14 और हिस्सा मिलता है, इस मामले में 3,

16
00:00:49,170 --> 00:00:51,590
यह एक int कास्टिंग द्वारा.

17
00:00:51,590 --> 00:00:53,900
चलो एक संक्षिप्त के लिए अंग्रेजी भाषा से एक उदाहरण लेते हैं

18
00:00:53,900 --> 00:00:56,910
प्रकार की समीक्षा की है, और देखने के लिए कैसे प्रकार कास्टिंग बदल सकते हैं

19
00:00:56,910 --> 00:00:59,380
जिस तरह से हम डेटा का एक टुकड़ा व्याख्या.

20
00:00:59,380 --> 00:01:05,269
डेटा के लिए, चलो प्रतीक यहाँ ले.

21
00:01:05,269 --> 00:01:07,570
मैं बस के रूप में इन ध्यान विन्यस्त लाइनों के लिए उल्लेख

22
00:01:07,570 --> 00:01:10,100
प्रतीकों, लेकिन कोई है जो अंग्रेजी भाषा जानता है के रूप में,

23
00:01:10,100 --> 00:01:12,750
आप तुरंत समझते हैं कि वे वास्तव में कर रहे हैं, पत्र.

24
00:01:12,750 --> 00:01:15,580
तुम संकेत भी डेटा प्रकार समझ है.

25
00:01:15,580 --> 00:01:17,620
पत्र के इस स्ट्रिंग को देखते हुए हम दो देख सकते हैं

26
00:01:17,620 --> 00:01:20,140
अलग अलग शब्द, अपने स्वयं के अर्थ के साथ प्रत्येक.

27
00:01:20,140 --> 00:01:25,530
संज्ञा, हवा बाहर चल रही है के रूप में हवा, है.

28
00:01:25,530 --> 00:01:28,280
और वहाँ क्रिया, हवा है, के रूप में मैं करने की जरूरत है

29
00:01:28,280 --> 00:01:31,410
मेरे एनालॉग घड़ी हवा.

30
00:01:31,410 --> 00:01:33,420
यह एक दिलचस्प उदाहरण है, क्योंकि हम देख सकते हैं

31
00:01:33,420 --> 00:01:36,270
प्रकार है कि हम अपने डेटा को असाइन, संज्ञा चाहे या कैसे

32
00:01:36,270 --> 00:01:39,080
क्रिया में परिवर्तन, कैसे हम उस डेटा का उपयोग -

33
00:01:39,080 --> 00:01:41,730
शब्द हवा या हवा के रूप में.

34
00:01:41,730 --> 00:01:44,100
हालांकि एक कंप्यूटर व्याकरण और भागों के बारे में परवाह नहीं

35
00:01:44,100 --> 00:01:47,750
अंग्रेजी भाषण का एक ही मूल सिद्धांत लागू होता है.

36
00:01:47,750 --> 00:01:50,290
यही है, हम सही की व्याख्या को बदल सकते हैं

37
00:01:50,290 --> 00:01:53,140
एक ही स्मृति में संग्रहीत डेटा बस यह एक कास्टिंग

38
00:01:53,140 --> 00:01:54,576
विभिन्न प्रकार.

39
00:01:54,576 --> 00:01:57,250
यहाँ एक 32-bit पर सबसे आम प्रकार का आकार

40
00:01:57,250 --> 00:01:58,340
ऑपरेटिंग सिस्टम.

41
00:01:58,340 --> 00:02:02,070
हम 1 बाइट int, और 4 बाइट्स पर नाव, एक लंबे समय में एक चार

42
00:02:02,070 --> 00:02:04,390
लंबी और 8 बाइट्स में एक डबल.

43
00:02:04,390 --> 00:02:07,670
क्योंकि एक int 4 बाइट्स लेता है, यह 32 बिट ले जाएगा

44
00:02:07,670 --> 00:02:10,060
जब यह स्मृति में एक द्विआधारी श्रृंखला के रूप में संग्रहीत किया जाता है

45
00:02:10,060 --> 00:02:11,500
शून्य और लोगों की.

46
00:02:11,500 --> 00:02:14,020
हमारे चर के रूप में लंबे समय के रूप में एक प्रकार int के रूप में बनी हुई है

47
00:02:14,020 --> 00:02:16,740
कंप्यूटर को हमेशा उन लोगों को और शून्य से परिवर्तित कर देंगे

48
00:02:16,740 --> 00:02:19,120
मूल संख्या में द्विआधारी.

49
00:02:19,120 --> 00:02:21,270
हालांकि, हम सैद्धांतिक रूप से उन 32 डाली सकता है

50
00:02:21,270 --> 00:02:23,510
बूलियन प्रकार की एक श्रृंखला में बिट्स.

51
00:02:23,510 --> 00:02:26,090
और फिर कंप्यूटर अब एक नंबर देख होगा, लेकिन

52
00:02:26,090 --> 00:02:28,810
शून्य और लोगों की बजाय एक संग्रह.

53
00:02:28,810 --> 00:02:31,570
हम भी एक अलग संख्यात्मक के रूप में है कि डेटा को पढ़ने की कोशिश कर सकते

54
00:02:31,570 --> 00:02:34,660
टाइप करें, या चार वर्णों की एक स्ट्रिंग के रूप में भी.

55
00:02:34,660 --> 00:02:37,820
जब कास्टिंग में संख्या के साथ निपटने, तुम कैसे पर विचार करना चाहिए

56
00:02:37,820 --> 00:02:40,470
अपने मूल्य की शुद्धता को प्रभावित हो जाएगा.

57
00:02:40,470 --> 00:02:43,240
ध्यान रखें कि सटीक ही रह सकता है,

58
00:02:43,240 --> 00:02:47,150
या आप खो सटीक है, लेकिन से आप सटीक कभी नहीं हासिल कर सकते हैं कर सकते हैं.

59
00:02:47,150 --> 00:02:49,060
चलो तीन सबसे आम तरीके है कि आप कर सकते हैं के लिए के माध्यम से जाना

60
00:02:49,060 --> 00:02:50,400
परिशुद्धता खो देते हैं.

61
00:02:50,400 --> 00:02:53,060
एक int के लिए एक नाव कास्टिंग सब कुछ के truncation कारण होगा

62
00:02:53,060 --> 00:02:54,900
दशमलव बिंदु के बाद, तो आप छोड़ रहे हैं

63
00:02:54,900 --> 00:02:55,950
पूरी संख्या के साथ.

64
00:02:55,950 --> 00:03:02,000
अगर हम ले नाव x जो 3.7 के बराबर होगा, हम डाल सकते हैं

65
00:03:02,000 --> 00:03:05,580
एक int द्वारा इस चर x बस में int लेखन

66
00:03:05,580 --> 00:03:07,050
कोष्ठकों.

67
00:03:07,050 --> 00:03:10,010
जब भी हम इस अवधि यहाँ का उपयोग करें, हम प्रभावी

68
00:03:10,010 --> 00:03:12,810
तीन मूल्य का उपयोग किया क्योंकि हम छोटा कर दिया गया है

69
00:03:12,810 --> 00:03:14,880
दशमलव बिंदु के बाद सब कुछ.

70
00:03:14,880 --> 00:03:17,210
हम भी एक int के लिए एक लंबे परिवर्तित कर सकते हैं, जो होगा

71
00:03:17,210 --> 00:03:20,760
इसी तरह उच्च आदेश बिट के एक हानि करने के लिए नेतृत्व.

72
00:03:20,760 --> 00:03:23,910
एक लंबे 8 बाइट्स, या स्मृति में 64 बिट लेता है.

73
00:03:23,910 --> 00:03:27,050
तो जब हम इसे एक int है जो केवल 4 बाइट्स, या 32 के लिए डाली

74
00:03:27,050 --> 00:03:29,820
बिट्स, हम अनिवार्य रूप से सभी बिट्स कि काट रही हैं

75
00:03:29,820 --> 00:03:32,420
उच्च द्विआधारी मूल्यों का प्रतिनिधित्व करते हैं.

76
00:03:32,420 --> 00:03:34,690
तुम भी एक नाव है, जो दे देंगे एक डबल डाली सकता है

77
00:03:34,690 --> 00:03:37,340
आप निकटतम संभव बिना दोहरी फ्लोट

78
00:03:37,340 --> 00:03:39,100
जरूरी यह गोलाई.

79
00:03:39,100 --> 00:03:41,840
हमारे int रूपांतरण के लिए लंबे समय तक नुकसान में करने के लिए इसी प्रकार

80
00:03:41,840 --> 00:03:44,890
सटीक है क्योंकि एक डबल अधिक डेटा शामिल हैं.

81
00:03:44,890 --> 00:03:47,910
एक डबल आप 53 महत्वपूर्ण बिट की दुकान करने की अनुमति देगा,

82
00:03:47,910 --> 00:03:50,650
मोटे तौर पर 16 महत्वपूर्ण अंक.

83
00:03:50,650 --> 00:03:53,050
जबकि एक नाव ही आप 24 की दुकान करने की अनुमति देगा

84
00:03:53,050 --> 00:03:56,235
महत्वपूर्ण बिट, लगभग सात महत्वपूर्ण अंक.

85
00:03:56,235 --> 00:03:58,700
इन पिछले दो मामलों में, यह उपयोगी हो करने के लिए लगता है कि हो सकता है

86
00:03:58,700 --> 00:04:01,200
एक तस्वीर रीसाइज़िंग के रूप में कास्टिंग लिखें.

87
00:04:01,200 --> 00:04:03,860
जब आप एक बड़े आकार से एक छोटे आकार के लिए जाना है, तो आप नहीं देख सकते हैं

88
00:04:03,860 --> 00:04:05,600
चीजों के रूप में स्पष्ट रूप से है क्योंकि आप डेटा खो दिया

89
00:04:05,600 --> 00:04:07,530
पिक्सल के रूप में.

90
00:04:07,530 --> 00:04:09,270
हम प्रकार कास्टिंग भी परेशानी का कारण बन सकते हैं जब

91
00:04:09,270 --> 00:04:11,050
मंगाई ints डाली.

92
00:04:11,050 --> 00:04:13,920
चूंकि एक 32-bit मशीन पर तैरता केवल 24 है

93
00:04:13,920 --> 00:04:16,959
महत्वपूर्ण बिट्स, वे सही मूल्यों का प्रतिनिधित्व नहीं कर सकते हैं

94
00:04:16,959 --> 00:04:22,750
24, या 16777217 की शक्ति को अधिक 2.

95
00:04:22,750 --> 00:04:25,540
अब स्पष्ट और निहित कास्टिंग के बारे में बात करते हैं.

96
00:04:25,540 --> 00:04:28,000
स्पष्ट कास्टिंग है जब हम कोष्ठक में प्रकार लिखना

97
00:04:28,000 --> 00:04:29,430
एक चर नाम से पहले.

98
00:04:29,430 --> 00:04:33,100
एक उदाहरण के रूप में, इससे पहले कि हम पहले कोष्ठकों में int लिखा हमारे

99
00:04:33,100 --> 00:04:35,640
चर x नाव.

100
00:04:35,640 --> 00:04:37,200
इस तरह, हम int मूल्य मिलता है,

101
00:04:37,200 --> 00:04:38,593
3.7 का छोटा मूल्य -

102
00:04:38,593 --> 00:04:40,370
3.

103
00:04:40,370 --> 00:04:42,970
अंतर्निहित कास्टिंग है जब संकलक स्वचालित रूप से बदलता है

104
00:04:42,970 --> 00:04:46,340
एक सुपर प्रकार के लिए समान प्रकार, या के कुछ अन्य प्रकार करता है

105
00:04:46,340 --> 00:04:48,310
उपयोगकर्ता को लिखने के लिए की आवश्यकता के बिना ढलाई

106
00:04:48,310 --> 00:04:49,720
किसी भी अतिरिक्त कोड.

107
00:04:49,720 --> 00:04:53,550
उदाहरण के लिए, जब हम 5 और 1.1 जोड़ने के लिए, हमारे मूल्यों को पहले से ही है

108
00:04:53,550 --> 00:04:55,680
प्रकार उनके साथ जुड़े.

109
00:04:55,680 --> 00:04:59,480
5 एक int है, जबकि 1.1 एक नाव है.

110
00:04:59,480 --> 00:05:02,390
आदेश में उन्हें जोड़ने के लिए, कंप्यूटर एक नाव में 5 डाले,

111
00:05:02,390 --> 00:05:04,530
जो में 5.0 लेखन के रूप में एक ही बात होती

112
00:05:04,530 --> 00:05:06,476
पहली जगह.

113
00:05:06,476 --> 00:05:13,210
लेकिन इस तरह से हम नाव 5, या 5.0, प्लस क्या कहते हैं पहले से ही था

114
00:05:13,210 --> 00:05:16,960
एक नाव, 1.1, और वहाँ से हम वास्तव में इन जोड़ सकते हैं

115
00:05:16,960 --> 00:05:18,640
मूल्यों और मूल्य 6.1 पाने के.

116
00:05:21,170 --> 00:05:23,500
अंतर्निहित कास्टिंग भी हमें के चर आवंटित करने की अनुमति देता है

117
00:05:23,500 --> 00:05:25,590
एक दूसरे के लिए विभिन्न प्रकार के.

118
00:05:25,590 --> 00:05:28,110
हम हमेशा एक से अधिक में एक कम सटीक प्रकार असाइन कर सकते हैं

119
00:05:28,110 --> 00:05:29,250
सटीक एक.

120
00:05:29,250 --> 00:05:37,060
उदाहरण के लिए, अगर हम एक डबल एक्स, और एक int y है -

121
00:05:37,060 --> 00:05:40,120
और ये किसी भी मूल्यों है कि हम उन्हें सेट हो सकता है -

122
00:05:40,120 --> 00:05:43,560
हम कह सकते हैं एक्स, वाई के बराबर होती है.

123
00:05:43,560 --> 00:05:46,340
हम तो क्योंकि डबल एक int से अधिक सटीक है,

124
00:05:46,340 --> 00:05:48,380
किसी भी जानकारी को खोना नहीं होगा.

125
00:05:48,380 --> 00:05:50,420
दूसरी ओर, यह जरूरी कहना सही नहीं होगा

126
00:05:50,420 --> 00:05:54,060
y एक्स के बराबर होती है, क्योंकि डबल एक बड़ा मूल्य की तुलना में हो सकता है

127
00:05:54,060 --> 00:05:55,220
पूर्णांक.

128
00:05:55,220 --> 00:05:57,420
और इसलिए पूर्णांक के लिए सभी धारण करने में सक्षम नहीं हो सकता है

129
00:05:57,420 --> 00:05:59,560
डबल में संग्रहीत जानकारी.

130
00:05:59,560 --> 00:06:02,610
अंतर्निहित कास्टिंग भी तरह तुलना ऑपरेटरों में प्रयोग किया जाता है

131
00:06:02,610 --> 00:06:06,410
से अधिक, कम से कम, या समानता ऑपरेटर.

132
00:06:06,410 --> 00:06:13,050
इस तरह से हम 5.1 अगर कह सकते हैं 5 से अधिक है, और हम मिल

133
00:06:13,050 --> 00:06:14,750
सच परिणाम.

134
00:06:14,750 --> 00:06:18,470
क्योंकि 5 एक int है, लेकिन यह एक नाव के लिए डाली जा क्रम में

135
00:06:18,470 --> 00:06:22,090
नाव के लिए 5.1 की तुलना में, हम कह सकता हूँ कि 5.1 है

136
00:06:22,090 --> 00:06:24,550
5.0 से अधिक है.

137
00:06:24,550 --> 00:06:31,320
वही कह रही है अगर 2.0 2 के बराबर होती बराबर होती है के साथ सच है.

138
00:06:31,320 --> 00:06:34,190
हम भी सच हो जाना चाहिए, क्योंकि कंप्यूटर डाली जाएगी

139
00:06:34,190 --> 00:06:39,750
2 पूर्णांक नाव और फिर कहते हैं कि 2.0 2.0 के बराबर होती है बराबर,

140
00:06:39,750 --> 00:06:41,660
यह सच है.

141
00:06:41,660 --> 00:06:44,180
भूल जाते हैं कि हम भी ints और घर का काम के बीच में नहीं डाल सकते हैं,

142
00:06:44,180 --> 00:06:46,350
या ASCII मूल्यों.

143
00:06:46,350 --> 00:06:49,690
घर का काम भी द्विआधारी करने के लिए कम करने की आवश्यकता है, जो तुम क्यों है

144
00:06:49,690 --> 00:06:51,920
आसानी से घर का काम और उनके संबंधित के बीच में परिवर्तित कर सकते हैं

145
00:06:51,920 --> 00:06:53,260
ASCII मूल्यों.

146
00:06:53,260 --> 00:06:56,180
इस बारे में अधिक जानने के लिए, ASCII पर हमारे वीडियो की जाँच करें.

147
00:06:56,180 --> 00:06:58,080
जब आप एक पल लेने के लिए कैसे डेटा संग्रहीत है के बारे में सोचते हैं,

148
00:06:58,080 --> 00:06:59,990
यह भावना का एक बहुत बनाने के लिए शुरू होता है.

149
00:06:59,990 --> 00:07:02,790
यह सिर्फ हवा और हवा के बीच अंतर की तरह है.

150
00:07:02,790 --> 00:07:05,490
डेटा एक ही है, लेकिन प्रकार बदल सकते हैं हम कैसे

151
00:07:05,490 --> 00:07:06,720
यह व्याख्या.

152
00:07:06,720 --> 00:07:10,430
मेरा नाम जॉर्डन Jozwiak, इस CS50 है.