2
00:00:00,000 --> 00:00:01,860
>> SPEAKER 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
మేము కోడ్ యొక్క ఒక లైన్ కలిగి ఉన్న తర్వాత గమనించండి
వాస్తవానికి, తెలుసా

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
అతిపెద్ద సాధ్యం నిర్దేశిస్తుంది
మీరు ఒక లో సూచిస్తుంది ఆ, Int

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
స్ట్రింగ్ ఉన్న లైన్, యూజర్ యొక్క
ఒక ఫార్మాట్ ఇది టైప్, "% i% సి",

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
ఈ సందర్భంలో,% i లో ఉంది
,% సి ఉంది వంటి.

33
00:01:42,020 --> 00:01:46,700
Sscanf లో ఒక Int కలుసుకుంటాడు అయితే
యూజర్ యొక్క ఇన్పుట్ ఆ, Int నిల్వ చేయబడుతుంది

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
అతను లేదా ఆమె ఏంచేయాలి ఉంటే,
మరియు కేవలం ఒక Int కంటే ఎక్కువ లో రకాల,

44
00:02:17,360 --> 00:02:20,530
మేము ఈ లో కనుగొనడం చేయగలరు
పద్ధతిలో, ఆ సందర్భంలో, sscanf ఎందుకంటే

45
00:02:20,530 --> 00:02:24,860
అధిక 2 తిరిగి అన్నారు
placeholders రెండు నిండిపోయాయి

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
ఒక Int అందించిన.

49
00:02:31,630 --> 00:02:34,480
>> మనమేం చేస్తాం ఉంటే sscanf
నిజానికి 1 తిరిగి?

50
00:02:34,480 --> 00:02:39,150
Well, మేము తక్షణమే విడిపించేందుకు ఆ
యూజర్ టైప్, మరియు మేము

51
00:02:39,150 --> 00:02:42,670
వెంటనే కలిగి, n తిరిగి
ఒక Int సంపాదించిన.

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