>> SPEAKER 1: యొక్క పరిశీలించి చూద్దాం CS50 లైబ్రరీ వద్ద,
ప్రత్యేకంగా దాని GetInt ఫంక్షన్.
ఇక్కడ మేము అసలు సోర్స్ కలిగి GetInt కోసం కోడ్.
మరియు అది చాలా పొడవుగా కాదు అని గుర్తించలేకపోతే, మరియు ఇది చాలా ఒక సమయంలో లూప్ కలిగి -
ఆ వద్ద ఒక అనంతమైన లూప్ - మాత్రమే మేము నిజంగా ఒకసారి ఒక విలువ తిరిగి
మేము అంచనా ఏ సంపాదించిన.
యొక్క ఇది నడవడానికి.
>> , మొదటి ఇక్కడ గమనించండి లూప్ ప్రారంభమవుతుంది అయితే.
మేము కోడ్ యొక్క ఒక లైన్ కలిగి ఉన్న తర్వాత గమనించండి వాస్తవానికి, తెలుసా
మరియు ఒక లో తిరిగి విలువ నిల్వ వేరియబుల్, రకం స్ట్రింగ్ యొక్క, లైన్ అని.
మేము అప్పుడు ఒక పవిత్రత చెక్ ఒక బిట్ చేయండి.
లైన్ == శూన్య, అప్పుడు మేము ఆసక్తికరంగా INT_MAX తిరిగి.
>> ఇప్పుడు అది INT_MAX అని అవుతుంది ఒక ప్రత్యేక స్థిరంగా చోట్ల ప్రకటించింది
అతిపెద్ద సాధ్యం నిర్దేశిస్తుంది మీరు ఒక లో సూచిస్తుంది ఆ, Int
ఈ వంటి ప్రోగ్రామ్.
ఇప్పుడు ఏకపక్ష తిరిగి నిర్ణయించుకుంది చేసిన ఒక సెంటినెల్ విలువ INT_MAX
రకాల, మేము వంటి రిజర్వు చేసిన ఒక లోపం అనగా సంభవించింది.
కాబట్టి మేము చెల్లించే ధర, వాస్తవానికి, ఉంది ఆ GetInt స్పష్టంగా కాదు
నిజానికి అంత పెద్ద సంఖ్య తిరిగి INT_MAX, ఇది కోరుకుంటున్నారు కూడా ఎందుకంటే,
ఆ తిరిగి విలువ నిజంగా ఉండాలి కాలర్ వివరించబడతాయి -
ఎవరైతే GetInt ఉపయోగించి -
విధమైన లోపం వంటి.
>> తదుపరి, నేను డిక్లేర్డ్ చేసిన గమనించవచ్చు ఒక పూర్ణాంకానికి n మరియు ఒక చార్ సి.
కోడ్ యొక్క ఈ తదుపరి లైన్, నేను ఒక కాల్ sscanf అనే, నేమి
నాలుగు వాదనలు.
స్ట్రింగ్ ఉన్న లైన్, యూజర్ యొక్క ఒక ఫార్మాట్ ఇది టైప్, "% i% సి",
నేను యూజర్ మైట్ ఆశించే వెబ్ స్ట్రింగ్ యొక్క చిరునామా తరువాత రకం,
n, మరియు సి యొక్క చిరునామా.
జీవితంలో ఇప్పుడు sscanf ప్రయోజనం నిజానికి ఉంది కోసం చూస్తున్న స్ట్రింగ్ స్కాన్
ప్రత్యేక ఫార్మాట్లో ప్రోగ్రామర్ ఆ రెండవ వాదన పేర్కొన్నా.
ఈ సందర్భంలో,% i లో ఉంది ,% సి ఉంది వంటి.
Sscanf లో ఒక Int కలుసుకుంటాడు అయితే యూజర్ యొక్క ఇన్పుట్ ఆ, Int నిల్వ చేయబడుతుంది
n అనే వేరియబుల్, లోపలి ఎందుకంటే మేము మూడవ వంటి అందించిన
n యొక్క చిరునామా sscanf కు వాదన.
ఏ sscanf నిజానికి వెళ్ళే అర్థం అక్కడ, మరియు దానిలో విలువ అప్డేట్.
>> ఇప్పుడు, సందర్భంలో యూజర్ రకాల మరింత ఏదో లో
ఒకటి లేదా ఎక్కువ అంకెలు కంటే -
ఇతర మాటలలో, విధమైన ఒక చార్ -
దీని చిరునామా రెండవ వేరియబుల్ సి, మేము దాని నాలుగోవాడు sscanf జారీ
వాదన కూడా జనాభా ఉంటుంది.
ఇప్పుడు ఒక కోసం తనిఖీ పైకి వినియోగదారు నుండి అదనపు పాత్ర
అతను లేదా ఆమె ఏంచేయాలి ఉంటే, మరియు కేవలం ఒక Int కంటే ఎక్కువ లో రకాల,
మేము ఈ లో కనుగొనడం చేయగలరు పద్ధతిలో, ఆ సందర్భంలో, sscanf ఎందుకంటే
అధిక 2 తిరిగి అన్నారు placeholders రెండు నిండిపోయాయి
విలువలతో.
కాని మనం బదులుగా ఆ sscanf ఆశతో ఉన్నాము యూజర్ అంటే, 1 తిరిగి
ఒక Int అందించిన.
>> మనమేం చేస్తాం ఉంటే sscanf నిజానికి 1 తిరిగి?
Well, మేము తక్షణమే విడిపించేందుకు ఆ యూజర్ టైప్, మరియు మేము
వెంటనే కలిగి, n తిరిగి ఒక Int సంపాదించిన.
ఎల్స్, sscanf 1 తిరిగి, మరియు లేదు ఉంటే యూజర్ అందువలన సహకరించలేదు,
మేము ఇంకా లైన్ విడిపించేందుకు, కాని మేము వేచి వినియోగదారును ప్రాంప్ట్.
మరియు మేము ఆ లోపలి ఇప్పటికీ ఉన్నారు ఎందుకంటే లేకపోతే అనంతమైన లూప్, ప్రక్రియ
మళ్ళీ ప్రారంభించడానికి, మరియు బహుశా మళ్ళీ, మరియు బహుశా మళ్ళీ వరకు యూజర్ వాస్తవానికి
మాకు ఒక పూర్ణాంకానికి అందిస్తుంది.