1
00:00:00,000 --> 00:00:00,410

2
00:00:00,410 --> 00:00:03,130
>> ડેવિડ જે MALAN: તેથી તે તારણ આપે છે કે
શબ્દમાળા નકલ લગભગ તરીકે નથી

3
00:00:03,130 --> 00:00:05,750
, એક મૂળ નકલ સરળ
પૂર્ણાંક અથવા ફ્લોટ છે.

4
00:00:05,750 --> 00:00:09,190
છેવટે, હૂડ નીચે શબ્દમાળા
ક્રમ અક્ષરો છે.

5
00:00:09,190 --> 00:00:13,130
તેથી શબ્દમાળા નકલ, તેથી, છે
તે સમગ્ર ક્રમ નકલ સમાવેશ

6
00:00:13,130 --> 00:00:14,240
અક્ષરો.

7
00:00:14,240 --> 00:00:17,470
>> ચાલો તેને પાછા અમારા ધ્યાન ચાલુ કરો
છેલ્લા અમલીકરણ અને આ બહાર ફાડી

8
00:00:17,470 --> 00:00:21,470
લાઇન, શબ્દમાળા ટી, એ સમકક્ષ છે
સ્પષ્ટ રીતે પૂરતી ન હતી.

9
00:00:21,470 --> 00:00:24,440
એ લાઇન સાથે બદલો દો કે
આ જેમ, તેના બદલે, જુએ છે.

10
00:00:24,440 --> 00:00:34,020
શબ્દમાળા ટી શબ્દમાળા લંબાઈ ના malloc નહીં
ચાર રચે છે એ વત્તા 1 વખત માપ.

11
00:00:34,020 --> 00:00:36,320
>> હવે રહ્યું થોડી ભાવ છે
કોડ આ વાક્ય પર.

12
00:00:36,320 --> 00:00:39,330
પ્રથમ, malloc છે, ટૂંકમાં મેમરી
ફાળવણી, અને

13
00:00:39,330 --> 00:00:40,700
કાર્ય માત્ર કે કરે છે.

14
00:00:40,700 --> 00:00:44,740
પૂર્ણાંક આપેલ છે, તો તે તમને આપે છે
ની મેમરી એક ભાગ સરનામું

15
00:00:44,740 --> 00:00:45,960
કે ઘણા બાઇટ્સ.

16
00:00:45,960 --> 00:00:50,090
વચ્ચે, આ શબ્દમાળા ઓ લંબાઈ વત્તા 1
અમે માંગો છો તે દર્શાવવા માટે જ છે

17
00:00:50,090 --> 00:00:54,690
એ પહેલાથી જ ધરાવે છે, જેમ કે ઘણા બાઇટ્સ,
તેના નલ ટર્મીનેટર, સહિત

18
00:00:54,690 --> 00:00:57,050
શબ્દમાળા ઓવરને અંતે બેકસ્લેશ 0.

19
00:00:57,050 --> 00:01:00,170
>> દરમિયાન, હું જરૂરી યાદ નથી
ચાર રચે છે પણ, કેવી રીતે મોટા

20
00:01:00,170 --> 00:01:04,340
મોટા ભાગની સિસ્ટમો પર ફક્ત 1 છે છતાં
બાઇટ છે, તેથી હું ઘરનાં પરચૂરણ કામો કદ કહી શકશો

21
00:01:04,340 --> 00:01:08,210
ગતિશીલ રીતે બહાર આકૃતિ કેવી રીતે મોટા
વ્યક્તિગત પાત્ર છે.

22
00:01:08,210 --> 00:01:12,550
એકવાર એક સાથે ગુણાકાર, હું પાછા મેળવો
હું જરૂર છે કે જે બાઇટ્સ કુલ સંખ્યા.

23
00:01:12,550 --> 00:01:14,680
>> પરંતુ malloc માટે શું નિષ્ફળ જાય તો
અમે જરૂર મેમરી પાછા?

24
00:01:14,680 --> 00:01:16,730
નીચે પ્રમાણે હું શ્રેષ્ઠ તે માટે તપાસો છો.

25
00:01:16,730 --> 00:01:23,330
ટી નલ સમકક્ષ હોય છે, તો પછી હું પ્રથમ જાઉં છું
નિઃશુલ્ક એ માટે, મેમરી ગેટ દ્વારા પરત

26
00:01:23,330 --> 00:01:27,120
શબ્દમાળા, અને પછી હું જાઉં છું
ભૂલ દર્શાવવા માટે, 1 આવો.

27
00:01:27,120 --> 00:01:30,360
>> બધા સારી છે પરંતુ જો, હું આગળ વધવા માટે જાઉં છું
ચાર લૂપ ઉપયોગ કરે છે અને ભારપૂર્વક કહેવું

28
00:01:30,360 --> 00:01:31,110
નીચે પ્રમાણે.

29
00:01:31,110 --> 00:01:36,000
પૂર્ણાંક માટે હું 0, એન સમકક્ષ વિષે
ઓ શબ્દમાળા લંબાઈ.

30
00:01:36,000 --> 00:01:40,350
હું લાંબા સમય સુધી હું છે આ કરવા જાઉં છું
હોય અથવા કોઇ n એ બરાબર છે કે જેથી હું

31
00:01:40,350 --> 00:01:44,460
દ્વારા અને સહિત ફરી વળવું
s માં નલ બંધ પાત્ર.

32
00:01:44,460 --> 00:01:47,450
>> અને દરેક પુનરાવૃત્તિ પર, હું છું
હું વધારતી જઈ રહી છે.

33
00:01:47,450 --> 00:01:52,496
દરમિયાન, આ લૂપની અંદર, નકલ
ની ટી આઇ મી માં એ માતાનો અક્ષર-i મી

34
00:01:52,496 --> 00:01:59,310
પાંચ, તે ટી કરવા પૂરતા છે
કૌંસ હું એ કૌંસ હું નોંધાયો નહીં.

41
00:01:59,320 --> 00:02:02,750
>> હવે, સેવ સંકલન કરીએ, અને
આ નવા કાર્યક્રમ ચલાવો.

42
00:02:02,750 --> 00:02:06,690
નકલ 1 કોઈ સ્લેશ નકલ 1 બનાવો.

43
00:02:06,690 --> 00:02:09,460
અને હું કંઈક જેમ કહેવું પડશે
હેલો બધા નાના અક્ષરોમાં.

44
00:02:09,460 --> 00:02:12,280
અને thankfully, આ સમય મારા
મૂળ યથાવત રહે છે.

45
00:02:12,280 --> 00:02:13,660
હેલો બધા નાના અક્ષરોમાં.

46
00:02:13,660 --> 00:02:15,540
પરંતુ નકલ, ખરેખર, મૂડી છે જ.

47
00:02:37,120 --> 00:02:38,963