2
00:00:00,000 --> 00:00:01,860
>> 1 વક્તા: માતાનો એક નજર
આ CS50 પુસ્તકાલય પર,

3
00:00:01,860 --> 00:00:05,190
ખાસ તેના GetInt કાર્ય કરે છે.

4
00:00:05,190 --> 00:00:07,820
અહીં અમે વાસ્તવિક સ્ત્રોત છે
GetInt માટે કોડ.

5
00:00:07,820 --> 00:00:12,050
અને તે ખૂબ લાંબુ નથી કે નોટિસ, અને
તે મોટા ભાગના જ્યારે લૂપ રચના -

6
00:00:12,050 --> 00:00:15,620
તે એક અનંત લૂપ - કે જે માત્ર
અમે ખરેખર એક વાર એક કિંમત આપે છે

7
00:00:15,620 --> 00:00:17,400
અમે અપેક્ષા શું મેળવેલ.

8
00:00:17,400 --> 00:00:18,700
આપણે તેના લઈ જવામાં.

9
00:00:18,700 --> 00:00:21,650
>> પ્રથમ અહીં નોંધ કરો કે આ
લૂપ શરૂ થાય છે.

10
00:00:21,650 --> 00:00:25,390
અમે કોડ એક વાક્ય છે કે આગામી નોંધ કરો
કે ખરેખર GetString કહે

11
00:00:25,390 --> 00:00:29,620
અને એક માં પરત કિંમત સંગ્રહ કરે છે
ચલ, પ્રકાર શબ્દમાળા, લાઇન છે.

12
00:00:29,620 --> 00:00:31,210
અમે પછી એક સેનીટી ચેક એક બીટ છે.

13
00:00:31,210 --> 00:00:35,770
રેખા == નલ હોય, તો પછી અમે જિજ્ઞાસાપૂર્વક
INT_MAX આવો.

14
00:00:35,770 --> 00:00:40,140
>> હવે તે INT_MAX તારણ આપે છે કે એક
ખાસ સતત તેના સિવાય જાહેર

15
00:00:40,140 --> 00:00:44,030
કે સૌથી શક્ય સ્પષ્ટ કરે
તમે માં પ્રતિનિધિત્વ કરી શકે છે કે પૂર્ણાંક

16
00:00:44,030 --> 00:00:45,160
આ જેવા કાર્યક્રમ.

17
00:00:45,160 --> 00:00:49,430
હવે અમે આપખુદ પરત ફરવાનું નક્કી કર્યું છે
એક સંત્રી કિંમત તરીકે INT_MAX

18
00:00:49,430 --> 00:00:53,120
પ્રકારના અમે અનામત કર્યું છે એક
જેનો અર્થ થાય છે એક ભૂલ આવી.

19
00:00:53,120 --> 00:00:56,230
તેથી અમે ચૂકવણી કિંમત, અલબત્ત, છે
કે GetInt દેખીતી રીતે નથી કરી શકો છો

20
00:00:56,230 --> 00:01:01,440
ખરેખર મોટા સંખ્યાબંધ પરત
INT_MAX, તે ઇચ્છે છે પણ જો કારણ કે,

21
00:01:01,440 --> 00:01:04,730
કે વળતર કિંમત ખરેખર જોઈએ
કોલર દ્વારા અર્થઘટન કરી -

22
00:01:04,730 --> 00:01:06,260
જેનો GetInt મદદથી છે -

23
00:01:06,260 --> 00:01:09,340
અમુક પ્રકારની ભૂલ તરીકે.

24
00:01:09,340 --> 00:01:13,840
>> આગળ, હું જાહેર કર્યું છે કે નોટિસ
પૂર્ણાંક n એ અને ચાર રચે સી.

25
00:01:13,840 --> 00:01:18,030
કોડ આ આગળના વાક્ય માં, હું કહી
sscanf કહેવાય કાર્ય, માં પસાર

26
00:01:18,030 --> 00:01:18,970
ચાર દલીલો.

27
00:01:18,970 --> 00:01:25,110
શબ્દમાળા છે જે લાઇન, વપરાશકર્તાની
બંધારણમાં જે લખ્યો, "% હું% C"

28
00:01:25,110 --> 00:01:28,850
હું વપરાશકર્તા શકે અપેક્ષા છું કે જેઓ શબ્દમાળા
ની સરનામા અનુસરતા પ્રકાર,

29
00:01:28,850 --> 00:01:30,920
n એ, અને સી ની સરનામું.

30
00:01:30,920 --> 00:01:34,860
જીવનમાં હવે આપણે sscanf હેતુ ખરેખર છે
પાંચ શોધી શબ્દમાળા સ્કેન

31
00:01:34,860 --> 00:01:38,700
ચોક્કસ બંધારણ છે કે જે પ્રોગ્રામર
કે બીજી દલીલ તરીકે સ્પષ્ટ છે.

32
00:01:38,700 --> 00:01:42,020
આ કિસ્સામાં,% હું છે
,% C છે કારણ કે ત્યાં.

33
00:01:42,020 --> 00:01:46,700
Sscanf માં પૂર્ણાંક સામનો તેથી જો
વપરાશકર્તાની ઇનપુટ, કે પૂર્ણાંક સંગ્રહિત કરવામાં આવશે

34
00:01:46,700 --> 00:01:50,270
n એ કહેવાય ચલ ની અંદર કારણ કે
અમે ત્રીજા તરીકે આપવામાં આવી છે

35
00:01:50,270 --> 00:01:52,810
n ના સરનામા sscanf માટે દલીલ.

36
00:01:52,810 --> 00:01:56,870
જે sscanf ખરેખર જાઓ શકે છે
ત્યાં, અને તેમાં કિંમત સુધારો.

37
00:01:56,870 --> 00:01:59,990
>> હવે, કિસ્સામાં વપરાશકર્તા પ્રકારો
વધુ કંઈક માં

38
00:01:59,990 --> 00:02:01,220
એક અથવા વધુ અંકો કરતાં -

39
00:02:01,220 --> 00:02:03,570
અન્ય શબ્દોમાં, અમુક પ્રકારની એક કોલસો બનાવો -

40
00:02:03,570 --> 00:02:07,940
જેની આંકડાના કે બીજા ચલ સી,
અમે તેના ચોથા તરીકે sscanf પસાર

41
00:02:07,940 --> 00:02:10,560
દલીલ પણ રચાયેલ કરવામાં આવશે.

42
00:02:10,560 --> 00:02:14,220
હવે એક માટે તપાસ ના ઊંધો
વપરાશકર્તા માંથી વધારાના પાત્ર છે

43
00:02:14,220 --> 00:02:17,360
કે તે અથવા તેણી સહકાર ન થાય તો,
અને માત્ર પૂર્ણાંક કરતાં વધુ પ્રકારો,

44
00:02:17,360 --> 00:02:20,530
અમે આ માં તે શોધવા માટે સક્ષમ હશો
રીતે, તે કિસ્સામાં, sscanf કારણ

45
00:02:20,530 --> 00:02:24,860
દર્શાવે છે, 2 પરત ચાલી રહ્યું છે કે
આ જગ્યામાં બંને ભરવામાં આવ્યા હતા

46
00:02:24,860 --> 00:02:25,600
કિંમતો સાથે.

47
00:02:25,600 --> 00:02:30,360
પરંતુ અમે તેના બદલે છે કે sscanf આશા કરી રહ્યા છીએ
માત્ર વપરાશકર્તા એટલે કે, 1 આપે છે

48
00:02:30,360 --> 00:02:31,630
પૂર્ણાંક છે.

49
00:02:31,630 --> 00:02:34,480
>> અમે શું કરી શકું જો sscanf
ખરેખર 1 આપે છે?

50
00:02:34,480 --> 00:02:39,150
વેલ, અમે તરત જ લીટી મુક્ત કે
તે પછી વપરાશકર્તા માં ટાઇપ, અને અમે

51
00:02:39,150 --> 00:02:42,670
તરત જ કર્યા, એન પાછા
પૂર્ણાંક મેળવેલ.

52
00:02:42,670 --> 00:02:47,180
બાકી, sscanf 1 પરત, અને ન થાય તો
વપરાશકર્તા તેથી સહકાર ન હતી,

53
00:02:47,180 --> 00:02:51,470
અમે હજુ પણ રેખા મુક્ત છે, પરંતુ અમે
હવે ફરીથી પ્રયત્ન કરવા માટે વપરાશકર્તાને પૂછે છે.

54
00:02:51,470 --> 00:02:55,390
અને અમે તે અંદર હજી પણ કારણ
અન્યથા અનંત લૂપ, પ્રક્રિયા

55
00:02:55,390 --> 00:03:00,190
ફરી શરૂ કરવા માટે, અને કદાચ ફરી, અને કરશે
કદાચ ફરી, ત્યાં સુધી વપરાશકર્તા ખરેખર

56
00:03:00,190 --> 00:03:01,500
અમને એક પૂર્ણાંક છે.

57
00:03:01,500 --> 00:03:21,490