1
00:00:00,000 --> 00:00:00,330

2
00:00:00,330 --> 00:00:01,830
>> ડેવીડના MALAN: તેથી કેવી રીતે કરી શકો છો
અમે આ સમસ્યા ઉકેલવા?

3
00:00:01,830 --> 00:00:05,310
વેલ, સરળ માર્ગ એ માત્ર ટાળવા છે
ints એકસાથે, અને તેની જગ્યાએ વ્યાખ્યાયિત

4
00:00:05,310 --> 00:00:06,960
ફ્લોટ પછી એક ફ્લોટ.

5
00:00:06,960 --> 00:00:12,460
ખાસ કરીને, માતાનો 1.0 માટે 1 બદલીએ
અને 10.0 માટે 10, અને પછી આ સેવ

6
00:00:12,460 --> 00:00:14,380
floats1.c તરીકે ફાઇલ.

7
00:00:14,380 --> 00:00:20,270
હવે મેક floats1 સાથે સંકલન કરીએ,
અને પછી floats1 સાથે ચલાવવા.

8
00:00:20,270 --> 00:00:22,590
અને હવે, હું ખરેખર 0.1 જુઓ.

9
00:00:22,590 --> 00:00:25,540
>> અમે હલ કરી શકે અન્ય રીત છે
તે છે, અને તે કાસ્ટિંગ મદદથી છે.

10
00:00:25,540 --> 00:00:29,750
કાસ્ટિંગ એક રૂપાંતર કરવાની પ્રક્રિયા છે
ડેટા પ્રકાર અન્ય માટે, તે એમ ધારી રહ્યા છીએ

11
00:00:29,750 --> 00:00:31,130
આમ કરવા માટે અર્થમાં બનાવે છે.

12
00:00:31,130 --> 00:00:34,370
આ કિસ્સામાં, હું શું કરી શકે છે પાછા જાઓ છે
હું છું જ્યાં કોડ ની આવૃત્તિને

13
00:00:34,370 --> 00:00:40,050
પૂર્ણાંક 10 દ્વારા પૂર્ણાંક એક વિભાજન, પરંતુ
હું સ્પષ્ટ રીતે કહી શકે છે કમ્પાઇલર

14
00:00:40,050 --> 00:00:43,990
હું તે છતાં 1 સારવાર કરવા માંગો છો કે જે
તે પૂર્ણાંક છે, તેમ છતાં, ફ્લોટ, અને

15
00:00:43,990 --> 00:00:48,270
હું તે ફ્લોટ તરીકે 10 સારવાર કરવા માંગો છો,
તે, પણ, એક પૂર્ણાંક છે, તેમ છતાં.

16
00:00:48,270 --> 00:00:51,760
>> વાસ્તવમાં, હું માત્ર સાથે દૂર વિચાર કરી શકે છે
, તરીકે ફ્લોટ એક આ નિર્ણાયક

17
00:00:51,760 --> 00:00:55,350
કારણ કે તમે એક દ્વારા ફ્લોટ વિભાજિત જો
પૂર્ણાંક, અથવા ફ્લોટ દ્વારા પૂર્ણાંક, સી કરશે

18
00:00:55,350 --> 00:00:57,550
તમે એક અપૂર્ણાંક બિંદુ કિંમત આવો.

19
00:00:57,550 --> 00:01:01,150
પરંતુ આ કિસ્સામાં, સારા પગલા માટે, હું પડશે
પુનઃકમ્પાઈલ, ફ્લોટ્સ માટે બંને કન્વર્ટ

20
00:01:01,150 --> 00:01:06,380
મેક floats1 સાથે મારા કાર્યક્રમ, પછી
કોઈ સ્લેશ floats1 સાથે ચલાવવા,

21
00:01:06,380 --> 00:01:08,770
અને હું પણ 0.1 જુઓ.

22
00:01:08,770 --> 00:01:10,983