ఉబుంటు 20.04లో C++లో Argc మరియు Argv అంటే ఏమిటి?
“argc” పరామితి ఆర్గ్యుమెంట్ గణనను సూచిస్తుంది, అయితే “argv” అనేది C++లో ప్రోగ్రామ్‌ను అమలు చేసే సమయంలో కమాండ్ లైన్ ద్వారా “main()” ఫంక్షన్‌కి పంపబడే అన్ని ఆర్గ్యుమెంట్‌లను కలిగి ఉండే అక్షర శ్రేణిని సూచిస్తుంది. ఇక్కడ, 'argc' అనేది ఎల్లప్పుడూ ఆమోదించబడిన ఆర్గ్యుమెంట్‌ల వాస్తవ సంఖ్య కంటే ఆర్గ్యుమెంట్ గణనను '1'గా చూపుతుందని మీరు తెలుసుకోవాలి. ఆబ్జెక్ట్ ఫైల్ పేరు కూడా కమాండ్-లైన్ ఆర్గ్యుమెంట్‌గా పరిగణించబడుతుంది కాబట్టి ఇది జరుగుతుంది. మీరు ఏదైనా డేటా రకానికి చెందిన కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లను “main()” ఫంక్షన్‌కి పంపవచ్చు. ఈ పారామితులు మీ “మెయిన్()” ఫంక్షన్‌లోని ప్రోటోటైప్‌లో మీరు వాటిని యాక్సెస్ చేయాలనుకుంటే దానిలో పేర్కొనబడిందని మీరు శ్రద్ధ వహించాలి. అయితే, 'ప్రధాన()' ఫంక్షన్ ఈ రెండు పారామితులు లేకుండా ఖచ్చితంగా పని చేస్తుంది. ఇది ఈ వ్యాసం యొక్క క్రింది విభాగంలో చర్చించబడుతుంది, దాని తర్వాత మేము ఉబుంటు 20.04లో C++లో ఈ రెండు పారామితుల వినియోగానికి వెళ్తాము.
C++లో Argc మరియు Argv లేని ప్రధాన విధి:
అన్నింటిలో మొదటిది, “argc” మరియు “argv” పారామితులను ఉపయోగించకుండా కూడా C++లోని “main()” ఫంక్షన్ ఖచ్చితంగా పని చేస్తుందని మేము మీకు చెప్పాలనుకుంటున్నాము. ఇది క్రింది C++ ప్రోగ్రామ్‌లో వర్ణించబడింది:
మేము ఈ ప్రోగ్రామ్‌లో ఎటువంటి వాదనలు లేకుండా సాధారణ “ప్రధాన()” ఫంక్షన్‌ని కలిగి ఉన్నాము. ఈ “ప్రధాన()” ఫంక్షన్‌లో, మేము టెర్మినల్‌లో నమూనా సందేశాన్ని మాత్రమే ముద్రిస్తున్నాము.
అప్పుడు, మేము ఈ ప్రాథమిక C++ ప్రోగ్రామ్‌ను క్రింద పేర్కొన్న కమాండ్ సహాయంతో కంపైల్ చేసాము:
$ g++ CommandLine.cpp –o కమాండ్‌లైన్
తరువాత, కింది ఆదేశాన్ని అమలు చేయడం ద్వారా మేము ఈ ప్రోగ్రామ్‌ను అమలు చేసాము:
$ . / కమాండ్ లైన్
ఈ సాధారణ C++ ప్రోగ్రామ్ యొక్క అవుట్‌పుట్ క్రింది చిత్రంలో చూపబడింది:
ఏ కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లను దాటకుండా C++ ప్రోగ్రామ్‌ను అమలు చేయడం:
ఇప్పుడు, మేము C++ ప్రోగ్రామ్‌ను అమలు చేయడానికి ప్రయత్నిస్తాము, దీనిలో “main()” ఫంక్షన్ “argc” మరియు “argv” పారామితులను ఆమోదించగలదు, అయినప్పటికీ, ఈ ప్రోగ్రామ్‌ను అమలు చేస్తున్నప్పుడు మేము ఈ ఆర్గ్యుమెంట్‌లను దానికి పంపము టెర్మినల్. చెప్పబడిన C++ ప్రోగ్రామ్ క్రింది చిత్రంలో చూపబడింది:
ఈ C++ ప్రోగ్రామ్‌లో, మన “main()” ఫంక్షన్ “argc” మరియు “argv” పారామితులను ఆమోదించగలదు. అయినప్పటికీ, మేము ఈ నిర్దిష్ట ఉదాహరణలో ఈ విలువలను దానికి పంపాలని భావించనందున, మేము ఉద్దేశపూర్వకంగా “argc”ని “0”కి సమం చేసాము, తద్వారా మేము దాని విలువను ముద్రించడానికి ప్రయత్నించినప్పుడు, అది ఏ చెత్త విలువను తిరిగి ఇవ్వదు. ఆ తరువాత, మేము టెర్మినల్‌లో “argc” పరామితి యొక్క విలువను ముద్రించాము. అప్పుడు, మేము టెర్మినల్‌లోని అన్ని కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లను ప్రింట్ చేయడానికి “ఫర్” లూప్‌ని ఉపయోగించాము.
దిగువ చూపిన ఆదేశాన్ని ఉపయోగించి మేము ఈ కోడ్‌ను కంపైల్ చేసాము:
$ g++ CommandLine.cpp –o కమాండ్‌లైన్ 
అప్పుడు, మేము ఈ ప్రోగ్రామ్‌ను అమలు చేయాలనుకున్నప్పుడు, మేము దీనికి ఎలాంటి కమాండ్-లైన్ ఆర్గ్యుమెంట్‌లను పంపలేదు, మీరు ఈ క్రింది కమాండ్ నుండి చూడవచ్చు:
$ . / కమాండ్ లైన్ 
దిగువ చిత్రంలో చూపిన ఈ C++ ప్రోగ్రామ్ యొక్క అవుట్‌పుట్ నుండి, మీరు ఈ ఫంక్షన్‌కి కమాండ్-లైన్ ఆర్గ్యుమెంట్‌లు ఏవీ పాస్ చేయలేదని మీరు చూడవచ్చు, దీని కారణంగా ఆర్గ్యుమెంట్ కౌంట్ “0” మరియు టెర్మినల్‌లో ఎటువంటి ఆర్గ్యుమెంట్‌లు ముద్రించబడలేదు ఎందుకంటే అక్షర శ్రేణి “ argv” కూడా ఖాళీగా ఉంది.
పూర్ణాంకం టైప్ కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లతో C++ ప్రోగ్రామ్‌ను అమలు చేయడం:
ఇప్పుడు, మేము పూర్ణాంక రకం కమాండ్-లైన్ ఆర్గ్యుమెంట్‌లను పంపడం ద్వారా అదే C++ ప్రోగ్రామ్‌ను అమలు చేయాలనుకుంటున్నాము. అయితే, అలా చేసే ముందు, కింది చిత్రంలో చూపిన విధంగా మేము మా కోడ్‌ను కొద్దిగా సవరించుకుంటాము:
మేము ఈ కోడ్‌కి చేసిన ఏకైక మార్పు ఏమిటంటే, మేము దాని నుండి “argc=0” అనే పంక్తిని తీసివేసాము ఎందుకంటే ఈ ఉదాహరణలో, మేము ఈ ప్రోగ్రామ్‌కు అమలు సమయంలో పంపిన కమాండ్ లైన్ ఆర్గ్యుమెంట్‌ల వాస్తవ సంఖ్యను ప్రింట్ చేయాలనుకుంటున్నాము. మిగిలిన కోడ్ పైన విభాగంలో ఉపయోగించిన విధంగానే ఉంటుంది.
దిగువ చూపిన ఆదేశాన్ని ఉపయోగించి మేము మా సవరించిన కోడ్‌ను తిరిగి కంపైల్ చేసాము:
$ g++ CommandLine.cpp –o కమాండ్‌లైన్ 
అప్పుడు, ఈ కోడ్‌ని అమలు చేయడానికి, మేము ఈ క్రింది కమాండ్-లైన్ ఆర్గ్యుమెంట్‌లను ఉపయోగించాము:
$ . / కమాండ్ లైన్ 1 రెండు 3 
ఈ C++ ప్రోగ్రామ్‌ని రన్ చేస్తున్నప్పుడు మనం దానికి మూడు పూర్ణాంకాల రకం కమాండ్-లైన్ ఆర్గ్యుమెంట్‌లను పాస్ చేసాము, అంటే 1, 2 మరియు 3.
ఈ సవరించిన ప్రోగ్రామ్ యొక్క అవుట్‌పుట్ క్రింది చిత్రంలో చూపబడింది:
ఈ C++ ప్రోగ్రామ్ ద్వారా అందించబడిన మొత్తం ఆర్గ్యుమెంట్‌ల సంఖ్య “4” అంటే, మనం పాస్ చేసిన మూడు పూర్ణాంక ఆర్గ్యుమెంట్‌లు + ఆబ్జెక్ట్ ఫైల్ పేరు. ఈ ప్రోగ్రామ్ టెర్మినల్‌పై “argv” అక్షర శ్రేణి యొక్క మూలకాలను కూడా ముద్రించింది, అంటే, ప్రోగ్రామ్ పేరుతో పాటు అమలు సమయంలో ఈ ప్రోగ్రామ్‌కు పంపబడిన వాస్తవ పూర్ణాంకాల రకం ఆర్గ్యుమెంట్‌లు.
క్యారెక్టర్ టైప్ కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లతో C++ ప్రోగ్రామ్‌ను అమలు చేయడం:
ఇప్పుడు, అదే C++ ప్రోగ్రామ్‌కి క్యారెక్టర్ టైప్ కమాండ్-లైన్ ఆర్గ్యుమెంట్‌లను పాస్ చేయడం ద్వారా ఎగ్జిక్యూట్ చేయడానికి ప్రయత్నించినప్పుడు అది బాగా పని చేస్తుందో లేదో చూడాలనుకుంటున్నాము. దాని కోసం, మేము దానిని మరింత సవరించాల్సిన అవసరం లేదు. మేము దానిని ఈ క్రింది విధంగా అక్షర రకం కమాండ్-లైన్ ఆర్గ్యుమెంట్‌లతో మాత్రమే అమలు చేయాలి:
$ . / కమాండ్‌లైన్ a b c d e f 
ఈ C++ ప్రోగ్రామ్‌ని రన్ చేస్తున్నప్పుడు, అంటే, a, b, c, d, e, మరియు f లకు మేము ఆరు-అక్షరాల రకం కమాండ్-లైన్ ఆర్గ్యుమెంట్‌లను పంపామని దీని అర్థం.
అదే C++ ప్రోగ్రామ్‌కు క్యారెక్టర్ టైప్ కమాండ్-లైన్ ఆర్గ్యుమెంట్‌లను పంపడం వల్ల ఉత్పత్తి చేయబడిన అవుట్‌పుట్ క్రింద చూపబడింది:
ఈ C++ ప్రోగ్రామ్ ద్వారా అందించబడిన మొత్తం ఆర్గ్యుమెంట్‌ల సంఖ్య “7” అంటే, మనం పాస్ చేసిన ఆరు-అక్షరాల ఆర్గ్యుమెంట్‌లు + ఆబ్జెక్ట్ ఫైల్ పేరు. ఈ ప్రోగ్రామ్ టెర్మినల్‌పై “argv” అక్షర శ్రేణి యొక్క మూలకాలను కూడా ముద్రించింది, అంటే, ప్రోగ్రామ్ పేరుతో పాటు అమలు సమయంలో ఈ ప్రోగ్రామ్‌కు పంపబడిన వాస్తవ అక్షర రకం వాదనలు.
ముగింపు:
ఈ కథనం రెండు కమాండ్-లైన్ ఆర్గ్యుమెంట్‌ల చర్చకు ఉద్దేశించబడింది, వీటిని “మెయిన్()” ఫంక్షన్ యొక్క పారామితులు అని కూడా పిలుస్తారు, అంటే “argc” మరియు “argv”. మేము ఈ రెండు పారామితుల యొక్క ప్రాముఖ్యత గురించి వాటి వినియోగాన్ని పేర్కొనడం ద్వారా మాట్లాడాము. అప్పుడు, ఉబుంటు 20.04లో C++లో “argc” మరియు “argv” వినియోగాన్ని వివరించే కొన్ని ఉదాహరణలను మేము మీతో పంచుకున్నాము. అంతేకాకుండా, ఈ పారామితులను ఉపయోగించకుండా కూడా, “ప్రధాన()” ఫంక్షన్ సంపూర్ణంగా పని చేస్తుందని కూడా మేము స్పష్టం చేసాము. కాబట్టి, మీరు ఈ కథనాన్ని ఒకసారి చదివితే, మీరు C++లో “argc” మరియు “argv” వినియోగాన్ని చాలా స్పష్టంగా అర్థం చేసుకుంటారు.