[Powered by Google Translate] [ఆదేశ పంక్తి వాదనలు]
[క్రిస్టోఫర్ బర్తలోమ్యోవ్ - హార్వర్డ్ యూనివర్శిటీ]
[- CS50.TV ఈ CS50 ఉంది]
ఒక ప్రోగ్రామ్ ఒక ఉపయోగకరమైన ఫీచర్ వినియోగదారు ఇన్పుట్ను ఆమోదిస్తే ఉంది.
ఇంతవరకు, మేము CS50 లైబ్రరీ కొన్ని విధులు అన్వేషించారు చేసిన
వంటి వినియోగదారు ఇన్పుట్ను, అంగీకరించడానికి ", స్ట్రింగ్ పొందండి"
అప్లికేషన్ అమలులో ఉన్నప్పుడు ఒక స్ట్రింగ్ కోసం, వినియోగదారు అడుగుతుంది.
>> మీరు మీ కార్యక్రమాన్ని ఇన్పుట్ను అందించాలి ఎక్కడ అయితే, కేసులు ఉన్నాయి
నిజానికి రన్ ముందు.
ఈ విధంగా, మీరు మీ వినియోగదారు నుండి అదనపు సమాచారం అడగాలి లేదు
సాధారణ పని అమలు అయితే.
ఉదాహరణకు, MV లేదా UNIX లో తరిలి ఆదేశం తీసుకోండి.
ఈ ఆదేశం యూజర్ ఒక ప్రదేశం నుండి మరొక ఫైల్ మారడానికి అనుమతిస్తుంది.
మాన్యువల్ పేజీలు ప్రకారం, MV రెండు ఆదేశ పంక్తి వాదనలు అంగీకరిస్తుంది:
ఫైల్ తరలించబడుతోంది మరియు నగర ఫైలుకు తరలించబడుతోంది.
కాబట్టి ఈ ఉదాహరణ రెండు వాదనలు ఒక ఆదేశ ఉంది.
కాబట్టి మేము ఎలా ఈ ఆదేశ పంక్తి వాదనలు ఉపయోగించుకున్న మా సి కార్యక్రమం చెప్పడం లేదు?
>> సరే, మేము అన్ని సి కార్యక్రమాలలో ఉపయోగించే ప్రధాన, ఒక రహస్య కలిగి అవుతుంది.
Argc మరియు argv: ప్రధాన రెండు పారామీటర్లను అంగీకరిస్తుంది.
యొక్క ఈ నిబంధనలు వెళ్ళి లెట్.
>> వాదన లెక్కింపు కోసం నిలుచునే మొదటి పారామితి, argc,
పూర్ణాంక ఒక డేటా రకాన్ని కలిగి ఉంది.
argc పారామితి ఆదేశం సహా వాదనలు సంఖ్య ఉంటుంది.
మా తరలింపు కమాండ్, మేము కేవలం రెండు వాదనలు ప్రదర్శించబడుతుంది అయితే,
argc యొక్క విలువ 3 ఉంటుంది.
వాదన వెక్టర్ అంటే రెండో పారామితి, argv,
తీగలను సూచించబడిన చార్ గమనికలు యొక్క వ్యూహం ఉంది.
>> ఇది argv ప్రతి మూలకం, సున్నా నుండి మొదలు అంటే
కమాండ్ మరియు వాదనలు ఉన్నాయి.
ఉదాహరణకు, argv [0], ఇది నేను, argv సున్నా చూడండి చేస్తాము
ఎల్లప్పుడూ అమలు చేయబడుతున్న ఆదేశం ఉంటాయి -
ఈ సందర్భంలో, MV.
argv [1] file.txt మొదటి వాదన, ఉంటాయి
మరియు argv [2] రెండవ వాదన ఉంటాయి, ~ / cs50 /.
argv చివరి వాదన ఎప్పుడూ శూన్య ఉంటుంది.
కాబట్టి యొక్క ఈ ఆదేశ పంక్తి వాదనలు అమలు అనుమతిస్తాయి.
మునుపటి వ్యాయామం, మేము ప్రధాన యొక్క పారామితిగా, ఏమీ అర్థం, శూన్యమైన ఉంచుతారు.
అయితే, క్రమంలో మాకు, ఆదేశ పంక్తి వాదనలు ఉపయోగించడానికి
మేము ప్రధాన Int argc, చార్ * argv [] యొక్క తప్ప మరియు స్థానం లోపల తొలగించాలి.
ఇప్పుడు, మీ వాదనలు ఇది argv నుండి మొత్తం మూలకం, యాక్సెస్ చెయ్యడానికి,
మీరు ఈ విధంగా అమరిక ద్వారా, iterate, లేదా లూప్ చేయవచ్చు.
కాబట్టి, లోపల ప్రధాన శరీరం, మేము ముందుకు వెళ్లి, లూప్ ఒక టైప్ చూడాలని:
కోసం (Int i = 0; i <argc; i + +).
>> మేము మాత్రమే కోడ్ ఒకటి లైనును అమలు ఉన్నందున మేము ఇక్కడ ఒక వంకర కలుపు అవసరం లేదు
ఈ లూప్ యొక్క శరీరం లోపల.
మేము, ముందుకు వెళ్ళి, ఒకసారి టాబ్ నొక్కండి చేస్తాము
అప్పుడు printf టైప్ ("argv [% d], ఒక పూర్ణాంకం విలువను సూచించడానికి,
కొత్త లైన్ పాత్ర తర్వాత, స్ట్రింగ్ కోసం,% s ఉంది.
అప్పుడు మేము లూప్ యొక్క ప్రస్తుత మళ్ళా కోసం printf నేను అందించే
మరియు argv [i] ప్రస్తుత ఆదేశ పంక్తి వాదన యొక్క స్ట్రింగ్ ప్రాతినిధ్యం కొరకు.
మేము రెండు వాదనలు తో దీన్ని అమలు చేసినప్పుడు, మేము టెర్మినల్ లో ప్రదర్శించబడదు వాదనలు చూస్తారు.
గతంలో మేము argv చార్ గమనికలు యొక్క వ్యూహం జరిగిన చెప్పారు.
>> ఈ సందర్భంలో ఉంటే అందువలన, ఎలా మేము అప్పుడు ప్రతి వాదన వ్యక్తిగత అక్షరాలు యాక్సెస్ చేయాలి?
ఉదాహరణకు, నేను మొదటి వాదన ఒక నిర్దిష్ట పాత్ర కోసం కనిపించాలని కోరిక ఏమి?
Well, సమాధానం మేము ఒక సమూహ లూప్ దరఖాస్తు అవసరం ఉంది
ఆ తర్వాత వాదన స్ట్రింగ్ లో అంశాల ప్రతి ద్వారా iterate కనిపిస్తుంది.
ఈ మీరు ఎలా ఉంది.
>> మొదటి, మేము example2.c యొక్క నకలును చేయడానికి వెళుతున్న.
అప్పుడు, లోపల లూప్ మొదటి యొక్క,
మేము లూప్ ఒక అదనపు జోడించండి చూడాలని.
కాబట్టి కోసం (ఇంట్ J = 0, n = strlen (argv [i]),
ఇది, మాకు ప్రస్తుత వాదన యొక్క పొడవు ఇస్తుంది
; J <n; j + +)
మేము ప్రతి పాత్ర స్థానాన్ని ముద్రించడానికి వెళుతున్న
printf ఉపయోగించి ప్రస్తుత వాదన లోపలి.
కాబట్టి, printf ("argv [% d], ప్రస్తుత వాదన యొక్క ఇండెక్స్ ప్రాతినిధ్యం,
అప్పుడు [% d] మరోసారి ప్రస్తుత వాదన యొక్క ప్రస్తుత పాత్ర ప్రాతినిధ్యం,
ఉంది:% సి, వాదన ప్రస్తుత పాత్ర కోసం.
చివరగా, మేము బయటి లూప్ యొక్క ఇండెక్స్ తో printf అందించడానికి, i,
అప్పుడు లోపలి లూప్ యొక్క సూచిక.
>> మరియు మా చివరి వాదన printf అందించిన వాదన నుండి అసలు పాత్ర కు
కమాండ్ లైన్ వద్ద.
ఇప్పుడు నేను ఒక స్ట్రింగ్ యొక్క పొడవు పొందటానికి స్ట్రింగ్ ఫంక్షన్ strlen ఉపయోగిస్తారు ఎందుకంటే,
నేను కూడా మా కలిగి యొక్క అగ్ర string.h లైబ్రరీ జోడించాలి.
కాబట్టి, ఆ విధంగా చేయడానికి, మేము అప్ వెళ్తారో, మరియు కేవలం stdio.h కింద, మేము చేయబోతున్నామని
# ఉన్నాయి.
>> కాబట్టి, యొక్క కంపైల్ మరియు అమలు మరియు అది అసలైన వాదన అందించడానికి అనుమతిస్తాయి.
>> మేము చూడగలరు మరియు, మేము ఇప్పుడు వాదన ప్రతి వ్యక్తి చార్ యొక్క ఖచ్చితమైన స్థానం కలిగి ఉన్నాయి.
కాబట్టి అంతే. నేను క్రిస్టోఫర్ బర్తలోమ్యోవ్ ఉన్నాను; ఈ CS50 ఉంది.
[CS50.TV]