1
00:00:00,000 --> 00:00:00,340

2
00:00:00,340 --> 00:00:01,960
>> 1 વક્તા: ઠીક હવે
કે છેલ્લા કાર્યક્રમ.

3
00:00:01,960 --> 00:00:04,920
અને આ જ સમયે, ચાલો સ્પષ્ટ ફાળવવા દો
અમુક મેમરી કે જેમાં

4
00:00:04,920 --> 00:00:06,550
વપરાશકર્તાની ઇનપુટ સંગ્રહિત કરવામાં આવશે.

5
00:00:06,550 --> 00:00:09,600
આમ કરવા માટે, ચાલો તેને પ્રથમ પર હજી મેળ બેસાડી દો
અમે એ જાહેર કોડ જ્યાં વાક્ય

6
00:00:09,600 --> 00:00:11,590
અગાઉ ચાર રચે સ્ટાર છે.

7
00:00:11,590 --> 00:00:14,210
આ જ સમયે, ચાલો ફરી જાહેર
તે નીચે પ્રમાણે -

8
00:00:14,210 --> 00:00:19,380
ચાર રચે છે એ કૌંસ 16, દાખલા તરીકે,
બંધ કૌંસ.

9
00:00:19,380 --> 00:00:23,690
>> અન્ય શબ્દોમાં, કોઈ માટે એ જાહેર દો
લાંબા સમય સુધી એક અક્ષર એક સરનામું છે,

10
00:00:23,690 --> 00:00:26,610
પરંતુ 16 અક્ષરો બદલે પણ દર્શાવે છે.

11
00:00:26,610 --> 00:00:30,295
આ રીતે, વપરાશકર્તા સુધી 15 માં ટાઈપ કરી શકો છો
અક્ષરો અને હજુ પણ માટે જગ્યા છોડો

12
00:00:30,295 --> 00:00:31,570
નલ ટર્મીનેટર.

13
00:00:31,570 --> 00:00:35,870
સાચવો માતાનો આગળ વધવા દો, સંકલન,
અને આ કાર્યક્રમ ચલાવો.

14
00:00:35,870 --> 00:00:40,770
Scanf2 કોઈ સ્લેશ scanf2 કરો.

15
00:00:40,770 --> 00:00:45,100
હવે હેલ્લો જેવી શબ્દમાળા લખો,
અને અમે હેલ્લો માટે આભાર માન્યો કરી રહ્યા છીએ.

16
00:00:45,100 --> 00:00:46,440
>> હવે, સમસ્યા હજુ પણ છે.

17
00:00:46,440 --> 00:00:50,140
હું માત્ર જ છે, કે જે હેલો માં લખ્યો
નલ માટે પાંચ અક્ષરો, વત્તા 1

18
00:00:50,140 --> 00:00:50,445
ટર્મિનેટર.

19
00:00:50,445 --> 00:00:53,610
તે માત્ર ત્યારે જ આપણને નહીં
છ બાઇટ્સ માટે જરૂર.

20
00:00:53,610 --> 00:00:56,740
>> પરંતુ દુર્ભાગ્યે, અમે માત્ર
કુલ 16 ફાળવવામાં.

21
00:00:56,740 --> 00:01:01,305
તેથી જો 16 માં વપરાશકર્તા ખરેખર પ્રકારના
અક્ષરો, કે 17, અથવા કેટલાક સો

22
00:01:01,305 --> 00:01:04,410
અક્ષરો, અમે હજુ પણ નથી જઈ રહ્યાં છો
આ માટે મેમરી પૂરતી જગ્યા છે

23
00:01:04,410 --> 00:01:05,400
વપરાશકર્તાની ઇનપુટ.

24
00:01:05,400 --> 00:01:07,750
અને હકીકતમાં, આ કરે છે
વપરાશકર્તા ઈનપુટ કરવા ખૂબ જ

25
00:01:07,750 --> 00:01:08,940
સામાન્ય રીતે મુશ્કેલ.

26
00:01:08,940 --> 00:01:12,270
અમે અમલ શા માટે અને ખરેખર, આ છે
પ્રથમ માં વિચાર શબ્દમાળા કાર્ય

27
00:01:12,270 --> 00:01:13,900
CS50 પુસ્તકાલય માં સ્થાન -

28
00:01:13,900 --> 00:01:16,900
તે નિયંત્રિત કરવા માટે બહાર આકૃતિ કેવી રીતે
પરિસ્થિતિ જ્યાં વપરાશકર્તા પ્રકારો માં

29
00:01:16,900 --> 00:01:19,710
અમે કરતાં વધુ અક્ષરો
શરૂઆતમાં કલ્પના કરી હતી.

30
00:01:19,710 --> 00:01:21,750
>> પ્રમાણિકપણે, વગર સંપૂર્ણપણે
આ કાર્યક્રમ પુનર્લેખન,

31
00:01:21,750 --> 00:01:23,290
આ બોલ પર કોઈ સ્વચ્છ ઉકેલ છે.

32
00:01:23,290 --> 00:01:26,970
તેના બદલે, અમે શું હશે વિચાર છે
એક પર વપરાશકર્તા પાસેથી એક અક્ષર

33
00:01:26,970 --> 00:01:28,860
સમય, ફરીથી અને ફરીથી.

34
00:01:28,860 --> 00:01:32,510
અને દરેક સમયે અમે અમે છો ખ્યાલ તો
મેમરી બહાર, અમે પર પડે

35
00:01:32,510 --> 00:01:36,450
તે બિંદુ પર પાછા જાઓ અને ફરી ફાળવવા
કેટલાક વધુ મેમરી, વપરાશકર્તાની નકલ

36
00:01:36,450 --> 00:01:39,400
અમારી પ્રથમ ભાગ જુના ઇનપુટ
નવા માં મેમરી,

37
00:01:39,400 --> 00:01:40,810
મેમરી મોટા ભાગ.

38
00:01:40,810 --> 00:01:44,610
અને પછી ફરીથી તે પ્રક્રિયા પુનરાવર્તન અને
વપરાશકર્તા પૂરી કરવામાં આવે છે ફરીથી ત્યાં સુધી

39
00:01:44,610 --> 00:01:45,860
તેના અથવા તેણીના ઇનપુટ.

40
00:01:45,860 --> 00:01:48,246