1
00:00:07,632 --> 00:00:10,270
[Powered by Google Translate] JORDAN 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
એક ફ્લોટ, અથવા તેનાથી ઊલટું માટે પૂર્ણાંક બદલવા જેવા કે.

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
જેમ કે C કોમ્પ્યુટર ભાષાઓમાં, બધા ચલો અમુક પ્રકારના હોય છે

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
પૂર્ણાંક, લાંબા લાંબા ફ્લોટ, જેમ કે આંકડાકીય માહિતી પ્રકારો

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
તે પૂર્ણાંક પર કાસ્ટિંગ દ્વારા.

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 બાઇટ પૂર્ણાંક, અને 4 બાઇટ્સ અંતે ફ્લોટ, લાંબા ખાતે ચાર રચે છે

42
00:02:02,070 --> 00:02:04,390
લાંબી અને 8 બાઇટ્સ ખાતે બેવડી.

43
00:02:04,390 --> 00:02:07,670
કારણ કે એક પૂર્ણાંક અપ 4 બાઇટ્સ લે છે, તે 32 બિટ્સ લેશે

44
00:02:07,670 --> 00:02:10,060
જ્યારે તે મેમરીમાં દ્વિસંગી શ્રેણી તરીકે સંગ્રહાયેલ છે

45
00:02:10,060 --> 00:02:11,500
zeros અને શૈલીઓનો.

46
00:02:11,500 --> 00:02:14,020
અમારા ચલ સુધી એક પ્રકાર પૂર્ણાંક, તરીકે રહે છે

47
00:02:14,020 --> 00:02:16,740
કોમ્પ્યુટર હંમેશા તે મુદ્દાઓ પર અને zeros માંથી રૂપાંતરિત કરશે

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
તેના બદલે zeros અને મુદ્દાઓ પર એક સંગ્રહ.

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
પૂર્ણાંક પર એક ફ્લોટ કાસ્ટિંગ બધું કાપી નાંખવાની રીત કારણ બનશે

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
જો અમે આ ફ્લોટ એક્સ જે 3.7 જેટલી થશે લેવા, અમે ભૂમિકા કરી શકો છો

65
00:03:02,000 --> 00:03:05,580
આ ચલ પૂર્ણાંક પર એક્સ ફક્ત માં પૂર્ણાંક લેખન

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
અમે પણ પૂર્ણાંક પર લાંબા લાંબા કન્વર્ટ કરી શકો છો, કે જે કરશે

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
તેથી જ્યારે અમે તેને પૂર્ણાંક છે કે જે માત્ર 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
જરૂરી rounding તે.

79
00:03:39,100 --> 00:03:41,840
અમારા પૂર્ણાંક રૂપાંતર લાંબા લાંબા, નુકશાન માટે સમાન

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
એક ઉદાહરણ તરીકે, પહેલા અમને પહેલાં કૌંસ માં પૂર્ણાંક લખ્યું અમારા

99
00:04:33,100 --> 00:04:35,640
ચલ x તરતા રહે છે.

100
00:04:35,640 --> 00:04:37,200
આ રીતે, અમે પૂર્ણાંક કિંમત મેળવવા માટે, તે

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 આ પૂર્ણાંક હોય છે, જ્યારે 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
હમણાં પૂરતું, જો આપણે ડબલ એક્સ, અને પૂર્ણાંક વાય છે -

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
અમે કારણ કે ડબલ પૂર્ણાંક કરતાં વધુ ચોકસાઇ ધરાવે છે તેથી,

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
વાય એક્સ સમકક્ષ છે, કારણ કે ડબલ મોટી કિંમત કરતાં હોય શકે છે

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 if કહી શકો 5 કરતા વધારે છે, અને અમે વિચાર

133
00:06:13,050 --> 00:06:14,750
સાચું પરિણામ.

134
00:06:14,750 --> 00:06:18,470
Because 5 પૂર્ણાંક છે, પરંતુ તે ફ્લોટ માટે ભૂમિકા આવશે કરવા માટે

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
આ જ કહેતા if 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 છે.